2. 程式人生 > >shiro原始碼分析篇5:結合redis實現session跨域

shiro原始碼分析篇5:結合redis實現session跨域

阿新 • • 發佈：2018-12-19

相信大家對session跨域也比較瞭解了。以前單臺伺服器session本地快取就可以了，現在分散式後，session集中管理，那麼用redis來管理是一個非常不錯的選擇。

在結合redis做session快取的時候，也遇到了很多坑，不過還算是解決了。

和上篇講述一樣，實現自定義快取，需要實現兩個介面Cache,CachaManager。
RedisCache.java

package com.share1024.cache;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.util.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * @author : yesheng
 * @Description :
 * @Date : 2017/10/22
 */
 

public class RedisCache<K,V> implements Cache<K,V> {

    private Logger logger = LoggerFactory.getLogger(RedisCache.class);

    private final String SHIRO_SESSION="shiro_session:";

    public String getKey(K key){
        return SHIRO_SESSION + key;
    }

    @Override
    public V get
 
(K key) throws CacheException {
        logger.info("get--從redis中獲取:{}",key);
        Object o =  SerializeUtils.deserialize(RedisUtil.getInstance().get(getKey(key).getBytes()));

        if(o == null){
            return null;
        }

        return (V)o;
    }

    @Override
    public V put(K key, V value
 
) throws CacheException {
        logger.info("put--儲存到redis，key:{},value:{}",key,value);
        get(key);

        byte[] b = SerializeUtils.serialize(value);
        Object o = SerializeUtils.deserialize(b);
        RedisUtil.getInstance().set(getKey(key).getBytes(),SerializeUtils.serialize(value));
        return get(key);
    }

    @Override
    public V remove(K key) throws CacheException {
        logger.info("remove--刪除key:{}",key);
        V value = get(key);
        RedisUtil.getInstance().del(getKey(key).getBytes());
        return value;
    }

    @Override
    public void clear() throws CacheException {
        logger.info("clear--清空快取");
        RedisUtil.getInstance().del((SHIRO_SESSION + "*").getBytes());
    }

    @Override
    public int size() {
        logger.info("size--獲取快取大小");
        return keys().size();
    }

    @Override
    public Set<K> keys() {
        logger.info("keys--獲取快取大小keys");
        return (Set<K>) RedisUtil.getInstance().keys(SHIRO_SESSION + "*");
    }

    @Override
    public Collection<V> values() {
        logger.info("values--獲取快取值values");
        Set<K> keys = keys();
        if (!CollectionUtils.isEmpty(keys)) {
            List<V> values = new ArrayList<V>(keys.size());
            for (K key : keys) {
                @SuppressWarnings("unchecked")
                V value = get(key);
                if (value != null) {
                    values.add(value);
                }
            }
            return Collections.unmodifiableList(values);
        } else {
            return Collections.emptyList();
        }
    }
}

RedisCacheManager.java

package com.share1024.cache;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;

import java.util.concurrent.ConcurrentHashMap;

/**
 * @author : yesheng
 * @Description :
 * @Date : 2017/10/22
 */
public class RedisCacheManager implements CacheManager{

    private final ConcurrentHashMap<String,Cache> caches = new ConcurrentHashMap<String, Cache>();

    public <K, V> Cache<K, V> getCache(String name) throws CacheException {

        Cache cache = caches.get(name);

        if(cache == null){
            cache = new RedisCache<K,V>();
            caches.put(name,cache);
        }
        return cache;
    }
}

RedisUtil.java太長 大家參考https://github.com/smallleaf/cacheWeb
SerializeUtils.java

package com.share1024.cache;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;

/**
 * @author : yesheng
 * @Description :
 * @Date : 2017/10/22
 */
public class SerializeUtils {
    private static Logger logger = LoggerFactory.getLogger(SerializeUtils.class);

    /**
     * 反序列化
     * @param bytes
     * @return
     */
    public static Object deserialize(byte[] bytes) {

        Object result = null;

        if (isEmpty(bytes)) {
            return null;
        }

        try {
            ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
            try {
                ObjectInputStream objectInputStream = new ObjectInputStream(byteStream);
                try {
                    result = objectInputStream.readObject();
                }
                catch (ClassNotFoundException ex) {
                    throw new Exception("Failed to deserialize object type", ex);
                }
            }
            catch (Throwable ex) {
                throw new Exception("Failed to deserialize", ex);
            }
        } catch (Exception e) {
            logger.error("Failed to deserialize",e);
        }
        return result;
    }

    public static boolean isEmpty(byte[] data) {
        return (data == null || data.length == 0);
    }

    /**
     * 序列化
     * @param object
     * @return
     */
    public static byte[] serialize(Object object) {

        byte[] result = null;

        if (object == null) {
            return new byte[0];
        }
        try {
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream(128);
            try  {
                if (!(object instanceof Serializable)) {
                    throw new IllegalArgumentException(SerializeUtils.class.getSimpleName() + " requires a Serializable payload " +
                            "but received an object of type [" + object.getClass().getName() + "]");
                }
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteStream);
                objectOutputStream.writeObject(object);
                objectOutputStream.flush();
                result =  byteStream.toByteArray();
            }
            catch (Throwable ex) {
                throw new Exception("Failed to serialize", ex);
            }
        } catch (Exception ex) {
            logger.error("Failed to serialize",ex);
        }
        return result;
    }

}

修改spring-shiro.xml

 <bean id="redisCacheManager" class="com.share1024.cache.RedisCacheManager"></bean>
   <!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="userRealm"/>
        <property name="sessionManager" ref="sessionManager"/>
        <!--<property name="cacheManager" ref="cacheManagerShiro"/>-->
        <property name="cacheManager" ref="redisCacheManager"/>
    </bean>

即可。
如何測試跨域，大家用nginx負載均衡一下就可以了。一臺伺服器登入，其他伺服器就不用再登入，session從redis中獲取。

在網上看到很多基本上是還要重寫sessionDao。從前面幾篇分析來看，如果只是要換個快取地方是完全沒有必要的。實現Cache,CacheManager介面即可。

當然如果有其它的業務要求就看情況實現sessionDao。

巨坑來了。
1、Redis儲存物件
序列化方式，來儲存
2、SimpleSession：shiro存入快取的都是SimpleSession。來看看這個類:

public class SimpleSession implements ValidatingSession, Serializable {

    // Serialization reminder:
    // You _MUST_ change this number if you introduce a change to this class
    // that is NOT serialization backwards compatible.  Serialization-compatible
    // changes do not require a change to this number.  If you need to generate
    // a new number in this case, use the JDK's 'serialver' program to generate it.
    private static final long serialVersionUID = -7125642695178165650L;

    //TODO - complete JavaDoc
    private transient static final Logger log = LoggerFactory.getLogger(SimpleSession.class);

    protected static final long MILLIS_PER_SECOND = 1000;
    protected static final long MILLIS_PER_MINUTE = 60 * MILLIS_PER_SECOND;
    protected static final long MILLIS_PER_HOUR = 60 * MILLIS_PER_MINUTE;

    //serialization bitmask fields. DO NOT CHANGE THE ORDER THEY ARE DECLARED!
    static int bitIndexCounter = 0;
    private static final int ID_BIT_MASK = 1 << bitIndexCounter++;
    private static final int START_TIMESTAMP_BIT_MASK = 1 << bitIndexCounter++;
    private static final int STOP_TIMESTAMP_BIT_MASK = 1 << bitIndexCounter++;
    private static final int LAST_ACCESS_TIME_BIT_MASK = 1 << bitIndexCounter++;
    private static final int TIMEOUT_BIT_MASK = 1 << bitIndexCounter++;
    private static final int EXPIRED_BIT_MASK = 1 << bitIndexCounter++;
    private static final int HOST_BIT_MASK = 1 << bitIndexCounter++;
    private static final int ATTRIBUTES_BIT_MASK = 1 << bitIndexCounter++;

    // ==============================================================
    // NOTICE:
    //
    // The following fields are marked as transient to avoid double-serialization.
    // They are in fact serialized (even though 'transient' usually indicates otherwise),
    // but they are serialized explicitly via the writeObject and readObject implementations
    // in this class.
    //
    // If we didn't declare them as transient, the out.defaultWriteObject(); call in writeObject would
    // serialize all non-transient fields as well, effectively doubly serializing the fields (also
    // doubling the serialization size).
    //
    // This finding, with discussion, was covered here:
    //
    // http://mail-archives.apache.org/mod_mbox/shiro-user/201109.mbox/%[email protected]%3E
    //
    // ==============================================================
    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;

大家發現沒有SimpleSession的屬性已經被transient修飾，序列化的時候應該不會被序列化進去啊。
我當時糾結了很久。最後發現SimpleSession，寫了這兩個方法writeObject(ObjectOutputStream)和readObject(ObjectInputStream)

    @SuppressWarnings({"unchecked"})
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        short bitMask = in.readShort();

        if (isFieldPresent(bitMask, ID_BIT_MASK)) {
            this.id = (Serializable) in.readObject();
        }
        if (isFieldPresent(bitMask, START_TIMESTAMP_BIT_MASK)) {
            this.startTimestamp = (Date) in.readObject();
        }
        if (isFieldPresent(bitMask, STOP_TIMESTAMP_BIT_MASK)) {
            this.stopTimestamp = (Date) in.readObject();
        }
        if (isFieldPresent(bitMask, LAST_ACCESS_TIME_BIT_MASK)) {
            this.lastAccessTime = (Date) in.readObject();
        }
        if (isFieldPresent(bitMask, TIMEOUT_BIT_MASK)) {
            this.timeout = in.readLong();
        }
        if (isFieldPresent(bitMask, EXPIRED_BIT_MASK)) {
            this.expired = in.readBoolean();
        }
        if (isFieldPresent(bitMask, HOST_BIT_MASK)) {
            this.host = in.readUTF();
        }
        if (isFieldPresent(bitMask, ATTRIBUTES_BIT_MASK)) {
            this.attributes = (Map<Object, Object>) in.readObject();
        }
    }
    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);
        }
    }

雖然屬性已經被transient，但自定義序列化方法，又讓他們重新序列化了。在這裡序列化的好處，就是我們可以做一些自定義操作，比如校驗資訊，序列化到本地，等等。看看上面為null就不序列化，這樣可以節省記憶體空間等等。

3、序列化報錯
我在進行測試時，發現登入成功後，登入的資訊一直儲存不到redis中。導致每次都要登入，找了很久都沒有發現原因。最終一步步debug終於發現。在做登入驗證的User類沒有實現Serializable。序列化一直報錯只是異常沒有丟擲。所以在做序列化有關工作時，要看看相關類是否能夠序列化。

這5篇從簡單登入開始，一直到現在能夠自定義快取，用redis來做session快取等等。
shiro篇已經過去。

談到session跨域。
等有時間我想再寫三篇，一篇是tomcat實現session跨域處理。一篇是分析spring-session實現原理。一篇是spring-session如何與shiro結合。

菜鳥不易，望有問題指出，共同進步。

相關推薦

shiro原始碼分析篇5:結合redis實現session跨域

相信大家對session跨域也比較瞭解了。以前單臺伺服器session本地快取就可以了，現在分散式後，session集中管理，那麼用redis來管理是一個非常不錯的選擇。 在結合redis做session快取的時候，也遇到了很多坑，不過還算是解決了。 和上篇講述一樣，實現自定義快

java結合wabacus實現session跨域、session共享（第二版）

宣告：該版相對於第一版有所改進。原因：每一版存在session覆蓋問題，分析如下： request().getServletContext().setAttribute("globelSession", session); 我們可以把globelSession想象成是索引

shiro原始碼分析篇4:自定義快取

這篇講解shiro如何管理session，如何與ehcache結合。我們自己如何寫個簡單的快取替換ehcache。 首先來看看配置 <!-- 快取管理器 使用Ehcache實現 --> <bean id="cacheManagerShiro" cla

shiro原始碼分析篇3:使用者登入快取登入資訊

上篇講了shiro是如何過濾請求連結，判斷使用者是否已經登入。 這篇就是講解shiro使用者登入時，如何把登入資訊快取起來，下次使用者登入其他需要登入的連結時，如何判斷已經登入了。 RetryLimitHashedCredentialsMatcher自定義的登入憑據，也就是登入的

shiro原始碼分析篇2:請求過濾，登入判斷

下面是我的配置檔案 spring-shiro.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"

shiro原始碼分析篇1:前言

目的：通過這幾篇shiro原始碼分析，用redis代替ehache做session快取。 相信大家對shiro也不陌生了，網上對shiro原始碼分析的也比較多了。筆者也看多很多優秀的部落格。這幾篇shiro原始碼分析的目的，就是弄明白，shiro是如何管理session的，如何通過r

springboot專案Nginx+Tomcat實現負載均衡結合Redis實現session共享問題

對於分散式使用Nginx+Tomcat實現負載均衡，當同一個使用者登入後，再次訪問可能分發到不同的服務，這樣我們就取不到之前登入session，出現未登入現象。所以我們必須解決共享session問題。  方式一：儲存在資料庫中 ， 使用者登入時，把session資訊儲存在資

php實現SESSION跨域

稍微大一點的網站，通常都會有不只一個伺服器，每個伺服器執行著不同的功能模組或者不同的子系統，他們使用不同的二級域名，比如www.a.com、i.a.com、bbs.a.com。而一個整體性強的網站，使用者系統是統一的，即一套使用者名稱、密碼在整個網站的各個子系統中都是可以登入使用的。各個伺服器共享使用

RocketMQ原始碼分析之RocketMQ事務訊息實現原理上篇(二階段提交)

根據上文的描述，傳送事務訊息的入口為： TransactionMQProducer#sendMessageInTransaction： public TransactionSendResult sendMessageInTransaction(final Message msg, final Object

Shiro許可權管理框架（二）：Shiro結合Redis實現分散式環境下的Session共享

首發地址：https://www.guitu18.com/post/2019/07/28/44.html 本篇是Shiro系列第二篇，使用Shiro基於Redis實現分散式環境下的Session共享。在講Session共享之前先說一下為什麼要做Session共享。 為什麼要做Session共享 什麼是Ses

【一起學原始碼-微服務】Feign 原始碼三：Feign結合Ribbon實現負載均衡的原理分析

前言 前情回顧 上一講我們已經知道了Feign的工作原理其實是在專案啟動的時候，通過JDK動態代理為每個FeignClinent生成一個動態代理。 動態代理的資料結構是：ReflectiveFeign.FeignInvocationHandler。其中包含target(裡面是serviceName等資訊)和d

php結合redis實現高並發下的搶購、秒殺功能

緩存 使用 fclose rtl global 簡單模擬 解決 fun 非阻塞 搶購、秒殺是如今很常見的一個應用場景，主要需要解決的問題有兩個： 1 高並發對數據庫產生的壓力 2 競爭狀態下如何解決庫存的正確減少（"超賣"問題） 對於第一個問題，已經很容易想到用緩存來處理搶

Mybatis原始碼分析（5）—— 外掛的原理

MyBatis 允許你在已對映語句執行過程中的某一點進行攔截呼叫。 預設情況下，可以使用外掛來攔截的方法呼叫包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, cl

Shiro原始碼分析(3) - 認證器(Authenticator)

本文在於分析Shiro原始碼，對於新學習的朋友可以參考 [開濤部落格](http://jinnianshilongnian.iteye.com/blog/2018398)進行學習。 Authenticator就是認證器，在Shiro中負責認證使用者提交的資訊，

Shiro原始碼分析(2) - 會話管理器(SessionManager)

本文在於分析Shiro原始碼，對於新學習的朋友可以參考 [開濤部落格](http://jinnianshilongnian.iteye.com/blog/2018398)進行學習。 本文對Shiro中的SessionManager進行分析，SessionMan

nginx原始碼分析（5）——監聽socket初始化

在nginx原始碼分析（4）中，看到了nginx的事件模型，但其中沒有介紹監聽socket的初始化。而對於web server來說，需要通過監聽socket來監聽客戶端的連線等。本篇將會具體介紹這方面的內容。還記得在前文介紹ngx_cycle_t結構時，它具有一個listening屬性，是一個數組，

精通SpringBoot——第七篇：整合Redis實現快取

專案中用到快取是很常見的事情， 快取能夠提升系統訪問的速度，減輕對資料庫的壓力等好處。今天我們來講講怎麼在spring boot 中整合redis 實現對資料庫查詢結果的快取。 首先第一步要做的就是在pom.xml檔案新增spring-boot-starter-data-redis。 要整合快取，必

spring boot 結合Redis 實現工具類

自己整理了 spring boot 結合 Redis 的工具類 引入依賴 <dependency>     <groupId>org.springframework.boot</groupId>     <art

Spring Boot 結合 Redis實現快取

當Redis作為快取使用時，我們可以將它作為Spring Cache的實現，直接通過註解使用@CacheConfig，@Cacheable，@CachePut，@CacheEvict。 引入依賴（SpringBoot從1.4版本開始，spring-boot-starter-redis依賴改名了。

原始碼分析篇之手寫springvc

1.先建立maven的web專案，結構如下 2.在web.xml新增如下配置 <servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>com.mayik