Spring boot shiro session cache ecache redis 共存配置

SecurityManager

對應 shiro來說 SecurityManager 非常重要，這裏配置了
Realm
CacheManager
RememberMeManager
sessionManager
可以說是shiro的核心

我們今天就是要 配置 sessionManager 和 CacheManager
讓 ecache和redis來緩存 session和 AuthorizationInfo的數據信息
使得應用能集羣部署，多個機器之間共享session和 認證授權數據信息。

SecurityManager的配置

    //配置核心安全事務管理器
    @Bean
    public SecurityManager securityManager(@Qualifier("authRealm")AuthRealm authRealm,@Qualifier("redisCacheManager")CacheManager
            cacheManager) {

       logger.info("--------------shiro已經加載----------------");
        DefaultWebSecurityManager manager=new DefaultWebSecurityManager();
        // 設置realm.
        manager.setRealm(authRealm);

        //注入緩存管理器;
        //注意:開發時請先關閉，如不關閉熱啓動會報錯
        manager.setCacheManager(cacheManager);//這個如果執行多次，也是同樣的一個對象;
        //注入記住我管理器;
        manager.setRememberMeManager(rememberMeManager());


        return manager;
    }

這裏配置了

 manager.setCacheManager(cacheManager)

CacheConfig 配置 ehCacheManager 和redisCacheManager

@Configuration
@EnableCaching
public class CacheConfig {
    private Logger logger = org.slf4j.LoggerFactory.getLogger(getClass());

    @Bean(name = "ehCacheManager")
    public EhCacheManager ehCacheManager() {
        logger.info("--------------ehCacheManager init---------------");
        EhCacheManager cacheManager = new EhCacheManager();
        cacheManager.setCacheManagerConfigFile("classpath:cache/ehcache-shiro.xml");
        logger.info("--------------ehCacheManager init---------------"+cacheManager);
        return cacheManager;
    }

    @Autowired
    private RedisTemplate redisTemplate;

    @Bean(name = "redisCacheManager")
    @Primary
    public RedisCacheManager redisCacheManager() {
        logger.info("--------------redis cache init---------------");
        RedisCacheManager cacheManager = new RedisCacheManager();
        cacheManager.setRedisTemplate(redisTemplate);
        logger.info("--------------redis cache ---------------"+cacheManager);
        return cacheManager;
    }
}

使用 ecache做緩存

1 、那麼 加入依賴

   <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>${ehcache.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache-core</artifactId>
            <version>${ehcache.core.version}</version>
        </dependency>
        <!-- shiro ehcache -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>${shiro.version}</version>
        </dependency>

2、配置 cacheManager

    @Bean(name = "ehCacheManager")
    public EhCacheManager ehCacheManager() {
        logger.info("--------------ehCacheManager init---------------");
        EhCacheManager cacheManager = new EhCacheManager();
        cacheManager.setCacheManagerConfigFile("classpath:cache/ehcache-shiro.xml");
        logger.info("--------------ehCacheManager init---------------"+cacheManager);
        return cacheManager;
    }

3、配置 ehcache-shiro.xml

<ehcache name="shiroCache">
    <!-- 設置緩存文件 .data 的創建路徑。
    如果該路徑是 Java 系統參數，當前虛擬機會重新賦值。
    下面的參數這樣解釋：
    user.home      – 用戶主目錄
    user.dir       – 用戶當前工作目錄
    java.io.tmpdir – 默認臨時文件路徑 -->
    <diskStore path="D:/test/ehcache" />
    <cacheManagerEventListenerFactory class="" properties="" />
    <!--缺省緩存配置。CacheManager 會把這些配置應用到程序中。
        下列屬性是 defaultCache 必須的:
        maxElementsInMemory：設置基於內存的緩存可存放對象的最大數目。
        maxElementsOnDisk：設置基於硬盤的緩存可存放對象的最大數目。
        maxInMemory       - 緩存可以存儲的總記錄量
        eternal           - 緩存是否永遠不銷燬.如果是，超時設置將被忽略，對象從不過期
        timeToIdleSeconds - 當緩存閒置時間(秒)超過該值，則緩存自動銷燬
        timeToLiveSeconds - 緩存創建之後，到達該時間(秒)緩存自動銷燬
        overflowToDisk    - 當緩存中的數據達到最大值時，是否把緩存數據寫入磁盤.
        -->
    <cache name="books"
           maxElementsInMemory="50000"
           timeToLiveSeconds="25">
    </cache>
    <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="20" timeToLiveSeconds="25"
                  overflowToDisk="false" diskPersistent="false" diskExpiryThreadIntervalSeconds="20" />
</ehcache>

4、SecurityManager 注入 ehCacheManager
@Qualifier(“ehCacheManager”)CacheManager

使用redis做緩存 auth數據

使用redis比較麻煩一些，沒有用

    <!-- https://mvnrepository.com/artifact/org.crazycake/shiro-redis -->
<dependency>
    <groupId>org.crazycake</groupId>
    <artifactId>shiro-redis</artifactId>
    <version>2.4.6</version>
</dependency>

這樣的 jar 只能自己來弄一個 cache 和 cacheManager
當然 也可以使用 shiro-redis 這樣就不需要自己實現 cache 和 cacheManager

我們先看自己實現的方式

1、實現Cache

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

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    private static final String REDIS_SHIRO_CACHE = "slife-shiro-cache:";
    private String cacheKey;
    private RedisTemplate<K, V> redisTemplate;
    private long globExpire = 30;

    @SuppressWarnings("rawtypes")
    public RedisCache(String name, RedisTemplate client) {
        this.cacheKey = REDIS_SHIRO_CACHE + name + ":";
        this.redisTemplate = client;
    }

    @Override
    public V get(K key) throws CacheException {
        redisTemplate.boundValueOps(getCacheKey(key)).expire(globExpire, TimeUnit.MINUTES);
        return redisTemplate.boundValueOps(getCacheKey(key)).get();
    }

    @Override
    public V put(K key, V value) throws CacheException {
        V old = get(key);
        redisTemplate.boundValueOps(getCacheKey(key)).set(value);
        return old;
    }

    @Override
    public V remove(K key) throws CacheException {
        V old = get(key);
        redisTemplate.delete(getCacheKey(key));
        return old;
    }

    @Override
    public void clear() throws CacheException {
        redisTemplate.delete(keys());
    }

    @Override
    public int size() {
        return keys().size();
    }

    @Override
    public Set<K> keys() {
        return redisTemplate.keys(getCacheKey("*"));
    }

    @Override
    public Collection<V> values() {
        Set<K> set = keys();
        List<V> list = new ArrayList<>();
        for (K s : set) {
            list.add(get(s));
        }
        return list;
    }

    private K getCacheKey(Object k) {
        return (K) (this.cacheKey + k);
    }
}

2、實現 CacheManager

public class RedisCacheManager implements CacheManager {

    private static final Logger logger = LoggerFactory.getLogger(RedisCacheManager.class);


    private RedisTemplate redisTemplate;

    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        return new RedisCache<K, V>(name, redisTemplate);
    }

    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


}

3、注入RedisCacheManager 到容器

 @Autowired
    private RedisTemplate redisTemplate;

    @Bean(name = "redisCacheManager")
    @Primary
    public RedisCacheManager redisCacheManager() {
        logger.info("--------------redis cache init---------------");
        RedisCacheManager cacheManager = new RedisCacheManager();
        cacheManager.setRedisTemplate(redisTemplate);
        logger.info("--------------redis cache ---------------"+cacheManager);
        return cacheManager;
    }

4、SecurityManager 注入 redisCacheManager
@Qualifier(“redisCacheManager”)CacheManager

ok 這樣 就搞定了 redis和ecache 緩存shrio的認證授權數據。

接下來看看 怎麼用使用redis進行基於shiro的session集羣共享

redis進行基於shiro的session集羣共享

1、加入依賴

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

2、 配置session

@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400*30) //maxInactiveIntervalInSeconds: 設置Session失效時間，使用Redis Session之後，原Boot的server.session.timeout屬性不再生效
public class SessionConfig {
}

這樣 就可以了

shiro-redis jar 緩存 shiro數據

1、加入依賴

<!-- https://mvnrepository.com/artifact/org.crazycake/shiro-redis -->
<dependency>
    <groupId>org.crazycake</groupId>
    <artifactId>shiro-redis</artifactId>
    <version>2.4.6</version>
</dependency>

2、 配置 redisCacheManager1

    @Bean(name = "redisCacheManager1")
    @Primary
    public RedisCacheManager redisCacheManager1() {
        logger.info("--------------redis cache init---------------");
        RedisCacheManager redisCacheManager=  new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        logger.info("--------------redis cache ---------------"+redisCacheManager);
        return redisCacheManager;
    }


    public RedisManager redisManager() {
        RedisManager redisManager= new RedisManager();
        redisManager.setHost("119.29.53.182");
        redisManager.setPassword("123456");
        redisManager.setPort(6379);
        return redisManager;
    }

3、SecurityManager 注入 redisCacheManager1
@Qualifier(“redisCacheManager1”)CacheManager
ok 這樣就搞定了

自己實現一些 操作 ecahe和redis的工具類

我的官網

我的官網http://guan2ye.com
我的CSDN地址http://blog.csdn.net/chenjianandiyi
我的簡書地址http://www.jianshu.com/u/9b5d1921ce34
我的githubhttps://github.com/javanan
我的碼雲地址https://gitee.com/jamen/
阿里雲優惠券https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=vf2b5zld&utm_source=vf2b5zld

阿里雲教程系列網站http://aliyun.guan2ye.com

我的開源項目spring boot 搭建的一個企業級快速開發腳手架

qq羣 421351927 大家可以相互學習。