精华内容
下载资源
问答
  • Spring Session 详解

    2021-03-01 14:24:52
    1.SpringSession简介 1.1 Session 会话管理及带来的问题 HTTP协议本身是无状态,的为了保存会话信息,浏览器Cookie通过SessionID标识会话请求,服务器以SessionID为key来存储会话信息。 在 Web 项目开发中, Session...

    1.SpringSession简介

    1.1 Session 会话管理及带来的问题

    HTTP协议本身是无状态,的为了保存会话信息,浏览器Cookie通过SessionID标识会话请求,服务器以SessionID为key来存储会话信息。 在 Web 项目开发中, Session 会话管理是一个很重要的部分, 用于存储与记录用户的状态或相关的数据。

    • 通常情况下 session 交由容器(tomcat) 来负责存储和管理, 但是如果项目部署在多台tomcat 中, 则 session 管理存在很大的问题
    • 多台 tomcat 之间无法共享 session, 比如用户在 tomcat A 服务器上已经登录了, 但当负载均衡跳转到 tomcat B 时, 由于 tomcat B 服务器并没有用户的登录信息,session 就失效了, 用户就退出了登录
    • 一旦 tomcat 容器关闭或重启也会导致 session 会话失效因此如果项目部署在多台 tomcat 中, 就需要解决 session 共享的问题

    1.2 SpringSession的特性

    使用框架的会话管理工具,也就是我们要介绍的 Spring session,这个方案既不依赖 tomcat 容器, 又不需要改动代码, 由 Spring session 框架为我们提供, 可以说是目前非常完美的 session 共享解决方案。Spring Session 是 Spring 家族中的一个子项目, 它提供一组 API 和实现, 用于管理用户的 session 信息.它把 servlet 容器实现的 httpSession 替换为 spring-session, 专注于解决 session 管理问题, Session 信息存储在 Redis 中, 可简单快速且无缝的集成到我们的应用中;

    Spring Session 的特性:

    • 提供用户 session 管理的 API 和实现
    • 提供 HttpSession, 以中立的方式取代 web 容器的 session, 比如 tomcat 中的session
    • 支持集群的 session 处理, 不必绑定到具体的 web 容器去解决集群下的 session共享问题

    2.入门案例

    2.1 创建项目

    (1)创建一个Maven的web module,名字为01-springsession-web
    在这里插入图片描述(2)完善Maven项目的结构

    • 在main目录下,创建java目录,并标记为Sources Root
      在这里插入图片描述
    • 在main目录下,创建resources目录,并标记为Resources Root
      在这里插入图片描述
    • 导入依赖
    <!--servlet依赖-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
        </dependency>
        <!--SpringSession redis 集成依赖-->
        <dependency>
          <groupId>org.springframework.session</groupId>
          <artifactId>spring-session-data-redis</artifactId>
          <version>1.3.1.RELEASE</version>
        </dependency>
        <!--Spring Web 模块依赖-->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>5.2.10.RELEASE</version>
        </dependency>
    

    2.2 代码开发

    (1) 创建向 session 放数据的 servlet

    package session.servlet;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @WebServlet(urlPatterns = "/setSession")
    public class SetSessionServlet extends HttpServlet {
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            req.getSession().setAttribute("url","http://www.baidu.com");
            resp.getWriter().write("OK");
        }
    }
    

    (2) 创建从 session 中获取数据的 servlet

    package session.servlet;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @WebServlet(urlPatterns = "/getSession")
    public class GetSessionServlet extends HttpServlet {
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            String url= (String) req.getSession().getAttribute("url");
            resp.getWriter().write(url==null?"NO Session":url);
        }
    }
    

    (3)部署访问测试(目前无法实现 session 共享)

    • 配置tomcat9100 服务器,给 tomcat 服务器取名,并修改端口号,并将项目部署到tomcat9100 上

    在这里插入图片描述

    • 配置tomcat9200服务器,操作步骤同上

    可以在9100端口的服务器上访问/setSession,再在9200端口的服务器上访问 /getSession
    这个时候我们通过测试会发现两个Tomcat服务器之间是无法共享session数据的

    2.3 SpringSession 集成配置

    • 在resources目录下创建如下两个配置文件在这里插入图片描述
    • applicationContext.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <import resource="classpath:springsession.xml"/>
    </beans>
    
    • springsession.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的注解支持,因为SpringSession中使用到了Spring的相关注解,因此需要启动Spring的注解,这一步是可以省略的
            通常工作时我们会使用 <context:component-scan base-package="com"/>来进行包扫描,这个标签中的功能就包含了
            <context:annotation-config/>的功能,因此实际工作时这个步骤是可以省略
         -->
        <context:annotation-config/>
    
        <!--
             定义一个用于配置SpringSession的bean标签配置
             只配置RedisHttpSessionConfiguration 的Bean 就可以实现同域名同项目的Session共享
             适合于我们的Nginx集群模式下的P2P项目部署
        -->
        <bean id="redisHttpSessionConfiguration" class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
            <!--配置Session的最大生命周期 单位 秒 默认值为1800 表示30分钟 -->
            <property name="maxInactiveIntervalInSeconds" value="1800"/>
        </bean>
    
    
        <!-- 配置 jedis 连接工厂, 用于连接 redis
             可选配置步骤,如果当前工程已经配置过了redis,那么这个过程可以省略
        -->
        <bean id="jedisConnectionFactory"
              class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
              <!--分别为主机名、redis端口号、redis密码-->
            <property name="hostName" value="127.0.0.1"/> 
            <property name="port" value="6379"/>
            <property name="password" value="123456" />
        </bean>
    </beans>
    
    • 点击 config 将这两个配置文件进行关联
      在这里插入图片描述

    这次通过上面已经介绍过的测试方法,我们可以发现session数据可以在端口号分别为9100和9200的两个不同的Tomcat服务器上实现共享了


    • 在浏览器(这里我使用的谷歌浏览器)上检查页面元素会发现两个页面上存储的cookie中存储的Session ID属性值和redis中相同。
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 上面的HASH文本框中便是redis上存储的Session ID值
    • lastAccessTime:最后一次访问时间
    • sessionAttr:session对象中存储数的属性
    • maxIntactiveInterval:session的最大生命周期,默认是30分钟
    • creationTime:session的创建时间

    3.同域名下不同项目的session共享

    3.1 案例

    1. 在 Deployment 选项卡下,设置本地 tomcat9100的Application context 为/p2p
    2. 在 Deployment 选 项卡下 ,设置本地 tomcat9200的Application context 为/shop
    3. 在idea中重新启动本地的两台 tomcat 服务器
    4. 在浏览器中访问 tomcat9100(p2p), 设置 session
      在这里插入图片描述
      session设置成功

    5. 在浏览器中访问 tomcat9200(shop),获取 session
      在这里插入图片描述
      获取不到session

    6. 分析 Session 共享失败原因
    • 我们通过浏览器提供的开发人员工具可以发现,这两个请求的 cookie 的路径(path)不一致(如下图),虽然我们已经加了Spring Session共享机制,但是后台服务器认为这是两个不同的会话(session),可以通过 Redis 客户端工具(Redis Destop Mananger) 查看,先清空,然后访问,发现是维护了两个不同的 session,所以不能实现共享。
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 同样redis中也存储了两个不同的session对象,其中一个session对象中没有sessionAttr属性。
      在这里插入图片描述
      在这里插入图片描述
    1. 解决方案:设置Cookie路径为根/上下文在springsession.xml文件中,加如下配置:
    <bean id="redisHttpSessionConfiguration" class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
            <!--配置Session的最大生命周期 单位 秒 默认值为1800 表示30分钟 -->
            <property name="maxInactiveIntervalInSeconds" value="1800"/>
            <!--注入一个Cookie的序列化规则对象 -->
            <property name="cookieSerializer" ref="defaultCookieSerializer"/>
    </bean>
    
        <!--配置一个Cookie序列化规则对象 用于改变Cookie的存放规则 -->
    <bean id="defaultCookieSerializer" class="org.springframework.session.web.http.DefaultCookieSerializer">
            <!--指定SpringSession的SessionId存放在域名的根路径下,用于实现同域名不同项目的Session共享 -->
            <property name="cookiePath" value="/" />
    </bean>
    
    1. 重新进行测试发现两个不同项目的session数据也能实现共享,且两个请求的cookie路径(path)相同均为" / "。且此时redis中也只有一个session对象。
      在这里插入图片描述

    3.同根域名不同二级子域名下的项目实现Session 共享

    同一个根域名,不同的二级子域名,比如北京和武汉的58同城域名:
    武汉的58同城
    在这里插入图片描述

    3.1案例

    添加域名映射: 找到C:\Windows\System32\drivers\etc路径下的hosts文件,在文件末尾加上:
    127.0.0.1 p2p.myweb.com
    127.0.0.1 shop.myweb.com

    • 通过测试发现这是无法实现两个服务器上session数据的共享
    • 原因:我们通过浏览器提供的开发人员工具可以发现,虽然这两个cookie 的路径(path)都设置为了“/”,但是这两个cookie的域名不一致,虽然我们已经加了Spring Session共享机制,但是后台服务器同样认为这是两个不同的会话(session),可以通过 Redis 客户端工具(Redis Destop Mananger)查看,先清空,然后访问,发现是维护了两个不同的session,所以不能实现共享,也就是说后台区分是否同一个 session 和路径和域名有关。
      在这里插入图片描述
      在这里插入图片描述
    • 解决方案:设置Cookie的域名为根域名 web.com,在 applicationContext-session.xml 文件中, 加如下配置:
      注意:域名要和 hosts 文件中配置的域名后面一样
    <!--配置一个Cookie序列化规则对象 用于改变Cookie的存放规则 -->
        <bean id="defaultCookieSerializer" class="org.springframework.session.web.http.DefaultCookieSerializer">
            <!--指定SpringSession的SessionId存放在域名的根路径下,用于实现同域名不同项目的Session共享 -->
            <property name="cookiePath" value="/" />
            <!--指定SpringSession的SessionId存放在根域名下,用于实现同根域名不同二级子域名下的Session共享
                适合应用在Nginx的虚拟主机的多城市站点部署
             -->
            <property name="domainName" value="myweb.com"/>
        </bean>
    
    • 经过测试,发现可以实现session共享
      在这里插入图片描述
      在这里插入图片描述
      此时两次请求的Session ID都是存放在.myweb.com域名下
    展开全文
  • Spring Session

    2021-05-28 17:56:51
    Spring Session 提供了集群 Session(Clustered Sessions)功能,默认采用外置的 Redis 来存储 Session 数据,以此来解决 Session 共享的问题。 2、步骤: (1)、添加依赖: <!--spring session--> <...

    1、说明: Spring Session 提供了一套创建和管理 Servlet HttpSession 的方案。Spring Session 提供了集群 Session(Clustered Sessions)功能,默认采用外置的 Redis 来存储 Session 数据,以此来解决 Session 共享的问题。
    2、步骤:
    (1)、添加依赖:

    <!--spring session-->
    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    

    (2)、创建配置类:

    import org.springframework.context.annotation.Configuration;
    import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
    
    
    @Configuration
    //maxInactiveIntervalInSeconds设置过期时间
    @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400*30)
    public class SessionConfig {
    }
    

    (3)、创建用于测试的controller:

    package com.controller;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import javax.servlet.http.HttpSession;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.UUID;
    
    
    @RestController
    public class RedisController {
    
        @RequestMapping("session")
        public String session(HttpSession session) {
            UUID uuid = (UUID) session.getAttribute("uid");
            if(uuid == null) {
                uuid = UUID.randomUUID();
            }
            session.setAttribute("uid", uuid);
    
            return session.getId();
        }
    
    
    }
    

    (4)、在redis数据库中可看到session数据,在redis可通过hgetall命令取值:hgetall spring:session:sessions:3bd8e3c1-960c-48ac-a67e-fdb19b3b1848

    展开全文
  • SpringSession 实例

    2021-05-27 18:55:29
    SpringSession 官方文档: https://spring.io/projects/spring-session 一.Spring Session简介 1. Spring Session概念: Spring Session 是Spring家族中的一个子项目,Spring Session提供了用于管理用户会话...

    SpringSession


    官方文档:

    https://spring.io/projects/spring-session

    一.Spring Session简介

    1. Spring Session概念:

    Spring Session 是Spring家族中的一个子项目,Spring Session提供了用于管理用户会话信息的API和实现。

    它把servlet容器实现的httpSession替换为spring-session,专注于解决 session管理问题,Session信息存储在Redis中,可简单快速且无缝的集成到我们的应用中

    2.  Spring Session的特性:

    Spring Session使支持集群会话变得很简单,而无需绑定到特定于应用程序容器的解决方案。它还提供与以下内容的透明集成:

    • HttpSession -允许以应用程序容器(即Tomcat)中立的方式替换HttpSession,并支持在标头中提供会话ID以与RESTful API一起使用

    • WebSocket -提供了在接收WebSocket消息时使HttpSession保持活动状态的功能

    • WebSession -允许以应用程序容器中立的方式替换Spring WebFlux的WebSession

    3.  Session会话共享方案

    第一种是使用容器扩展插件来实现,比如基于Tomcat的tomcat-redis-session-manager插件,基于Jetty的jetty-session-redis插件、memcached-session-manager插件;这个方案的好处是对项目来说是透明的,无需改动代码,但是由于过于依赖容器,一旦容器升级或者更换意味着又得重新配置

    第二种是 使用Nginx负载均衡的ip_hash策略实现用户每次访问都绑定到同一台具体的后台tomcat服务器实现session总是存在

    第三种是自己写一套Session会话管理的工具类,在需要使用会话的时候都从自己的工具类中获取,而工具类后端存储可以放到Redis中,这个方案灵活性很好,但开发需要一些额外的时间

    第四种是使用框架的会话管理工具,也就是本文所使用的Spring session,这个方案既不依赖tomcat容器,又不需要改动代码,由Spring session框架为我们提供,可以说是目前非常完美的session共享解决方案

    4.spring-session分为以下核心模块:

    SessionRepositoryFilter:Servlet规范中Filter的实现,用来切换HttpSession至Spring Session,包装HttpServletRequest和HttpServletResponse

    HttpServerletRequest/HttpServletResponse/HttpSessionWrapper包装器:包装原有的HttpServletRequest、HttpServletResponse和Spring Session,实现切换Session和透明继承HttpSession的关键之所在

    Session:Spring Session模块

    SessionRepository:管理Spring Session的模块

    HttpSessionStrategy:映射HttpRequst和HttpResponse到Session的策略

    二.Spring Session示例

       1.在idea中  新建两个 springboot 项目

         springsession01 和 springsession02

        2. 导入依赖

    <-- 父依赖 -->

     <parent>

            <artifactId>spring-boot-starter-parent</artifactId>

            <groupId>org.springframework.boot</groupId>

            <version>2.3.1.RELEASE</version>

     </parent>

        <dependencies>

            <dependency>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-starter-web</artifactId>

            </dependency>

            <!-- 引入 springboot&redis 整合场景 -->

            <dependency>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-starter-data-redis</artifactId>

            </dependency>

            <!-- 引入 springboot&springsession 整合场景 -->

            <dependency>

                <groupId>org.springframework.session</groupId>

                <artifactId>spring-session-data-redis</artifactId>

            </dependency>

    </dependencies>

          3. 分别写两个项目(springsession01 和 springsession02)的主启动类

         4.在springsession01 中 写 TestController  

          设置session

    package com.crowd.controller;

    import org.springframework.web.bind.annotation.RequestMapping;

    import org.springframework.web.bind.annotation.RestController;

    import javax.servlet.http.HttpSession;

    @RestController

    public class TestController {

        @RequestMapping("/test/spring/session/save")

        public String testSession(HttpSession session){

            session.setAttribute("name","hjj");

            return "测试 session 共享";

        }

    }

        5.在springsession02 中 获取session中的

    @RestController

    public class TestController {

    @RequestMapping("/test/spring/session/retrieve")

    public String testSession(HttpSession session){

            String name = (String) session.getAttribute("name");

            return name;

        }

    }

       

         6. 配置 application.yml   

         springsession01中:

    #redis 配置

    spring:

      redis:

        host: 127.0.0.1

        jedis:

          pool:

            max-idle: 100

      session:

        store-type: redis   # springsession 配置   type= redis

         springsession02中:

    #redis 配置

    spring:

      

      redis:

        host: 127.0.0.1

        #redis连接池配置

        jedis:

          pool:

            max-idle: 100

      session:

        store-type: redis   # springsession 配置   type= redis

    #

    server:

      port: 8383

        7. 分别启动两个 项目 测试

    http://localhost:8080/test/spring/session/save

    http://localhost:8383/test/spring/session/retrieve

    Windows+R  输入cmd  

    在redis 中查找有没有 name

    注意:

    如果是Redis在linux 上面的 ,首先要开启虚拟机,开启Redis服务

    还要修改 application.yml  中的

    redis:

        host:  

    如果 启动 报错

    Exception in thread “main“ redis.clients.jedis.exceptions.JedisDataException

    原因分析:

    1)机器之间网络无法联通

    2)ip和端口号不正确

    3)虚拟机中防火墙的原因(可能性较大)

    4)redis.conf 中bind 127.0.0.1 未用#注释掉

    参考解决方案:

    1,关闭linux防火墙

    Centos6

    查看防火墙状态: 

    [root@centos6 ~]# service iptables status

    iptables:未运行防火墙。

    开启防火墙:

    [root@centos6 ~]# service iptables start

    关闭防火墙:

    [root@centos6 ~]# service iptables stop

    centos7

    #查看防火墙状态:,注意firewall与-cmd之间无空格 

    firewall-cmd  --state

    #关闭防火墙

    systemctl stop firewalld.service

    #开启防火墙

    systemctl start firewalld.service

    #禁用防火墙

    systemctl disable firewalld.service 

    2,注释 redis.conf 配置文件中的  # bind 127.0.0.1,并将protected-mode设为no

    1. 修改redis.conf

          vim redis.conf

          2. 修改

         #bind 127.0.0.1

         protected-mode no


     

    展开全文
  • Spring Session会话管理

    2021-12-04 16:23:58
    Spring Session 一、 HttpSession 回顾 1 什么是 HttpSession 是 JavaWeb 服务端提供的用来建立与客户端会话状态的对象。 二、 Session 共享 1 什么是 Session 共享 是指在一个浏览器对应多个 Web 服务时,服务端的 ...

    Spring Session

    一、 HttpSession 回顾

    1 什么是 HttpSession

    是 JavaWeb 服务端提供的用来建立与客户端会话状态的对象。

    二、 Session 共享

    1 什么是 Session 共享

    是指在一个浏览器对应多个 Web 服务时,服务端的 Session 数据需要共享。

    2 Session 共享应用场景

    1. 单点登录
    2. Web 服务器集群等场景都需要用到

    3 Session 共享常见的解决方案

    3.1Session 复制

    通过对应服务器的配置开启服务器的Session复制功能,在集群中的几台服务器之间同步Session对象,似的每台服务器上都保存所有的Session信息,这样任何一台宕机都不会导致Session的数据丢失,服务器使用Session时,直接从本地获取。这种方式的缺点也比较明显。因为Session需要实时同步,并且同步过程是有应用服务来完成,由此对服务器的性能损耗也比较大。

    3.2Session 绑定

    利用 hash 算法,比如 nginx 的 ip_hash,使得同一个 Ip 的请求分发到同一台服务器上。这种方式不符合对系统的高可用要求,因为一旦某台服务器宕机,那么该机器上的Session 也就不复存在了,用户请求切换到其他机器后么有 Session,无法完成业务处理。

    3.3利用 Cookie 记录 Session

    Session 记录在客户端,每次请求服务器的时候,将 Session 放在请求中发送给服务器,服务器处理完请求后再将修改后的 Session 响应给客户端。这里的客户端就是 cookie。

    利用 cookie 记录 Session 的也有缺点,比如受 cookie 大小的限制,能记录的信息有限,安全性低,每次请求响应都需要传递 cookie,影响性能,如果用户关闭 cookie,访问就不正常。

    3.4Session 服务器

    Session 服务器可以解决上面的所有的问题,利用独立部署的 Session 服务器统一管理Session,服务器每次读写 Session 时,都访问 Session 服务器。
    对于 Session 服务器,我们可以使用 Redis 或者 MongoDB 等内存数据库来保存 Session中的数据,以此替换掉服务中的 HttpSession。达到 Session 共享的效果。

    三、 什么是 Spring Session

    Spring Session 是 Spring 的项目之一。Spring Session 提供了一套创建和管理 Servlet HttpSession 的方案,默认采用外置的 Redis 来存储 Session 数据,以此来解决 Session 共享的问题。

    四、 Spring Session 的使用

    1 安装 Redis

    第一步 需要在 linux 系统中安装 gcc
    命令:yum install -y gcc-c++

    第二步 需要将下载好的 redis 压缩包添加到 linux 服务器中
    版本:redis-3.0.0.tar.gz
    redis 的版本:副版本号奇数版本号是测试版,不建议在生产环境中使用。
    偶数版本时稳定版建议在生产环境中使用。
    3.0 版本更新比较大。集成了集群技术

    第三步 解压压缩包
    命令:tar -zxvf redis......

    第四步 编译 redis
    命令:进入 redis 的解压完毕的根目录下 执行命令:make

    第五步 安装 redis
    命 令 : 进 入 redis 的 解 压 完 毕 的 根 目 录 下 , 执 行 命 令 : make install PREFIX=/usr/local/redis

    第六步:启动 redis

    1,前端启动
    在 bin 目录下执行命令: ./redis-server (ctrl+c)退出 redis

    2.后端启动
    (1)先将 redis 解压目录下的 redis.conf 文件拷贝到 安装好的 redis 的 bin 目录下
    命令:cp redis.conf /usr/local/redis/bin
    (2)修改拷贝过来的 redis.conf 配置文件
    命令:vim redis.conf

    将 daemonize no 改为 yes
    

    (3)启动 redis
    在 bin 目录下执行命令:./redis-server redis.conf
    (4)查看 redis 启动是否成功
    输入命令:ps aux|grep redis
    (5) 关闭 redis 的命令

    ./redis-cli shutdown
    

    第七步:测试 redis
    在 bin 目录下启动 redis 自带的客户端 ./redis-cli
    常见 redis 命令:

    ping--->pong
    

    2 搭建案例环境

    2.1版本介绍

    JDK:1.8
    Spring Boot:2.1.6.RELEASE
    Spring Session:Bean-SR3
    

    2.2创建项目

    创建父工程 spring_session在这里插入图片描述
    创建模块 session_service1
    在这里插入图片描述
    创建模块 session_service2
    在这里插入图片描述

    2.3修改 POM 文件添加坐标依赖

    修改父工程 POM 文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.bjsxt</groupId>
        <artifactId>spring_session</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>session_service1</module>
            <module>session_service2</module>
        </modules>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
        </parent>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.session</groupId>
                    <artifactId>spring-session-bom</artifactId>
                    <version>Bean-SR3</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <!--web Starter-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <!--Spring session data redis-->
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-redis</artifactId>
            </dependency>
    
            <!--Lettuce 是一个基于Netty的NIO方式处理Redis的技术-->
            <dependency>
                <groupId>io.lettuce</groupId>
                <artifactId>lettuce-core</artifactId>
            </dependency>
        </dependencies>
    
    </project>
    

    3 添加配置文件

    3.1session_service1

    #服务端口
    server:
    	port: 8080
    spring:
    	redis:
    		host: 192.168.70.156 #Redis 配置
    		port: 6379
    		password:
    		database: 0
    

    3.2session_service2

    #服务端口
    server:
    	port: 8081
    spring:
    	redis:
    		host: 192.168.70.156 #Redis 配置
    		port: 6379
    		password:
    		database: 0
    

    4 创建启动类

    4.1session_service1

    @SpringBootApplication
    @EnableRedisHttpSession(redisNamespace="myspringsession")
    public class Service1Application {
        public static void main(String[] args){
            SpringApplication.run(Service1Application.class,args);
        }
    }
    

    4.2session_service2

    @SpringBootApplication
    @EnableRedisHttpSession(redisNamespace="myspringsession")
    public class Service2Application {
        public static void main(String[] args){
            SpringApplication.run(Service2Application.class,args);
        }
    }
    

    5 编写测试代码测试效果

    5.1session_service1

    5.1.1创建 Controller

    @RestController
    @RequestMapping("service1")
    public class WebController {
    
        @RequestMapping("/setMsg")
        public String setMsg(HttpSession session,String msg){
            session.setAttribute("msg",msg);
            return "ok";
        }
    }
    

    5.2session_service2

    5.2.1创建 Controller

    @RestController
    @RequestMapping("/service2")
    public class WebController {
    
        @RequestMapping("/getMsg")
        public String getMsg(HttpSession session){
            String msg = (String) session.getAttribute("msg");
            return msg;
        }
    }
    

    5.2.2测试

    在这里插入图片描述

    6 共享自定义对象

    6.1创建 Users 实体类

    public class Users implements Serializable {
        private String username;
        private String userpwd;
         private Roles roles;
    
        public Roles getRoles() {
            return roles;
        }
    
        public void setRoles(Roles roles) {
            this.roles = roles;
        }
       
        public String getUsername() {
            return username;
        }
    
        public String getUserpwd() {
            return userpwd;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setUserpwd(String userpwd) {
            this.userpwd = userpwd;
        }
    }
    

    6.2修改 session_service1 的 controller

    @RestController
    @RequestMapping("service1")
    public class WebController {
    
        @RequestMapping("/setMsg")
        public String setMsg(HttpSession session,String msg){
            session.setAttribute("msg",msg);
            return "ok";
        }
    
        /**
         * 获取Users信息,保存到HttpSession中
         */
        @RequestMapping("/addUsers")
        public String addUsers(HttpSession session, Users users){
            Roles roles = new Roles();
            roles.setRoleid(1);
            roles.setRolename("管理员");
            users.setRoles(roles);
            session.setAttribute("u",users);
            return "ok";
        }
    }
    

    6.3修改 session_service2 的 controller

    @RestController
    @RequestMapping("/service2")
    public class WebController {
    
        @RequestMapping("/getMsg")
        public String getMsg(HttpSession session){
            String msg = (String) session.getAttribute("msg");
            return msg;
        }
    
        /**
         * 获取HttpSession中的Users对象
         */
        @RequestMapping("/getUsers")
        public Users getUsers(HttpSession session){
            Users users = (Users) session.getAttribute("u");
            return users;
        }
    }
    

    6.4测试

    在这里插入图片描述

    7 Spring Session 的 Redis 存储结构

    spring:session:expirations:(Set 结构)用户 ttl 过期时间记录这个 k 中的值是一个时间戳,根据这个 Session 过期时刻滚动至下一分钟而计算得出。这个 k 的过期时间为 Session 的最大过期时间 + 5 分钟。

    spring:session:sessions:(Hash 结构)

    maxInactiveInterval:过期时间间隔
    
    creationTime:创建时间
    
    lastAccessedTime:最后访问时间
    
    sessionAttr:Attributes 中的数据存储 Session 的详细信息,包括 Session 的过期时间间隔、最后的访问时间、attributes的值。这个 k 的过期时间为 Session 的最大过期时间 + 5 分钟。
    

    spring:session:sessions:expires:(String 结构)过期时间记录这个 k-v 不存储任何有用数据,只是表示 Session 过期而设置。
    这个 k 在 Redis 中的过期时间即为 Session 的过期时间间隔。

    8 设置 Session 的失效时间

    8.1在注解中设置失效时间

    @SpringBootApplication
    @EnableRedisHttpSession(maxInactiveIntervalInSeconds=10)
    public class Service1Application {
    	public static void main(String[] args){
    		SpringApplication.run(Service1Application.class,args);
    	}
    }
    

    9 @EnableRedisHttpSession 注解讲解

    9.1maxInactiveIntervalInSeconds

    设置 Session 的失效时间,单位为秒。默认(1800 秒)30 分钟。

    9.2redisNamespace

    为键定义唯一的命名空间。该值用于通过更改前缀与默认 spring:session 隔离会话

    9.3redisFlushMode

    Redis 会话的刷新模式。默认值为“保存”

    9.4cleanupCron

    过期会话清理作业的 cron 表达式。默认值("0 * * * * *")每分钟运行一次。

    10 更换 Spring Session 的序列化器

    Spring Session 中默认的序列化器为 jdk 序列化器,该序列化器效率低下,内存再用大。
    我们可以根据自己的需要更换其他序列化器,如 GenericJackson2JsonRedisSerializer 序列化器。

    10.1在配置类中创建自定义序列化器

    @Configuration
    public class SpringSessionConfig {
    	/**
    	* 更换默认的序列化器
    	*
    	*/
    	@Bean("springSessionDefaultRedisSerializer")
    	public RedisSerializer defaultRedisSerializer(){
    		return getSerizlizer();
    	}
    	/**
    	* 定义序列化器
    	*/
    	private RedisSerializer getSerizlizer(){
    		return new GenericJackson2JsonRedisSerializer();
    	}
    }
    

    添加角色管理:

    public class Roles implements Serializable {
        private Integer roleid;
        private String rolename;
    
        public void setRoleid(Integer roleid) {
            this.roleid = roleid;
        }
    
        public void setRolename(String rolename) {
            this.rolename = rolename;
        }
    
        public Integer getRoleid() {
            return roleid;
        }
    
        public String getRolename() {
            return rolename;
        }
    }
    

    10.2 测试

    在这里插入图片描述

    Spring Session MongoDB

    一、 Spring Session MongoDB 简介

    1 什么是 Spring Session MongoDB

    Spring Session MongoDB 是 Spring Session 的二级项目。其功能与 Spring Session 是相同
    的。Spring Session MongoDB 提供了一个 API 和实现,用于通过利用 Spring Data MongoDB
    来管理存储在 MongoDB 中的用户会话信息。

    2 他与 Spring Session 的区别

    Spring Session 与 Spring Session MongoDB 的作用是相同的。都是来解决 Session 共享问题。不同的是 Spring Session 默认的是依赖于 Redis 作为数据缓存平台,而 Spring Session MongoDB 是依赖于 MongoDB来作为数据缓存平台的。

    二、 Spring Session MongoDB 的使用

    1 安装 MongoDB

    1.1下载 MongoDB

    mongodb-linux-x86_64-4.0.9.tgz
    

    1.2解压 tgz 文件

    [root@localhost temp]# tar -zxf mongodb-linux-x86_64-4.0.9.tgz
    

    1.3创建数据库目录

    [root@localhost etc]# mkdir -p data/db
    

    1.4创建日志文件

    [root@localhost etc]# touch mongodb.log
    

    1.5创建配置文件

    [root@localhost etc]# vim mongodb.conf
    

    在这里插入图片描述

    1.6启动 MongoDB

    [root@localhost bin]# ./mongod --cofnig /usr/local/mongodb/etc/mongodb.conf
    

    1.7创建 sxt 库

    > use sxt
    

    2 搭建案例环境

    2.1技术版本

    JDK:1.8
    Spring Boot2.1.6RELEASE
    Spring Session MongoDBBean-SR3
    

    2.2创建项目

    在这里插入图片描述

    2.3修改 POM 文件添加依赖

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.bjsxt</groupId>
        <artifactId>session_mongodb</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>session_mongo1</module>
            <module>session_mongo2</module>
        </modules>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
        </parent>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.session</groupId>
                    <artifactId>spring-session-bom</artifactId>
                    <version>Bean-SR3</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-mongodb</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-mongodb</artifactId>
            </dependency>
        </dependencies>
    
    </project>
    

    2.4添加配置文件

    2.4.1Session_monog1

    #配置服务的端口
    server:
      port: 8080
    #配置MongoDB的链接信息
    spring:
      data:
        mongodb:
          host: 192.168.70.156
          port: 27017
          database: sxt
      session:
        store-type: mongodb
    

    2.4.2Session_mongo2

    #配置服务的端口
    server:
      port: 8081
    #配置MongoDB的链接信息
    spring:
      data:
        mongodb:
          host: 192.168.70.156
          port: 27017
          database: sxt
      session:
        store-type: mongodb 
    

    2.5创建启动类

    2.5.1Session_mongo1

    @SpringBootApplication
    @EnableMongoHttpSession
    public class Mongo1Application {
        public static void main(String[] args){
            SpringApplication.run(Mongo1Application.class,args);
        }
    }
    

    2.5.2Session_mongo2

    @SpringBootApplication
    @EnableMongoHttpSession
    public class Mongo2Application {
        public static void main(String[] args){
            SpringApplication.run(Mongo2Application.class,args);
        }
    }
    

    3 编写测试代码

    3.1Session_mongo1

    @RestController
    @RequestMapping("/service1")
    public class WebController {
    
        /**
         * 将数据存放到HttpSession中
         */
        @RequestMapping("/setMsg")
        public String getMsg(HttpSession session,String msg){
            session.setAttribute("msg",msg);
            return "ok";
        }
     }
    

    3.2Session_mongo2

    @RestController
    @RequestMapping("/service2")
    public class WebController {
    
        /**
         * 获取HttpSession中的数据
         */
        @RequestMapping("/getMsg")
        public String getMsg(HttpSession session){
            String msg = (String) session.getAttribute("msg");
            return msg;
        }
    }
    

    3.3修改 MongoDB 的配置文件添加 bind_ip

    dbpath=/usr/local/mongodb/data/db
    logpath=/usr/local/mongodb/log/mongodb.log
    port=27017
    fork=true
    bind_ip=0.0.0.0
    

    3.4测试

    在这里插入图片描述

    4 共享自定义对象

    4.1创建 Users 类

    public class Users implements Serializable {
        private String username;
        private String userpwd;
    
        public String getUsername() {
            return username;
        }
    
        public String getUserpwd() {
            return userpwd;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setUserpwd(String userpwd) {
            this.userpwd = userpwd;
        }
    }
    

    4.2session_mongo1

    @RestController
    @RequestMapping("/service1")
    public class WebController {
    
        /**
         * 将数据存放到HttpSession中
         */
        @RequestMapping("/setMsg")
        public String getMsg(HttpSession session,String msg){
            session.setAttribute("msg",msg);
            return "ok";
        }
    
        /**
         * 获取数据封装Users
         */
        @RequestMapping("/setUsers")
        public String setUsers(HttpSession session, Users users){
            session.setAttribute("users",users);
            return "ok";
        }
    }
    

    4.3session_mongo2

    @RestController
    @RequestMapping("/service2")
    public class WebController {
    
        /**
         * 获取HttpSession中的数据
         */
        @RequestMapping("/getMsg")
        public String getMsg(HttpSession session){
            String msg = (String) session.getAttribute("msg");
            return msg;
        }
    
        /**
         * 从HttpSession中获取Users
         */
        @RequestMapping("/getUsers")
        public Object getUsers(HttpSession session){
            Users users = (Users) session.getAttribute("users");
            return users;
        }
    }
    

    4.4测试

    在这里插入图片描述

    5 Spring Session MongoDB 的存结构

    { "_id" : "fe3f6cea-c3e2-426b-a47a-cf21c5b848cb", "created" :
    ISODate("2019-07-12T12:46:48.916Z"), "accessed" : ISODate("2019-07-12T12:46:48.919Z"), "interval" : "PT30M", "principal" : null, "expireAt" : ISODate("2019-07-12T13:16:48.919Z"), "attr" :
    BinData(0,"rO0ABXNyABFqYXZhLnV0aWwuSGFzaE1hcAUH2sHDFmDRAwACRgAKbG9h
    ZEZhY3RvckkACXRocmVzaG9sZHhwP0AAAAAAAAx3CAAAABAAAAABdAAFdXNlcnN
    zcgAcY29tLmJqc3h0Lm1vbmdvLmRvbWFpbi5Vc2Vyc5EM02IkljhzAgACTAAIdXNlcm5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztMAAd1c2VycHdkcQB+AAR4cHQABWFkbWludAAFYWRtaW54") }
    

    6 设置 Session 失效时间

    @SpringBootApplication
    @EnableMongoHttpSession(maxInactiveIntervalInSeconds=10)
    public class Mongo1Application {
    	public static void main(String[] args){
    		SpringApplication.run(Mongo1Application.class,args);
    	}
    }
    

    7 @EnableMongoHttpSession 注解讲解

    maxInactiveIntervalInSeconds:设置 Session 失效时间
    collectionName:设置 MongoDBCollections 的名称
    

    8 更换 Spring Session MongoDB 的序列化器

    Spring Session MongoDB 默认使用的是 JDK 序列化器。

    8.1创建配置类添加 Jackson 序列化器

    /**
     * 更换Spring Session MongoDB的序列化器
     */
    @Configuration
    public class SessionMongoConfig {
        @Bean
        JacksonMongoSessionConverter mongoSessionConverter() {
            return new JacksonMongoSessionConverter();
        }
    }
    

    8.2修改实体类,添加@JsonAutoDetect 注解

    @JsonAutoDetect(fieldVisibility=JsonAutoDetect.Visibility.ANY)
    public class Users implements Serializable {
        private String username;
        private String userpwd;
    
        public String getUsername() {
            return username;
        }
    
        public String getUserpwd() {
            return userpwd;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setUserpwd(String userpwd) {
            this.userpwd = userpwd;
        }
    }
    

    8.3 测试

    在这里插入图片描述
    Spring Security

    展开全文
  • SpringSession

    2021-12-09 18:14:31
    用户第一次登录自己的账号时,服务器需要命令浏览器保存一个sessionid=xxx的cookie,以后浏览器再访问时会携带...-- 整合springsession --> <dependency> <groupId>org.springframework.session</g
  • spring session

    2021-01-21 20:38:16
    Spring Session 配置3.1 Session 配置3.1.1 依赖库3.1.2 配置类4. Spring Request 拦截器4.1 创建拦截器4.2 实现 WebMvcConfigurer 1. Cookie 主要分析服务端 Spring 工程是如何使用 Cookie 的,有读、写两种操作 ...
  • Spring Session的使用

    2021-01-13 18:17:05
    Spring Session的使用 在集群部署时Session共享是一个问题,但是不用担心Spring Session提供了集中管理Session的方案 集成Spring SessionSpring Boot 应用(JDBC) 加入以下依赖 <dependency> <groupId...
  • SpringSession系列之通过Redis统计在线用户数量,最近遇到一个比较紧急的任务,要求统计在线用户,目的是配合性能测评,要求证明自己系统的在线用户能够达标,不过系统因为历史原因,并没有这个功能,所以只能去...
  • Spring Session & Redis实现Session共享 前后端分离Session、单点登录实现 Session 共享简单方案,充当笔记 一、Session和Cookie 1.Session简介: Session及会话,是web开发中得一种会话跟踪技术。 Session会话...
  • 只要在创建SpringBoot的时候按以下步骤即可 application.properties文件说明 # 应用名称 spring.application.name=test02 # 应用服务 WEB 访问端口 ...#不同项目的session共享 #server.servlet..
  • 1、引入maven依赖 ...org.springframework.session</groupId> <artifactId>spring-session-data-redis</artifactId> </dependency> 2、配置 spring: session: store-type: re
  • springSession配置redis存session HttpSession 回顾 什么是 HttpSession 是 JavaWeb 服务端提供的用来建立与客户端会话状态的对象。 Session 共享 什么是 Session 共享 是指在一个浏览器访问多个 Web 服务时,...
  • 来源:blog.csdn.net/qq_30062181/article/details/85108102今天给大家简单介绍下spring session的使用。本篇主要介绍使用redis...
  • Spring Session是什么?解决了什么问题? Spring SessionSpring系列的一个子项目,是SpringSession的一个基础框架封装。 谈到Session(会话),session数据保存在服务端,我们对他并不陌生,比如在日常的Java Web...
  • --配置spring session的依赖--> <dependency> <groupId>org.springframework.session</groupId> <artifactId>spring-session-core</artifactId> <version>2.0.2.RELEASE<...
  • SpringSession系统对接CAS单点登录遇到的反序列化问题。业务背景:最近在对接CAS单点登录,遇到一个问题,加班到凌晨,先描述一下背景,首先公司的系统是基于Spring Session做的单点登录,目的是引用Spring Session...
  • Spring Session不再执行config命令 最近由于拼多多强制要求服务商必须入拼多多云,不上就给你应用给下架了,被逼无奈只有做了;拼多多的尿性就是什么东西都得买他的,容器、数据库、redis,连出云访问都要花钱申请...
  • 严重: Servlet.service() for servlet [spring] in context with path [/] threw exceptionorg.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org....
  • 后端:springcloud,springsecurity 前端:AntDesign Pro v4,React 前端有多个项目,本地开发时,多个前端项目在不同的端口上启动,部署到环境后通过同一个一级域名下的两个不同的二级域名去访问两个前端系统,要求...
  • Spring Session + Redis——自定义JSON序列化解决方案 问题分析 RedisHttpSessionConfiguration中,Bean名称必须是springSessionDefaultRedisSerializer才能指定Jackson序列化器。 @Autowired(required = false...
  • 下面的内容要给大家讲到的就是springsession跨域方面的问题,一起来详细的了解一下springsession跨域方面的内容吧。问题:在上面的架构当中,客户端发起了一个请求,在这个请求到达了nginx上面之后,就被Nginx转达到...
  • 文章目录快速入门 Spring Session + RedisSpring Session 原理 快速入门 Spring Session + Redis Spring Session 原理 Spring Session 主要是利用过滤器,偷梁换柱,实现session储存无感知的切换。 Spring ...
  • 框架中使用spring security、spring sessionsession的存储使用了redis。因此对于session的监听通过HttpSessionListener的方式已经监听不到session创建和销毁事件。其实spring session框架是有提供session事件的...
  • 利用redis进行springSession的存储:存储:// 在session中保存用户信息HttpSession session = httpRequest.getSession(true);session.setAttribute(Constants.SESSION_KEY_USER + userToken, user);// 存储...
  • SpringSession 中因为我们要实现不依赖容器本身的 getSession 实现,因此需要扩展 HttpServletRequset ,通过重写 getSession 来实现分布式 session 的能力。下面就来看下 SpringSession 中对于 ...
  • spring session共享,注入Bean的方式如下,提供的方法只能指定要拦截的URL,但不能过滤指定URL。 @Bean public FilterRegistrationBean sessionRepositoryFilter(SessionRepositoryFilter<? extends ...
  • Spring Boot——Spring Session Redis整合Spring Security时错误【RedisConnectionFactory is required】解决方案 Spring Security + Spring Session + Redis——【SecurityContext】和【AuthenticationToken】JSON...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 265,275
精华内容 106,110
关键字:

springsession

spring 订阅
友情链接: walnut.rar