Spring-Session 知识点和源码分析（上）

最新推荐文章于 2023-06-28 16:49:46 发布

杨宗健

最新推荐文章于 2023-06-28 16:49:46 发布

阅读量342

点赞数

分类专栏： java框架

本文链接：https://blog.csdn.net/ameir_yang/article/details/86714510

版权

java框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、什么是 session ？每一个用户只拥有一个 session 。

（1）Session 的作用就是让我们的服务器记住是哪个用户，也就是浏览器访问过我。当我发起一个会话，我们的服务器端就会为我们产生 session，每一个session对应一个sessionID，然后将这个sessionID存放在cookie中然后将cookie存放在我们的浏览器中，然后我们在不关闭浏览器的条件下，每次发送请求的时候，会默认的无条件的将我们的对应这个服务器的 cookie 重新发送给我们的服务器，这样我们的服务器就重新难道了存放在cookie中的sessionID，从而就找到了对应的session，这样就实现了服务器记住我们用户。我们在很多情况都会使用过 cookie 来跟踪我们的 session，用cookie来存放 sessionID实现跟踪。

每一个用户（浏览器）都对应一个唯一的独有的 sessionID，通过这个sessionID可以找到唯一对应的 session，我们浏览器的cookie中保存着第一次会话由服务器传递过来的sessionID。

【URL重写技术解决我们的session追踪问题】：

如果我们的浏览器禁止了向 cookie 中存放数据，那么我们的服务器就没有办法向我们的 cookie中存放 sessionID，那样我们怎样实现对 session的跟踪？

解答：这里我们使用到了一个【URL重写】技术。

这个技术非常好理解：就是在我们每次发送请求的时候，我们的浏览器会将从服务器哪里接收到的 sessionID 当做一个请求参数挂在请求的最后，如：

Http://localhost:8080/myweb/index.jsp?sessionId=xxxxx 。

这个参数在我们的服务器端会被接收，我们服务器拿到这个参数之后，用来查找判断这个sessionId对应哪个session。

【session 的管理】

（1）session 通常是交给我们的 tomcat容器管理的。因为我们的tomcat是用来处理动态资源的，所以我们得tomcat中的一个容器专门用来存放我们的 session 。

（2）但是我们的实际开发中我们不单单只涉及一个 tomcat服务器了，我们是多个tomcat服务器集群的，而且我们用户和tomcat之间还存在一个nginx，这个nginx是用来做负载均衡的。这时候就出现了一个问题：

我们的 nginx负载均衡如果不做任何的配置，nginx接收到的请求分发到的tomcat可能是不相同的，因为nginx是根据tomcat的压力和一定的规则来进行分发请求的，所以我们用户每次发出的请求处理请求的 tomcat不一定是相同的。

但是我们的每一个tomcat中都部署相同的 web项目，所以我们的用户在每次访问我们的页面的时候虽然是不同的 tomcat进行处理，但是显示的网站是相同的。

因为每次处理请求的tomcat 是不相同的，就会造成一个问题：session的丢失和不能共享的问题：

因为每次由nginx负载均衡的原因分到的tomcat不相同，所以每次都找不到上一次请求会话sessionId对应的session，所以导致这次的tomcat认为这个请求是新的请求，也是新的一次会话，所以产生新的 session，然后返回新的sessionId，然后代替掉浏览器中的cookie中的sessionId，这样就每次用户登录之后发出一个请求然后刷新一下页面就退出了，就变成了登录又退出登录退出这样的情况。这就是tomcat集群部署之后存在的问题。

****我们怎样解决tomcat集群部署和nginx负载均衡产生的 session不共享丢失的问题呢？

【第一种方案】：ip_hash策略：这个策略是我们nginx负载均衡时在nginx.Conf配置文件下配置的请求分配策略。

Ip_hash的原理：一个ip地址绑定一个tomcat服务器。其中涉及一个计算公式：

Hash函数( ip地址 ) % 2 == 取余，余数对应tomcat的编号。

所以只要ip地址不变，对应的 tomcat编号就不变。

但是这种解决 session丢失问题的方法不好：因为这样我们的ip地址就不能变了，如果我们今天从山东用的山东移动，明天去了河北，用的河北移动，这样session就没了，意思是ip地址不能改变的，如果你ip变了，就有可能调到了另一个服务器中去了，左脚在北京右脚进了河北，ip变化了，然后跳转tomcat，然后用户就丢失了session，就退出登录了。

【第二种方案】：Spring Session 框架。

这种技术可以使 session 同步，可以对session进行管理，解决集群部署之后产生的session丢失不同步的问题。

*****它是怎么实现的？

我们的spring session 以中立的身份，取代和代替我们 tomcat中的 httpsession，然后将session中的信息数据存放在 redis 中。

知识点：为什么存放在redis中呢？

我们的redis是将数据存放在内存中的，而且我们可以给数据设置存放的最大生命时间，达到最大生命时间之后就会被自动删除，这一点和我们的session的最大空闲时间是相同相似的。而且我们从内存中读取数据是很快的。

作用步骤：

（1）用自身的 Spring-Session 以中立的方式替换我们的 http-Session。

（2）然后将 session中的数据信息存放进 redis 中。

（3）只需要配置不需要写任何的代码，就可以实现springsesson功能。

开发步骤：使用springsession开发步骤。

1.添加springsession的 maven 依赖。 
1）
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
    <version>1.3.1.RELEASE</version>
</dependency>
这个依赖 是对我们的 spring-data-redis依赖的封装。这是依赖是我们springsession所依赖的jar包 。

2）
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.8.RELEASE</version>
</dependency>
这个依赖 是我们 在 spring框架中 【操作redis】时 所需要的依赖。

3）
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
我们的【spring-data-redis】这个依赖 在操作 redis的时候，底层所依赖的jar包是jedis包，实际上 我们【spring-data-redis】包底层是通过【jedis】包来操作我们的redis的。

4）
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.3.13.RELEASE</version>
</dependency>
我们的spring-session是在web项目中使用，所以涉及到了web项目和spring，所以需要使用【spring-web】这个依赖。

5）我们在开发web项目时，所需要的一些依赖，可加可不加，加了有提示不报错。
<!-- servlet依赖的jar包start -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
</dependency>
<!-- servlet依赖的jar包start -->

<!-- jsp依赖jar包start -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.1</version>
</dependency>
<!-- jsp依赖jar包end -->

<!--jstl标签依赖的jar包start -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!--jstl标签依赖的jar包end -->
分别是【servlet依赖】，【jsp依赖】 和 【jstl依赖】。

2.我们在web.xml文件文件中配置springSessionRespositoryFilter过滤器。
SpringSessionRespositoryFilter：springSession仓库过滤器。
我认为这个过滤器的作用是：将 我们 所有的 httpSession替换成 springsession，然后将我们session中的信息数据存放在redis中。 

applicationContext-session.xml配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- spring注解、bean的处理器 -->
    <!--这个标签 是用来 激活注解 的-->
    <context:annotation-config/>

    <!-- Spring session 的配置类 -->
    <!--RedisHttpSessionConfiguration这个类专门是用来处理 redis 和 httpsession之间的关系的类-->
    <!--
           我们的RedisHttpSessionConfiguration 这个类中 有很多很多的注解，但是 RedisHttpSessionConfiguration里面的这些方法上类上的注解并没有被激活。
           所以我们需要  <context:annotation-config/> 这个标签激活一下 我们 我们的RedisHttpSessionConfiguration类中的注解。
           如果我们不进行 注解激活，那么我们的RedisHttpSessionConfiguration是不能使用的，会报错。
    -->
    <bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration"/>


    <!--配置 redis的连接时  所需要的 信息 的-->


    <!--
    spring 封装了 RedisTemplate 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。
    -->


    <!--
         读取redis.properties属性配置文件
         在我们的 applictionContext-session.xml中引入redis的配置文件，然后就可以使用EL表达式进行赋值了。
    -->
    <context:property-placeholder location="classpath:redis.properties"/>


    <!--下面的配置是为了告诉我们的springsession怎么连接redis的，只需要告诉我们的springsession怎么连接redis,我们都不需要创建RedisTemplate 对象 -->
    <!-- 配置jedis连接工厂，用于连接redis -->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.hostName}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value="${redis.password}"/>
        <property name="usePool" value="${redis.usePool}"/>
        <property name="timeout" value="${redis.timeout}"/>
    </bean>


</beans>

redis.properties ：
redis.hostName=192.168.xxx.xxx
redis.port=6379
redis.password=xxxx
redis.usePool=true
redis.timeout=15000

Web.xml ：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">

    <!--SpringSessionRespositoryFilter 这是一个spring-session框架的全局过滤器-->
    <!--org.springframework.web.filter.DelegatingFilterProxy就是我们的SpringSessionRespositoryFilter的jar包-->
    <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>


    <!--
        （1）因为涉及到了spring，所以我们需要spring配置文件，所以需要使用 contextLoader监听器，来监视我们context创建的时刻。
        （2）在context创建的时刻，就将我们的spring配置文件 读取和加载进我们的内存，然后spring容器中就创建好我们需要的实体对象了。
        （3）使用contextLoaderListener 就是为了加载我们的 spring配置文件 。
    -->

    <!-- needed for ContextLoaderListener -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- Bootstraps the root web application context before servlet initialization -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

</web-app>

我们的session 通过 Spring-session这个框架存放到了我们的redis中。我们session默认最大空闲时间为30minute。

这个类因为有这个注解，所以它有一个定时任务的功能。每个段时间就检查一下我们的session最后一次访问时间，看看我们在最后一次访问之后，有没有过30分钟啊，如果30分钟都没有访问过：

就利用圈1 和圈3 这两个 key配合起来对我们圈1,2,3 这三个key的删除。

我们真正的session存放在我们的圈2里面，我们圈1 和圈3 是配合起来在session失效的时候删除这三个key的。

Redis中存放的资源类型：

动态资源或常量：因为我们的 Redis管理数据是以键值对的方式进行管理的。但是存放的动态资源和常量我们一般都设置最大生命时间，所以说在redis中存放的数据都是不持久的动态资源，虽然可以长久的存放，但是我们人为的设置了最大生命时间了。
利用spring-session框架存放我们的 session对象，并且存放的session对象最大空闲会话时间为30分钟。

********为什么我们的 spring-session 框架可以让我们的 session对象共享？

由上面关系图我们可以看出：

（1） redis是在【所有】的tomcat服务器的后面。

（2） redis中存放了所有的 session对象。

（3）所有的 tomcat 想获取 session 都需要去 redis中获取。

（4）tomcat 从 redis 中获取到 session 的过程不需要我们参与，全权由我们的Spring-session操作完成，spring-session帮我们将session拦截到然后存放进我们的 redis中，然后我们想要获取的时候，spring-session通过浏览器传递过来的cookie中的sessionId来自动从redis中帮我们查找对应sessionId的session。

总结：

之所以我们的session共享了，是因为我们将所有的session存放进了一个公共的空间了，所有的tomcat都可以随便的自动的从这个公共空间获取session了。原来没有配置springsession的时候我们的session是存放在 tomcat中的容器里，这个容器是封闭的，是与其他tomcat没有任何交涉的，所以session不共享。

*********我们判断一个用户是否登陆的依据是什么？

我们的用户登录之后我们的tomcat 就会创建一个session对象，这个session对象是和我们的用户一一对应的，session里面存放着这个用户的所有信息。当我们的用户浏览器发送请求后，请求携带者cookie中的sessionId到达我们的服务器，然后我们的tomcat服务器从redis中获取 sessionId对应的session，如果找到了说明这个用户是登陆状态就显示登陆，如果没有找到对应的session对象，说明该用户没有登录，就显示未登录状态。

Path是cookie的路径不相同，产生两个session：

P2p项目