shiro redis 集群

最新推荐文章于 2024-06-05 18:02:56 发布
最新推荐文章于 2024-06-05 18:02:56 发布
阅读量495 收藏 2
点赞数
分类专栏： shiro 文章标签： shiro redis session 缓存 集群

1、配置文件

2、代码结构

3、session共享代码 
package com.fangxin365.cms.cluster.session;

import java.io.Serializable;
import java.util.Collection;

import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fangxin365.cms.cluster.listener.CustomSessionListener;
import com.fangxin365.cms.cluster.utils.LoggerUtils;

public class CustomShiroSessionDAO extends AbstractSessionDAO {
	
	private static Logger logger = LoggerFactory.getLogger(CustomSessionListener.class);

	private ShiroSessionRepository shiroSessionRepository;
	
	@Override
	protected Serializable doCreate(Session session) {
		logger.info("CustomShiroSessionDAO =====> doCreate");
		Serializable sessionId = this.generateSessionId(session);
		this.assignSessionId(session, sessionId);
		getShiroSessionRepository().saveSession(session);
		return sessionId;
	}

	@Override
	public void update(Session session) throws UnknownSessionException {
		logger.info("CustomShiroSessionDAO =====> update");
		getShiroSessionRepository().saveSession(session);
	}
	
	@Override
	protected Session doReadSession(Serializable sessionId) {
		logger.info("CustomShiroSessionDAO =====> doReadSession");
		return getShiroSessionRepository().getSession(sessionId);
	}
	
	@Override
	public Collection
     
     
      
       getActiveSessions() {
		logger.info("CustomShiroSessionDAO =====> getActiveSessions");
		return getShiroSessionRepository().getAllSessions();
	}

	@Override
	public void delete(Session session) {
		logger.info("CustomShiroSessionDAO =====> delete");
		if (session == null) {
			LoggerUtils.error(getClass(), "Session 不能为null");
			return;
		}
		Serializable id = session.getId();
		if (id != null)
			getShiroSessionRepository().deleteSession(id);
	}

	// -----------------------//
	// Getter & Setter methods
	// -----------------------//
	public ShiroSessionRepository getShiroSessionRepository() {
		return shiroSessionRepository;
	}

	public void setShiroSessionRepository(ShiroSessionRepository shiroSessionRepository) {
		this.shiroSessionRepository = shiroSessionRepository;
	}
	
}
     
     
package com.fangxin365.cms.cluster.session;

import java.io.Serializable;
import java.util.Collection;

import org.apache.shiro.session.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fangxin365.cms.cluster.cache.JedisManager;
import com.fangxin365.cms.cluster.session.ShiroSessionRepository;
import com.fangxin365.cms.cluster.utils.LoggerUtils;
import com.fangxin365.cms.cluster.utils.SerializeUtils;

public class JedisShiroSessionRepository implements ShiroSessionRepository {
	
	private static Logger logger = LoggerFactory.getLogger(JedisShiroSessionRepository.class);
    
	public static final String REDIS_SHIRO_SESSION = "fx365-shiro-redis-session:";
    //这里有个小BUG，因为Redis使用序列化后，Key反序列化回来发现前面有一段乱码
    public static final String REDIS_SHIRO_ALL = "*fx365-shiro-redis-session:*";
    
    private static final int SESSION_VAL_TIME_SPAN = 180000;
    private static final int DB_INDEX = 1;

    private JedisManager jedisManager;

    @Override
    public void saveSession(Session session) {
    	logger.info("JedisShiroSessionRepository =====> saveSession");
        if (session == null || session.getId() == null)
            throw new NullPointerException("session is empty");
        try {
            byte[] key = SerializeUtils.serialize(buildRedisSessionKey(session.getId()));
            byte[] value = SerializeUtils.serialize(session);
            long sessionTimeOut = session.getTimeout() / 1000;
            Long expireTime = sessionTimeOut + SESSION_VAL_TIME_SPAN + (5 * 60);
            
            getJedisManager().saveValueByKey(DB_INDEX, key, value, expireTime.intValue());
        } catch (Exception e) {
        	LoggerUtils.fmtError(getClass(), e, "save session error，id:[%s]",session.getId());
        }
    }
    
    @Override
    public Session getSession(Serializable id) {
		logger.info("JedisShiroSessionRepository =====> getSession");
        if (id == null)
        	 throw new NullPointerException("session id is empty");
        Session session = null;
        try {
            byte[] value = getJedisManager().getValueByKey(DB_INDEX, SerializeUtils.serialize(buildRedisSessionKey(id)));
            session = (Session)SerializeUtils.deserialize(value);
        } catch (Exception e) {
        	LoggerUtils.fmtError(getClass(), e, "获取session异常，id:[%s]",id);
        }
        return session;
    }
    
    @Override
    public Collection
      
      
       
        getAllSessions() {
    	logger.info("JedisShiroSessionRepository =====> getAllSessions");
    	Collection
       
       
        
         sessions = null;
		try {
			sessions = getJedisManager().getAllSession(DB_INDEX,REDIS_SHIRO_SESSION);
		} catch (Exception e) {
			LoggerUtils.fmtError(getClass(), e, "获取全部session异常");
		}
       
        return sessions;
    }

    @Override
    public void deleteSession(Serializable id) {
    	logger.info("JedisShiroSessionRepository =====> deleteSession");
        if (id == null) {
            throw new NullPointerException("session id is empty");
        }
        try {
            getJedisManager().deleteByKey(DB_INDEX, SerializeUtils.serialize(buildRedisSessionKey(id)));
        } catch (Exception e) {
        	LoggerUtils.fmtError(getClass(), e, "删除session出现异常，id:[%s]",id);
        }
    }

    private String buildRedisSessionKey(Serializable sessionId) {
        return REDIS_SHIRO_SESSION + sessionId;
    }

    // -----------------------//
 	// Getter & Setter methods
 	// -----------------------//
    public JedisManager getJedisManager() {
        return jedisManager;
    }

    public void setJedisManager(JedisManager jedisManager) {
        this.jedisManager = jedisManager;
    }
    
}
       
       
      
      
package com.fangxin365.cms.cluster.session;

import org.apache.shiro.session.Session;

import java.io.Serializable;
import java.util.Collection;

/**
 * Session操作
 */
public interface ShiroSessionRepository {

	/**
	 * 存储Session
	 */
	void saveSession(Session session);

	/**
	 * 删除session
	 */
	void deleteSession(Serializable sessionId);

	/**
	 * 获取session
	 */
	Session getSession(Serializable sessionId);

	/**
	 * 获取所有session
	 */
	Collection
      
      
       
        getAllSessions();
}

4、cache共享代码 
package com.fangxin365.cms.cluster.cache.impl;

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

import com.fangxin365.cms.cluster.cache.ShiroCacheManager;

public class CustomShiroCacheManager implements CacheManager, Destroyable {

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

	private ShiroCacheManager shiroCacheManager;

	@Override
	public 
       
       
        
         Cache
        
        
         
          getCache(String name) throws CacheException {
		logger.info("CustomShiroCacheManager =====> getCache");
		return getShiroCacheManager().getCache(name);
	}

	@Override
	public void destroy() throws Exception {
		logger.info("CustomShiroCacheManager =====> destroy");
		shiroCacheManager.destroy();
	}

	// -----------------------//
	// Getter & Setter methods
	// -----------------------//
	public ShiroCacheManager getShiroCacheManager() {
		return shiroCacheManager;
	}

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

}
        
        
       
       
package com.fangxin365.cms.cluster.cache.impl;

import org.apache.shiro.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fangxin365.cms.cluster.cache.JedisManager;
import com.fangxin365.cms.cluster.cache.JedisShiroCache;
import com.fangxin365.cms.cluster.cache.ShiroCacheManager;

public class JedisShiroCacheManager implements ShiroCacheManager {

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

	private JedisManager jedisManager;

	@Override
	public 
       
       
        
         Cache
        
        
         
          getCache(String name) {
		logger.info("JedisShiroCacheManager =====> getCache");
		return new JedisShiroCache
         
         
          
          (name, getJedisManager());
	}

	@Override
	public void destroy() {
		logger.info("JedisShiroCacheManager =====> destroy");
		// 如果和其他系统，或者应用在一起就不能关闭
		// getJedisManager().getJedis().shutdown();
	}

	// -----------------------//
	// Getter & Setter methods
	// -----------------------//
	public JedisManager getJedisManager() {
		return jedisManager;
	}

	public void setJedisManager(JedisManager jedisManager) {
		this.jedisManager = jedisManager;
	}
	
}

         
         
        
        
       
       
package com.fangxin365.cms.cluster.cache;

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

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

import com.fangxin365.cms.cluster.utils.LoggerUtils;
import com.fangxin365.cms.cluster.utils.SerializeUtils;

@SuppressWarnings("unchecked")
public class JedisShiroCache
       
       
        
         implements Cache
        
        
         
          {
	
	private static Logger logger = LoggerFactory.getLogger(JedisShiroCache.class);

	/**
	 * 为了不和其他的缓存混淆，采用追加前缀方式以作区分
	 */
	private static final String REDIS_SHIRO_CACHE = "fx365-shiro-redis-cache:";
	
	private static final int DB_INDEX = 1;

	private JedisManager jedisManager;

	private String name;

	@SuppressWarnings("rawtypes")
	static final Class
         
         
          
           SELF = JedisShiroCache.class;

	public JedisShiroCache(String name, JedisManager jedisManager) {
		this.name = name;
		this.jedisManager = jedisManager;
	}

	/**
	 * 自定义relm中的授权/认证的类名加上授权/认证英文名字
	 */
	public String getName() {
		if (name == null)
			return "";
		return name;
	}

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

	@Override
	public V get(K key) throws CacheException {
		logger.info("JedisShiroCache =====> get");
		byte[] byteKey = SerializeUtils.serialize(buildCacheKey(key));
		byte[] byteValue = new byte[0];
		try {
			byteValue = jedisManager.getValueByKey(DB_INDEX, byteKey);
		} catch (Exception e) {
			LoggerUtils.error(SELF, "get value by cache throw exception", e);
		}
		return (V) SerializeUtils.deserialize(byteValue);
	}

	@Override
	public V put(K key, V value) throws CacheException {
		logger.info("JedisShiroCache =====> put");
		V previos = get(key);
		try {
			jedisManager.saveValueByKey(DB_INDEX, SerializeUtils.serialize(buildCacheKey(key)), SerializeUtils.serialize(value), -1);
		} catch (Exception e) {
			LoggerUtils.error(SELF, "put cache throw exception", e);
		}
		return previos;
	}

	@Override
	public V remove(K key) throws CacheException {
		logger.info("JedisShiroCache =====> remove");
		V previos = get(key);
		try {
			jedisManager.deleteByKey(DB_INDEX, SerializeUtils.serialize(buildCacheKey(key)));
		} catch (Exception e) {
			LoggerUtils.error(SELF, "remove cache  throw exception", e);
		}
		return previos;
	}

	@Override
	public void clear() throws CacheException {
		logger.info("JedisShiroCache =====> clear");
	}

	@Override
	public int size() {
		logger.info("JedisShiroCache =====> size");
		if (keys() == null)
			return 0;
		return keys().size();
	}

	@Override
	public Set
          
          
           
            keys() {
		logger.info("JedisShiroCache =====> keys");
		return null;
	}

	@Override
	public Collection
           
           
             values() { logger.info("JedisShiroCache =====> values"); return null; } private String buildCacheKey(Object key) { logger.info("JedisShiroCache =====> buildCacheKey"); return REDIS_SHIRO_CACHE + getName() + ":" + key; } } 
           
          
          
         
         
        
        
       
       
package com.fangxin365.cms.cluster.cache;

import org.apache.shiro.cache.Cache;

public interface ShiroCacheManager {

    
       
       
        
         Cache
        
        
         
          getCache(String name);

    void destroy();

}

5、session监听 
package com.fangxin365.cms.cluster.listener;

import org.apache.shiro.session.Session;
import org.apache.shiro.session.SessionListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fangxin365.cms.cluster.session.ShiroSessionRepository;

public class CustomSessionListener implements SessionListener {
	
	private static Logger logger = LoggerFactory.getLogger(CustomSessionListener.class);

	private ShiroSessionRepository shiroSessionRepository;

	/**
	 * 一个会话的生命周期开始
	 */
	@Override
	public void onStart(Session session) {
		logger.info("CustomSessionListener =====> onStart");
	}

	/**
	 * 一个会话的生命周期结束
	 */
	@Override
	public void onStop(Session session) {
		logger.info("CustomSessionListener =====> onStop");
	}

	@Override
	public void onExpiration(Session session) {
		logger.info("CustomSessionListener =====> onExpiration");
		shiroSessionRepository.deleteSession(session.getId());
	}

	// -----------------------//
	// Getter & Setter methods
	// -----------------------//
	public ShiroSessionRepository getShiroSessionRepository() {
		return shiroSessionRepository;
	}

	public void setShiroSessionRepository(ShiroSessionRepository shiroSessionRepository) {
		this.shiroSessionRepository = shiroSessionRepository;
	}

}

6、jedis管理 
package com.fangxin365.cms.cluster.cache;

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

import org.apache.shiro.session.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisConnectionException;

import com.fangxin365.cms.cluster.session.JedisShiroSessionRepository;
import com.fangxin365.cms.cluster.utils.LoggerUtils;
import com.fangxin365.cms.cluster.utils.SerializeUtils;

public class JedisManager {
	
	private static Logger logger = LoggerFactory.getLogger(JedisManager.class);

	private JedisPool jedisPool;

	public Jedis getJedis() {
		Jedis jedis = null;
		try {
			jedis = getJedisPool().getResource();
		} catch (Exception e) {
			throw new JedisConnectionException(e);
		}
		return jedis;
	}

	public void returnResource(Jedis jedis, boolean isBroken) {
		if (jedis == null)
			return;
		jedis.close();
	}
	
	public void saveValueByKey(int dbIndex, byte[] key, byte[] value, int expireTime) throws Exception {
		logger.info("JedisManager =====> saveValueByKey");
		Jedis jedis = null;
		boolean isBroken = false;
		try {
			jedis = getJedis();
			jedis.select(dbIndex);
			jedis.set(key, value);
			if (expireTime > 0)
				jedis.expire(key, expireTime);
		} catch (Exception e) {
			isBroken = true;
			throw e;
		} finally {
			returnResource(jedis, isBroken);
		}
	}

	public byte[] getValueByKey(int dbIndex, byte[] key) throws Exception {
		logger.info("JedisManager =====> getValueByKey");
		Jedis jedis = null;
		byte[] result = null;
		boolean isBroken = false;
		try {
			jedis = getJedis();
			jedis.select(dbIndex);
			result = jedis.get(key);
		} catch (Exception e) {
			isBroken = true;
			throw e;
		} finally {
			returnResource(jedis, isBroken);
		}
		return result;
	}
	
	/**
	 * 获取所有Session
	 */
	public Collection
          
          
           
            getAllSession(int dbIndex, String redisShiroSession) throws Exception {
		logger.info("JedisManager =====> getAllSession");
		Jedis jedis = null;
		boolean isBroken = false;
		Set
           
           
            
             sessions = new HashSet
            
            
             
             ();
		try {
			jedis = getJedis();
			jedis.select(dbIndex);

			Set
             
             
              
               byteKeys = jedis.keys((JedisShiroSessionRepository.REDIS_SHIRO_ALL).getBytes());
			if (byteKeys != null && byteKeys.size() > 0) {
				for (byte[] bs : byteKeys) {
					Session obj = (Session)SerializeUtils.deserialize(jedis.get(bs));
					if (obj instanceof Session) {
						sessions.add(obj);
					}
				}
			}
		} catch (Exception e) {
			isBroken = true;
			throw e;
		} finally {
			returnResource(jedis, isBroken);
		}
		return sessions;
	}

	public void deleteByKey(int dbIndex, byte[] key) throws Exception {
		logger.info("JedisManager =====> deleteByKey");
		Jedis jedis = null;
		boolean isBroken = false;
		try {
			jedis = getJedis();
			jedis.select(dbIndex);
			Long result = jedis.del(key);
			LoggerUtils.fmtDebug(getClass(), "删除Session结果：%s", result);
		} catch (Exception e) {
			isBroken = true;
			throw e;
		} finally {
			returnResource(jedis, isBroken);
		}
	}
	
	// -----------------------//
	// Getter & Setter methods
	// -----------------------//
	public JedisPool getJedisPool() {
		return jedisPool;
	}

	public void setJedisPool(JedisPool jedisPool) {
		this.jedisPool = jedisPool;
	}
	
}

7、工具类 
package com.fangxin365.cms.cluster.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.wjw.kryo.wrapper.KryoSerializer;

public class SerializeUtils {

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

	public static Object deserialize(byte[] bytes) {
		Object result = null;

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

		try {
			result = KryoSerializer.read(bytes);
		} catch (Exception e) {
			logger.error("Failed to deserialize", e);
		}
		return result;
	}

	public static byte[] serialize(Object object) {
		byte[] result = null;

		if (object == null) {
			return new byte[0];
		}

		try {
			result = KryoSerializer.write(object);
		} catch (Exception ex) {
			logger.error("Failed to serialize", ex);
		}
		return result;
	}

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

}
package com.fangxin365.cms.cluster.utils;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

/**
 * Log输出封装
 */
public class LoggerUtils {
	
	/**
	 * 是否开启Debug
	 */
	public static boolean isDebug = Logger.getLogger(LoggerUtils.class).isDebugEnabled();

	/**
	 * Debug 输出
	 * 
	 * @param clazz 目标.Class
	 * @param message 输出信息
	 */
	public static void debug(Class
             
              clazz, String message) {
		if (!isDebug)
			return;
		Logger logger = Logger.getLogger(clazz);
		logger.debug(message);
	}

	/**
	 * Debug 输出
	 * 
	 * @param clazz 目标.Class
	 * @param fmtString 输出信息key
	 * @param value 输出信息value
	 */
	public static void fmtDebug(Class
             
              clazz, String fmtString, Object... value) {
		if (!isDebug)
			return;
		if (StringUtils.isBlank(fmtString)) {
			return;
		}
		if (null != value && value.length != 0) {
			fmtString = String.format(fmtString, value);
		}
		debug(clazz, fmtString);
	}

	/**
	 * Error 输出
	 * 
	 * @param clazz 目标.Class
	 * @param message 输出信息
	 * @param e 异常类
	 */
	public static void error(Class
             
              clazz, String message, Exception e) {
		Logger logger = Logger.getLogger(clazz);
		if (null == e) {
			logger.error(message);
			return;
		}
		logger.error(message, e);
	}

	/**
	 * Error 输出
	 * 
	 * @param clazz 目标.Class
	 * @param message 输出信息
	 */
	public static void error(Class
             
              clazz, String message) {
		error(clazz, message, null);
	}

	/**
	 * 异常填充值输出
	 * 
	 * @param clazz 目标.Class
	 * @param fmtString 输出信息key
	 * @param e 异常类
	 * @param value 输出信息value
	 */
	public static void fmtError(Class
             
              clazz, Exception e, String fmtString, Object... value) {
		if (StringUtils.isBlank(fmtString)) {
			return;
		}
		if (null != value && value.length != 0) {
			fmtString = String.format(fmtString, value);
		}
		error(clazz, fmtString, e);
	}

	/**
	 * 异常填充值输出
	 * 
	 * @param clazz 目标.Class
	 * @param fmtString 输出信息key
	 * @param value 输出信息value
	 */
	public static void fmtError(Class
             
              clazz, String fmtString, Object... value) {
		if (StringUtils.isBlank(fmtString)) {
			return;
		}
		if (null != value && value.length != 0) {
			fmtString = String.format(fmtString, value);
		}
		error(clazz, fmtString);
	}
}

8、存储结果


相爱莫相离
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Shiro与Redis集成，集群下的session共享
jrn1012的专栏
04-22 1万+
本文主要介绍通过Shiro管理session，并将session缓存到redis中，这样可以在集群中使用。 Shiro除了在管理session上使用redis，也在可以缓存用户权限，即cacheManager可以通过redis来扩展。 本文从cacheManager 和 sessionManager这两部分讲解Shiro与Redis的集成
shiro redis集群介绍
臣本布衣，躬耕于南阳
04-13 2271
本文主要针对shiro和redis的集群，讲解why shiro+redis集群以及集群的好处。完整项目的源码请查看（附件源码已撤销）：研究完善的shiro redis集群项目 有源码    下面主要讲解web项目开发中如何使用shiro和redis做集群，shiro redis集群介绍： 当一个使用shiro开发的项目被定位为单机部署，不需要集群部署时，我们可以不考虑shiro redi
分布式Shiro，SpringBoot项目Shiro整合Redis
最新发布
shy_1762538422的博客
06-05 711
分布式Shiro，SpringBoot项目Shiro整合Redis
springboot+shiro+redis实现session共享和cache共享
ldcaws的专栏
06-26 2617
在分布式应用中，若是使用了负载均衡，用户第一次访问，连接的A服务器，进行了登录操作进入了系统，当用户再次操作时，请求被转发到了B服务器，用户并没有在B进行登录，此时用户又来到了登录页面，这是难以理解和接受的，这就引出了session共享。对于shiro安全框架如何实现session共享？shiro共享分为两方面，一个是session共享，一个是cache共享。下面聊聊在springboot工程中整合shiro框架，并通过redis实现session共享和cache共享。
第十三节 Shiro集成Redis实现分布式集群Session共享
大宇的博客，欢迎访问
04-15 7982
一、使用Redis共享Session原理 所有服务器的session信息都存储到了同一个Redis集群中，即所有的服务都将 Session 的信息存储到 Redis 集群中，无论是对 Session 的注销、更新都会同步到集群中，达到了 Session 共享的目的。 Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的...
shiro连接redis集群 根据org.crazycake.shiro包改造源码
02-06
在分布式系统中，尤其是在使用Redis作为缓存或session存储时，Shiro的原生支持可能无法直接与Redis集群配合工作。这里提到的"shiro-redis-cluster"项目，显然是针对这个问题进行的一个定制化改造，它使得Shiro能够...
springboot+shiro+redis整合
03-12
在IT行业中，SpringBoot、Shiro和Redis是三个非常重要的技术组件，它们分别在不同的领域发挥着关键作用。本文将详细讲解如何将这三个组件整合在一起，实现一个高效、安全的Web应用。 首先，SpringBoot是Spring框架...
springboot +shiro+redis实现session共享（方案二）1
08-08
"Spring Boot + Shiro + Redis 实现 Session 共享方案二" 1. 概述 本文档旨在介绍如何使用 Spring Boot、Shiro 和 Redis 实现分布式 session 共享，以解决 Web 应用程序的登录 session 统一问题。 2. 相关依赖 ...
Shiro集成 Redis 方案
01-07
Redis 的高可用性和高性能特性使得它成为 Shiro 在集群环境下的理想缓存解决方案。在实际应用中，你可能还需要结合其他技术，如 Spring Boot 或者 Dubbo，来更好地整合 Shiro 和 Redis，实现完整的安全和缓存管理。
shiro redis session共享
05-24
标题“shiro redis session共享”涉及...在实际生产环境中，Redis还可以配置为集群模式，以保证高可用性和数据安全性。总的来说，Shiro结合Redis是一种有效且常见的session共享解决方案，尤其适用于分布式微服务架构。
shiro 在集群环境下用redis(集群版)做session共享
GoodIdea
05-05 2893
如今集群环境已是服务器主流,在集群环境中，session共享一般通过应用服务器的session复制或者存储在公用的缓存服务器上，本文主要介绍通过Shiro管理session，并将session缓存到redis集群版中，这样可以在集群中使用。Shiro除了在管理session上使用redis，也在可以缓存用户权限，即cacheManager可以通过redis来扩展。下面从 sessionManage...
shiro session_java：shiro高级篇——3
weixin_39687667的博客
11-26 121
第七章 实现分布式会话SessionManager1、会话的问题2、分布式会话实现思路【1】原理分析 所有服务器的session信息都存储到了同一个Redis集群中，即所有的服务都将 Session 的信息存储到 Redis 集群中，无论是对 Session 的注销、更新都会同步到集群中，达到了 Session 共享的目的。Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客...
Shiro精通到集群
05-31
<img src="https://img-bss.csdn.net/201905310157235032.png" alt="" />
Shiro学习（10）Session管理
m0_67403073的博客
08-24 2570
但是如在web环境中，如果用户不主动退出是不知道会话是否过期的，因此需要定期的检测会话是否过期，Shiro提供了会话验证调度器SessionValidationScheduler来做这件事情。Shiro提供了完整的企业级会话管理功能，不依赖于底层容器（如web容器tomcat），不管JavaSE还是JavaEE环境都可以使用，提供了会话管理、会话事件监听、会话存储/持久化、容器无关的集群、失效/过期支持、对Web的透明支持、SSO单点登录的支持等特性。更新会话最后访问时间及销毁会话；
springboot整合shiro和redis（超详细案例演示）
m0_57232638的博客
07-08 3098
将Spring Boot、Redis和Shiro整合在一起具有多个优势。首先，通过与Spring Boot的集成，可以简化开发过程，利用其自动配置和约定优于配置的原则。其次，Redis作为高性能的缓存和存储系统，可以提供快速的数据访问和响应时间，通过与Spring Boot和Shiro的整合，可以实现更高效的会话管理和身份验证。此外，通过将Shiro的会话存储在Redis中，可以实现分布式会话管理和高可用性，并支持共享会话和无状态应用程序架构。
Shiro实战系列--整合shiro-redis
IT利刃出鞘的博客
10-18 1万+
本文用实例介绍shiro通过引入shiro-redis来缓存权限。使用SpringBoot整合Shiro。
shiro——session会话管理
热门推荐
dgh112233的博客
08-23 1万+
目录 1. 会话 1.1 Session 接口 1.2 SessionManager 会话管理 1.3 SessionListener 会话监听 2. 会话持久化 2.1 SessionDAO接口 2.2AbstractSessionDAO类 2.3 CachingSessionDAO 类 2.4 EnterpriseCacheSessionDAO 类 2.5 Memo...
shiro使用redis作为缓存
cui_xf_的博客
11-25 6840
应用场景：Shiro的为每个用户的角色和权限信息提供缓存支持，通过Shiro自己定义的CacheManager实现，默认实现有Ehcache和内存（就是一个Map结构），在应用中通常使用redis作为缓存服务器，因此使用redis来作为shiro的缓存。 优缺点：一般来说缓存放在本地，通过本地内存进行缓存速度更快，但是在分布式环境下，修改了用户权限需要经行协同。将缓存和Session放在统一的数据...
shiro redis
11-02
Spring Boot、Redis和Shiro是三个不同的技术。其中，Shiro是一个用于身份验证、授权和会话管理的Java安全框架，可以帮助开发者快速地实现安全功能。Redis是一个高性能的键值存储系统，可以用于缓存、消息队列、会话...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值