精华内容
下载资源
问答
  • 最近在搭建cas单点登录...在对tomcat的session进行持久时,cas系统的登录流程被打断,无法进行完整的登录流程。 经过几天的钻研,发现问题出在cas server登录流程中的spring web flow流程这一块。 大致情况如下: spr

    最近在搭建cas单点登录系统 ,在建立集群时发生一个问题。

    搭建的环境是tomcat+tomcat-redis-session-manager+redis+cas

    在对tomcat的session进行持久化时,cas系统的登录流程被打断,无法进行完整的登录流程。

    经过几天的钻研,发现问题出在cas server登录流程中的spring web flow流程这一块。

    大致问题如下:

    spring web flow里面跟session进行了绑定操作,conversation这个对象里面存在的对象,嵌套了很多对象,跟session进行绑定的时候直接从session中获取conversation,然后直接修改了conversation之后没有将conversation对象再回放到session中,所以session如果持久化了,webFlow再进行下一个流程从数据库里取session数据就会找不到这个数据,找不到这个数据的后果就是整个webflow流程无法继续进行。

    所以如果session的实现类是操作jvm的内存的话是没有问题,因为取出来之后直接修改就是修改的最真实的对象。但是现在的方案是将session中的值都存在redis中,webFlow代码中很多地方都是直接从session中取值然后进行修改,最终无法体现到redis中,所以会出现登录流程走不通的问题。


    最近发现目前cas源代码太过臃肿,估计是换了一批有一批开发人员维护的原因;每个维护人员的代码风格都不一样,导致源代码修改难度不小;虽然cas那么多年在通用性上面做的还不错,现在的问题就是对集群支持不足。

    解决方案:

    1、使用组播方式实现session复制(session无法持久化,依旧存放在jvm内存中,并且session复制效率较低,可作为暂时性方案)

    2、重新实现cas的登录流程(绕过web-flow登录流程即可,对cas-core源代码足够熟悉可以采用此方案)

    3、使用其他第三方SSO框架或者自己实现一套单点登录系统(推荐此方案)

    展开全文
  • 面试官:讲讲session的持久

    千次阅读 多人点赞 2020-09-26 12:40:26
    一、session知识回顾 1.1 session何时创建? 默认第一次访问时,使用到了HttpSession就会创建(request.getSession),访问JSP时由于会自备九大内置对象,因此也会创建session(jsp本质上也是一个servlet,从这个...

    一、session知识回顾

    1.1 session何时创建?

    默认第一次访问时,使用到了HttpSession就会创建(request.getSession),访问JSP时由于会自备九大内置对象,因此也会创建session

    1.2 session何时销毁?

    1):当session存活时间到期时销毁(默认30分钟)

    可以在web.xml中配置,延长session的存活时间:

    <session-config>
    <!-- 单位:分钟 -->
       <session-timeout>30</session-timeout>
    </session-config>
    

    2):调用session的invalidate()方法时销毁

    3):调用session.setMaxInactiveInterval()方法时间到期时销毁(此方法单位为分钟)

    4):服务器关闭,session销毁

    二、session如何持久化?

    2.1 概念

    使用session的钝化与活化可以使session进行磁盘的持久化

    钝化后可以保存到磁盘,文件名为:sessionid.session,下次客户端访问原来的会话(服务器关闭之前的)只要带上原来的sessionid即可把上一次的会话找回来(活化)

    在这里插入图片描述

    session钝化后,如果遇到session.invalidate(),session.setMaxInactiveInterval()时间到期,钝化的文件会自动删除。

    2.2 代码实现session持久化

    1)创建一个web项目

    • 依赖:
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-api</artifactId>
        <version>8.5.41</version>
    </dependency>
    

    2)在web项目中添加如下配置:

    在这里插入图片描述

    <Context>
        <!-- maxIdleSwap:session中的对象多长时间不使用就钝化(单位为分钟) -->
        <!-- directory:钝化后的对象的文件写到磁盘的哪个目录下  配置钝化的对象文件在work/catalina/localhost/钝化文件 -->
        <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
            <Store className="org.apache.catalina.session.FileStore" directory="d:/aaa" />
        </Manager>
    </Context>
    

    3)编写钝化类

    要使session存储的对象能钝化和活化必须实现HttpSessionAcivationListener接口,要能将对象存储到硬盘上必须实现Serializable接口

    package com.lscl.entity;
    
    import javax.servlet.http.HttpSessionActivationListener;
    import javax.servlet.http.HttpSessionEvent;
    import java.io.Serializable;
    
    /**
     * 要使session存储的对象能钝化和活化必须实现HttpSessionAcivationListener接口
     * 要能将对象存储到硬盘上必须实现Serializable接口
     */
    public class Person implements HttpSessionActivationListener, Serializable {
    
        private String id;
        private String name;
    
        public Person() {
        }
    
        public Person(String id, String name) {
            this.id = id;
            this.name = name;
        }
    
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        //钝化时执行的方法
        public void sessionWillPassivate(HttpSessionEvent se) {
            // TODO Auto-generated method stub
            System.out.println("Person钝化了");
        }
    
        //活化时执行的方法
        public void sessionDidActivate(HttpSessionEvent se) {
            // TODO Auto-generated method stub
            System.out.println("Person活化了");
    
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    • 创建session:
    package com.lscl.servlet;
    
    import com.lscl.entity.Person;
    
    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("/create")
    public class CreateServlet extends HttpServlet {
    
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
            System.out.println("create访问成功..."+req.getSession().getId());
    
            Person person=new Person("1","张三");
    
            // 将对象存入session
            req.getSession().setAttribute("person",person);
    
        }
    }
    
    
    • 查询session:
    package com.lscl.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("/query")
    public class QueryServlet extends HttpServlet {
    
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
            System.out.println("query访问成功..."+req.getSession().getId());
            System.out.println(req.getSession().getAttribute("person"));
        }
    }
    
    
    • 删除session:
    package com.lscl.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("/delete")
    public class DeleteServlet extends HttpServlet {
    
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
            System.out.println("delete访问成功..."+req.getSession().getId());
    
            // 销毁session(钝化的文件也会被删除)
            req.getSession().invalidate();
        }
    }
    
    

    2.3 测试session的持久化

    1)访问地址:http://localhost:8080/create创建session,并等1分钟(等待session钝化)

    在这里插入图片描述

    查看session文件:
    在这里插入图片描述

    2)重新启动服务器(session销毁),访问http://localhost:8080/query,查看控制台信息

    在这里插入图片描述
    发现服务器重启之后(session销毁),会话中的数据依旧能够找回来;

    • 这里说一点,服务器重启后,是session销毁了,并不是cookie(sessionid)销毁了,cookie依旧保存在前端浏览器,只要cookie没有销毁,前端依旧带的是上传的会话id来到后台

    我们换个浏览器,访问http://localhost:8080/query,发现sessionid又是新的了,此时服务器又会创建一个新的session
    在这里插入图片描述

    3)访问http://localhost:8080/delete,发现session文件被删除了

    三、总结一下

    • session的持久化:session的持久化分为钝化活化,将session中的内容持久化到磁盘称为钝化,钝化后的session会永久保存在磁盘中,当session销毁时,.session文件也会被删除

    • 被持久化的对象必须实现HttpSessionAcivationListenerSerializable接口

    • 我们平时关闭浏览器之后,session的会话信息查询不到了并不是session销毁了,而是前端的cookie销毁了,此cookie上保存了上次会话的id,访问后台时,会自动带上,如果后台发现没有带上sessionid则创建一个新的session,并将此session的id写回前端,前端保存到cookie上;至于session何时销毁,文章开篇已经说了

    记得点赞

    展开全文
  • spring-session自定义序列

    千次阅读 2018-05-05 13:22:29
    spring-session默认采用jdk序列方法,该方法效率低下、内存占用大,且需要额外修改代码。故需要自定义序列方法自定义序列方法使用jackson库首先需要一个类作为序列的工具,需要实现RedisSerializer该接口在反...

    spring-session默认采用jdk序列化方法,该方法效率低下、内存占用大,且需要额外修改代码。故需要自定义序列化方法


    自定义序列方法使用jackson库


    首先需要一个类作为序列化的工具,需要实现

    RedisSerializer

    该接口在反序列化时没有提供对应的class对象,因此使用jackson反序列化时,都会返回成Object对象


    因此我的解决思路是,在序列化时,获取对应bean的class,将其和bean序列化后的结果一并返回,存入redis

    反序列化时,首先将byte数组转化成字符串,在从中截取存入的class字符串,作为参数传入jackson反序列化方法中

    问题:对于带有泛型的bean,无法将其转化成真正适合的类型

    解决方案:对于list,map,set等集合类,获取其第一个元素的class,存入redis

    缺点:要求集合类元素必须是同一个子类,不能来自于同一个父类


    问题:spring-session在删除attribute时,并没有真正从redis中删除,只是将value置为null,此时也会调用该类做序列化

    解决方案:查看spring-session源码得知,对于null值得处理方法为直接返回一个个数为0的byte数组,反序列化时直接返回null即可


    import cn.nsu.edu.web.four.config.BaseStatic;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.type.TypeFactory;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    import org.springframework.data.redis.serializer.SerializationUtils;
    
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.util.*;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class SessionSerializer implements RedisSerializer<Object> {
        @Autowired
        private ObjectMapper mapper;
        private Logger logger = LoggerFactory.getLogger(getClass());
        private final String separator = "=";
        private final String classPrefix = "<";
        private final String classSuffix = ">";
        private final String classSeparator = ",";
    
        private Pattern pattern;
    
        public SessionSerializer() {
            pattern = Pattern.compile("<(.*)>");
    
    
        }
    
        /**
         * 获取class,包含集合类的泛型
         * <p>暂只支持最多两个泛型,同时集合内数据必须为同一个实现类,不可将泛型声明成父类</p>
         *
         * @param obj 将要序列化的对象
         * @return 没有泛型,形式为java.lang.String<>
         * <p>一个泛型,形式为java.lang.String<java.lang.String></p>
         * <p>两个个泛型,形式为java.lang.String<java.lang.String,java.lang.String></p>
         */
        private String getBegin(Object obj) {
            StringBuilder builder = new StringBuilder(obj.getClass().toString().substring(6) + classPrefix);
            if (obj instanceof List) {
                List list = ((List) obj);
                if (!list.isEmpty()) {
                    Object temp = list.get(0);
                    builder.append(temp.getClass().toString().substring(6));
                }
            } else if (obj instanceof Map) {
                Map map = ((Map) obj);
                Iterator iterator = map.keySet().iterator();
                if (iterator.hasNext()) {
                    Object key = iterator.next();
                    Object value = map.get(key);
                    builder.append(key.getClass().toString().substring(6)).append(classSeparator).append(value.getClass().toString().substring(6));
                }
            } else if (obj instanceof Set) {
                Set set = ((Set) obj);
                Iterator iterator = set.iterator();
    
                if (iterator.hasNext()) {
                    Object value = iterator.next();
                    builder.append(value.getClass().toString().substring(6));
                }
            }
            builder.append(classSuffix);
            return builder.toString();
        }
    
        @Override
        public byte[] serialize(Object o) throws SerializationException {
            if (o == null)
                return new byte[0];
            try {
                String builder = getBegin(o) +
                        separator +
                        mapper.writeValueAsString(o);
                return builder.getBytes(BaseStatic.CHARSET);
            } catch (UnsupportedEncodingException | JsonProcessingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
            if (bytes == null || bytes.length == 0) return null;//已被删除的session
            try {
                String temp = new String(bytes, BaseStatic.CHARSET);
    
                String cl[] = getClass(temp);
    
                if (cl == null) {
                    throw new RuntimeException("错误的序列化结果=" + temp);
                }
                if (cl.length == 1) {
                    return mapper.readValue(temp.substring(temp.indexOf(separator) + 1), Class.forName(cl[0]));
                } else if (cl.length == 2) {
                    TypeFactory factory = mapper.getTypeFactory();
                    JavaType type = factory.constructParametricType(Class.forName(cl[0]), Class.forName(cl[1]));
                    return mapper.readValue(temp.substring(temp.indexOf(separator) + 1), type);
                } else if (cl.length == 3) {
                    TypeFactory factory = mapper.getTypeFactory();
                    JavaType type = factory.constructParametricType(Class.forName(cl[0]), Class.forName(cl[1]), Class.forName(cl[2]));
                    return mapper.readValue(temp.substring(temp.indexOf(separator) + 1), type);
                }
            } catch (ClassNotFoundException | IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 解析字符串,获取class
         * <p>一个类型,java.lang.String<>={}</p>
         * <p>两个类型,后面为泛型,java.lang.String<java.lang.String>={}</p>
         * <p>三个类型,后面为泛型,java.lang.String<java.lang.String,java.lang.String>={}</p>
         *
         * @param value 包含class的字符串
         * @return 返回所有类的数组
         */
        private String[] getClass(String value) {
            int index = value.indexOf(classPrefix);
            if (index != -1) {
                Matcher matcher = pattern.matcher(value.subSequence(index, value.indexOf(classSuffix) + 1));
                if (matcher.find()) {
                    String temp = matcher.group(1);
                    if (temp.isEmpty()) {//没有泛型
                        return new String[]{value.substring(0, index)};
                    } else if (temp.contains(classSeparator)) {//两个泛型
                        int nextIndex = temp.indexOf(classSeparator);
                        return new String[]{
                                value.substring(0, index),
                                temp.substring(0, nextIndex),
                                temp.substring(nextIndex + 1)
                        };
                    } else {//一个泛型
                        return new String[]{
                                value.substring(0, index),
                                temp
                        };
                    }
                }
            }
            return null;
    
        }
    }
    

    配置spring-session序列化,在之前的配置文件上进行修改

     <bean id="springSessionDefaultRedisSerializer" class="cn.nsu.edu.web.four.session.serializer.SessionSerializer"/>
        <bean id="jedisConnectionFactory"
              class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
            <property name="hostName" value="${redis.host}"/>
            <property name="port" value="${redis.port}"/>
            <property name="timeout" value="${redis.timeout}"/>
            <property name="password" value="${redis.password}"/>
            <property name="database" value="${redis.database}"/>
            <property name="usePool" value="true"/>
            <property name="poolConfig" ref="redisPoolConfig"/>
    
        </bean>
    
    
        <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
            <property name="connectionFactory" ref="jedisConnectionFactory"/>
            <property name="defaultSerializer" ref="springSessionDefaultRedisSerializer"/>
            <!--指定序列化类-->
            <property name="valueSerializer" ref="springSessionDefaultRedisSerializer"/>
            <property name="hashValueSerializer" ref="springSessionDefaultRedisSerializer"/>
        </bean>



    展开全文
  • Tomcat7 session 持久关闭

    千次阅读 2018-05-08 16:46:47
    Tomcat7 session 持久关闭tomcat 7默认开启session持久功能,这样当你的tomcat重启之后,会自动重新加载session,但是有时候我们不需要这个功能。

    Tomcat7 session 持久化关闭

    tomcat 7默认开启session持久化功能,这样当你的tomcat重启之后,会自动重新加载session,这样当tomcat重启了保存在session里面的信息也不会丢失,但是有时候我们并不需要这个功能。

    所以我们就有了关闭session持久化的需求。

    不过这个持久化在使用eclipse加载tomcat的时候是没有效果的,但是部署在服务器就产生效果了,也不知道是为啥。

    打开tomcat目录>conf>context.xml,这是所有web应用共享的配置信息。
    找到下面的一段话

        <!-- Uncomment this to disable session persistence across Tomcat restarts -->
        <!--
        <Manager pathname="" />
        -->

    注释翻译过来就是“取消注释以禁用session持久化当tomcat重启的时候”,所以只要将<Manager pathname="" />注释取消,那么tomcat重启的时候就不会进行持久化了。

    默认情况下,tomcat使用StandardManager来管理session,当tomcat关闭,或者web应用被重新加载的时候,会对内存中的HttpSession对象进行持久化,把它们保存在文件系统中,默认的文件是(比如:host name是localhost,app name是test):
    work\Catalina\localhost\test\SESSIONS.ser

    展开全文
  • session作为一个容器,首先要知道的就是session 存在的位置 :在服务器的内存中 ; session的特点有以下2个【应用场景】: ①共享request域; ② 可用于 :保存用户信息, 来判断用户是否登录 ;比如,在登录...
  • Session的序列和反序列

    千次阅读 2017-10-21 12:35:00
    JavaWeb之Session的序列和反序列 && Session的活化和钝化 4506 应用场景: 1.一般来说,服务器启动后,就不会再关闭了,但是如果逼不得已需要重启,而用户会话还在进行相应的操作,...
  • Tomcat Session 漏洞漏洞描述影响版本安全版本安全建议操作步骤下载你要升级的Tomcat 10.0.0-M5版本:备份旧的tomcat(这部分非必须,根据自己情况而定)开始安装新版本禁止使用Session持久功能FileStore取消...
  • sessionsession简介session的生存周期session存储登录标志?cookie+session存储用户信息以区分用户注销代码实现实现思路登录验证后台程序 loginRecv.php登录成功页面 loginSuccessPage.php跳转页面subPage1.php注销...
  • 前言:PHP反序列也是web安全中常见的一种漏洞,这次就先来大致了解一下PHP反序列漏洞。 一、PHP序列和反序列 在学习PHP反序列漏洞时,先来了解一下基础的知识。 (一)PHP序列 函数 : serialize() 所有...
  • 在进行接口自动测试时,有好多接口都基于登陆接口的响应值来关联进行操作的,在次之前试了很多方法,都没有成功,其实很简单用session来做。 1、在登陆接口创建一个全局session # -*- coding: utf-8 -*- import ...
  • * 设置spring session redis 序列方式 * @param factory * @return */ @Bean public SessionRepository sessionRepository(RedisConnectionFactory factory){ RedisOperationsSessionRepository session...
  • tomcat中session持久配置

    千次阅读 2017-01-11 14:07:57
    修改tomcat配置文件:conf/context.mxl <Manager className="org.apache.catalina.session.PersistentManager" > debug=0 saveOnRestart="true" maxActiveSession="-1" minIdleSwap="-1
  • 版本: ...org.springframework.session</groupId> <artifactId>spring-session-data-redis</artifactId> </dependency> <dependency> <groupId>org.springfr
  • 服务器session持久 SESSION.ser文件

    千次阅读 2016-09-11 14:58:05
    我们知道服务器上的session是生存时间是可以设置的,那么问题来了! 当我们的session时间设置为3个小时,运行一个小时之后服务器关闭了,那这些已经生成的生存时间为3个小时的session(还没有超过生存时间)是存在还是...
  • tomcat session反序列漏洞分析

    千次阅读 2020-06-02 17:06:18
    CVE-2020-9484 tomcat session反序列漏洞</h1> 漏洞通告 可以看到利用条件较为苛刻,并且在复现的时候需要做一定配置 修改PersistenceManager配置,这个配置是在tomcat目录的conf目录中的context.xml中...
  • 1、安装express-sessionsession持久中间件 npm install express-session session持久插件安装说明 mac、linux平台使用session-file-store npm install session-file-store win平台使用nedb-session-...
  • WebSocket的session是不能够被序列的,java.io.NotSerializableException 两种解决方案: 使用spring session自定义session. 既然无法序列化session,那还是存储在Map中,各服务器通过发布订阅变相实现共享...
  • session持久

    千次阅读 2018-08-24 16:46:34
    目录 ...最近同事在做Session外置的功能,我对Session持久、共享也不太了解,学习一下。   一般来说,Tomcat原生的持久化Session方式,有StandardManager和PersistentManager。 版本说明:apa...
  • 1、先来说一下 shiro session 序列到 redis 中的过程 shiro session 放入到 redis 中的 过程(序列过程):1、将 shiro 的 SimpleSession 通过 RedisTemple 模板,有两种方案,即 Jackson 和 fastJson ,都...
  • 今天我们就来看看集群部署,Spring Security 要如何处理 session 并发。 本文是 Spring Security 系列第 17 篇,阅读前面的文章有助于更好的理解本文: 挖一个大坑,Spring Security 开搞! 松哥手把手带你入门
  • 会话Session的持久处理

    千次阅读 2015-10-04 16:06:30
     左半边部分在博客session类中的session缓存时间的两种设置方式中已经详细说明了,在本文章中重点说持久。 持久相对客户端来说是透明的,不能进行修改,全部设置都是默认设置,其定义类似session缓存时间的...
  • 但是这样就会有一个问题,Spring boot在封装Request对象时会将当前SESSION中所有属性对象反序列,反序列都成功以后,将SESSION对象生成。如果有一个微服务将本地的自定义Bean对象放置到SES...
  • Redis习惯使用 Json格式来存储了,spring-session 2.0 开始网上找的方法已经都不适用了,文档里也没说清楚,通过分析源码最后解决。 这里简单介绍一下我的解决方法 1、pom依赖   &lt;dependency&gt; ...
  • 这一篇来继续说说Spring Session Redis中的数据存储,将默认的JDK序列存储修改为使用Fastjson存储,实际上我们知道JDK序列的性能非常慢,而且我们无法直观的查看其中的数据,另外一个我不确定使用JD...
  • 1.错误十月 11, 2016 8:37:18 上午 org.apache.catalina.session.StandardManager doLoad SEVERE: IOException while loading persisted sessions: java.io.WriteAbortedException: writing aborted; java.io....
  • Session钝化机制的本质就在于把服务器中不经常使用的Session对象暂时序列到系统文件系统或是数据库系统中,当被使用时反序列到内存中,整个过程由服务器自动完成。 springboot2.x对session持久是默认禁用的 ...
  • 但是分布式存在websocket session共享问题,于是考虑radis存储session,但是遇到websocket session不支持序列,无法存储。 一番搜索后有了以下几个方案 1. 使用spring session自定义session. 2. 既然
  • session的序列、反序列以及钝化、活化序列:把session持久到硬盘中(比如服务器关闭时)反序列:当服务器重启的时候,还原原来的session,内存中的session被销毁钝化:所谓钝化session,就是把session通过...
  • shiro session序列失败问题

    千次阅读 2019-03-13 17:17:33
    场景 今天一时兴起想要做个...shiro SessionDao 的session 实现了ValidatingSession接口,当序列时转变成字符串会导致多出来 “valid”:true 解决方法 存储session字段修改为byte[] 反序列的代码修改为 Si...
  • 我把session放在了数据库里,比如这样:但长时间未登录后,再次使用我记下的 JESESSIONID登录时,报错序列失败和local class incompatible protected Serializable doCreate(Session session) { Serializable ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 593,700
精华内容 237,480
关键字:

去session化