集群情况下Session共享解决方案 redis
java项目集群部署,使用spring-session、redis实现session共享
java项⽬集群部署,使⽤spring-session、redis实现session共享redis服务命令redis-server --service-install redis.windows.conf --loglevel verbose // 安装redis服务redis-server.exe redis.windows.conf //启动redis服务redis-server --service-uninstall //卸载服务redis-server --service-stop //卸载服务web项⽬需要引⼊的jar包项⽬xml相关配置<!-- Jedis连接池配置参数 --><bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"><!-- 控制⼀个pool最多有多少个状态为idle(空闲)的jedis实例 --><property name="maxIdle" value="100"></property><!-- 控制⼀个pool可分配多少个jedis实例 --><property name="maxTotal" value="200"></property><!-- 表⽰当borrow⼀个jedis实例时,最⼤的等待时间,如果超过等待时间,则直接抛出JedisConnectionException --><property name="maxWaitMillis" value="1000"></property><!-- 在borrow⼀个jedis实例时,是否提前进⾏validate操作;如果为true,则得到的jedis实例均是可⽤的 --><property name="testOnBorrow" value="true"></property></bean><!--redis连接⼯⼚ --><bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"><!-- 连接池配置引⽤ --><property name="poolConfig" ref="jedisPoolConfig"></property><!-- 主机IP地址 --><property name="hostName" value="你的IP地址"></property><!-- 端⼝号 --><property name="port" value="6379"></property><!-- 访问密码 --><property name="password" value="你设置的访问密码" /><!-- 是否使⽤池 --><property name="usePool" value="true"></property></bean><!-- 将session放⼊redis --><bean id="redisHttpSessionConfiguration" class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration"><!-- session过期时间,单位是秒 --><property name="maxInactiveIntervalInSeconds" value="1800"/></bean>web.xml 相关⽂件配置<!-- spring session的过滤器配置,注意此过滤器必须放在其他过滤器之前 --><filter><filter-name>springSessionRepositoryFilter</filter-name><filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class></filter><filter-mapping><filter-name>springSessionRepositoryFilter</filter-name><url-pattern>/*</url-pattern><dispatcher>REQUEST</dispatcher><dispatcher>ERROR</dispatcher></filter-mapping>。
redis共享session原理
redis共享session原理Redis是一款开源的高性能键值数据库,它支持在内存中存储数据,具有快速读写的特点。
在分布式系统中,为了提高系统的可伸缩性和可靠性,常常需要将Session数据进行共享。
本文将介绍如何使用Redis实现Session数据的共享,并解释其原理。
一、什么是Session在Web开发中,Session是一种记录用户状态的机制。
当用户第一次访问一个网站时,服务器会为其分配一个唯一的Session ID,并将该ID存储在用户的浏览器中。
随后,用户的每一次请求都会携带这个Session ID,服务器通过它来识别用户,进而获取和更新用户的状态数据。
二、为什么需要共享Session在传统的应用架构中,每个Web服务器都会拥有自己的Session数据存储空间。
然而,随着应用规模的扩大,单个服务器的性能可能无法满足需求,因此引入了负载均衡器来分发请求。
但是,由于每个服务器都有各自独立的Session数据,导致用户在不同的服务器之间切换时,其Session状态无法保持一致。
为了解决这个问题,可以将Session数据集中存储在一个共享的地方,比如Redis中。
这样,不论用户请求被转发到哪个服务器,都能够共享相同的Session数据,从而实现状态的一致性。
三、使用Redis共享Session的步骤1. 安装并启动Redis服务器。
2. 配置Web应用程序,使其将Session数据存储到Redis中。
一般情况下,需要修改应用的配置文件,指定Redis的连接信息和存储方式。
3. 在用户请求到达Web服务器后,服务器会解析请求中携带的Session ID。
如果Session ID有效,则通过Redis查询该Session对应的数据。
如果Session ID无效,则创建一个新的Session,并将其ID返回给用户。
4. 在用户的每一次请求中,服务器都会更新Session数据,并将更新后的数据存储到Redis中。
基于nginx tomcat redis分布式web应用的session共享配置
基于nginx tomcat redis分布式web应用的session共享配置一、前言nginx作为目前最流行的开源反向代理HTTP Server,用于实现资源缓存、web server负载均衡等功能,由于其轻量级、高性能、高可靠等特点在互联网项目中有着非常普遍的应用,相关概念网上有丰富的介绍。
分布式web server 集群部署后需要实现session共享,针对tomcat 服务器的实现方案多种多样,比如tomcat cluster session 广播、nginx IP hash策略、nginx sticky module等方案,本文主要介绍了使用redis服务器进行session 统一存储管理的共享方案。
相关应用结构参照下图:二、环境配置测试环境基于Linux CentOS 6.5,请先安装tomcat、redis、nginx相关环境,不作详细描述,本文测试配置如下:三、构建tomcat-redis-session-manager-master1、由于源码构建基于gradle,请先配置gradle环境。
2、从github获取tomcat-redis-session-manager-master 源码,地址如下:https:///jcoleman/tomcat-redis-session-manager3、找到源码中的 build.gradle 文件,由于作者使用了第三方仓库(sonatype),需要注册帐号,太麻烦,注释后直接使用maven中央仓库,同时注释签名相关脚本并增加依赖包的输出脚本copyJars(dist目录),修改后的 build.gradle文件如下:View Code4、执行gradle命令构建源码,编译输出tomcat-redis-session-manager-master 及依赖jar包gradle build -x test copyJars所有输出列表文件如下:四、tomcat 配置安装配置两台tomcat web服务器,分别修改Connector 端口号为8080和9090,并确保都能正常工作,当然如果分布在不同的主机则可以使用相同端口号。
spring-session-data-redis解决session共享的问题
spring-session-data-redis解决session共享的问题分布式系统要做到⽤户友好,需要对⽤户的session进⾏存储,存储的⽅式有以下⼏种:1. 本地缓存2. 数据库3. ⽂件4. 缓存服务器可以看⼀些不同⽅案的优缺点1.本地机器或者本地缓存。
优点:速度快缺点:服务宕机后重启⽤户信息丢失,⽤户不优好2.数据库。
优点:技术栈简单缺点:速度慢3.⽂件。
优点:技术栈简单,速度适中缺点:⽆灾备或者灾备⽅案成本⾼4.缓存服务器。
⼀般是内存服务器,优点:速度快可以和原有技术栈契合,有现成的解决⽅案。
缺点:不明显如果使⽤java语⾔,并且缓存服务器为redis,可以使⽤开源的spring session项⽬来解决。
spring session项⽬现有三个⾃项⽬,分别是spring-session-data-redis 使⽤redis⽅式spring-session-hazelcast 使⽤hazelcast⽅式spring-session-jdbc 使⽤jdbc⽅式在这⾥我建议⼤家使⽤redis⽅式,它提供了注解式和编程式不同的⽅法。
具体如何使⽤,⽹上有很多实例,我就不赘述。
我想和⼤家⼀起深⼊内部看⼀下,spring-session项⽬的github地址为:https:///spring-projects/spring-session.git我们只看spring-session-data-redis,实现⾮常简单。
它总共只有12个类核⼼类只有⼀个RedisOperationsSessionRepository这个类内部定义了session的实现RedisSession/*** A custom implementation of {@link Session} that uses a {@link MapSession} as the* basis for its mapping. It keeps track of any attributes that have changed. When* {@link org.springframework.session.data.redis.RedisOperationsSessionRepository.RedisSession#saveDelta()}* is invoked all the attributes that have been changed will be persisted.** @author Rob Winch* @since 1.0*/final class RedisSession implements Session {private final MapSession cached;private Instant originalLastAccessTime;private Map<String, Object> delta = new HashMap<>();private boolean isNew;private String originalPrincipalName;private String originalSessionId;注意:delta 是增量 cached是存量我们来看这个RedisSession的创建销毁及修改RedisSession内部存储如下(⽰例)* <pre>* HMSET spring:session:sessions:33fdd1b6-b496-4b33-9f7d-df96679d32fe creationTime 1404360000000 maxInactiveInterval 1800 lastAccessedTime 1404360000000 sessionAttr:attrName someAttrValue sessionAttr2:attrName someAttrV * EXPIRE spring:session:sessions:33fdd1b6-b496-4b33-9f7d-df96679d32fe 2100* APPEND spring:session:sessions:expires:33fdd1b6-b496-4b33-9f7d-df96679d32fe ""* EXPIRE spring:session:sessions:expires:33fdd1b6-b496-4b33-9f7d-df96679d32fe 1800* SADD spring:session:expirations:1439245080000 expires:33fdd1b6-b496-4b33-9f7d-df96679d32fe* EXPIRE spring:session:expirations1439245080000 2100* </pre>RedisSession的数据结构是Hash* <p>* Each session is stored in Redis as a* <a href="http://redis.io/topics/data-types#hashes">Hash</a>. Each session is set and* updated using the <a href="http://redis.io/commands/hmset">HMSET command</a>. An* example of how each session is stored can be seen below.* </p>RedisSession的失效* <h3>Expiration</h3>** <p>* An expiration is associated to each session using the* <a href="http://redis.io/commands/expire">EXPIRE command</a> based upon the* {@link org.springframework.session.data.redis.RedisOperationsSessionRepository.RedisSession#getMaxInactiveInterval()} * . For example:* </p>RedisSession的更新有⼀个⽐较重要的⽅法:/*** Saves any attributes that have been changed and updates the expiration of this* session.*/private void saveDelta() {String sessionId = getId();saveChangeSessionId(sessionId);if (this.delta.isEmpty()) {return;}getSessionBoundHashOperations(sessionId).putAll(this.delta);String principalSessionKey = getSessionAttrNameKey(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME);String securityPrincipalSessionKey = getSessionAttrNameKey(SPRING_SECURITY_CONTEXT);if (this.delta.containsKey(principalSessionKey)|| this.delta.containsKey(securityPrincipalSessionKey)) {if (this.originalPrincipalName != null) {String originalPrincipalRedisKey = getPrincipalKey(this.originalPrincipalName);RedisOperationsSessionRepository.this.sessionRedisOperations.boundSetOps(originalPrincipalRedisKey).remove(sessionId);}String principal = PRINCIPAL_NAME_RESOLVER.resolvePrincipal(this);this.originalPrincipalName = principal;if (principal != null) {String principalRedisKey = getPrincipalKey(principal);RedisOperationsSessionRepository.this.sessionRedisOperations.boundSetOps(principalRedisKey).add(sessionId);}}this.delta = new HashMap<>(this.delta.size());Long originalExpiration = (this.originalLastAccessTime != null)this.originalLastAccessTime.plus(getMaxInactiveInterval()).toEpochMilli(): null;RedisOperationsSessionRepository.this.expirationPolicy.onExpirationUpdated(originalExpiration, this);}⼩结:1.session是键值对形式的,对应redis的数据结构hash2.session的存储形式使⽤redis⾮常⽅便。
nginx-redis-tomcat7集群session共享
nginx-redis-tomcat7集群session共享一: 安装介质准备:(1)tomcat7(2)Nginx 及相关组件:(3)Redis 相关组件及jar包(根据个人习惯,在linux的根目录下建了一个tmp文件夹,所需介质全部放到该文件夹下)先确保linux系统上已安装有gcc及相关编译组件。
二: 安装redis1):进入到tmp目录下,解压redis的相关文件进行安装,# tar zxvf redis-2.8.23.tar.gz# cd redis-2.8.23#make# make install安装完成后在redis 的src 目录下有redis-benchmark、redis-check-aof、redis-check-dump redis-cli、redis-server 等几个可执行文件,其中redis-server 是redis server 的启动服务,redis-cli 可进入redis 客户端;此外,在解压后的文件夹中还有redis的配置文件redis.conf 。
可以在usr下建一个redis 目录,将上述可执行文件拷贝到该文件夹下。
2):测试redis是否安装成功a-启动redis 服务#./redis-server ,启动成功后看到如下界面Redis 的默认端口是6379 ,b-启动redis client 端进行测试#./redis-cli 启动redis 的客户端服务,出现如下界面,我们可以利用redis设置一个简单缓存进行测试:c-上述现象都正常说明redis安装没有问题,上述方式启动时使用的是默认配置,我们可以修改redis的配置文件,按照我们的要求进行修改;这里从别的地方截个图供参考:上述只是配置的一部分,可根据自己的要求进行配置修改。
修改完成后让redis使用我们修改的配置文件#./redis-server redis.conf (根据自定义文件启动加载配置)三: 安装Nginx1)先安装nignx 运行时依赖的zlib 及pcre进入temp目录下,解压zlib 和pcre 并进行配置安装(1)安装zlib# tar zxvf zlib-1.2.8.tar.gz# cd zlib-1.2.8# ./configure --prefix=/usr/local/zlib (可以不配置目录,安装到默认目录下) #make && make install(2)安装pcre# tar zxvf pcre-8.32.tar.gz# cd pcre-8.32# ./configure --prefix=/usr/local/pcre (可以不配置目录,安装到默认目录下) #make && make install2)安装Nginx# tar zxvf nginx1.4.0.tar.gz# cd nginx1.4.0# mkdir /usr/nginx (在usr目录下创建nginx的安装目录)# ./configure --prefix=/usr/nginx#make && make install3)配置Nginx#cd /usr/nginx/conf#vi nginx.conf配置参考如下:(可实现session共享和负载的基本配置)#user nobody;worker_processes 1;#error_log logs/error.log;#error_log logs/error.log notice;#error_log logs/error.log info;#pid logs/nginx.pid;events {worker_connections 1024;}http {include mime.types;default_type application/octet-stream;#log_format main '$remote_addr - $remote_user[$time_local] "$request" ' # '$status $body_bytes_sent "$http_referer" '# '"$http_user_agent" "$http_x_forwarded_for"';#access_log logs/access.log main;sendfile on;#tcp_nopush on;#keepalive_timeout 0;keepalive_timeout 65;gzip on;#配置负载的三个tomcat服务器upstream {# 这里还可以根据服务器压力配置权重,(注意tomcat访问端口)server 127.0.0.1:8088;server 127.0.0.1:8087;}#server {listen 9999; #nginx监听端口server_name ; #nginx服务所在主机charset utf-8;#access_log logs/host.access.log main;#location / {root html;index index.html index.htm;proxy_pass ; #代理三个tomcat服务器集群地址proxy_set_header X-Real-IP $remote_addr;client_max_body_size 100m;}#error_page 404 /404.html;# redirect server error pages to the static page /50x.html#error_page 500 502 503 504 /50x.html;location = /50x.html {root html;}# proxy the PHP scripts to Apache listening on 127.0.0.1:80 ##location ~ \.php$ {# proxy_pass http://127.0.0.1;#}# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000##location ~ \.php$ {# root html;# fastcgi_pass 127.0.0.1:9000;# fastcgi_index index.php;# fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;# include fastcgi_params;#}# deny access to .htaccess files, if Apache's document root # concurs with nginx's one##location ~ /\.ht {# deny all;#}}# another virtual host using mix of IP-, name-, and port-based configuration ##server {# listen 8000;# listen somename:8080;# server_name somename alias another.alias;# location / {# root html;# index index.html index.htm;# }#}# HTTPS server##server {# listen 443;# server_name localhost;# ssl on;# ssl_certificate cert.pem;# ssl_certificate_key cert.key;# ssl_session_timeout 5m;# ssl_protocols SSLv2 SSLv3 TLSv1;# ssl_ciphers HIGH:!aNULL:!MD5;# ssl_prefer_server_ciphers on;# location / {# root html;# index index.html index.htm;# }#}}四: 安装tomcat在usr 目录下准备两个tomcat,分别为redis-tomcat701,redis-tomcat702,并将test.jsp页面部署到webapp下。
redis集群 session共享原理
redis集群session共享原理摘要:1.Redis 集群概述2.Redis 集群中实现session 共享的原理3.Redis 集群中实现session 共享的具体方法4.Redis 集群中session 共享的优势和应用场景5.总结正文:一、Redis 集群概述Redis 是一个高性能的内存数据库,其支持多种数据结构,如字符串、哈希表、列表、集合和有序集合等。
Redis 集群是指将多个Redis 实例通过网络连接组成一个整体,共同提供服务,具备高可用性、高并发和数据持久化等特点。
在Redis 集群中,可以实现session 共享,使得多个应用实例之间能够共享同一个用户的登录状态。
二、Redis 集群中实现session 共享的原理Redis 集群中实现session 共享的原理是通过将session 数据存储在Redis 中,多个应用实例可以通过Redis 协议获取和操作session 数据。
当一个用户在应用A 中登录时,应用A 会将用户的登录信息(如用户ID、密码等)和一个唯一的session ID 存储在Redis 中。
当用户在应用B 中登录时,应用B 会检查Redis 中是否存在该用户的session ID,如果存在,则获取该用户的session 数据,否则创建一个新的session。
通过这种方式,可以实现session 在多个应用实例之间的共享。
三、Redis 集群中实现session 共享的具体方法1.使用Redis 协议:Redis 提供了多种协议,如TCP、UDP 和Redsion 等,可以通过这些协议将session 数据存储在Redis 中,并供多个应用实例访问。
2.使用Redis 集群:Redis 集群可以将多个Redis 实例组成一个整体,提供高可用性和高并发能力。
在Redis 集群中,可以使用集群内部的节点来存储和访问session 数据。
3.使用Java Redis 客户端库:在Java 应用中,可以使用Redis 客户端库(如Jedis 或Lettuce 等)来连接Redis 集群,实现对session 数据的存储和访问。
redis共享session原理
redis共享session原理随着互联网的快速发展,网站的用户量也越来越大,如何高效地管理用户的登录状态成为了一个重要的问题。
传统的方式是将用户的登录状态保存在服务器的内存中,但是随着用户量的增加,服务器的内存压力也会越来越大。
为了解决这个问题,一种新的技术被广泛应用于网站的开发中,那就是Redis共享session。
Redis是一个开源的内存数据库,它以键值对的形式存储数据,并且支持多种数据结构。
在Redis中,我们可以将用户的登录状态保存在内存中,这样可以大大提高网站的性能和并发能力。
Redis共享session的原理如下:首先,当用户登录成功后,服务器会生成一个唯一的session ID,并将该ID保存在Redis中。
同时,服务器会将该session ID发送给客户端,客户端将该session ID保存在Cookie中。
当用户再次访问网站时,客户端会将Cookie中的session ID发送给服务器。
服务器接收到session ID后,会去Redis中查找对应的session 信息。
如果找到了对应的session信息,说明用户已经登录过,服务器会根据session信息判断用户的身份,并返回相应的页面给客户端。
如果没有找到对应的session信息,说明用户没有登录或者session 已经过期,服务器会要求用户重新登录。
通过这种方式,我们可以将用户的登录状态保存在Redis中,而不是服务器的内存中。
这样做的好处是,可以减轻服务器的内存压力,提高网站的性能和并发能力。
另外,Redis还提供了一些其他的功能,可以进一步提高网站的性能和可靠性。
例如,我们可以设置session的过期时间,当session过期后,Redis会自动删除该session信息。
这样可以避免session信息过多导致内存溢出的问题。
此外,Redis还支持主从复制和持久化等功能,可以保证数据的安全性和可靠性。
当主服务器宕机时,从服务器可以接管主服务器的工作,确保网站的正常运行。
session共享问题解决方案
php session 共用作業系統:ubuntu 12.04web1 : IP:10.0.0.24web2: IP: 10.0.0.4web3: IP: 10.0.0.25web1 安裝1.安裝memcached(apache2和php5 安裝就不多說了 )apt-get install memcached php5-memcache將etc/memcached.conf中的127.0.0.1 改成伺服器地址我這裏是10.0.0.24.可以給memcache 單建一個用戶去跑服務,默認是nobody,我就不去建了。
將/etc/php5/apache2/conf.d/memcache.ini 裏的extension=memcache.so 前注釋去掉。
然後重啟動apache2 查看phpinfo 中的"Registered save handlers" 會有"files user memcache" 這3個可用。
2。
然後修改/etc/php5/apache2/php.inisession.save_handler = memcachesession.save_path = "tcp://10.0.0.24:11211"使用多個memcached server 時用逗號","隔開也可以在.htaccess :php_value session.save_handler "memcache"php_value session.save_path "tcp://10.0.0.24:11211"再或者在某個一個應用中:ini_set("session.save_handler", "memcache");ini_set("session.save_path", "tcp://10.0.0.24:11211");3.啟動memcached/etc/init.d/memcached start4. 在程式中使用 memcache 來作 session 存儲,用例子測試一下:<?phpsession_start();if (!isset($_SESSION['TEST'])) {$_SESSION['TEST'] = time();}$_SESSION['TEST3'] = time();print $_SESSION['TEST'];print "<br><br>";print $_SESSION['TEST3'];print "<br><br>";print session_id();?>用 sessionid 去 memcached 裏查詢一下:<?php$memcache = memcache_connect('10.0.0.24', 11211);var_dump($memcache->get('27f535433865c7e250d2d1062322edfd')); ?>會有看到string(37) "TEST|i:1219222593;TEST3|i:1219222611;"這樣的輸出,證明session正常工作了。
redis共享session实现方式
redis共享session实现方式Redis共享session实现方式在分布式系统中,会话管理是一项关键任务,因为它涉及到用户认证、用户状态管理以及跨服务器的会话共享等问题。
为了解决这些问题,开发人员通常会使用Redis作为会话存储。
Redis是一种内存数据库,具有高性能和可扩展性,非常适合用作会话存储。
本文将详细介绍Redis共享session的实现方式,涵盖以下主题:1. 什么是共享session2. Redis的特性和优势3. 单实例Redis共享session方案4. 基于Redis集群的共享session方案5. 高可用性和容错性的考虑6. 总结和展望1. 什么是共享sessionSession是一种服务器端的会话管理机制。
当用户访问一个应用程序时,服务器会为用户创建一个会话,并在后续的请求中通过Cookie或URL重写方式将会话ID传递给客户端。
客户端在发送请求时带上会话ID,服务器通过会话ID来获取和管理用户的会话数据。
在分布式系统中,共享session是指多台服务器之间共享同一个会话数据。
当用户在一个服务器上登录后,其他服务器也能够识别并保持该用户的登录状态。
2. Redis的特性和优势Redis是一种开源的内存数据库,具有以下特性和优势:- 高性能:Redis完全基于内存操作,速度非常快。
- 持久性:Redis支持将内存中的数据周期性地写入磁盘,以实现数据持久化。
- 多数据结构支持:Redis支持多种数据结构,包括字符串、哈希、列表、集合和有序集合等。
- 高可用性:Redis支持主从复制和哨兵模式,以实现高可用性和故障恢复。
- 分布式集群:Redis Cluster是一种分布式的数据存储解决方案,支持数据的自动分片和故障转移。
- 发布/订阅模式:Redis支持发布和订阅模式,用于实现消息的发布和订阅。
3. 单实例Redis共享session方案单实例Redis共享session是最简单的实现方式,适用于小型网站或系统。
redis session共享原理
redis session共享原理随着Web应用的不断发展,Session的使用越来越广泛,而Session的共享也成为了一个必须解决的问题。
Redis是一个高性能的内存数据库,具有快速读写能力和数据持久化的特点,因此被广泛应用于Session的共享。
1. Session的概念Session是Web应用中的一个重要概念,指的是服务器与客户端之间建立的一种会话机制。
在HTTP协议的无状态性下,Session提供了一种记录和存储用户信息的手段,让Web应用能够跟踪用户的状态和行为。
Session通常存储在服务器端的内存中,包含了用户的登录态、购物车信息、浏览记录等。
2. Session的问题Session的使用虽然方便,但也存在一些问题。
首先,Session的存储通常是在服务器端的内存中,如果服务器重启或者负载均衡导致用户请求被分配到其他服务器上,原本存储在内存中的Session信息将会丢失,用户需要重新登录。
其次,Session的存储是有限的,如果Session中存储的数据量过大,会导致服务器内存占用过高,影响服务器的性能。
因此,Session的共享成为了一个必须解决的问题。
3. Redis的优势Redis作为一个高性能的内存数据库,具有以下优势:(1)快速读写能力。
Redis采用了基于内存的数据存储方式,因此读写速度非常快,可以满足高并发的需求。
(2)数据持久化。
Redis支持将数据持久化到磁盘中,即使服务器重启也不会丢失数据。
(3)支持集群。
Redis支持分布式部署,可以通过搭建Redis集群来提高性能和可用性。
4. Redis Session的共享原理Redis Session的共享原理是将Session数据存储在Redis中,通过Session ID来标识不同的Session。
当用户访问Web应用时,服务器会从Redis中获取用户的Session数据,如果没有获取到,则说明用户还没有登录或者Session已经过期,需要重新登录。
使用Tomcat基于redis的session共享机制集群部署
使⽤Tomcat基于redis的session共享机制集群部署常见的session集群⽅案:session复制和session共享Session复制:指session信息会在集群节点之间复制,每个节点服务上都会有相同的session信息;主要是实现后端多个节点的冗余功能。
但是node之间通信频繁,响应速度有影响,多并发,⾼频发操作的情况下,性能存在严重问题;Session共享:通俗来说就是⼀个浏览器对应多个web服务时,服务端的session数据需要共享【集群环境】因为是在个⼈虚机模拟,资源有限,故tomcat和redis环境复⽤(Ps:软件环境需要的话,可以找到博客左边的联系⽅式)软件环境:jdk1.8.0、redis-5.0.3.tar.gz、apache-tomcat-8.0.50.tar.gz、redisson-tomcat-8-3.12.1.jar、redisson-all-3.12.1.jarNginx代理端:192.168.109.100Tomcat_node1/redis服务: 192.168.109.101Tomcat_node2 :192.168.109.102【集群部署】部署redis环境#tar xvf redis-5.0.3.tar.gz#cd redis-5.0.3#make#cp redis.conf /etc/#cd src#cp redis-cli redis-server redis-sentinel /usr/sbin/打开redis配置⽂件/etc/redis.conf,修改两个配置项的值为如下内容:#vim /etc/redis.confbind 0.0.0.0daemonize yes最后,启动redis服务即可#/usr/sbin/redis-server /etc/redis.conf【部署tomcat环境】⾸先部署jdk环境#mkdir /usr/java#tar zxvf jdk1.8.0_131.tar.gz -C /usr/java/#vim /erc/profileexport JAVA_HOME=/usr/java/jdk1.8.0_131export PATH=$PATH:$JAVA_HOME/binexport CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$CLASSPATH#source /etc/profile#tar zxvf apache-tomcat-8.0.50.tar.gz -C /usr/local/#mv /usr/local/apache-tomcat-8.0.50/ /usr/local/tomcat8⽬前为⽌tomcat部署完毕,接下来整合tomcat与redis实现session共享下载完毕之后将两个jar包解压到/usr/local/tomcat8/lib/⽬录下⾯#mv redis-sson-al-3.12.1.jar redisson-tomcat-8-3.12.1.jar /usr/local/tomcat8/lib#jar redis-sson-al-3.12.1.jar#jar redisson-tomcat-8-3.12.1.jar增加RedissonSessionManager配置# vim /usr/local/tomcat8/conf/context.xml<Manager className="org.redisson.tomcat.RedissonSessionManager"configPath="${catalina.base}/conf/redisson.json" readMode="REDIS" updateMode="DEFAULT"/>#vim /usr/local/tomcat8/conf/redisson.json{"singleServerConfig":{"idleConnectionTimeout":10000,"connectTimeout":10000,"timeout":3000,"retryAttempts":3,"retryInterval":1500,"password":null,"subscriptionsPerConnection":5,"clientName":null,"address": "redis://127.0.0.1:6379", #这⾥的IP地址如果是将redis和tomcat放在⼀起就写127.0.0.1,如果是分离部署的话,就写redis所在的主机IP "subscriptionConnectionMinimumIdleSize":1,"subscriptionConnectionPoolSize":50,"connectionMinimumIdleSize":32,"connectionPoolSize":64,"database":0,"dnsMonitoringInterval":5000},"threads":0,"nettyThreads":0,"codec":{"class":"org.redisson.codec.FstCodec"},"transportMode":"NIO"}最后⼀步就是写⼀个⽤于访问tomcat的测试页⾯#vim /usr/local/tomcat8/webapps/ROOT/testsession.jsp<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%><%String path = request.getContextPath();String basePath = request.getScheme() + "://"+ request.getServerName() + ":" + request.getServerPort()+ path + "/";%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>Welcome to visit tomcat1</title></head><body><center><h1>Welcome to visit tomcat1</h1></center><center><h3>sessionId:</h3><%=session.getId()%><h3>session创建时间:</h3><%=session.getCreationTime()%><center></body></html>重启tomcat服务让配置⽣效即可# /usr/local/tomcat8/bin/startup.sh【测试】在这⾥我们可以看到tomcat测试页⾯可以正常访问,登录redis客户端,我们发现,redis已经⽣成了session信息;配置第⼆个tomcat实例的话,按照上述操作步骤即可,需要注意的是tomcat测试页⾯要保证与109.101不冲突即可另外这⾥的redisson.json配置指定109.101上即可,因为之前将redis部署在了109.101上,此时的109.102不需要在安装redis,直接指定redis的IP即可[root@hostname-109102 lib]# cat /usr/local/tomcat8/conf/redisson.json{"singleServerConfig":{"idleConnectionTimeout":10000,"connectTimeout":10000,"timeout":3000,"retryAttempts":3,"retryInterval":1500,"password":null,"subscriptionsPerConnection":5,"clientName":null,"address": "redis://192.168.109.101:6379","subscriptionConnectionMinimumIdleSize":1,"subscriptionConnectionPoolSize":50,"connectionMinimumIdleSize":32,"connectionPoolSize":64,"database":0,"dnsMonitoringInterval":5000},"threads":0,"nettyThreads":0,"codec":{"class":"org.redisson.codec.FstCodec"},"transportMode":"NIO"}【Nginx】#tar zxvf nginx-1.14.2.tar.gz -C /usr/src/# cd /usr/src/nginx-1.14.2/#./configure \--user=www \--group=www \--prefix=/usr/local/nginx \--sbin-path=/usr/local/nginx/sbin/nginx \--conf-path=/usr/local/nginx/conf/nginx.conf \--error-log-path=/usr/local/nginx/logs/error.log \--http-log-path=/usr/local/nginx/logs/access.log \--pid-path=/var/run/nginx.pid \--lock-path=/var/lock/subsys/nginx \--with-http_stub_status_module \--with-http_ssl_module \--with-http_gzip_static_module \--with-pcre# make# make install# ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/# vim /usr/local/nginx/conf/nginx.confuser www;worker_processes 8;events {worker_connections 65536;}http {include mime.types;default_type application/octet-stream;sendfile on;keepalive_timeout 65;upstream tomcat {server 192.168.109.101:8080 weight=1;server 192.168.109.102:8080 weight=1;}server {listen 80;server_name localhost;location / {proxy_pass http://tomcat;}error_page 500502503504 /50x.html;location = /50x.html {root html;}location ~ \.php$ {root html;fastcgi_pass 127.0.0.1:9000;fastcgi_index index.php;fastcgi_param SCRIPT_FILENAME /usr/local/nginx/html$fastcgi_script_name;include fastcgi_params;}}}nginx -s reload #重启nginxNginx配置完毕之后,通过访问192.168.109.100nginx代理端即可均衡后端两台tomcat,不停的刷新会轮训切换两个tomcat页⾯,但是session值并没有发⽣改变,⽽且都相同。
nginx+php负载均衡集群环境中的session共享方案梳理
nginx+php负载均衡集群环境中的session共享方案梳理在网站使用nginx+php做负载均衡情况下,同一个IP访问同一个页面会被分配到不同的服务器上,如果session不同步的话,就会出现很多问题,比如说最常见的登录状态。
下面罗列几种nginx负载均衡中session同步的方式1)不使用session,换用cookiesession是存放在服务器端的,cookie是存放在客户端的,我们可以把用户访问页面产生的session放到cookie里面,就是以cookie为中转站。
你访问web服务器A,产生了session 然后把它放到cookie里面,当你的请求被分配到B服务器时,服务器B先判断服务器有没有这个session,如果没有,再去看看客户端的cookie里面有没有这个session,如果也没有,说明session真的不存,如果cookie里面有,就把cookie 里面的sessoin同步到服务器B,这样就可以实现session的同步了。
说明:这种方法实现起来简单,方便,也不会加大数据库的负担,但是如果客户端把cookie禁掉了的话,那么session 就无从同步了,这样会给网站带来损失;cookie的安全性不高,虽然它已经加了密,但是还是可以伪造的。
2)session存在数据库(MySQL)中PHP可以配置将session保存在数据库中,这种方法是把存放session的表和其他数据库表放在一起,如果mysql也做了集群的话,每个mysql节点都要有这张表,并且这张session表数据表要实时同步。
但是要注意的是:用数据库来同步session,会加大数据库的IO,增加数据库的负担。
而且数据库读写速度较慢,不利于session的适时同步。
3)session存在memcache或者redis中memcache可以做分布式,php配置文件中设置存储方式为memcache,这样php自己会建立一个session集群,将session数据存储在memcache中。
分布式中使用Redis实现Session共享(一)
分布式中使⽤Redis实现Session共享(⼀) 上⼀篇介绍了如何使⽤部署⼀个简单的分布式系统,⽂章结尾留下了⼏个问题,其中⼀个是"如何解决多站点下Session共享"。
这篇⽂章将会介绍如何使⽤Redis,下⼀篇在此基础上实现Session。
这⾥特别说明⼀下,其实没有必要使⽤Redis来解决Session共享。
提供了StateServer模式来共享Session,这⾥重复造轮⼦的⽬的1:熟悉Redis的基本知识和使⽤ 2.学习和巩固Session的实现原理。
3.学习Redis应⽤场景阅读⽬录Redis安装配置redis是⼀个key-value存储系统。
和Memcached类似,它⽀持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。
这些数据类型都⽀持push/pop、add/remove及取交集并集和差集及更丰富的操作,⽽且这些操作都是原⼦性的。
在此基础上,redis⽀持各种不同⽅式的排序。
与memcached⼀样,为了保证效率,数据都是缓存在内存中。
区别的是redis会周期性的把更新的数据写⼊磁盘或者把修改操作写⼊追加的记录⽂件,并且在此基础上实现了master-slave(主从)同步。
最新版本的redis版本为3.0.3,⽀持集群功能。
我这下载的是window版本的,实际场景都是安装在linux系统下的。
下载地址:。
更多下载地址: 官⽹: MSOpenTech: dmajkic:下载完成之后解压运⾏redis-server.exe就启动了redis了,启动后会在进程⾥⾯看到reids。
1.读写分离配置redis的读写分离需要修改配置⽂件,把解压的⽂件复制了⼀份。
两份⽂件是⼀样的,分别命名为MasterRedis-2.8.19(主redis服务),SlaveRedis-2.8.19(从redis服务)。
SpringBoot+SpringSession+Redis实现session共享及唯一登录示例
SpringBoot+SpringSession+Redis实现session共享及唯⼀登录⽰例最近在学习springboot,session这个点⼀直困扰了我好久,今天把这些天踩的坑分享出来吧,希望能帮助更多的⼈。
⼀、pom.xml配置<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.springframework.session</groupId><artifactId>spring-session-data-redis</artifactId></dependency>⼆、application.properties的redis配置#redisspring.redis.host=127.0.0.1spring.redis.port=6379spring.redis.password=123456spring.redis.pool.max-idle=8spring.redis.pool.min-idle=0spring.redis.pool.max-active=8spring.redis.pool.max-wait=-1#超时⼀定要⼤于0spring.redis.timeout=3000spring.session.store-type=redis在配置redis时需要确保redis安装正确,并且配置notify-keyspace-events Egx,spring.redis.timeout设置为⼤于0,我当时这⾥配置为0时springboot时启不起来。
集群环境(session多服务器共享的方案梳理)
集群环境(session多服务器共享的⽅案梳理)⽬前业界解决session共享的⼏种思路,我总结如下:第⼀种办法:把原来存储在服务器磁盘上的session数据存储到客户端的cookie中去。
这样⼦,就不需要涉及到数据共享了。
a客户端请求的时候,原来⽣成在服务器的数据⽣成到浏览器的cookie中,根据cookie中的数据识别⽤户。
php由原来的”从本地(也就是服务器)磁盘上读取session数据”转变为”浏览器的cookie中读取数据”,这样⼦,在多台php服务器负载均衡的情况下,即便第⼀秒请求是a服务器,第⼆秒请求是b服务器,都不需要管哪台服务器了。
反正都是读取客户端上的cookie数据。
⼀般是把session数据按照⾃⼰定义的加密规则,加密后后存在cookie中。
数据保存在cookie中这种做法有好处,也有坏处。
好处是服务器的压⼒减⼩了,因为session数据不存在服务器磁盘上。
根本就不会出现session读取不到的问题。
带来的弊端是:⽹络请求占⽤很多。
每次请求时,客户端都要通过cookie发送session数据给服务器。
另外,浏览器对cookie的⼤⼩存在限制。
每个浏览器限制是不同的。
Firefox和Safari允许cookie多达4097个字节,包括名(name)、值(value)和等号。
Opera允许cookie多达4096个字节,包括:名(name)、值(value)和等号。
Internet Explorer允许cookie多达4095个字节,包括:名(name)、值(value)和等号。
所以第⼀种⽅案不适合⾼访问量的情况下,因为⾼访问量的情况下,每次请求浏览器都要发送session数据给服务器。
⼀般⼀个cookie⼤⼩2k的样⼦。
要占⽤很多带宽了(服务器购买带宽是⼀个很⼤费⽤),成本增⾼。
归纳为带宽性能,速度问题。
存储到cookie中去,第⼆⽅⾯是安全问题:把session数据放到客户端,⼀般session中存的都是重要性数据(帐号、昵称、⽤户id等),会存在安全问题。
Java集群环境之间如何共享SESSION
Java集群环境之间如何共享SESSION问题:Java集群环境之间如何共享SESSION 回答:随着互联网的日益壮大,网站的pv和uv成线性或者指数倍的增加.单服务器单数据库早已经不能满足实际需求.比如像盛大,淘宝这样的大型网络公司,更是如此.集群,也就是让一组计算机服务器协同工作,达解决大并发,大数据量瓶颈问题.但是在群集中,session往往是一个比饺头疼的问题.一般情况下,session不可跨服务器而存在.下面给出几种session共享的解决方案.第一种,客户端解决方法.把session加密后存在cookie中,每次session信息被写在客服端,然后经浏览器再次提交到服务器.即使两次请求在集群中的两台服务器上完成,也可以到达session共享.这种解决方法的优点是session信息不用存放在服务器端,大大减轻了服务器的压力.另一个优点是一个session中的两次或多次请求可以在一个群集中的多个服务器上完成,可以避免单端故障.目前,淘宝是采用的这种解决方案.基于Cookie的Session共享这个方案我们可能比较陌生,但它在大型网站中还是比较普遍被使用。
原理是将全站用户的Session信息加密、序列化后以Cookie 的方式,统一种植在根域名下(如:),利用浏览器访问该根域名下的所有二级域名站点时,会传递与之域名对应的所有Cookie内容的特性,从而实现用户的Cookie化Session 在多服务间的共享访问。
这个方案的优点无需额外的服务器资源;缺点是由于受http协议头信心长度的限制,仅能够存储小部分的用户信息,同时Cookie 化的Session内容需要进行安全加解密(如:采用DES、RSA等进行明文加解密;再由MD5、SHA-1等算法进行防伪认证),另外它也会占用一定的带宽资源,因为浏览器会在请求当前域名下任何资源时将本地Cookie附加在http头中传递到服务器。
第二种,提供一个群集保存session共享信息.其他应用统统把自己的session信息存放到session群集服务器组.当应用系统需要session信息的时候直接到session群集服务器上读取.这种方式具有第一种方式的第二个优点.第三种,配置负载均衡服务器,让用户的一个session在一个服务器完成.定时的备份session信息到salve上面.一台服务器down 掉后,通过均衡服务器透明把用户的请求转发到群集中的其他服务器上,此时需要从salve上读取备份的session信息.开发人员可以根据自己的实际情况选择适合自己的session共享方式.。
session共享方案
Session共享方案本文将介绍什么是Session以及Session共享方案。
首先,我们将了解Session 的基本概念,然后探讨为什么需要共享Session以及Session共享的常见方法。
最后,我们将重点介绍一种常用的Session共享方案。
1. 什么是Session?在Web开发中,Session是一种用来存储用户会话数据的机制。
用户通过与Web服务器建立连接后,服务器会为该用户创建一个Session对象来保存用户的会话状态。
Session对象包含了用户的身份信息、浏览历史和其他需要跨请求共享的数据。
Session是无状态的,也就是说,服务器无法直接知道用户的上下文信息。
为了解决这个问题,服务器会为每个用户创建一个唯一的Session ID,并将该ID存储在Cookie中发送给用户的浏览器。
浏览器在后续的请求中会通过Cookie将Session ID发送给服务器,服务器借此找回对应的Session对象。
2. 为什么需要共享Session?在某些情况下,我们可能需要在多个服务器之间共享Session。
下面是一些常见的场景:•负载均衡:当网站流量较大时,可能需要通过负载均衡将请求分配到不同的服务器上。
如果每个服务器都有自己的Session存储,那么用户在不同的服务器上将无法访问其Session数据,导致用户体验不佳。
•高可用性:当服务器发生故障时,可能需要将请求重新路由到其他可用的服务器上。
如果服务器之间无法共享Session,用户可能需要重新登录或丢失其会话状态。
•跨服务访问:有时候我们需要通过多个服务协同工作,这些服务可能位于不同的服务器上。
为了在这些服务之间共享Session,我们需要一种Session共享方案。
3. Session共享的常见方法下面将介绍几种常见的Session共享方法:3.1. Session复制Session复制是一种最简单的Session共享方案。
在这种方案中,所有的Session数据都会在每个服务器上复制一份。
springboot(9)redis(连接,增删改查,集群,和session一起使用)
springboot(9)redis(连接,增删改查,集群,和session⼀起使⽤)1.建⽴连接1.1 pom.xml<!-- redis 相关⽀持 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-redis</artifactId><version>1.3.2.RELEASE</version></dependency>1.2 application.properties#Servlet端⼝号server.port=8088# REDIS (RedisProperties)# Redis数据库索引(默认为0)spring.redis.database=0# Redis服务器地址spring.redis.host=192.168.88.134# Redis服务器连接端⼝spring.redis.port=6379# Redis服务器连接密码(默认为空)spring.redis.password=123456# 连接池最⼤连接数(使⽤负值表⽰没有限制)spring.redis.pool.max-active=8# 连接池最⼤阻塞等待时间(使⽤负值表⽰没有限制)spring.redis.pool.max-wait=-1# 连接池中的最⼤空闲连接spring.redis.pool.max-idle=8# 连接池中的最⼩空闲连接spring.redis.pool.min-idle=0# 连接超时时间(毫秒)spring.redis.timeout=01.3 StringRedisTemplateTest.javapackage com.guilf.servlet;import org.junit.Test;import org.junit.runner.RunWith;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.data.redis.core.StringRedisTemplate;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/*** Created by hong on 2017/5/2.*/@RunWith(SpringJUnit4ClassRunner.class)@SpringBootTestpublic class StringRedisTemplateTest {private final Logger logger = LoggerFactory.getLogger(this.getClass());@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Testpublic void test(){stringRedisTemplate.opsForValue().set("aaa","aaa111");(stringRedisTemplate.opsForValue().get("aaa"));}} 1.4 运⾏测试2,对增删改查 redis的操作package com.hong.service.impl;import com.hong.domain.City;import com.hong.mapper.CityMapper;import com.hong.service.CityService;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.core.ValueOperations;import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;/****/@Servicepublic class CityServiceImpl implements CityService {private final Logger logger = LoggerFactory.getLogger(this.getClass());@Autowiredprivate CityMapper cityMapper;@Autowiredprivate RedisTemplate redisTemplate;private final String KEY_PREFIX = "city_";/*** 获取城市逻辑:* 如果缓存存在,从缓存中获取城市信息* 如果缓存不存在,从 DB 中获取城市信息,然后插⼊缓存*/@Overridepublic City findOneCity(Integer id) {ValueOperations<String, City> valueOperations = redisTemplate.opsForValue();//缓存存在String key = KEY_PREFIX + id;boolean hasKey = redisTemplate.hasKey(key);if (hasKey) {City city = valueOperations.get(key);("CityServiceImpl.findOneCity() : 从缓存中获取了城市 >> " + city.toString()); return city;}//从mysql 数据库中获取数据City city = cityMapper.selectByPrimaryKey(id);//存⼊缓存中.valueOperations.set(key, city, 10, TimeUnit.SECONDS);("CityServiceImpl.findOneCity() : 城市加⼊了缓存 >> " + city.toString());return city;}@Overridepublic int saveCity(City city) {return cityMapper.insert(city);}@Overridepublic int modifyCity(City city) {//更新DB中的数据int count = cityMapper.updateByPrimaryKey(city);//如果缓存中存在,移除。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
集群情况下Session共享解决方案redis
1、集群情况下session会产生什么原因?
由于session存放在服务器端,集群下用户可能访问不同的服务器,则可能session无法共享。
2、Session共享解决方案
1)NGINX做的负载均衡可以绑定ip_hash,从而使同一个IP访问同一个服务器------------------该方案使得集群失去意义。
2)利用数据库同步session----------------------太过复杂
3)利用cookie同步session(保存一个session到本地,再次访问将其带到服务器端)----------------------安全性差、http请求都需要带参数增加了带宽消耗
4)使用session集群,存放到redis中(spring-session)
3、spring-session项目,解决session共享问题
<!--spring boot 与redis应用基本环境配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
<!--spring session 与redis应用基本环境配置,需要开启redis后才可以使用,不然启动Spring boot会报错 --> <dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
创建SessionConfig
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import
org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession; //这个类用配置redis服务器的连接
//maxInactiveIntervalInSeconds为SpringSession的过期时间(单位:秒)
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800)
Public class SessionConfig {
//冒号后的值为没有配置文件时,制动装载的默认值
@Value("${redis.hostname:localhost}")
String HostName;
@Value("${redis.port:6379}")
int Port;
@Bean
Public JedisConnectionFactory connectionFactory() {
JedisConnectionFactory connection = new JedisConnectionFactory();
connection.setPort(Port);
connection.setHostName(HostName);
return connection;
}
}
初始化Session:
//初始化Session配置
Public class SessionInitializer extends AbstractHttpSessionApplicationInitializer{ Public SessionInitializer() {
super(SessionConfig.class);
}
}
控制层代码
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SessionController {
@Value("${server.port}")
private String PORT;
@RequestMapping("/index")
public String index() {
return "index:" + PORT;
}
/** * @methodDesc: 功能描述:(往session存放值)
*/ @RequestMapping("/setSession")
public String setSession(HttpServletRequest request, String sessionKey, String sessionValue) {
HttpSession session = request.getSession(true);
session.setAttribute(sessionKey, sessionValue);
return "success,port:" + PORT;
}
/** * @methodDesc: 功能描述:(从Session获取值)
*/ @RequestMapping("/getSession")
public String getSession(HttpServletRequest request, String sessionKey) { HttpSession session =null;
try {
session = request.getSession(false);
} catch (Exception e) {
e.printStackTrace();
}
String value=null;
if(session!=null){
value = (String) session.getAttribute(sessionKey);
}
return "sessionValue:" + value + ",port:" + PORT;
}
}
六、高并发解决方案
业务数据库-》数据水平分割(分区分表分库)、读写分离
业务应用-》逻辑代码优化(算法优化)、公共数据缓存
应用服务器-》反向静态代理、配置优化、负载均衡(apache分发,多tomcat实例) 系统环境-》JVM调优
页面优化-》减少页面连接数、页面尺寸瘦身
动态资源和静态资源分离
CDN加速
服务分布式部署。