spring+spring-session+redis+Jedis实现session跨平台共享

        网上有很多关于spring集成redis解决session共享的博文，但是对于我这种初学者来说，没有一篇是完整的，为此，我爬了很长时间的坑，在此记录下来，方便后来者少爬坑。
         spring要集成redis，除了添加相应的jar包外，自己的服务也要安装redis这个软件，对于不了解redis的同学来说，这里容易踩坑，对于使用windows的同学来说，就不要去官网上找了，其他地方有（Redis-x64-3.2.100.msi百度下，可以下载）。
        Redis-x64-3.2.100.msi安装，安装过程中，所有选项全选。安装完成后，找到安装目录，将redis.windows-service.conf文件里requirepass 前面的#号去掉，后面改成自己的密码，例如requirepass 123456。然后去服务里面看看是否正常启动。（其他系统安装redis网上有很多资料）



       然后打开cmd，将目录切换到安装目录



       启动redis客户端，看看密码是否设置成功。


       初次设置值失败，要输入密码



       添加和查看都可以了，说明我们的redis已经配置成功了。（也可以使用第三方软件查看redis里面的值，比如RedisDesktopManager）
接下来配置spring，可以注解，也可以配置，我的是配置
web.xml

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<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>
</filter-mapping>

applicationContext.xml(引入redis.properties不会的自己百度)

<!-- redis config start -->
       <context:property-placeholder location="classpath:config/redis.properties" />
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}" />
<property name="port" value="${redis.port}" />
<property name="password" value="${redis.pass}" />
<property name="timeout" value="${redis.timeout}" />
<property name="poolConfig" ref="jedisPoolConfig" />
<property name="usePool" value="true" />
</bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<property name="keySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer"></bean>
</property>
<property name="valueSerializer">
<bean
class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"></bean>
</property>

<property name="hashKeySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer"></bean>
</property>
<property name="hashValueSerializer">
<bean
class="org.springframework.data.redis.serializer.JacksonJsonRedisSerializer">
<constructor-arg type="java.lang.Class" value="java.lang.Object"></constructor-arg>
</bean>
</property>
</bean>
<!-- 将session放入redis -->
<bean id="redisHttpSessionConfiguration"
class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
<property name="maxInactiveIntervalInSeconds" value="${redis.maxIIISeconds}" />
</bean>

<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1">
<list>
<bean name="slaver" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis.host}" />
<constructor-arg index="1" value="${redis.port}"
type="int" />
</bean>
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis.host}" />
<constructor-arg index="1" value="${redis.port}"
type="int" />
</bean>
</list>
</constructor-arg>
</bean>

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${redis.maxTotal}" />
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
<property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}" />
<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
<property name="testWhileIdle" value="${redis.testWhileIdle}" />
<property name="testOnReturn" value="${redis.testOnReturn}" />
<property name="jmxEnabled" value="${redis.jmxEnabled}" />
<property name="jmxNamePrefix" value="${redis.jmxNamePrefix}" />
<property name="blockWhenExhausted" value="${redis.blockWhenExhausted}" />
</bean>
<!-- redis config end -->

redis.properties 参数根据情况自行调整(spring mvc 对引入多个properties文件，有些版本可能有限制，可以添加到项目已有的properties文件里面，别踩这个坑)

redis.database=0
redis.host=127.0.0.1
redis.port=6379
redis.pass=123456
redis.timeout=2000
redis.maxIIISeconds=1800
redis.maxTotal=2048
redis.maxActive=600
redis.maxWait=-1
redis.maxIdle=300
redis.minIdle=0
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.minEvictableIdleTimeMillis=-1
redis.softMinEvictableIdleTimeMillis=10000
redis.maxWaitMillis=1500
redis.testOnBorrow=true
redis.testWhileIdle=true
redis.testOnReturn=false
redis.jmxEnabled=true
redis.jmxNamePrefix=X
redis.blockWhenExhausted=false

       所需jar包：spring-data-redis-1.5.2.RELEASE.jar、jedis-2.4.2.jar（这两个包一定要版本相对应，不然会报错）、commons-pool2-2.4.2.jar、jackson-all-1.9.9.jar、spring-session-1.3.1.RELEASE.jar其他jar包就不列出来了。(使用maven配置依赖也是一会事情)
       这样就算是全配置完成了，所有session的内容全部存入到了redis里面了。如果要存入对象，该类必须可以序列化，也就是说要implements java.io.Serializable实现序列化（Serializable接口是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。redis里面不是能直接存入对象的）。
       接下来是怎么样实现共享session，其实很简单（我使用的是tomcat 7，其他容器没有测试）

       原理就是第一次请求服务时，服务器将session id发送到客户端保存，后面客户端每次请求都通过Cookie送回服务器验证，按照规定格式传回spring是可以自己处理的，也就是实现了共享。

       在任意请求页面添加

Cookie[] cookies = request.getCookies();
if(cookies!=null){
for(int i=0;i<cookies.length;i++){
Cookie cookie = cookies[i];
System.out.println("sessionName:"+cookie.getName());
System.out.println("sessionValue:"+cookie.getValue());
}
}else{
System.out.println("cookie null.");
}

       运行一下，就可以知道，在Cookie里面 session id是如何标识的，输出结果：
       sessionName:SESSION
       sessionValue:491266b1-0f4a-47e1-bc01-9710e14560b6

       这就很清楚了，我们只需要在每次请求的Cookie里添加 SESSION，服务器接收后就不会生成新的session id，就会认为是之前的会话，从而实现了session共享。如果脱离上述配置直接在Cookie里添加 SESSION，是不能实现session共享的。

       例如，微信小程序里面，第一次请求服务器时，将服务器发送过来的session id保存到缓存里面

var session_id = wx.getStorageSync('WX_SESSION');//本地取存储的sessionID
//第1次
var header = { 'content-type': 'application/json', 'Cookie': 'SESSION=""' };
if (session_id != "" && session_id != null) {//第2+次
header = { 'content-type': 'application/json', 'Cookie': 'SESSION =' + session_id}
}
wx.request({
url: 'https://localhost/wx/beforeLogin',
//method: 'POST',
header: header,
data: {
code: res.code
},
success: function (res) {
wx.setStorageSync("WX_SESSION", res.data.session_id)//存储的sessionID
console.log(res.data.session_id)

}})

      后面每次请求时，在header里将之前存的session id以“SESSION”为键值添加到Cookie中，很关键，这样就可以了共享session了