欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Spring Boot分布式系统实践【扩展1】shiro+redis实现session共享、simplesession反序列化失败的问题定位及反思改进

程序员文章站 2022-04-08 19:28:57
前言 调试之前请先关闭Favicon配置 不然会发现有2个请求(如果用nginx+ 浏览器调试的话) 序列化工具类【fastjson版本1.2.37】 发现transient修饰,所以Fastjson不会对这些transient属性进行持久化,所以有了方案二,重写可以json序列化的对象 同时发现有 ......

前言

调试之前请先关闭favicon配置

spring:
    favicon:
      enabled: false

不然会发现有2个请求(如果用nginx+ 浏览器调试的话)
Spring Boot分布式系统实践【扩展1】shiro+redis实现session共享、simplesession反序列化失败的问题定位及反思改进

序列化工具类【fastjson版本1.2.37】

```public class fastjson2jsonredisserializer implements redisserializer {

    public static final charset default_charset = charset.forname("utf-8");

    private class clazz;

    public fastjson2jsonredisserializer(class clazz) {
        super();
        this.clazz = clazz;
    }

    @override
    public byte[] serialize(t t) throws serializationexception {
        if (t == null) {
            return new byte[0];
        }
        return json.tojsonstring(t, serializerfeature.writeclassname).getbytes(default_charset);
    }

    @override
    public t deserialize(byte[] bytes) throws serializationexception {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        string str = new string(bytes, default_charset);

        return (t) json.parseobject(str, clazz);

    }
}

 `org.apache.shiro.session.mgt.simplesession存储到redis中会发现已经丢失了所有属性`

![image [1].png](https://upload-images.jianshu.io/upload_images/231328-ab9c9ca3c2b43710.png?imagemogr2/auto-orient/strip%7cimageview2/2/w/1240)
 
 #### 查看simplesession源码:

public class simplesession implements validatingsession, serializable {

    private transient serializable id;
    private transient date starttimestamp;
    private transient date stoptimestamp;
    private transient date lastaccesstime;
    private transient long timeout;
    private transient boolean expired;
    private transient string host;
    private transient map<object, object> attributes;
/* serializes this object to the specified output stream for jdk serialization.

  • @param out output stream used for object serialization.
  • @throws ioexception if any of this object's fields cannot be written to the stream.
  • @since 1.0
    */
    private void writeobject(objectoutputstream out) throws ioexception {
        out.defaultwriteobject();
        short alteredfieldsbitmask = getalteredfieldsbitmask();
        out.writeshort(alteredfieldsbitmask);
        if (id != null) {
            out.writeobject(id);
        }
        if (starttimestamp != null) {
            out.writeobject(starttimestamp);
        }
        if (stoptimestamp != null) {
            out.writeobject(stoptimestamp);
        }
        if (lastaccesstime != null) {
            out.writeobject(lastaccesstime);
        }
        if (timeout != 0l) {
            out.writelong(timeout);
        }
        if (expired) {
            out.writeboolean(expired);
        }
        if (host != null) {
            out.writeutf(host);
        }
        if (!collectionutils.isempty(attributes)) {
            out.writeobject(attributes);
        }
    }

/*

  • reconstitutes this object based on the specified inputstream for jdk serialization.
  • @param in the input stream to use for reading data to populate this object.
  • @throws ioexception            if the input stream cannot be used.
  • @throws classnotfoundexception if a required class needed for instantiation is not available in the present jvm
  • @since 1.0
    */
    @suppresswarnings({"unchecked"})
    private void readobject(objectinputstream in) throws ioexception, classnotfoundexception {
***发现transient修饰,所以fastjson不会对这些transient属性进行持久化,所以有了方案二,重写可以json序列化的对象
同时发现有writeobject()方法写着“ serializes this object to the specified output stream for jdk serialization.”,
所以有了方案一,修改序列化工具( 默认使用jdkserializationredisserializer,这个序列化模式会将value序列化成字节码)
问题我们就好对症下药了***
## 方案一:

修改序列化工具类 (`这个方式其实有问题`)

public class fastjson2jsonredisserializer implements redisserializer {
    private class clazz;
    public fastjson2jsonredisserializer(class clazz) {
        super();
        this.clazz = clazz;
    }
    @override
    public byte[] serialize(t t) {
        return objectutils.serialize(t);
    }
    @override
    public t deserialize(byte[] bytes) {
        return (t) objectutils.unserialize(bytes);
    }
}

### objectutils的方法如下:

/**

  • 序列化对象
  • @param object
  • @return
    */
    public static byte[] serialize(object object) {
       objectoutputstream oos = null;
       bytearrayoutputstream baos = null;
       try {
          if (object != null){
             baos = new bytearrayoutputstream();
             oos = new objectoutputstream(baos);
             oos.writeobject(object);
             return baos.tobytearray();
          }
       } catch (exception e) {
          e.printstacktrace();
       }
       return null;
    }

/**

  • 反序列化对象
  • @param bytes
  • @return
    */
    public static object unserialize(byte[] bytes) {
       bytearrayinputstream bais = null;
       try {
          if (bytes != null && bytes.length > 0){
             bais = new bytearrayinputstream(bytes);
             objectinputstream ois = new objectinputstream(bais);
             return ois.readobject();
          }
       } catch (exception e) {
          e.printstacktrace();
       }
       return null;
    }
***`此方案会严重依赖对象class,如果反序列化时class对象不存在则会报错
修改为: jdkserializationredisserializer
`***
 
![image [2].png](https://upload-images.jianshu.io/upload_images/231328-900964ebbd4757e2.png?imagemogr2/auto-orient/strip%7cimageview2/2/w/900)

### 方案二:

***继承simplesession并重写
让相关的字段可以被序列化(不被transient修饰)
重写之后一定要重写sessionmanager里的方法***

@override
protected session newsessioninstance(sessioncontext context) {
simplesession session = new myredissession(context.gethost());
// session.setid(idgen.uuid());
session.settimeout(sessionutils.session_time);
return session;
}

#### 由方案二引发的另一个问题就是:
**`在微服务开发过程中,为了使用方便经常会将频繁访问的信息如用户、权限等放置到session中,便于服务访问,而且,微服务间为了共享session,通常会使用redis共享存储。但是这样就会有一个问题,在封装request对象时会将当前session中所有属性对象反序列化,反序列化都成功以后,将session对象生成。如果有一个微服务将本地的自定义bean对象放置到session中,则其他微服务都将出现反序列化失败,请求异常,服务将不能够使用了,这是一个灾难性问题。`**
##### 以下是为了解决下面问题提出来的一种思路。
反序列化失败在于attribute中添加了复杂对象,由此推出以下解决方案:

1. 将复杂对象的(即非基本类型的)key进行tostring转换(转换之后再md5缩减字符串,或者用类名代替)
2. 将复杂对象的(即非基本类型的)value进行json化(不使用不转换的懒加载模式)

`注意:
日期对象的处理(单独处理)`

  /**
     * 通过类型转换,将string反序列化成对象
     * @param key
     * @param value
     * @return
     */
    public object getobjectvalue(string key,string value){
        if(key == null || value == null){
           return null;
        }
        string clz = key.replace(flag_str,"");
        try {
           class aclass = class.forname(clz);
           if(aclass.equals(date.class)){
               return dateutils.parsedate(value);
           }
          return   jsonobject.parseobject(value,aclass);
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
//        如果反序列化失败就进行json化处理
        return jsonobject.parseobject(value);
    }

```
经过如此处理可以在所有系统里共享缓存
唯一缺点就是太复杂了,可能引起其他系统的修改导致反序列化失败(这个下次再讨论或者实验,因为有这么复杂的功夫,就可以考虑用jwt)

还有一种方案是将复杂对象放到redis中去,实行懒加载机制(不用的复杂对象,不从redis里获取,暂未实现测试)