一、可道云项目结合redis缓存部署

redis缓存可道云项目数据及会话，加快网站访问速度

环境准备：

1.下载可道云开源代码，部署在web01服务器上。

可道云官网下载

下载源码，解压到指定目录，授权。

[root@web01 ~]# wget wget https://static.kodcloud.com/update/download/kodbox.1.22.zip
[root@web01 ~]# mkdir /code/kedaoyun -p
[root@web01 ~]# unzip kodbox.1.22.zip -d /code/kedaoyun
[root@web01 ~]# chmod -R www.www /code/kedaoyun

2.编写配置文件

[root@web01 conf.d]# cat kedaoyun.conf 
server {
	listen 80;
	server_name kdy.bertwu.net;
	root /code/kedaoyun;

	location / {
		index index.php;
	}
	location ~ .*\.php$ {
		fastcgi_pass 127.0.0.1:9000;
		fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
		include fastcgi_params;
		
	}

}

3.mysql数据库授权远程登录,确保db01开启了远程连接用户。

MariaDB [(none)]> grant all privileges on *.* to 'app'@'172.16.1.%' identified by '123kod456';

4.db01上创建可道云数据库

MariaDB [(none)]> create database kodbox;
Query OK, 1 row affected (0.00 sec)

5.配置hosts文件，浏览器访问 kdy.bertwu.net

6. redis服务器上安装redis并启用

[root@redis01 ~]# yum install redis -y

7.配置 redis 监听在本地的内网网卡上

[root@redis01 ~]# sed -i '/^bind/c bind 127.0.0.1 172.16.1.41' /etc/redis.conf

8.启动redis

[root@redis01 ~]# systemctl start redis
[root@redis01 ~]# systemctl enable redis
[root@redis01 ~]# netstat -ntlp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 172.16.1.41:6379        0.0.0.0:*               LISTEN      1262/redis-server 1 
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      1262/redis-server 1

9.接入redis

10.查看redis已经有用户的数据了

127.0.0.1:6379> keys *
 1) "ac3e2_UserModel_getInfoFull_ID_1"
 2) "43abe268181757bedee0e410ac6c5e4b"
 3) "ac3e2_SystemOption_System.storageList"
 4) "ac3e2_SystemOption_System.sourceAuthList"
 5) "ac3e2_UserModel_getInfoSimple_ID_1"
 6) "ac3e2_SystemOption_System.noticeList"
 7) "ac3e2_UserTagSourceModel_listData_ID_0"

二、Nginx负载均衡会话共享

1.1 什么是会话保持

会话（Session）跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。当用户登陆一个网站服务器，网站服务器会将用户的登陆信息存储下来（存储下来的内容叫 Session ）以保证我们能够一直处于 ”登陆在线“ 状态。

1.2 为什么需要会话保持

由于我们使用的是负载均衡轮询机制，会导致用户请求分散在不同的节点，从而造成会话无法保持。假设用户A，通过负载均衡登陆了网站，此时会话信息存储在A节点，那么当它一刷新，负载均衡会将请求分发给B节点，那么B节点没有用户A的登陆信息，就会提示用户A登陆，当A用户点击登陆时又会将请求分发给C节点，从而造成用户A无法实现会话保持。

1.3 Cookie机制、Session机制、token机制

请参考：
Cookie与Session
彻底理解cookie，session，token的区别
cookie保存在客户端，但是不安全。session存在服务器端，由服务器保存，但是会增加服务器压力，而且负载均衡机制会调度在不同节点。token是结合了两者的优势。

1.4 如何实现会话保持

1. 粘性session：指Ngnix每次都将同一用户的所有请求转发至同一台服务器上，及Nginx的 IP_hash。
2. session复制（几乎不用）：每次session发生变化，就广播给集群中的服务器，使所有的服务器上的session相同。
3. session共享：缓存session至内存数据库中，使用redis，memcached实现。（可以设置过期时间，过期自动清理）
4. session持久化：将session存储至数据库中，像操作数据一样操作session。（会导致数据库大量脏数据，几乎不用）

1.5 会话保持场景实践

环境准备：

1.下载 下载phpmyadmin项目
官网
2.解压到指定目录制作软连接，授权

[root@web01 ~]# unzip phpMyAdmin-5.1.1-all-languages.zip -d /code # 解压
[root@web01 ~]# cd /code/
[root@web01 code]# ln -s phpMyAdmin-5.1.1-all-languages/ phpmyadmin # 制作软连接
[root@web01 code]# ll
lrwxrwxrwx  1 root root   31 Aug 18 19:57 phpmyadmin -> phpMyAdmin-5.1.1-all-languages/
[root@web01 code]# chown -R www.www phpmyadmin/  # 授权

3.修改 phpmyadmin 连接远程的数据库

[root@web01 code]# cd phpmyadmin/
[root@web01 phpmyadmin]# cp config.sample.inc.php config.inc.php # 修改样本名，然后修改内容
[root@web01 phpmyadmin]# vim config.inc.php
$cfg['Servers'][$i]['host'] = '172.16.1.51';

4编写nginx配置文件

[root@web01 conf.d]# cat phpmyadmin.conf 
server {
	listen 80;
	server_name phpmyadmin.bertwu.net;
	root /code/phpmyadmin;
	location / {
	index index.php index.htmp;
	
	}
	location ~ .*\.php$ {
		fastcgi_pass 127.0.0.1:9000;
		fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
		include fastcgi_params;
	} 
}

[root@web01 conf.d]# nginx -t
[root@web01 conf.d]# systemctl reload nginx

5.db01端授权远程用户登录

MariaDB [(none)]> grant all privileges on *.* to 'app'@'172.16.1.%' identified by '123guest456';
Query OK, 0 rows affected (0.00 sec)

7.浏览器测试是否连接成功
8.web02节点同样的部署
9.编写负载均衡nginx配置文件
编写一份 proxy 负载均衡的配置文件，将请求调度到后端 web 节点

[root@lb01 conf.d]# cat lb_phpmyadmin.conf 
upstream lb_phpmyadmin {
	server 172.16.1.7:80;
	server 172.16.1.8:80;
}

server {
	listen 80;
	server_name phpmyadmin.bertwu.net;
	location / {
		proxy_pass http://lb_phpmyadmin;
		include proxy_params;
	}
}


[root@lb01 conf.d]# nginx -t
[root@lb01 conf.d]# nginx -t

其中proxy_params配置如下

[root@lb01 nginx]# cat proxy_params 
# ip
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

# http version
proxy_http_version 1.1;
proxy_set_header Connection "";

# timeout
proxy_connect_timeout 120s;
proxy_read_timeout 120s;
proxy_send_timeout 120s;

# buffer
proxy_buffering on;
proxy_buffer_size 8k;
proxy_buffers 8 8k;

10.redis01服务器上安装redis并启用

[root@redis01 ~]# yum install redis -y

11.配置 redis 监听在本地的内网网卡上

[root@redis01 ~]# sed -i '/^bind/c bind 127.0.0.1 172.16.1.41' /etc/redis.conf

12.启动redis

[root@redis01 ~]# systemctl start redis
[root@redis01 ~]# systemctl enable redis
[root@redis01 ~]# netstat -ntlp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 172.16.1.41:6379        0.0.0.0:*               LISTEN      1262/redis-server 1 
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      1262/redis-server 1

13.配置php连接Redis
1.修改 /etc/php.ini 文件。[所有节点都需要操作]

[root@web01 conf.d]# vim /etc/php.ini
session.save_handler = redis
session.save_path = "tcp://172.16.1.41:6379"
;session.save_path = "tcp://172.16.1.41:6379?auth=123456" #如果redis存在密码，则使用该方式

2.注释 php-fpm.d/www.conf 里面的两条内容，否则 session 内容会一直写入 /var/lib/php/session 目录中，从而造成会话共享失败。(所有节点都需要操作)

[root@web01 conf.d]# vim /etc/php-fpm.d/www.conf 
;php_value[session.save_handler] = files
;php_value[session.save_path] = /var/lib/php/session

3.重启 php-fpm 服务。(所有节点都需要操作)

[root@web01 conf.d]# php-fpm -t
[root@web01 conf.d]# systemctl restart nginx

14.测试集群会话共享
1.浏览器查看请求响应的cookie信息

2检查 redis 中是否存在 cookie 对应的 session 信息

[root@redis01 ~]# redis-cli
127.0.0.1:6379> 
127.0.0.1:6379> keys *
1) "PHPREDIS_SESSION:b7681e67c147e7ce1e296a5b650b9b4d"
127.0.0.1:6379> 

3.此时用户的 cookie 始终都不会发生任何变化，无论请求被负载调度到那一台后端web 节点服务器都不会出现没有登陆情况。

三、 后端节点异常容错机制

使用nginx负载均衡时，如何将后端请求超时的服务器流量平滑的切换到另一台上？如果后台服务连接超时，Nginx是本身是有机制的，如果出现一个节点down掉的时候，Nginx会更据你具体负载均衡的设置，将请求转移到其他的节点上，但是，如果后台服务连接没有down掉，而是返回了错误异常码 如:504、502、500，该怎么办？

3.1 配置语法

# 当其中一台返回错误码 404,500 等错误时，可以分配到下一台服务器程序继续处理，提高平台访问成功率。
proxy_next_upstream  error | timeout | http_500 | http_502 | http_503 | http_504 |http_404;

3.2 场景示例

blog项目为例，如果有一个节点php-fpm服务异常停止，这样前端用户请求页面就会时而502时而正常，用户体验度极差。

解决方案：

[root@lb01 conf.d]# cat proxy_blog.conf 
upstream blog {
	server 172.16.1.7:80;
	server 172.16.1.8:80;
}


server {
	listen 80;
	server_name blog.bertwu.net;
	location / {
		proxy_pass http://blog;
		proxy_next_upstream error timeout http_500 http_502 http_503 http_504;
		proxy_next_upstream_tries 2; # 尝试的次数
		proxy_next_upstream_timeout 3s; # 尝试的超时时间
		include /etc/nginx/proxy_params;
	}
}

四、Nginx负载均衡调度场景

4.1 根据uri进行调度(路由)

由于资源有限，每个集群其实是一台主机，基于开放多端口模拟集群中的多台主机。

web01配置如下：

[root@web01 conf.d]# cat uri.conf 
server {
	listen 8081;
	server_name uri.bertwu.net;
	root /code/user1;
	location / {
		index index.html;
	}
}

server {
	listen 8082;
	server_name uri.bertwu.net;
	root /code/user2;
	location / {
		index index.html;
	}
}


[root@web01 conf.d]# mkdir /code/user1
[root@web01 conf.d]# mkdir /code/user2
[root@web01 conf.d]# echo 'user-8081' > /code/user1/index.html
[root@web01 conf.d]# echo 'user-8082' > /code/user2/index.html
[root@web01 conf.d]# nginx -t
[root@web01 conf.d]# systemctl reload nginx

web02配置如下：

[root@web02 conf.d]# cat uri.conf 
server {
	listen 8081;
	server_name uri.bertwu.net;
	root /code/pass1;
	location / {
		index index.html;
	}
}

server {
	listen 8082;
	server_name uri.bertwu.net;
	root /code/pass2;
	location / {
		index index.html;
	}
}


[root@web02 conf.d]# mkdir /code/pass1
[root@web02 conf.d]# mkdir /code/pass2
[root@web02 conf.d]# echo 'pass-8081' > /code/pass1/index.html
[root@web02 conf.d]# echo 'pass-8082' > /code/pass2/index.html
[root@web02 conf.d]# nginx -t
[root@web02 conf.d]# systemctl reload nginx

lb01负载均衡配置如下：

[root@lb01 conf.d]# cat lb_uri.conf 
upstream user {
	server 172.16.1.7:8081;
	server 172.16.1.7:8082;
}

upstream pass {
	server 172.16.1.8:8081;
	server 172.16.1.8:8082;
}


server {
	listen 80;
	server_name uri.bertwu.net;
	
	location /user {
		proxy_pass http://user;
		include proxy_params;
	}
	
	location /pass {
		proxy_pass http://pass;
		include proxy_params;
	}
}
[root@lb01 conf.d]# nginx -t
[root@lb01 conf.d]# systemctl reload nginx

前端修改完hosts文件后访问http://uri.bertwu.net/user 或http://uri.bertwu.net/pass，都会报404错误。打开任意一个节点的错误日志发现：

2021/08/19 00:22:01 [error] 2804#2804: *198 open() "/code/user1/user" failed (2: No such file or directory), client: 172.16.1.5, server: uri.bertwu.net, request: "GET /user HTTP/1.1", host: "uri.bertwu.net"

TMD 竟然路径成了 /code/user1/user ，这是为什么？

4.2 Proxy添加/与不添加/

在使用proxy_pass反向代理时，最后结尾添加/和不添加/有什么区别?

proxy_pass http://localhost:8080;
proxy_pass http://localhost:8080/;

不添加时
#用户请求URL： /user/index.html
#请求到达Nginx负载均衡： /user/index.html
#Nginx负载均衡到后端节点： /user/index.html

添加/时
#用户请求URL： /user/index.html
#请求到达Nginx负载均衡： /user/index.html
#Nginx负载均衡到后端节点： /index.html

1.带 / 意味着Nginx代理会修改用户请求的URL，将location匹配的URL进行删除。
2.不带 / 意味着Nginx代理不会修改用户请求的URL，而是直接代理到后端应用服务器

上述问题只需要在prox_pass后面加/,代码如下：

[root@lb01 conf.d]# cat lb_uri.conf 
upstream user {
	server 172.16.1.7:8081;
	server 172.16.1.7:8082;
}

upstream pass {
	server 172.16.1.8:8081;
	server 172.16.1.8:8082;
}


server {
	listen 80;
	server_name uri.bertwu.net;
	
	location /user {
		proxy_pass http://user/;
		include proxy_params;
	}
	
	location /pass {
		proxy_pass http://pass/;
		include proxy_params;
	}
}

方案二，创建/code/user1/user 目录，将/code/user1/index.htm 移动到code/user1/user/index.html ,其他节点同理。

4.3 根据请求设备进行调度

[root@lb01 conf.d]# cat agent.conf 
upstream phone {
	server 172.16.1.7:80;
	
}

upstream pc {
	server 172.16.1.8:80;
}



server {
	listen 80;
	charset utf-8;
	include proxy_params;
	default_type text/html;
	server_name agent.bertwu.net;
	location / {
		if ($http_user_agent ~* 'android|iphone|ipad') {
			proxy_pass http://phone;
		}
	
		if ($http_user_agent ~* 'MSIE|Trident') {
			return 200 "浏览器真棒！";
		}
		proxy_pass http://pc;
	}
	
}

[root@web02 conf.d]# cat pc.conf 
server {
	listen 80;
	server_name agent.bertwu.net;
	root /code/pc;
	location / {

		index index.html;
	}
}

server {
	listen 80;
	server_name agent.bertwu.net;
	root /code/phone;
	location / {
		index index.html;
	}
}

五、 Nginx多级代理获取真实IP

5.1 多级代理获取地址概述

用户发起请求，沿途可能会经过多级代理，最终抵达应用节点，那应用节点如何获取客户端真实IP地址
1：通过X-Forwarded-For透传客户端的真实IP实现方式
2：使用Nginx RealIP模块实现客户端地址透传

5.2 多级代理获取地址实践

5.1 多级代理获取地址概述

用户发起请求，经过多级代理之后， web服务器无法直接获取到客户端真实的IP地址。
$remote_addr获取的是上级反反向代理的IP地址。 反向代理服务器在转发请求的http头信息中，
增加http_x_forwarded_for信息，用来记录客户端IP地址和客户端请求的服务器地址的详细过程。

5.2.1.环境准备

一级代理 10.0.0.5 proxy_node1
二级代理 10.0.0.7 proxy_node2
三级代理 10.0.0.9 proxy_node3
真实节点 10.0.0.8 webserver
路径：
10.0.0.1--->10.0.0.5----->10.0.0.9------>10.0.0.8

5.2.2 配置一级代理

[root@lproxy_node1 conf.d]# cat proxy_node1.conf 
server {
	listen 80;
	server_name ip.bertwu.net;
	location / {
		proxy_pass http://10.0.0.7:80;
		proxy_http_version 1.1;
		proxy_set_header Connection "";
		proxy_set_header Host $http_host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
}

5.2.3 配置二级代理

[root@proxy_node2 conf.d]# cat proxy_node2.conf 
server {
	listen 80;
	server_name ip.bertwu.net;
	location / {
		proxy_pass http://10.0.0.9:80;
		proxy_http_version 1.1;
		proxy_set_header Connection "";
		proxy_set_header Host $http_host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
}

5.2.4 配置三级代理

[root@proxy_node3 conf.d]# cat proxy_node3.conf 
server {
	listen 80;
	server_name ip.bertwu.net;
	location / {
		proxy_pass http://10.0.0.8:80;
		proxy_http_version 1.1;
		proxy_set_header Connection "";
		proxy_set_header Host $http_host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
}

5.2.5 配置webserver

web02.conf  web.conf    
[root@weberver conf.d]# cat web.conf 
server {
	listen 80;
	server_name ip.bertwu.net;
	root /code/ip;
	location / {
		index index.html;
	}
}

5.2.5 浏览器访问ip.bertwu.net，观察并分析各节点日志

以下是各级代理的访问日志信息，请注意观察第一段$remote_addr 和最后一段$http_x_forwarded_for的信息。

# 一级代理日志
10.0.0.1 - - [20/Aug/2021:00:24:12 +0800] "GET / HTTP/1.1" 200 11 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "-"
# 二级代理日志
10.0.0.5 - - [20/Aug/2021:00:24:12 +0800] "GET / HTTP/1.1" 200 11 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1"
# 三级代理日志
172.16.1.7 - - [20/Aug/2021:00:24:12 +0800] "GET / HTTP/1.1" 200 11 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1, 10.0.0.5"
# webserver日志
10.0.0.9 - - [20/Aug/2021:00:24:12 +0800] "GET / HTTP/1.1" 200 11 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1, 10.0.0.5, 10.0.0.7"

5.3 RealiP模块获取真实IP

使用nginx Realip_module获取多级代理下的客户端真实IP地址,在后端Web节点上添加如下配置即可（Realip需要知道所有沿途经过的代理节点的IP地址或IP段）；

[root@web02 conf.d]# cat web.conf 
server {
	listen 80;
	server_name ip.bertwu.net;
	set_real_ip_from 10.0.0.5;
	set_real_ip_from 10.0.0.7;
	set_real_ip_from 10.0.0.9;
	real_ip_header X-Forwarded-For;
	real_ip_recursive on;
	root /code/ip;
	location / {
		index index.html;
	}
}


#set_real_ip_from：真实服务器上一级代理的IP地址或者IP段,可以写多行   
#real_ip_header：从哪个header头检索出需要的IP地址    
#real_ip_recursive：递归排除set_real_ip_from里面出现的IP,其余没有出现的认为是用户真实IP

再次查看日志：

# 一级代理日志
10.0.0.1 - - [20/Aug/2021:01:06:39 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "-"
# 二级代理日志
10.0.0.5 - - [20/Aug/2021:01:06:39 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1"
# 三级代理日志
10.0.0.7 - - [20/Aug/2021:01:06:39 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1, 10.0.0.5"
# webserver日志
10.0.0.1 - - [20/Aug/2021:01:06:39 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1, 10.0.0.5, 10.0.0.7"

可以看到，最终结果是

10.0.0.1 - - [20/Aug/2021:01:06:39 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36" "10.0.0.1, 10.0.0.5, 10.0.0.7"

而10.0.0.5、10.0.0.7、10.0.0.9都出现在出现在set_real_ip_from中，仅仅10.0.0.1没出现，那么他就被认为是用户真实的ip地址，同时会被赋值到 $remote_addr变量中，这样我们的程序无需做任何修改，直接使用$remote_addr变量即可获取真实IP地址。

继上一遍文章，使用nginx实现负载均衡以后，新的问题又产生了，当使用负载均衡以后，我们如何实现session共享，因为session是保存在服务端的，对于单体应用来说这不是问题，因为只有一个服务器，但是在多个服务器的情况下，我们在A服务器登陆成功，session存在A服务器，下一次请求被转发到了B,但是B服务器中没有对应的用户信息，重新让用户登录肯定不合适，这个时候我们需要将该session信息放在一个公共的地方，不管后续请求被转发到了哪个服务器，我们都去从公共的位置去取，这样就实现了session共享(类似问题的解决方案有很多，比如存入数据库、配置tomcat实现session同步，使用jwt等等)，今天我们使用的是spring session+redis来实现.

此处的代码基于上一篇的nginx实现负载均衡
改造而来。
1.pom文件引入相关依赖(这是我全部的依赖，贴出来方便复制粘贴)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.weige</groupId>
    <artifactId>test-db-nginx</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test-db-nginx</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.6.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.session/spring-session-data-redis -->
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
            <version>2.6.3</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>bookTest86</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.配置redis相关信息

spring.redis.host=127.0.0.1
spring.redis.port=6380
spring.redis.password=123456

3.添加一个配置类

package com.weige.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;


/**
 * Created with IntelliJ IDEA.
 *
 * @Author: weige
 * @Date: 2022/07/13/19:41
 * @Description:
 */
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 70)//session过期时间，单位为秒
public class RedisSessionConfig {


}

4.添加一个模拟用户登录/注销的接口

package com.weige.controller;

import com.weige.entity.User;
import com.weige.vo.RespBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: weige
 * @Date: 2022/07/13/7:59
 * @Description:
 */
@RestController
public class UserController {
    @Value("${server.port}")
    private  String port;

    //登录
    @PostMapping("/login")
    public RespBean login( HttpServletRequest request){
        HttpSession session=request.getSession();
        //获取当前的sessionId
        String sessionId = session.getId();
        //懒得传入，在这里写死的，能说明问题就行
        User user=new User();
        user.setUsername("悟空");
        user.setPassword("123456");
        user.setAddress("北京市天安门");
        System.out.println("登陆成功，sessionId:"+sessionId+";user===>"+user);
        session.setAttribute(sessionId,user);

        return RespBean.ok("登陆成功:"+port,user);

    }
    //获取当前用户
    @GetMapping("/getuser")
    public RespBean getuser(HttpServletRequest request){
        HttpSession session=request.getSession();
        String sessionId = session.getId();
        System.out.println("获取用户，sessionId==>"+sessionId);
        return RespBean.ok("登陆成功:"+port,session.getAttribute(sessionId));

    }
    //注销
    @GetMapping("/logout")
    public RespBean loginout(String username, HttpServletRequest request){
        HttpSession session=request.getSession();
        //这里不做查询，直接清除session
        String sessionId = session.getId();
        System.out.println("注销登录，sessionId==>"+sessionId+"服务端口:"+port);
        session.removeAttribute(sessionId);


        return RespBean.ok("注销成功:"+port);

    }
}

5.改造获取数据的接口，添加了对用户是否登录的判断

package com.weige.controller;

import com.weige.entity.Book;
import com.weige.entity.User;
import com.weige.service.BookService;
import com.weige.vo.RespBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: weige
 * @Date: 2022/07/11/20:57
 * @Description:
 */
@RestController
@RequestMapping("/book")
public class BookController {
    @Autowired
    BookService bookService;

    @Value("${server.port}")
    private  String port;

   @GetMapping("/")
   public RespBean getAllBooks(HttpSession session){
       //HttpSession session=request.getSession();
       String sessionId = session.getId();
       System.out.println("查询book，sessionId==>"+sessionId+"服务端口:"+port);
       User user= ((User) session.getAttribute(sessionId));
       if(user==null){
           return RespBean.error("用户还没登录，请先登录！服务端口:"+port);
       }
       System.out.println("我从session中拿到了User--->"+user );
       List<Book> books=bookService.getAllBooks();

       return RespBean.ok(port,books);
   }

   @PostMapping("/")
   public RespBean addBook(@RequestBody Book book){
       int ret=bookService.addBook(book);
       return RespBean.ok(port,ret);
   }
   @PutMapping("/")
   public RespBean updateBook(@RequestBody Book book){
       int ret=bookService.updateBook(book);
       return RespBean.ok(port,ret);
   }

   @DeleteMapping("/{id}")
   public RespBean delBook(@PathVariable Integer id){
       int ret=bookService.delBook(id);
       return RespBean.ok(port,ret);
   }
}

关键的信息就是这些，在获取全部book信息的时候,会根据sessionId,从当前session中获取用户信息，如果用户不存在，就提示没有登录，登录后可以正常获取，我们将项目打包，放在服务器上，以8886和8887端口启动，结合之前配置的nginx负载均衡,我们希望无论在那一台服务上登录过，都可以正常的获取book信息，这样我们session共享的需求就实现了

(1)启动8886

(2)启动8887

(3)请求获取book接口，提示未登录，此时提供服务的是8886

(4)请求登录接口，注意此时提供服务的是8887,多次请求，8886和8887会交替出现，这是因为我们在nginx中配置的权重

(5)再次请求获取book接口(此时提供服务的是8886)

以上说明，同一个session，我们从任意一台服务器登陆成功后，在其它服务器上都可以获取到session中的用户信息，实现了session共享。

一、传统Session机制及身份认证方案

1、Cookie与服务器的交互

如上图，http是无状态的协议，客户每次读取web页面时，服务器都打开新的会话，而且服务器也不会自动维护客户的上下文信息。比如我们现在要实现一个电商内的购物车功能，要怎么才能知道哪些购物车请求对应的是来自同一个客户的请求呢？session就是一种保存上下文信息的机制，它是针对每一个用户的，变量的值保存在服务器端，通过SessionID来区分不同的客户。session是以cookie或URL重写为基础的，默认使用cookie来实现，系统会创造一个名为JSESSIONID的值输出到cookie。

注意JSESSIONID是存储于浏览器内存中的，并不是写到硬盘上的，如果我们把浏览器的cookie禁止，则web服务器会采用URL重写的方式传递Sessionid，我们就可以在地址栏看到 sessionid=KWJHUG6JJM65之类的字符串。 通常JSESSIONID是不能跨窗口使用的，当你新开了一个浏览器窗口进入相同页面时，系统会赋予你一个新的sessionid，这样我们信息共享的目的就达不到了。

2、服务器端的session的机制

session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构(也可能就是使用散列表)来保存信息。但程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否包含了一个JSESSIONID标识的sessionid，如果已经包含一个session id则说明以前已经为此客户创建过session，服务器就根据sessionid把这个session检索出来使用(如果检索不到，可能会新建一个，这种情况可能出现在服务端已经删除了该用户对应的session对象，但用户人为地在请求的URL后面附加上一个JSESSION的参数)。

如果客户请求不包含 session id，则为此客户创建一个session并且生成一个与此session相关联的session id，这个session id将在本次响应中返回给客户端保存。对每次http请求，都经历以下步骤处理：服务端首先查找对应的cookie的值（sessionid）。 根据sessionid从服务器端session存储中获取对应id的 session数据，进行返回。 如果找不到sessionid，服务器端就创建session，生成sessionid对应的cookie，写入到响应头中。

3、基于session的身份认证

看下图：

因为http请求是无状态请求，所以在Web领域，几乎所有的身份认证过程，都是这种模式。

二、集群下Session困境及解决方案

如上图，随着分布式架构的流行，单个服务器已经不能满足系统的需要了，通常都会把系统部署在多台服务器上，通过负载均衡把请求分发到其中的一台服务器上，这样很可能同一个用户的请求被分发到不同的服务器上，因为session是保存在服务器上的，那么很有可能第一次请求访问的A服务器，创建了session，但是第二次访问到了B服务器，这时就会出现取不到session的情况。我们知道，Session一般是用来存会话全局的用户信息（不仅仅是登陆方面的问题），用来简化/加速后续的业务请求。要在集群环境下使用，最好的的解决办法就是使用session共享：

1、Session共享方案

传统的session由服务器端生成并存储，当应用进行分布式集群部署的时候，如何保证不同服务器上session信息能够共享呢？两种实现思路：session集中存储（redis，memcached，hbase等）。不同服务器上session数据进行复制，此方案延迟问题比较严重。 我们一般推荐第一种方案，基于session集中存储的实现方案，见下图：

具体过程如下：

新增Filter拦截请求，包装HttpServletRequest（使用HttpServletRequestWrapper） 改写getSession方法，从第三方存储中获取session数据（若没有则创建一个），返回自定义的HttpSession实例在http返回response时，提交session信息到第三方存储中。

2、需要考虑的问题

2.1、需要考虑以下问题：

session数据如何在Redis中存储？

session属性变更何时触发存储？

2.2、实现：

考虑到session中数据类似map的结构，采用redis中hash存储session数据比较合适，如果使用单个value存储session数据，不加锁的情况下，就会存在session覆盖的问题，因此使用hash存储session，每次只保存本次变更session属性的数据，避免了锁处理，性能更好。如果每改一个session的属性就触发存储，在变更较多session属性时会触发多次redis写操作， 对性能也会有影响，我们是在每次请求处理完后，做一次session的写入，并且写入变更过的属性。如果本次没有做session的更改，是不会做redis写入的，仅当没有变更的session超过一个时间阀值（不变更session刷新过期时间的阀值），就会触发session保存，以便session能够延长有效期。

3、代码实战

3.1、新建项目springboot-session-bussiness

主要实现正常的登录拦截功能，为后面项目改造提供参考。

代码参见：springboot-platform------>springboot-session-bussiness模块

代码git地址：https://gitee.com/hankin_chj/springboot-platform.git

3.2、新建springboot-session-bussiness模块

该模块为公共模块，主要用于为其他服务提供统一的session拦截、分装等功能，主要对系统的request和session对象进行重写，其他服务需要用到request的时候就使用封装好的MyRequestWrapper来获取session相关内容。

1）重写HttpSession

public class MySession implements Serializable,HttpSession {
    private static final long serialVersionUID = -3923541488767125713L;
    private String id;
    private Map<String,Object> attrs;
    .....

2）request封装代码实现如下：

public class MyRequestWrapper extends HttpServletRequestWrapper {
    private volatile boolean committed = false;
    private String uuid = UUID.randomUUID().toString();
    private MySession session;
    private RedisTemplate redisTemplate;
    public MyRequestWrapper(HttpServletRequest request,RedisTemplate redisTemplate) {
        super(request);
        this.redisTemplate = redisTemplate;
    }
    // 提交session内值到redis
    public void commitSession() {
        if (committed) {
            return;
        }
        committed = true;
        MySession session = this.getSession();
        if (session != null && null != session.getAttrs()) {
            redisTemplate.opsForHash().putAll(session.getId(),session.getAttrs());
        }
    }
    //创建新session
    public MySession createSession() {
        String sessionId = CookieBasedSession.getRequestedSessionId(this);//从页面传来的
        Map<String,Object> attr ;
        if (null != sessionId){
            attr = redisTemplate.opsForHash().entries(sessionId);
        } else {
            System.out.println("create session by rId:"+uuid);
            sessionId = UUID.randomUUID().toString();
            attr = new HashMap<>();
        }
        //session成员变量持有
        session = new MySession();
        session.setId(sessionId);
        session.setAttrs(attr);
        return session;
    }
    //或取session
    public MySession getSession() {
        return this.getSession(true);
    }
    // 取session
    public MySession getSession(boolean create) {
        if (null != session){
            return session;
        }
        return this.createSession();
    }
    //是否已登陆
    public boolean isLogin(){
        Object user = getSession().getAttribute(SessionFilter.USER_INFO);
        return null != user;
    }
}

3）包装request对象，提交session到redis，SessionFilter代码实现：

public class SessionFilter implements Filter {
    public static final String USER_INFO = "user";
    private RedisTemplate redisTemplate;
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;
        //包装request对象
        MyRequestWrapper myRequestWrapper = new MyRequestWrapper(request,redisTemplate);
        //如果未登陆，则拒绝请求，转向登陆页面
        String requestUrl = request.getServletPath();
        if (!"/toLogin".equals(requestUrl)//不是登陆页面
                && !requestUrl.startsWith("/login")//不是去登陆
                && !myRequestWrapper.isLogin()) {//不是登陆状态
            request.getRequestDispatcher("/toLogin").forward(myRequestWrapper,response);
            return ;
        }
        try {
            filterChain.doFilter(myRequestWrapper,servletResponse);
        } finally {
            //提交session到redis
            myRequestWrapper.commitSession();
        }
    }
    @Override
    public void destroy() { }
}

4）工具类CookieBasedSession通过cookie获取sessionID：

public class CookieBasedSession{
    public static final String COOKIE_NAME_SESSION = "psession";
    public static String getRequestedSessionId(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (cookies == null) {
            return null;
        }
        for (Cookie cookie : cookies) {
            if (cookie == null) {
                continue;
            }
            if (!COOKIE_NAME_SESSION.equalsIgnoreCase(cookie.getName())) {
                continue;
            }
            return cookie.getValue();
        }
        return null;
    }
    public static void onNewSession(HttpServletRequest request,HttpServletResponse response) {
        HttpSession session = request.getSession();
        String sessionId = session.getId();
        Cookie cookie = new Cookie(COOKIE_NAME_SESSION, sessionId);
        cookie.setHttpOnly(true);
        cookie.setPath(request.getContextPath() + "/");
        // 设置一级域名
        cookie.setDomain("dev.com");
        cookie.setMaxAge(Integer.MAX_VALUE);
        response.addCookie(cookie);
    }
}

3.3、新建springboot-sessionA与springboot-sessionB项目

SessionA和sessionB项目代码基本一致，知识配置不一样，模拟两个业务服务登录场景

1）pom文件配置

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.chj</groupId>
        <artifactId>springboot-session-support</artifactId>
        <version>1.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!--使用swagger2-->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.6.1</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.6.1</version>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.1.3.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2）application.yml配置

spring:
  redis:
      host: 127.0.0.1
      port: 6379
  devtools:
      restart:
        enabled: true                       #开启
        additional-paths: src/main/java     #监听目录
swagger:
  host: local.dev.com

3）controller层代码实现，注意接口参数MyRequestWrapper代替了HttpServletRequest

@Controller
public class IndexController {
    @GetMapping("/toLogin")
    public String toLogin(Model model,MyRequestWrapper request) {//仅限本次会话
        UserForm user = new UserForm();
        user.setUsername("hankin");
        user.setPassword("hankin");
        user.setBackurl(request.getParameter("url"));
        model.addAttribute("user", user);
        return "login";
    }
    @PostMapping("/login")
    public void login(@ModelAttribute UserForm user,MyRequestWrapper request,HttpServletResponse response) throws IOException, ServletException {
        request.getSession().setAttribute(SessionFilter.USER_INFO,user);
        //TODO 种cookie
        CookieBasedSession.onNewSession(request,response);
        //重定向
        response.sendRedirect("/index");
    }

    @GetMapping("/index")
    public ModelAndView index(MyRequestWrapper request) {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("user", request.getSession().getAttribute(SessionFilter.USER_INFO));
        request.getSession().setAttribute("test","123");
        return modelAndView;
    }
}

4）session配置将SessionFilter注入到servlet容器

/**
 * 把SessionFilter 注册掉servlet容器里面
 */
@Configuration
public class SessionConfig {
    //配置filter生效
    @Bean
    public FilterRegistrationBean sessionFilterRegistration(SessionFilter sessionFilter) {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(sessionFilter);
        registration.addUrlPatterns("/*");
        registration.addInitParameter("paramName", "paramValue");
        registration.setName("sessionFilter");
        registration.setOrder(1);
        return registration;
    }
    //定义过滤器组件
    @Bean
    public SessionFilter sessionFilter(RedisTemplate redisTemplate){
        SessionFilter sessionFilter = new SessionFilter();
        sessionFilter.setRedisTemplate(redisTemplate);
        return sessionFilter;
    }
}

注意：

SessionA和sessionB两个服务的登录方法里面都会讲讲session信息放到一级域名cookie里面，所以一旦一个系统登录，另外一个系统也会从这个一级域名下面获取到登录信息。

@PostMapping("/login")
public void login(@ModelAttribute UserForm user, MyRequestWrapper request, HttpServletResponse response) throws IOException, ServletException {
    request.getSession().setAttribute(SessionFilter.USER_INFO,user);
    //种cookie
    CookieBasedSession.onNewSession(request,response);
    //重定向
    response.sendRedirect("/index");
}

3.4、启动服务访问测试：

http://a.dev.com:8090/index

http://b.dev.com:8091/index

A、B服务刚开始访问都是未登录状态如下：

当a登录以后刷新b服务，发现已经是登录状态：

三、多服务下的登陆困境及SSO方案

1、SSO的产生背景

较大的企业内部，一般都有很多的业务支持系统为其提供相应的管理和IT服务。通常来说，每个单独的系统都会有自己的安全体系和身份认证系统。进入每个系统都需要进行登录，这样的局面不仅给管理上带来了很大的困难，对客户来说也极不友好。那么如何让客户只需登陆一次，就可以进入多个系统，而不需要重新登录呢？

“单点登录”就是专为解决此类问题的。其大致思想流程如下：通过一个ticket进行串接各系统间的用户信息

2、SSO的底层原理CAS

2.1、起点

1）对于完全不同域名的系统，cookie是无法跨域名共享的，因此sessionId在页面端也无法共享。

2）cas方案，直接启用一个专业的用来登陆的域名（比如：cas.com）来供所有的系统的sessionId。

3）当业务系统（如 b.com）被打开时，借助cast系统来登陆，具体流程参见2.2

4）cas.com的登陆页面被打开时，如果此时cas.com本来就是登陆状态的，则自动返回生成ticket给业务系统。整个单点登陆的关键部位，是利用cas.com的cookie保持cas.com是登陆状态，此后任何第三个系统跳入，都将自动完成登陆过程。

5）本示例中，使用了redis来做cas的服务接口，根据工作情况，自行替换为合适的服务接口(主要是根据sessionid来判断用户是否已登陆)。

6）为提高安全性，ticket应该使用过即作废(本例中,会用有效期机制)。

2.2、cas登陆的全过程：

1）b.com打开时，发现自己未登陆，于是跳转到cas.com去登陆。 

2）cas.com登陆页面被打开，用户输入帐户/密码登陆成功。

3）cas.com登陆成功，种cookie到cas.com域名下，把sessionid放入后台redis《ticket，sessionId》然后页面跳回b.com。

4）b.com重新被打开，发现仍然是未登陆，但是有了一个ticket值。

5）b.com用ticket值，到redis里查到sessionid，并做session同步，种cookie到自己域名下面，页面原地重跳。

6）b.com打开自己页面，此时有了cookie，后台校验登陆状态，成功。

3、代码实战：

新建项目：springboot-cas-login，springboot-cas-website，springboot-cas-website

3.1、springboot-cas-login项目核心代码配置如下：

1）pom配置

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springboot-cas-login</artifactId>
<name>springboot-cas-login</name>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <java.version>1.8</java.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

2）application.yml配置，注意本地host配置域名cas.com

#启动: http://cas.com:8080/index
server:
  port: 8080
  compression:
    enabled: true
  connection-timeout: 3000
spring:
  redis:
      host: 127.0.0.1
      port: 6379

3）登录拦截过滤处理类代码

public class LoginFilter implements Filter {
    public static final String USER_INFO = "user";
    @Override
    public void init(FilterConfig filterConfig) throws ServletException { }
    @Override
    public void doFilter(ServletRequest servletRequest,ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;
        Object userInfo = request.getSession().getAttribute(USER_INFO);;
        //TODO 如果未登陆，则拒绝请求，转向登陆页面
        String requestUrl = request.getServletPath();
        if (!"/toLogin".equals(requestUrl)//不是登陆页面
                && !requestUrl.startsWith("/login")//不是去登陆
                && null == userInfo) {//不是登陆状态
            request.getRequestDispatcher("/toLogin").forward(request,response);
            return ;
        }
        filterChain.doFilter(request,servletResponse);
    }
    @Override
    public void destroy() {
    }
}

4）配置filter生效

@Configuration
public class LoginConfig {
    //配置filter生效
    @Bean
    public FilterRegistrationBean sessionFilterRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new LoginFilter());
        registration.addUrlPatterns("/*");
        registration.addInitParameter("paramName", "paramValue");
        registration.setName("sessionFilter");
        registration.setOrder(1);
        return registration;
    }
}

5）接口访问类代码

@Controller
public class IndexController {
    @Autowired
    private RedisTemplate redisTemplate;
    @GetMapping("/toLogin")
    public String toLogin(Model model,HttpServletRequest request) {
        Object userInfo = request.getSession().getAttribute(LoginFilter.USER_INFO);
        //不为空，则是已登陆状态
        if (null != userInfo){
            String ticket = UUID.randomUUID().toString();
            redisTemplate.opsForValue().set(ticket,userInfo,2, TimeUnit.SECONDS);
            return "redirect:"+request.getParameter("url")+"?ticket="+ticket;
        }
        UserForm user = new UserForm();
        user.setUsername("hankin");
        user.setPassword("hankin");
        user.setBackurl(request.getParameter("url"));
        model.addAttribute("user", user);
        return "login";
    }
    @PostMapping("/login")
    public void login(@ModelAttribute UserForm user,HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException {
        System.out.println("backurl:"+user.getBackurl());
        request.getSession().setAttribute(LoginFilter.USER_INFO,user);
        //TODO 登陆成功，创建用户信息票据
        String ticket = UUID.randomUUID().toString();
        redisTemplate.opsForValue().set(ticket,user,20, TimeUnit.SECONDS);
        //TODO 重定向，回原url---a.com
        if (null == user.getBackurl() || user.getBackurl().length()==0){
            response.sendRedirect("/index");
        } else {
            response.sendRedirect(user.getBackurl()+"?ticket="+ticket);
        }
    }
    @GetMapping("/index")
    public ModelAndView index(HttpServletRequest request) {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("user", request.getSession().getAttribute(LoginFilter.USER_INFO));
        request.getSession().setAttribute("test","123");
        return modelAndView;
    }
}

3.2、springboot-cas-website项目代码配置

其他配置基本同cas-login项目一样，唯一不同的就是拦截过滤代码部分：

1）如果未登陆，则拒绝请求，转向登陆页面；

2）有票据，则使用票据去尝试拿取用户信息；

3）无法得到用户信息，则去登陆页面；

4）将用户信息，加载进session中。

public class SSOFilter implements Filter {
    private RedisTemplate redisTemplate;
    public static final String USER_INFO = "user";
    public SSOFilter(RedisTemplate redisTemplate){
        this.redisTemplate = redisTemplate;
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;
        Object userInfo = request.getSession().getAttribute(USER_INFO);;
        //TODO 如果未登陆，则拒绝请求，转向登陆页面
        String requestUrl = request.getServletPath();
        if (!"/toLogin".equals(requestUrl)//不是登陆页面
                && !requestUrl.startsWith("/login")//不是去登陆
                && null == userInfo) {//不是登陆状态
            String ticket = request.getParameter("ticket");
            //TODO 有票据,则使用票据去尝试拿取用户信息
            if (null != ticket){
                userInfo = redisTemplate.opsForValue().get(ticket);
            }
            //TODO 无法得到用户信息，则去登陆页面
            if (null == userInfo){
                response.sendRedirect("http://cas.com:8080/toLogin?url="+request.getRequestURL().toString());
                return ;
            }
            // TODO 将用户信息，加载进session中
            request.getSession().setAttribute(SSOFilter.USER_INFO,userInfo);
            redisTemplate.delete(ticket);
        }
        filterChain.doFilter(request,servletResponse);
    }
    @Override
    public void destroy() { }
}

3.3、springboot-cas-website2项目代码

springboot-cas-website2与springboot-cas-website代码一样，除了application.yml配置文件。

3.4、启动项目测试

访问地址：

http://cas.com:8080/index

http://cas.com:8080/toLogin?url=http://a.com:8090/index

http://a.com:8090/index?ticket=1ef7a91b-ea3b-4990-a46d-eaeeaaf37a3b

http://b.com:8091/index?ticket=38089aee-6dc9-498c-8284-ef4b95fb2368

开始没登录的时候三个地址访问进去都是跳转到登录页面，需要登录当有一个地方登录以后，再次访问其他两个地址，发现都已经登录成功，结果如下所示：