利用redis同步登陆实现session共享

最新推荐文章于 2023-02-16 08:40:10 发布
最新推荐文章于 2023-02-16 08:40:10 发布
阅读量521 收藏
点赞数
分类专栏： 技术 redis 文章标签： 技术 redis session共享

     由于一直在弄oa系统，涉及与公司的其它系统整合；

    今天要弄的是用redis做同步登陆，即在oa里登陆成功后即可在其它系统实现一键登陆。

   oa是用shiro登陆的，shiro里也提供了一个redis的同步session机制，不过在测试时发现，不能用，同一个请求都会产生不同的sessionid，应该是shiro底层问题，在读取sessionid时由于某些原因总是为空，于是就时不时产生一个新的sessionid，这样就没办法实现同步了，同步需要只使用一个sessionid.

   既然不用shiro的，那么就要自己来实现，就得做个filter，拦截在系统的最前面，即在shiro的filter的前面，

这里是SSOFilter.

   本来想存session到redis的，后来想到公司还有其它语言的系统，有.net的，这可能会对他们造成读取困难，那就直接以sessionid为key,userName为value存到redis里吧。

 下面上源码吧！

  RedisManager

 

package sy.sso;

import java.util.Set;

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import sy.action.InitAction;

public class RedisManager {
	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	/*private String host = "172.16.6.3";*/
	private String host = "127.0.0.1";

	private int port = 6379;
	private String dbindex = "0";

	private String password = "123456";
	// 0 - never expire
	private int expire = 30;
	private int timeout = 2000;

	private JedisPool jedisPool = null;

	public RedisManager() {
          init();
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getDbindex() {
		return dbindex;
	}

	public void setDbindex(String dbindex) {
		this.dbindex = dbindex;
	}

	/**
	 * 初始化方法
	 */
	public void init() {
		if (jedisPool == null) {
			//jedisPool = new JedisPool(new JedisPoolConfig(), host, port, timeout, password, Integer.parseInt(dbindex));
			jedisPool = new JedisPool(new JedisPoolConfig(), host, port, timeout, null, Integer.parseInt(dbindex));

		}
	}

	/**
	 * get value from redis
	 *
	 * @param key
	 * @return
	 */
	public byte[] get(byte[] key) {
		logger.debug("getkey:" + new String(key));
		byte[] value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			 jedis.auth(password);
			value = jedis.get(key);

		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 返回指定hash的field数量
	 *
	 * @param key
	 * @return
	 */
	public Long hlen(String key) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			 jedis.auth(password);
			value = jedis.hlen(key);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 获取指定的hash field
	 *
	 * @param key
	 * @return
	 */
	public String hget(String key, String value) {
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.hget(key, value);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 设置hash field为指定值，如果key不存在，则先创建
	 *
	 * @param key
	 * @return
	 */
	public Long hset(String key, String value1, String value2) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.hset(key, value1, value2);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 添加一个string元素到,key对应的set集合中，成功返回1,如果元素以及在集合中返回0,key对应的set不存在返回错误
	 *
	 * @param key
	 * @return
	 */
	public Long sadd(String key, String value1) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.sadd(key, value1);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 为key指定过期时间，单位是秒。返回1成功，0表示key已经设置过过期时间或者不存在
	 *
	 * @param key
	 * @return
	 */
	public Long expire(String key, int value1) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.expire(key, value1);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 判断member是否在set中
	 *
	 * @param key
	 * @return
	 */
	public Boolean sismember(String key, String value1) {
		Boolean value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.sismember(key, value1);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * 从key对应set中移除给定元素，成功返回1，如果member在集合中不
	 *
	 * @param key
	 * @return
	 */
	public Long srem(String key, String value1) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.srem(key, value1);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * set
	 *
	 * @param key
	 * @param value
	 * @return
	 */
	public byte[] set(byte[] key, byte[] value) {

		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			jedis.set(key, value);
			if (this.expire != 0) {
				jedis.expire(key, this.expire);
			}
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * set
	 *
	 * @param key
	 * @param value
	 * @param expire
	 * @return
	 */
	public byte[] set(byte[] key, byte[] value, int expire) {

		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			jedis.set(key, value);
			if (expire != 0) {
				jedis.expire(key, expire);
			}
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	/**
	 * del
	 *
	 * @param key
	 */
	public void del(byte[] key) {
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			jedis.del(key);
		} finally {
			jedisPool.returnResource(jedis);
		}
	}

	/**
	 * flush
	 */
	public void flushDB() {
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			jedis.flushDB();
		} finally {
			jedisPool.returnResource(jedis);
		}
	}

	/**
	 * size
	 */
	public Long dbSize() {
		Long dbSize = 0L;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			dbSize = jedis.dbSize();
		} finally {
			jedisPool.returnResource(jedis);
		}
		return dbSize;
	}

	/**
	 * keys
	 *
	 * @param regex
	 * @return
	 */
	public Set<byte[]> keys(String pattern) {
		Set<byte[]> keys = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			keys = jedis.keys(pattern.getBytes());
		} finally {
			jedisPool.returnResource(jedis);
		}
		return keys;
	}

	public String getHost() {
		return host;
	}

	public void setHost(String host) {
		this.host = host;
	}

	public int getPort() {
		return port;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public int getExpire() {
		return expire;
	}

	public void setExpire(int expire) {
		this.expire = expire;
	}

	public static void main(String[] args) {
		// Jedis jedis = new Jedis("192.168.126.89", 6379);
		// jedis.auth("123456");
		RedisManager manager = new RedisManager();
		manager.setHost("192.168.126.89");

		manager.init();
		for (int i = 0; i < 100000; i++) {
			// BoardItem item = new BoardItem(i+"", "clientId"+i, i, 8, 0);
			String item = i + "|" + "clientId" + i;
			manager.zadd("test", i, item);
		}
		// jedis.set("aa", "记录了");
		// System.out.println(jedis.get("aa"));
		System.out.println(manager.zrevrange("test", 0, 100));
		System.out.println(manager.zrange("test", 0, 100));

	}

	/**
	 * 有序SET 添加
	 *
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 */
	public Long zadd(String key, double score, String member) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zadd(key, score, member);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Long zrem(String key, String member) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrem(key, member);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Set<String> zrevrange(String key, long start, long end) {
		Set<String> value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrevrange(key, start, end);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Set<String> zrange(String key, long start, long end) {
		Set<String> value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrange(key, start, end);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Long zrank(String key, String member) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrank(key, member);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Long zrevrank(String key, String member) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrevrank(key, member);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Long zcard(String key) {
		Long value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zcard(key);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Set<redis.clients.jedis.Tuple> zrangeWithScores(String key, long start, long end) {
		Set<redis.clients.jedis.Tuple> value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrangeWithScores(key, start, end);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Set<redis.clients.jedis.Tuple> zrevrangeWithScores(String key, long start, long end) {
		Set<redis.clients.jedis.Tuple> value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrevrangeWithScores(key, start, end);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}

	public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int limit) {
		Set<String> value = null;
		Jedis jedis = jedisPool.getResource();
		try {
			jedis.auth(password);
			value = jedis.zrevrangeByScore(key, max, min, offset, limit);
		} finally {
			jedisPool.returnResource(jedis);
		}
		return value;
	}
}

 RedisDAO

 

 

package sy.sso;

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

import javax.servlet.http.HttpSession;

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

import sy.util.base.SerializeUtils;

public class RedisDAO   {

	private static Logger logger = LoggerFactory.getLogger(RedisDAO.class);
	/**
	 * shiro-redis的session对象前缀
	 */
	private final String REDIS_SESSION_PRE = "redis_session:";

	private RedisManager redisManager;
    private int timeOut=1800000;//默认30分钟

	public void update(String sessionid,String userName)  {
		this.save(sessionid,userName);
	}

	/**
	 * save session
	 *
	 * @param session
	 * @throws UnknownHttpSessionException
	 */
	private void save(String sessionid,String userName)  {
		if (userName == null) {
			logger.error("userName or userName id is null");
			return;
		}

		byte[] key = getByteKey(sessionid);
		byte[] value = SerializeUtils.serialize(userName);


		int expire =timeOut/1000;

		this.redisManager.set(key, value, expire);
	}


	public void delete(String sessionid) {
		if (sessionid == null) {
			logger.error("userName or userName id is null");
			return;
		}
		redisManager.del(this.getByteKey(sessionid));

	}


	public Collection<String> getActives() {
		Set<String> userNames = new HashSet<String>();

		Set<byte[]> keys = redisManager.keys(this.REDIS_SESSION_PRE + "*");
		if (keys != null && keys.size() > 0) {
			for (byte[] key : keys) {
				String s = (String) SerializeUtils.deserialize(redisManager.get(key));
				userNames.add(s);
			}
		}

		return userNames;
	}




	public String doRead(Serializable sessionId) {
		if (sessionId == null) {
			logger.error("userName id is null");
			return null;
		}

		String s = (String) SerializeUtils.deserialize(redisManager.get(this.getByteKey(sessionId)));

		return s;
	}

	/**
	 * 获得byte[]型的key
	 *
	 * @param key
	 * @return
	 */
	private byte[] getByteKey(Serializable sessionid) {
		String preKey = this.REDIS_SESSION_PRE + sessionid;
		return preKey.getBytes();
	}

	public RedisManager getRedisManager() {
		return redisManager;
	}

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

		/**
		 * 初始化redisManager
		 */
		this.redisManager.init();
	}

	public int getTimeOut() {
		return timeOut;
	}

	public void setTimeOut(int timeOut) {
		this.timeOut = timeOut;
	}


}

 SSOFilter 这个类里一些装载的类如用户的那些按实际的来，只是提供模式，这里写的是本系统的，如要拿来用，请自行修改.

 

 

package sy.sso;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.subject.Subject.Builder;
import org.apache.shiro.util.ThreadContext;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.subject.WebSubject;
import org.hibernate.Hibernate;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import sy.model.base.frame.SessionInfo;
import sy.model.base.frame.Syorganization;
import sy.model.base.frame.Syrole;
import sy.model.base.frame.Syuser;
import sy.model.dtom.Tuser;
import sy.service.base.frame.SyuserServiceI;
import sy.service.dtom.business.TuserServiceI;
import sy.util.base.ConfigUtil;
import sy.util.base.HqlFilter;
import sy.util.base.IpUtil;

/**
 * 用于redis同步登陆
 *
 * @author miraclerz
 *
 */
public class SSOFilter implements Filter {

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

	private  RedisDAO redisDAO;
	private SyuserServiceI syuserServiceI;
	private TuserServiceI tuserServiceI;
	private DefaultWebSecurityManager securityManager;

	public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;


		SessionInfo sessionInfo = null;
		if(request.getSession().getAttribute(ConfigUtil.getSessionInfoName())!=null)
		{
		sessionInfo=(SessionInfo)request.getSession().getAttribute(ConfigUtil.getSessionInfoName());
		}

		String requestURI = request.getRequestURI();
         //取得url里的JSESSIONID
    	String JSESSIONID = StringUtils.substringAfterLast(requestURI, "JSESSIONID=");

        if(request.getSession().getAttribute("JSESSIONID")!=null)
        {//如果session里的JSESSIONID不为空，表示已经登陆了，JSESSIONID就用这个了
        	JSESSIONID=(String) request.getSession().getAttribute("JSESSIONID");
        }

		 String  userName=null;
		if(sessionInfo==null&&JSESSIONID!=null&&!"".equals(JSESSIONID))
		{//如果没登陆且JSESSIONID不为空，即url地址里有JSESSIONID
          userName=redisDAO.doRead(JSESSIONID);
          logger.info(userName+":同步登陆");
		}

     	if(sessionInfo==null&&userName!=null)
		{
		HqlFilter hqlFilter = new HqlFilter();
		hqlFilter.addFilter("QUERY_t#loginname_S_EQ", userName);
 		Syuser user = syuserServiceI.getByFilter(hqlFilter);

 		HqlFilter hqlFiltert = new HqlFilter();
		hqlFiltert.addFilter("QUERY_t#username_S_EQ", userName);
 		Tuser tuser = tuserServiceI.getByFilter(hqlFiltert);

		if (user != null&&tuser!=null) {
		    sessionInfo = new SessionInfo();
			Hibernate.initialize(user.getSyroles());
			Hibernate.initialize(user.getSyorganizations());
			Hibernate.initialize(user.getSyresources());
			for (Syrole role : user.getSyroles()) {
				Hibernate.initialize(role.getSyresources());
			}
			for (Syorganization organization : user.getSyorganizations()) {
				Hibernate.initialize(organization.getSyresources());
			}

			user.setIp(IpUtil.getIpAddr(request));
			sessionInfo.setUser(user);


			//同步登陆shiro
		    SecurityUtils.setSecurityManager(securityManager);//
		    Builder builder = new WebSubject.Builder(request,response);
		    builder.authenticated(true);
		    Subject subject= builder.buildSubject();
		    //设置用户的session(如果不是shiro，就直接是普通的在这里设置session就行了)
		    subject.getSession().setAttribute(ConfigUtil.getSessionInfoName(), sessionInfo);
		    //在session里保存登陆时的sessionid，这个sessionid会存到redis里去，本系统也会一直用这个作同步
		    subject.getSession().setAttribute("JSESSIONID", JSESSIONID);
		    ThreadContext.bind(subject);//线程变量中绑定一个已通过验证的Subject对象
		}
		}
       if(sessionInfo!=null)
       {
    	   redisDAO.update(JSESSIONID,sessionInfo.getUser().getLoginname());
	       System.out.println("同步session啦=>"+JSESSIONID);
       }
		chain.doFilter(request, response);
	}

		public void init(FilterConfig filterConfig) throws ServletException {
		//这些是因为filter无法直接自动装载spring里的bean，于是用下面的方法也取得bean
		ServletContext context = filterConfig.getServletContext();
        ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(context);
        redisDAO = (RedisDAO) ctx.getBean("redisDAO");//直接以bean名称来取
        securityManager = (DefaultWebSecurityManager) ctx.getBean("securityManager");
        syuserServiceI=(SyuserServiceI)ctx.getBean("syuserServiceImpl");
        tuserServiceI=(TuserServiceI)ctx.getBean("tuserServiceImpl");

      /*  String[] syuserServices=ctx.getBeanNamesForType(SyuserServiceI.class);//取得所有这个接口的实现类的bean名(以接口装载的不知道bean名是啥)
        syuserServiceI = (SyuserServiceI)ctx.getBean(syuserServices[0]);//取第一个实现类名
        logger.info("实现类名:"+syuserServices[0]);
        String[] tuserServices=ctx.getBeanNamesForType(TuserServiceI.class);
        tuserServiceI = (TuserServiceI)ctx.getBean(tuserServices[0]);
*/
	}

	public void destroy() {
	}
}

 

  在spring 的配置文件里要加上redis的配置

   <bean id="redisDAO" class="sy.sso.RedisDAO">
      <property name="timeOut" value="1800000"></property>
		<property name="redisManager" >
		    <bean class="sy.sso.RedisManager">
				<!-- <property name="host" value="172.16.6.3"></property> -->
				<property name="host" value="127.0.0.1"></property>
				<property name="dbindex" value="0"></property>
				<property name="password" value="123456"></property>
			</bean>
		</property>
	</bean>

 在web.xml里加上（shiro的filter的前面）

<!--sso同步登陆filter  -->
  <filter>
    <filter-name>ssofilter</filter-name>
    <filter-class>sy.sso.SSOFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>ssofilter</filter-name>
    <url-pattern>/*.sy</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>ssofilter</filter-name>
    <url-pattern>*.jsp</url-pattern>
  </filter-mapping>

   其它系统同步时也一样是这样，配置一个ssoFilter，在这个filter里先判断是否已经登陆，如果已经登陆就直接跳过不理了，如果没登陆就判断是否地址上带有JSESSIONID，如果有就取出来，去redis里看有没有这个值，如果没有就忽略跳过，如果有就取出用户名，用这个用户名去自己的系统里把用户信息取出来，然后设置到session里就完成同步了.

在oa里还要在session的listener里对session的创建和销毁里要同步设置redis信息；

/**
	 * 向session里增加属性时调用(用户成功登陆后会调用)
	 */
	public void attributeAdded(HttpSessionBindingEvent evt) {

		String name = evt.getName();
		logger.debug("向session存入属性：" + name);
		if (ConfigUtil.getSessionInfoName().equals(name)) {// 如果存入的属性是sessionInfo的话
			HttpSession session = evt.getSession();
			SessionInfo sessionInfo = (SessionInfo) session.getAttribute(name);
			if (sessionInfo != null) {
				// System.out.println(sessionInfo.getUser().getName() + "登录了");
				//SyonlineServiceI syonlineService = (SyonlineServiceI) ctx.getBean("syonlineServiceImpl");
				Syonline online = new Syonline();
				online.setType("1");// 登录
				online.setLoginname(sessionInfo.getUser().getLoginname());
				online.setIp(sessionInfo.getUser().getIp());
			 	syonlineService.save(online);
                //登陆成功后把信息存到redis
				session.setAttribute("JSESSIONID", evt.getSession().getId());
				redisDAO.update(evt.getSession().getId(),sessionInfo.getUser().getLoginname());

			}


		}
	}

 

/**
	 * session销毁(用户退出系统时会调用)
	 */
	public void sessionDestroyed(HttpSessionEvent evt) {
		HttpSession session = evt.getSession();
		if (session != null) {
			logger.debug("session销毁：" + session.getId());
			SessionInfo sessionInfo = (SessionInfo) session.getAttribute(ConfigUtil.getSessionInfoName());
			if (sessionInfo != null) {
				// System.out.println(sessionInfo.getUser().getName() + "注销了");
			//	SyonlineServiceI syonlineService = (SyonlineServiceI) ctx.getBean("syonlineServiceImpl");
				Syonline online = new Syonline();
				online.setType("0");// 注销
				online.setLoginname(sessionInfo.getUser().getLoginname());
				online.setIp(sessionInfo.getUser().getIp());
				syonlineService.save(online);

				//用户退出后把用户信息从redis里删除
				Object JSESSIONID=session.getAttribute("JSESSIONID");
				if(JSESSIONID!=null)
				{
					redisDAO.delete((String) JSESSIONID);
				}
			}
		}
	}

 

 

 

 

   跳转的地址类似这样写:

<a target="_blank" href="http://127.0.0.1:8089/oa/login.jsp;JSESSIONID=<%=request.getSession().getAttribute("JSESSIONID")%>">另一个系统go</a>

 

  OK,系统同步登陆就搞定了！

 

 

Redis集群实现分布式Session共享
悦分享
01-10 2320
Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上，这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。在实际工作中我们建议使用外部的缓存设备来共享 Session，避免单个服务器节点挂掉而影响服务，共享数据都会放到外部缓存容器中。
Redis实战之 实现共享Session：
最新发布
2302_80742310的博客
09-22 651
在这个方案中，他确实可以使用对应路径的拦截，同时刷新登录token令牌的存活时间，但是现在这个拦截器他只是拦截需要被拦截的路径，假设当前用户访问了一些不需要拦截的路径，那么这个拦截器就不会生效，所以此时令牌刷新的动作实际上就不会执行，所以这个方案他是存在问题的。
Redis-Session-同步
06-06
此Jar 包。博主亲自实现Redis+Session同步。
分布式集群Session共享 简单多tomcat8+redis的session共享实现
热门推荐
jerome
09-25 3万+
什么是Session         用户使用网站的服务，基本上需要浏览器与Web服务器的多次交互。HTTP协议本身是无状态的，需要基于HTTP协议支持会话状态的机制。这样的机制应该可以使Web服务器从多次单独的HTTP请求中看到“会话”，也就是知道那些请求是来自哪个会话的。         具体实现方式为：在会话开始时，分配一个唯一的会话表示（SessionId），通过Coo
Redis-实现Session同步
qq_24579913的博客
06-06 422
最近公司让做个Session同步，网上搜到了很多文章。大部分都是自己没实现过，拷贝粘贴，都是在坑人。实现不了 Session同步。不过，最后还是让我给弄成了。最主要的原因是因为jar包不对。 Jar 包地址——- http://download.youkuaiyun.com/detail/qq_24579913/9542632 tomcat 7 在lib 目录下把jar 文件拷贝进去。 common
Java中使用Redis实现Session共享
任枫的博客
04-29 1万+
参考：https://blog.youkuaiyun.com/u013490585/article/details/70258470 原理： 使用redis实现session共享是基于session集中存储的实现方案，即把session放在一个公共的redis服务器里，三个服务器节点Ａ,节点Ｂ,节点Ｃ都连接着这个公用redis服务器，从而在请求时从公用的redis里查询存放的session值。这就是实现了...
redis session共享 java_SpringBoot 使用 Redis 实现 Session 共享
weixin_39981400的博客
02-12 203
SpringBoot 使用 Redis 实现 Session 共享使用 Redis 实现 Session 共享1 什么是 Session由于 HTTP 协议是无状态的协议，因而服务端需要记录用户的状态时，就需要用某种机制来识具体的用户。Session 是另一种记录客户状态的机制，不同的是 Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把...
tomcat7 + redis + nginx 实现session共享的jar包
04-26
综上所述，"tomcat7 + redis + nginx 实现session共享的jar包"是通过利用Redis作为中央session存储，结合Nginx的负载均衡能力，解决了分布式环境下的session一致性问题。这个解决方案既保证了用户体验的连续性，也...
tomcat-redis实现session共享
03-06
通过以上步骤，我们可以实现基于Redis的Session共享，提高Web应用的可扩展性和可用性。这种方式不仅解决了跨服务器的Session同步问题，还提供了Session持久化的能力，即使Tomcat重启，用户的状态也能得以保留。同时...
PHP使用Redis实现Session共享的实现示例
10-17
总结来说，PHP利用Redis实现Session共享能够帮助构建可扩展的Web应用，提供高性能的会话管理机制。通过配置或自定义会话存储处理器，可以灵活地控制session数据的存储、读取和删除过程，确保多服务器环境下用户会话...
利用redis实现session共享
06-29
利用Nginx进行分布式部署，并使用redis实现session共享，https://blog.youkuaiyun.com/qq_34742298/article/details/80857173
java web session跨域共享（redis）
04-14
session共享
java redis session共享实现,Springboot集成Spring session利用redis来实现session共享
weixin_33603963的博客
03-13 162
1.在spring boot的文档中，告诉我们添加@EnableRedisHttpSession来开启spring session支持，配置如下：@SpringBootApplication@EnableRedisHttpSessionpublic class DemoApplication {public static void main(String[] args) {SpringApplic...
Redis+SpringBoot完成session同步
weixin_47036562的博客
02-16 197
redis，springboot建立session同步
redis session共享java_使用Redis实现session共享
weixin_31198993的博客
02-12 180
@import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);jedis-2.1.0.jartomcat-redis-session-manager-1.2-tom...
redis实现session同步功能
weixin_30886233的博客
04-27 62
今天看了一篇讲解该问题的博文：https://blog.youkuaiyun.com/ppt0501/article/details/46700221 觉得非常好，先记录下来，里边过滤器的代码没太看懂~回头可看~ 转载于:https://www.cnblogs.com/shenbo-/p/8963202.html...
java redis实现session共享_redis实现分布式session共享
weixin_36269709的博客
03-06 968
在讲解redis分布式session共享之前，我们先聊聊tomcat中session管理机制，包括：请求过程中session操作，sessionid解析过程，servlet获取session流程，以及tomca中session的管理机制。Tomcat session管理机制请求过程中的session操作：在请求过程中首先要解析请求中的sessionid信息，然后将sessionid存储到reque...
java session 共享
li20040723的专栏
10-23 461
下载terracotta-3.7.7-SNAPSHOT.zip    解压后配置一个tc
Tomcat与Redis整合实现Session共享教程
利用Redis实现session共享是一种常见的技术方案。其基本原理是将Tomcat中生成的session数据存储到Redis中，当其他服务器需要访问session数据时，可以通过网络访问Redis服务器上的数据。这样就实现了不同服务器间...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值