Redis解决老项目集群Session共享案例与回顾

最新推荐文章于 2022-05-03 00:43:16 发布
最新推荐文章于 2022-05-03 00:43:16 发布
阅读量968 收藏 1
点赞数
分类专栏： # 架构设计 # Cache/Memcache/Redis 文章标签： 架构设计 redis session共享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boonya/article/details/103726430
版权

老项目突然之间客户要用了而且用户量还不少，后端移动端都需要给升级。第一改进的时候做了移动端与后端的服务分流，这次升级为分布式集群模式。分布式集群模式需要解决Session共享问题和数据一致性分布式锁处理。因为历史原因，应用是单体应用并非微服务技术实现。为应对移动端大概20000左右的用户使用量做的如下改造。

目录

服务器端口分配管理

分布式集群session共享管理

Tomcat session共享设置

业务系统Session管理

Nginx集群配置管理

遇到的问题

回顾历史版本改造改进处理

服务器端口分配管理

服务器作用与集群部署的节点说明(实际应用过程中并没有使用到这么多集群节点，规划的多一点备用)。

分布式集群session共享管理

Tomcat session共享设置

做分布式除了Token，一般需要解决Session共享问题。

 这一块都是基于tomcat的改造细节就不多说了，实验过程用的是mzd123的。配置说明：

1、修改Tomcat/config/redis-data-cache.properties  =====解决redissession同步问题

2、检查Tomcat/lib是否存在commons-logging-1.2.jar、commons-pool2-2.4.2.jar、jedis-2.9.0.jar、tomcat-cluster-redis-session-manager-2.0.4.jar   =====解决redissession同步问题


3、设置Tomcat/config/context.xml    =====解决redissession同步问题

<!--redis管理session配置-->
	<Valve className="tomcat.request.session.redis.SessionHandlerValve"/>
    <Manager className="tomcat.request.session.redis.SessionManager"/>

节点可以看下Tomcat目录结构：

业务系统Session管理

首先添加一个Session监听监控应用系统Session创建和销毁等操作，下面的代码有其他业务凑合看吧：

SessionListener.java

package com.boonya.listener;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import org.apache.log4j.Logger;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.boonya.cache.XHTSystemConfig;
import com.boonya.webservice.util.RedisDistributedLock;
import com.boonya.webservice.util.RedisUtil;
import com.boonya.xht.util.Constants;
import data.common.util.StringUtils;

/**
 * 
 * @function 功能：系统Session管理
 * @author PJL
 * @package com.boonya.listener
 * @filename SessionListener.java
 * @time 2019年12月19日 下午6:08:03
 */
public class SessionListener implements HttpSessionListener,HttpSessionAttributeListener {
	
	private static Logger logger = Logger.getLogger(SessionListener.class);

	/**
	 * 保存当前登录的所有用户
	 */
	public static Map<HttpSession, String> loginUser = new ConcurrentHashMap<HttpSession, String>();
	
	/**
	 * 记录当前在线用户数量
	 */
	public static Long loginCount = 0L;
	
	/**
	 * 用这个作为session中的key,userName 为手机号
	 */
	public static String SESSION_LOGIN_NAME = "userName";
	

	/**
	 * session创建时监听
	 */
	@Override
	public void sessionCreated(HttpSessionEvent arg0) {
		//logger.info("sessionCreated");
	}

	/**
	 * session销毁时
	 */
	@Override
	public void sessionDestroyed(HttpSessionEvent arg0) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			try {
				// 删除共享REDIS SESSION KEY
				RedisUtil.expire(arg0.getSession().getId(), Constants.MOBILE_TOKEN_KEY_EXPIRED_NOW);
				// 删除REDIS SESSION KEY
				String key=Constants.CLUSTER_USER_SESSION_KEY+arg0.getSession().getId();
				RedisUtil.expire(key, Constants.MOBILE_TOKEN_KEY_EXPIRED_NOW);
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				// 更新登录session数量
				updateLoginUserCount();
			}
		} else {
			try {
				// 移除用户session
				loginUser.remove(arg0.getSession());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

	/**
	 * 添加属性时
	 */
	@Override
	public void attributeAdded(HttpSessionBindingEvent arg0) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			// 如果添加的属性是用户名, 则加入map中
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				try {
					// REDIS SESSION KEY
					String key=Constants.CLUSTER_USER_SESSION_KEY+arg0.getSession().getId();
					// 设置登录session
					RedisUtil.hset(key, arg0.getSession().getId(), arg0.getValue().toString());
					RedisUtil.expire(key, Constants.MOBILE_TOKEN_KEY_ONE_HOUR);
					
					// 设置登录用户名
					String userName=(String) arg0.getSession().getAttribute(SESSION_LOGIN_NAME);
					String userNameKey=Constants.CLUSTER_USER_SESSION_USER+arg0.getSession().getId();
					RedisUtil.hset(userNameKey, userName,userName);
					RedisUtil.expire(userNameKey, Constants.MOBILE_TOKEN_KEY_ONE_HOUR);
					
					// 更新登录session数量
					updateLoginUserCount();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} else {
			// 如果添加的属性是用户名, 则加入map中
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				loginUser.put(arg0.getSession(), arg0.getValue().toString());
				loginCount++;
			}
		}
		

	}

	/**
	 * 移除属性时
	 */
	@Override
	public void attributeRemoved(HttpSessionBindingEvent arg0) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			// 如果添加的属性是用户名, 则加入map中
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				try {
					// REDIS SESSION KEY
					String key=Constants.CLUSTER_USER_SESSION_KEY+arg0.getSession().getId();
					// 设置登录session立即失效
					RedisUtil.expire(key, Constants.MOBILE_TOKEN_KEY_EXPIRED_NOW);
					
					// 设置登录用户名
					String userNameKey=Constants.CLUSTER_USER_SESSION_USER+arg0.getSession().getId();
					RedisUtil.expire(userNameKey, Constants.MOBILE_TOKEN_KEY_EXPIRED_NOW);
					
					// 更新登录session数量
					updateLoginUserCount();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} else {
			// 如果移除的属性是用户名, 则从map中移除
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				try {
					loginUser.remove(arg0.getSession());
					loginCount--;
				} catch (Exception e) {
				}
			}
		}
	}

	/**
	 * 属性更新时
	 */
	@Override
	public void attributeReplaced(HttpSessionBindingEvent arg0) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				try {
					// REDIS SESSION KEY
					String key=Constants.CLUSTER_USER_SESSION_KEY+arg0.getSession().getId();
					// 设置登录session
					RedisUtil.hset(key, arg0.getSession().getId(), arg0.getValue().toString());
					RedisUtil.expire(key, Constants.MOBILE_TOKEN_KEY_ONE_HOUR);
					
					// 设置登录用户名
					String userName=(String) arg0.getSession().getAttribute(SESSION_LOGIN_NAME);
					String userNameKey=Constants.CLUSTER_USER_SESSION_USER+arg0.getSession().getId();
					RedisUtil.hset(userNameKey, userName,userName);
					RedisUtil.expire(userNameKey, Constants.MOBILE_TOKEN_KEY_ONE_HOUR);
				} catch (Exception e) {
					e.printStackTrace();
				}finally{
					// 更换新登录用户数量
					updateLoginUserCount();
				}
				
			}
		} else {
			if (arg0.getName().equals(SESSION_LOGIN_NAME)) {
				loginUser.put(arg0.getSession(), arg0.getValue().toString());
			}
		}
	}

	/**
	 * 判断当前用户是否已经登录
	 * 
	 * @param userId
	 * @return
	 */
	public static boolean isLogonUser(String userName) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			HttpServletRequest request=((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
			String username=RedisUtil.hget(Constants.CLUSTER_USER_SESSION_USER+request.getSession().getId(), userName);
			if(StringUtils.IsNullOrEmpty(username)){
				return false;
			}
			return true;
		} else {
			Set<HttpSession> keys = SessionListener.loginUser.keySet();
			for (HttpSession key : keys) {
				if (SessionListener.loginUser.get(key).equals(userName)) {
					return true;
				}
			}
			return false;
		}

	}

	/**
	 * 判断当前session是否已经登录
	 * 
	 * @param hs
	 * @return
	 */
	public static boolean isLogonUser(HttpSession hs) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			String sessionValue=RedisUtil.hget(Constants.CLUSTER_USER_SESSION_KEY+hs.getId(), hs.getId());
			if(StringUtils.IsNullOrEmpty(sessionValue)){
				return false;
			}
			return true;
		} else {
			Set<HttpSession> keys = SessionListener.loginUser.keySet();
			for (HttpSession key : keys) {
				if (key.equals(hs)) {
					return true;
				}
			}
			return false;
		}

	}

	/**
	 * 获取当前登录用户的数量
	 * 
	 * @return
	 */
	public static Long getLoginUserCount() {
		if (XHTSystemConfig.clusterModeForTomcat) {
			// 获取数量
			String key=Constants.CLUSTER_USER_SESSION_KEY.substring(0, Constants.CLUSTER_USER_SESSION_KEY.length()-1);
			String newKey=key+":*";
			// 模糊查询
			Set<String> keys=RedisUtil.keys(newKey);
			Long userNumber=0L;
			if(null!=keys){
				userNumber=Long.valueOf( keys.size()+"");
			}
			return userNumber;
		} else {
			return loginCount;
		}
	}
	
	/**
	 * 更新用户数量统计
	 * 
	 */
	public static long updateLoginUserCount(){
		final String requestId=UUID.randomUUID().toString();
		boolean success=RedisDistributedLock.tryGetDistributedLock(
				Constants.CLUSTER_APPLICATION_COUNT_LOCK, requestId,
				Constants.CLUSTER_APPLICATION_COUNT_LOCK_TIME);
		
		logger.error("更新USER COUNT分布式锁:"+success);
		// 获取登录session数量
		long countSession=getLoginUserCount();
		while(!success){
			try {
				Thread.sleep(100);
				logger.error("更新USER COUNT分布式锁:休眠1000ms!");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			success=RedisDistributedLock.tryGetDistributedLock(
					Constants.CLUSTER_APPLICATION_COUNT_LOCK, requestId,
					Constants.CLUSTER_APPLICATION_COUNT_LOCK_TIME);
			if(success){
				countSession=getLoginUserCount();
			    break;
			}
		}
		// 分布式不宜进行加减运算
	    RedisUtil.set(Constants.CLUSTER_USER_SESSION_COUNT, countSession+"");
	    RedisDistributedLock.releaseDistributedLock(
	    		Constants.CLUSTER_APPLICATION_COUNT_LOCK, requestId);
		logger.error("释放更新USER COUNT分布式锁成功!");
		return countSession;
	}

	/**
	 * 清除已经登录用户的缓存
	 * 
	 * @param userName
	 */
	@SuppressWarnings("rawtypes")
	public static void removeSession(String userName) {
		if (XHTSystemConfig.clusterModeForTomcat) {
			try {
				HttpServletRequest request=((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
				// REDIS SESSION KEY
				String key=Constants.CLUSTER_USER_SESSION_KEY+request.getSession().getId();
				
				// 设置登录session立即失效
				RedisUtil.expire(key, Constants.MOBILE_TOKEN_KEY_EXPIRED_NOW);
				
				// 更换新登录用户数量
				updateLoginUserCount();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			Set<HttpSession> keys = SessionListener.loginUser.keySet();
			// 如果使用老remove方法则要用iterator遍历。
			Iterator iterator = keys.iterator();
			while (iterator.hasNext()) {
				Object key = iterator.next();
				if (!StringUtils.IsNullOrEmpty(userName)
						&& userName.equals(SessionListener.loginUser.get(key))) {
					/** 这行代码是关键。否则报concurrentModificationException **/
					/** 详情原因见：http://www.cnblogs.com/dolphin0520/p/3933551.html **/
					iterator.remove();

					loginUser.remove(key);
					loginCount--;
				}
			}
		}
	}

}

注意：核心关注Session创建和销毁。

web.xml配置监听：

<listener>
		<listener-class>com.boonya.listener.SessionListener</listener-class> 
</listener>

Nginx集群配置管理

106前置机内网外服务器Nginx配置（服务和代理在同一台机器），之前有同事建议做每个集群的虚拟机部署，因为只是为了验收收钱不必要做的太复杂故而未予以采纳。

http {
    include       mime.types;
    #default_type  application/octet-stream;
	default_type  text/html;
	
	charset utf-8;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;
	
	#nginx服务器与被代理服务连接超时时间，代理超时
	proxy_connect_timeout 300;

	#nginx服务器发送数据给被代理服务器超时时间，单位秒，
	#规定时间内nginx服务器没发送数据，则超时
	proxy_send_timeout 300;

	#nginx服务器接收被代理服务器数据超时时间，单位秒，
	#规定时间内nginx服务器没收到数据，则超时
	proxy_read_timeout 300;
	
	proxy_buffer_size 64k;
	proxy_buffers   8  128k;
	proxy_busy_buffers_size 128k;
	proxy_temp_file_write_size 128k;
	
 	# 客户端请求头设置
	client_header_buffer_size 10m;
	# 客户端请求体过大设置
    client_max_body_size 128m;

    #gzip  on;
	gzip  on;
	
	#BS WEB集群配置：服务器列表10
	upstream WebCluster{
		server localhost:9001 weight=1;
		server localhost:9002 weight=1;
		server localhost:9003 weight=1;
		server localhost:9004 weight=1;
		server localhost:9005 weight=1;
		server localhost:9006 weight=1;
		server localhost:9007 weight=1;
		server localhost:9008 weight=1;
		server localhost:9009 weight=1;
		server localhost:9010 weight=1;
	}
		
	#APP集群配置：服务器列表3
	upstream AppCluster{
		server localhost:9021 weight=1;
		server localhost:9022 weight=1;
		server localhost:9023 weight=1;
	}

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;
		
		# 限请求数配置
        #limit_req_zone $binary_remote_addr zone=perip:20m rate=100r/s;
        #limit_req_zone $server_name zone=perserver:20m rate=10000r/s;
		
		 #移动端服务代理转发配置IP地址请求适配
        location ^~ /webService/ {
            proxy_pass  http://AppCluster/webService/;
            proxy_redirect    off;
            proxy_set_header  Host $host;
            proxy_set_header  X-real-ip $remote_addr;
            proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
            #limit_req zone=perip  burst=1000;
            #limit_req zone=perserver burst=100000;
        }
		
		# 集群统一文件访问路径
		location ^~ /upload/ {
            alias  D:/application-images/upload/;
        }
		
		# 移动端APP下载代理
		location /forestryapp/ {
		   alias D:/forestryapp/;
		}
		
		
        # 默认访问后台管理系统服务
        location / {
			proxy_http_version 1.1;
			proxy_set_header Upgrade $http_upgrade;
			proxy_set_header Connection "Upgrade";
            #root   html;
            #index  home.html index.html server.html;
			proxy_pass http://WebCluster;
        }
     #.....
   }
#.....
}

遇到的问题

1、连接池关闭问题：Jedis连接池未关闭导致Redis连接池、Tomcat线程资源耗尽，主要是引入了Redis分布式锁做用户Session数量的统计而这部分代码没有关闭jedis连接，实际上没必要加锁，因为可以直接读取节点获得数量，只是为了从redis里面直接看结果而做的辅助处理。

2、共享Session 移除问题：隐约觉得哪里没有做完就匆忙上线了，结果用户的组织机构无法过滤，因为共享session没有移除即使单个Tomcat注销了但是整个Redis管理的共享session并没有被移除掉，只需要在session销毁的地方移除掉共享Session的redis key。

3、集群节点卡壳：没有启动的节点Nginx配置策略没有完善导致轮询过程中卡顿。

回顾历史版本改造改进处理

1、第一次改造：移动端和后端分流。

2、第二次改造：MySQL数据库索引解决查询慢的问题（包括轨迹查询、统计分析等）。

3、第三次改造：从内存方式全面转向Redis读取。

4、第四次改造：Redis主从方式，从节点只读负责系统业务数据查看。

5、第五次改造：组织机构人员树与地图联动分离后地图聚合数据改造，分布式集群支持。

注：由于历史原因组织机构人员树加载要10几秒，上万节点后加上业务耦合到树上计算基本树就没法用了。这次树与地图联动分离页面加载提升到1秒以内，并且得到了客户的认可这是最可贵的，索引查询数据5万左右的可以做到毫秒级分页加载。

Redis集群实现分布式Session共享
悦分享
01-10 2205
Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上，这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。在实际工作中我们建议使用外部的缓存设备来共享 Session，避免单个服务器节点挂掉而影响服务，共享数据都会放到外部缓存容器中。
redis集群 共享session解决
JC.Lin的博客
02-03 5131
java web项目，不依赖于web容器，实现负载均衡，必须解决session共享问题。网上解决方法有很多，但是我觉得使用 spring-session +redis是最方面快捷的，不用重复造轮子，且不用修改项目的代码，并且使项目使用的session与web容器解耦， 完全由容器的httpsession转为使用spring提供的session. 具体怎么使用，请访问spring的官方网站。 ...
tomcat容器 实现session共享案例
02-06
tomcat7 + java7 环境下，实现容器环境下，多服务器间的session共享。底层通过redis实现。（文件中包含所需的jar、配置说明和demo文件）
通过Redis集群实现Session共享方案
BXA
11-13 972
Redis + Tomcat + Nginx 集群实现 Session 共享一、插件地址二、插件讲解1、解压后的文件三、使用方法：第一步：第二步：第三步：第四步：第五步：四、Nginx集群1、下载Nignx：2、下载后解压：D:\soft\nginx-1.12.23、修改Nginx配置文件nginx.conf3.1 在http{……}里加上upstream，如下：3.2、修改location / ...
分布式集群Session共享 简单多tomcat8+redis的session共享实现
02-05
完美实现分布式集群Session共享 简单多tomcat8+redis的session共享实现，支持tomcat8、tomcat8.5、tomcat9，不能用直接联系我积分双倍返回。
SpringSession+Redis实现Session共享案例
06-10
SpringSession+Redis实现Session共享案例，详情请看http://blog.csdn.net/u012702547/article/details/72991283
redis 集群共享Session
09-03
关于Session的问题 网上有各个方面的针对，有在nginx 上处理： ip_hash的session，有在 tomcat 做处理：修改Context文件，有针对项目做处理。本篇就是对项目处理
Redis --- 实战篇
shuai_h的博客
07-20 977
Redis缓存
说说Redis分布式锁是如何实现的。含Redis面试专题及答案
m0_67322837的博客
04-18 1641
前言 近来，分布式的问题被广泛提及，比如分布式事务、分布式框架、ZooKeeper、SpringCloud等等。本文先回顾锁的概念，再介绍分布式锁，以及如何用Redis来实现分布式锁。 一、锁的基本了解 首先，回顾一下我们工作学习中的锁的概念。 为什么要先讲锁再讲分布式锁呢？ 我们都清楚，锁的作用是要解决多线程对共享资源的访问而产生的线程安全问题，而在平时生活中用到锁的情况其实并不多，可能有些朋友对锁的概念和一些基本的使用不是很清楚，所以我们先看锁，再深入介绍分布式锁。 通过一个卖票的小案例来看
第一章 Redis基础(简介+下载和安装+基本操作)----黑马
无
05-03 387
目标1：能够说出NoSQL的概念，redis的应用场景，能够完成redis的下载安装与启动以及一些常用的配置 目标2：能够说出redis常用的5种数据类型，对应这些数据类型的基本操作，应用场景及对应的解决方案 目标3：能够说出redis中常用的一些基本指令 目标4：能够使用jedis完成客户端应用程序的开发 目标5：能够说出redis数据持久化的两种方式，各自相关的操作配置及指令，以及两种方式的优缺点比较......
JavaEE电商项目实战：魔力商城快速构建
课程重点包括理解电商行业背景、构建SSM框架的后台工程、SOA架构的改造、使用Dubbo服务化、商品管理和前端系统搭建、缓存与搜索系统集成、单点登录与Session共享、购物车与订单系统的实现，以及最终的系统部署。...
Redis深度剖析：揭示redis-py工作机制的10个秘密
Redis作为一个高性能的分布式内存数据库，其独特之处在于提供了多种数据结构，并且支持持久化和复制等多种功能。本章将对Redis的核心特性进行简要概述，为后续章节中的深入讲解做铺垫。我们将从Redis的应用场景开始...
springboot+redis集群实现redis集群状态下的session共享
紫莫的博客
09-03 4398
springboot+redis的案例很多,但是redis集群的案例很少,so~笔者在这里记录一下~ 一、springboot依靠@EnableRedisHttpSession来开启spring session支持，该注解是由spring-session-data-redis提供的，所以在pom.xml文件中添加如下依赖： &lt;!-- redis --&gt; &lt;depen...
SpringSession实现分布式系统session共享案例实战
厉害哥哥的博客
05-20 496
引言 正文 结语
Redis存储tomcat session集群共享
xiaogg3678的专栏
09-18 169
基本环境 Redis 2.4.10 Nginx 1.10.1 Tomcat 7 Jdk 7 Node1 :172.18.50.100 Node2 : 172.18.50.101 Nginx配置 #定义集群的集合,将所有可用的node都添加到upstream中 upstream cluster { server 172.18.50.100:8080; server...
springboot shiro redis缓存和session共享例子
05-17
实现springboot 、shiro 、redis缓存和session共享源码例子
redis——（8）实现分布式集群环境session共享
奇点
04-03 323
多机器部署同一套服务（多机器部署同一套代码），性能更好，更承受更高的用户并发 1、cookie与session 1） Cookie是什么？ Cookie 是一小段文本信息，伴随着用户请求和页面在 Web 服务器和浏览器之间传递。Cookie 包含每次用户访问站点时 Web 应用程序都可以读取的信息，我们可以看到在服务器写的cookie，会通过响应头Set-Cooki...
Redis实现分布式集群环境session共享
q736317048的博客
02-18 281
多机器部署同一套服务（代码），性能更好，能承受更高的用户并发 当一个用户发送请求到第一台机器，内存存储sessioni的话，剩余的99台每次还需要存储 Cookie与Session Cookie： Cookie 是一小段文本信息，伴随着用户请求和页面在 Web 服务器和浏览器之间传递。Cookie 包含每次用户访问站点时 Web 应用程序都可以读取的信息，我们可以看到在服务器写的cookie，会通过响应头Set-Cookie的方式写入到浏览器 HTTP协议是无状态的，并非TCP一样进行三次握手，对于一个浏
redis实现分布式集群环境session共享
zssz1026的专栏
04-16 59
架构案例分析
zylg
10-11 1672
架构师案例分析 <1> 嵌入式操作系统 3 <2> 系统可靠性 3 <3>应用系统数据架构 6 <4>数据库 7 <5>开发方法 9 <6>软件架构设计 11 <7>构件 13 <8>UML 15 <9>面向服务架构SOA 17 <10> 嵌入式 19 <十一> 数据库 22 <十二> 系统建模 24 <十三> 结构化分析 27 <十四>结构
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值