【shiro整合緩存的時候多次讀取緩存無法優化】

shiro整合緩存的時候多次讀取緩存無法優化
我也踩过这个坑( 1 )
已统计您的踩坑,无需重复点击
回答(1)
详细描述
错误截图
源码
@Component
public class RedisSessionDAO extends EnterpriseCacheSessionDAO{
    private static Logger logger = LoggerFactory.getLogger(RedisSessionDAO.class);

    // session 在redis过期时间是60分钟60*60
    private static int expireTime = 3600;

    private static String prefix = "shiro-session:";

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // 创建session，保存到数据库(redis)
    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = super.doCreate(session);
        logger.debug("创建session:{}", session.getId());
        redisTemplate.opsForValue().set(prefix + sessionId.toString(), session);
        return sessionId;
    }

    // 获取session
    @Override
    protected Session doReadSession(Serializable sessionId) {
        logger.debug("获取session:{}", sessionId);
        // 先从缓存中获取session，如果没有再去数据库中获取
        Session session = super.doReadSession(sessionId);
        if (session == null) {
            session = (Session) redisTemplate.opsForValue().get(prefix + sessionId.toString());
        }
        return session;
    }

    // 更新session的最后一次访问时间
    @Override
    protected void doUpdate(Session session) {
        super.doUpdate(session);
        logger.debug("更新session:{}", session.getId());
        String key = prefix + session.getId().toString();
        if (!redisTemplate.hasKey(key)) {
            redisTemplate.opsForValue().set(key, session);
        }
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    // 删除session
    @Override
    protected void doDelete(Session session) {
        logger.debug("删除session:{}", session.getId());
        super.doDelete(session);
        redisTemplate.delete(prefix + session.getId().toString());
    }
}
/**
 * shiro缓存实现
 * @param <K>
 * @param <V>
 */
@SuppressWarnings("unchecked")
public class ShiroCache <K, V> implements Cache<K, V> {

    private static Logger logger = LoggerFactory.getLogger(ShiroCache.class);
    private static final String REDIS_SHIRO_CACHE = "shiro-cache:";
    private String cacheKey;
    private RedisTemplate<K, V> redisTemplate;
    private long globExpire = 60;

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

        //根据Key获取缓存中的值
        @Override
        public V get(K key) throws CacheException {
//        System.out.println("|"+getCacheKey(key)+"|");
//        if(redisTemplate.boundValueOps(getCacheKey(key))==null||"".equals(redisTemplate.boundValueOps(getCacheKey(key)))){
//            return null;
//        }
            // System.out.println("|"+redisTemplate.boundValueOps(getCacheKey(key))+"|");
            logger.info("读取shirocache:"+key);
            redisTemplate.boundValueOps(getCacheKey(key)).expire(globExpire, TimeUnit.MINUTES);
            return redisTemplate.boundValueOps(getCacheKey(key)).get();
        }

        //往缓存中放入key-value，返回缓存中之前的值
        @Override
        public V put(K key, V value) throws CacheException {
            V old = get(key);
            logger.info("更新shirocache:"+key);
            redisTemplate.boundValueOps(getCacheKey(key)).set(value);
            return old;
        }

        //移除缓存中key对应的值，返回该值
        @Override
        public V remove(K key) throws CacheException {
            V old = get(key);
//            logger.info("删除shirocache:"+key);
            redisTemplate.delete(getCacheKey(key));
            return old;
        }

        //清空整个缓存
        @Override
        public void clear() throws CacheException {
            redisTemplate.delete(keys());
        }

        //返回缓存大小
        @Override
        public int size() {
            return keys().size();
        }

        //获取缓存中所有的key
        @Override
        public Set<K> keys() {
            return redisTemplate.keys(getCacheKey("*"));
        }

        //获取缓存中所有的value
        @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);
        }
}

public class RedisCacheManager implements CacheManager{
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    //根据缓存名字获取一个Cache
    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        return new ShiroCache<K, V>(name, redisTemplate);
    }

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

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
}
编辑于2024-11-21
时间排序
热门排序
[无名弟子]李恪非
0

這個問題嘗試好幾天還沒有解決，暫時放棄~

查看全部>

编辑于2018-07-30
去第页