apache shiro使用nginx集群如何解决cache共享

最新推荐文章于 2024-05-04 21:01:28 发布

a1522365779

最新推荐文章于 2024-05-04 21:01:28 发布

阅读量504

点赞数

CC 4.0 BY-SA版权

分类专栏： nginx

本文链接：https://blog.youkuaiyun.com/a1522365779/article/details/75669609

nginx 专栏收录该内容

4 篇文章

订阅专栏

本文介绍如何使用Redis替代Shiro默认缓存管理器，实现权限缓存的集群共享。通过自定义RedisCacheManager及JedisShiroCacheManager等组件，确保在分布式环境中Shiro的缓存一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

如果要实现集群共享cache，我们就不能用shiro默认的方式处理了。

之前在我的项目当中使用的cacheManager:

<bean id="cacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager" />

 <!-- Shiro 配置 -->
	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
	    <property name="sessionMode" value="native"></property>
	    <property name="sessionManager" ref="sessionManager"/>
		<property name="cacheManager" ref="cacheManager"/>
		<property name="realm" ref="shiroDbRealm" />
	</bean>

现在需要做出一些修改：

<bean id="cacheManager" class="com.xinding.travel.security.RedisCacheManager" >
		<property name="shiroCacheManager" ref="jedisShiroCacheManager"/>
	</bean>

<!-- shiro 缓存实现，对ShiroCacheManager，我是采用redis的实现 -->
	<bean id="jedisShiroCacheManager" class="com.xinding.travel.security.JedisShiroCacheManager">
		<property name="redisManager" ref="redisManager"/>
	</bean>

RedisCacheManager:

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

/**
 * Created by Maggie on 2017/7/14.
 */
public class RedisCacheManager implements CacheManager {

    private ShiroCacheManager shiroCacheManager;

    @Override
    public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        return getShiroCacheManager().getCache(s);
    }

    public ShiroCacheManager getShiroCacheManager() {
        return shiroCacheManager;
    }

    public void setShiroCacheManager(ShiroCacheManager shiroCacheManager) {
        this.shiroCacheManager = shiroCacheManager;
    }

}

JedisShiroCacheManager:

import org.apache.shiro.cache.Cache;

/**
 * Created by Maggie on 2017/7/14.
 */
public class JedisShiroCacheManager implements ShiroCacheManager {

    public RedisManager getRedisManager() {
        return redisManager;
    }

    public void setRedisManager(RedisManager redisManager) {
        this.redisManager = redisManager;
    }

    private RedisManager redisManager;

    @Override
    public <K, V> Cache<K, V> getCache(String name) {
        return new JedisShiroCache<K, V>(name, getRedisManager());
    }
}

JedisShiroCache:

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

import java.util.Collection;
import java.util.Set;

/**
 * Created by Maggie on 2017/7/14.
 */
public class JedisShiroCache<K, V> implements Cache<K, V> {

    /**
     * 为了不和其他的缓存混淆，采用追加前缀方式以作区分
     */
    private static final String REDIS_SHIRO_CACHE = "shiro_redis_session:";

    private RedisManager redisManager;

    private String name;

    public JedisShiroCache(String name, RedisManager redisManager) {
        this.name = name;
        this.redisManager = redisManager;
    }

    @Override
    public V get(K k) throws CacheException {
        byte[] byteKey = SerializeUtil.serialize(buildCacheKey(k));
        byte[] byteValue = new byte[0];
        try {
            byteValue =redisManager.queryObjectByKey(byteKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (V) SerializeUtil.deserialize(byteValue);
    }

    @Override
    public V put(K k, V v) throws CacheException {
        V previos = get(k);
        try {
            redisManager.insertObject(k.toString(),SerializeUtil.serialize(v),0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return previos;
    }

    @Override
    public V remove(K k) throws CacheException {
        V previos = get(k);
        try {
            redisManager.deleteObject(k.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return previos;
    }

    @Override
    public void clear() throws CacheException {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public Set<K> keys() {
        return null;
    }

    @Override
    public Collection<V> values() {
        return null;
    }

    private String buildCacheKey(Object key) {
        return REDIS_SHIRO_CACHE + getName() + ":" + key;
    }

    public String getName() {
        if (name == null)
            return "";
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

这样配置之后。我的权限的缓存就会由redis管理。这就满足了shiro集群的要求了。