单点登录又称之为Single Sign On，简称SSO，单点登录可以通过基于用户会话的共享，他分文两种，
- Redis+Cookie分布式会话来实现【相同顶级域名；基于Redis】
- CAS系统（中央认证服务）【不同顶级域名；独立的登录系统】
一、相同顶级域名的单点登录【使用Redis+Cookie实现】
比如说现在有个一级域名为 www.imooc.com ，是教育类网站，但是慕课网有其他的产品线，可以通过构建二级域名提供服务给用户访问，比如： music.imooop.imooc.com ， blog.imooc.com 等等，分别为慕课音乐，慕课电商以及慕课博客等，用户只需要在其中一个站点登录，那么其他站点也会随之而登录。
也就是说，用户自始至终只在某一个网站下登录后，那么他所产生的会话，就共享给了其他的网站，实现了单点网站登录后，同时间接登录了其他的网站，那么单点登录，他们的会话是共享的，都是同一个用户会话。
1、什么是会话
会话Session代表的是客户端与服务器的—次交互过程， 这个过程可以是连续也可以是时断时续的。曾经的Servlet时代 (jsp) ’ — 旦用户与服务端交互， 服务器tomcat就会为用户创建—个session, 同时 前端会有—个jsessionid, 每次交互都会携带。如此—来， 服务器只要在接到用户请求时候， 就可以拿到jsession id, 并根据这个ID在内 存中找到对应的会话session, 当拿到session会话后， 那么我们就可以操作会话了。会话存活期间，我们就能认为用户—直处千正在使用着网站的状态，— 旦session超期过时， 那么就可以认为用户已经离开网站， 停止交互了。用户的身份信息， 我们也是通过session来判断的， 在session中可以保存不同用户的信息。
session在单体中的使用， 代码如下：
@GetMapping("/setSession")
public Object setSession(HttpServletRequest request) {
HttpSession session = request.getSession();
session.setAttribute("userInfo", "new user");
session.setMaxInactiveInterval(3600);
session.getAttribute("userInfo");
// session.removeAttribute("userInfo");
return "ok";
}
1.1 有状态会话
Tomcat中的会话， 就是有状态的， 一旦用户和服务端交互，就有会话， 会话保存了用户的信息， 这样用户就有状态”了 ， 服务端会和每个客户端都保持着这样的—层关系，这个由容器来管理（也就是tomcat) , 这个session会话是保存到内存空间里的， 如此一来， 当不同的用户访问服务端， 那么就能通过会话知道谁是谁了。tomcat 会话的出现也是为了让http请求变的有状态。如果用户不再和服务 端交互， 那么会话超时则消失， 结 束 了他的生命周期。如此—来，每个用户其实都会有一个会话被维护， 这就是有状态会话。
场景：在传统项目或者jsp项目中是使用的最多的session都是有状态的， sess ion的存在就是为了弥补http的无状态。
- 注： to mcat会话可以通过手段实现多系统之间的状态同步， 但是会损耗—定的时间， — 旦发生同步那么用户请求就会等待， 这种做法不可取。
先来看—下单个tomcat会话， 这个就是有状态的，用 户首次访问服务端， 这个时候会话产生， 并且会设置jsessio nid 放入cookie中 ， 后续 每次请求都会携带jsessionid以保持用户状态。
1.2 为何使用无状态会话
1.3 无状态会话
HTTP请求是无状态的， 用户向服务端发起多个请求， 服务端并不会知道这多次请求都是来自同—用户， 这个就是无状态的。cookie 的出现就是为了有状态的记录用户。
常见的， ios 与服务端交互， 安卓与服务端交互，前后端分离，小程序与服务端交互，他 们都是通过发起http来调用接口数据的， 每次交互服务端都不会拿到客户端的状态，但是我们可以通过手段去处理，比如每次用户发起请求的时候携带—个userid 或者user-token， 如此—来， 就能让服务端根据用户id或token来获得相应的数据。每个用户的下—次请求都能被服务端识别来自同—个用户。
1.3.1 动静分离会话
用户请求服务端，由于动静分离， 前端发起http请求， 不会携带任何状态， 当用户第一次请求以后， 我们手动设置一个token, 作为 用户会话， 放入redis中， 如此作为redis-session, 并且这个token设 置后放入前端cookie中 (app或小程序可以放入本地缓存）， 如此后续交互过程中， 前端只需要传递token给后端， 后端就能识别这个用户请求来自谁了。
1.3.2 集群分布式系统会话
集群或分布式系统本质都是多个系统，假设这个里有两个服务器节点， 分别是AB系统， 他们可以是集群， 也可以是分布式系统，—开始用户和A系统交互， 那么这个时候的用户状态， 我们可以保存到redis中，作为A系统的会话信息， 随后用户的请求进入到了B系统， 那么B系统中的会话我也同样和redis 关联， 如此AB系统的session就统—了。当然cookie是会随着用户的访问携带过来的。那么这个其实就是分布式会话， 通过redis来保存用户的状态。
3.3 类似关系： 局部变量与全局变量
Tomcat会话相当于—个类中某个方法的局部变量，只 能在当前方法中使用； 分布式会话相当于—个类中的公用全局变量， 可以被类中诸多方法使用。如下代码：
distributedSession是这个类中的全局变量，可以在其他的方法中被使用到，而userSession和orderSession是在方法中的局部变量，局部变量只能在本方法中使用，全局变量可以在其他方法里都能使用。那么分布式会话和单个tomcat会话其实也是—样的道理
2、Redis+Cookie分布式用户会话
Cookie + Redis 所实现的分布式会话后端是基于redis的，如此会话可以流窜在后端的任意系统，都能获取到缓存中的用户数据信息，前端通过使用cookie，可以保一级二级下获取，那么这样一来，cookie中的信息userid和token是可以在发送请求的时候携带上的，这样从前端请求后端后是可以获取拿到的，这样一来，其实登录注册以后，其实cookie和redis中都会带有用户信息，只要用户不退出，那么就能在任意一个站点实现登录了。
- 那么这个原理主要也是cookie和网站的依赖关系，顶级域名 www.imooc.com 和 *.imooc.com 的cookie值是可以共享的，可以被携带比如设置为 .imooc.com ， .t.mukewang.com ，如此是OK的
- 二级域名自己的独立cookie是不能共享的，不能被其他二级域名获取，比如： music.imooc.com 的cookie是不能被 mtv.imooc.com 共
互不影响，要共享必须设置为 .imooc.com 。
2.1 方式一：手动编码实现Redis用户会话
在用户注册或登录后，后端会给用户生成一个全局唯一的token，然后将该token保存在cookie中返回给前端、同时保存在redis中一份。
前端生成的cookie中包含后端给该用户生成的唯一token:
redis中保存的该用户的唯一token：
当用户修改个人资料时，后端也需要同时重新为该用户生成一个新的token，然后放入cookie和redis中。
用户退出登录时，清空redis中该用户的token
2.2 方式二：基于SpringSession实现用户Redis会话【与Spring的耦合度高】
引入 Spring Session 依赖
<!--引入 Spring Session 依赖-->
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
<!--引入 Spring安全框架-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
配置存储类型
spring:
session:
store-type: redis
在启动类中开启redis作为spring session
@EnableRedisHttpSession // 开启redis作为spring session
开启redis作为spring session
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
3、分布式会话拦截器
3.1 注册拦截器
WebMvcConfig.java
package com.whx.config;
import com.whx.controller.interceptor.UserTokenInterceptor;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
// 实现静态资源的映射
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/META-INF/resources/") // 映射swagger2
.addResourceLocations("file:/workspaces/images/"); // 映射本地静态资源
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
@Bean
public UserTokenInterceptor userTokenInterceptor() {
return new UserTokenInterceptor();
}
/**
* 注册拦截器
* @param registry
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(userTokenInterceptor())
.addPathPatterns("/hello")
.addPathPatterns("/shopcart/add")
.addPathPatterns("/shopcart/del")
.addPathPatterns("/address/list")
.addPathPatterns("/address/add")
.addPathPatterns("/address/update")
.addPathPatterns("/address/setDefalut")
.addPathPatterns("/address/delete")
.addPathPatterns("/orders/*")
.addPathPatterns("/center/*")
.addPathPatterns("/userInfo/*")
.addPathPatterns("/myorders/*")
.addPathPatterns("/mycomments/*")
.excludePathPatterns("/myorders/deliver")
.excludePathPatterns("/orders/notifyMerchantOrderPaid");
WebMvcConfigurer.super.addInterceptors(registry);
}
}
3.2 编写拦截器逻辑
package com.whx.controller.interceptor;
import com.whx.utils.IMOOCJSONResult;
import com.whx.utils.JsonUtils;
import com.whx.utils.RedisOperator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
public class UserTokenInterceptor implements HandlerInterceptor {
@Autowired
private RedisOperator redisOperator;
public static final String REDIS_USER_TOKEN = "redis_user_token";
/**
* 拦截请求，在访问controller调用之前
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
/**
* false: 请求被拦截，被驳回，验证出现问题
* true: 请求在经过验证校验以后，是OK的，是可以放行的
*/
// System.out.println("进入到拦截器，被拦截。。。");
String userId = request.getHeader("headerUserId");
String userToken = request.getHeader("headerUserToken");
if (StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(userToken)) {
String uniqueToken = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
if (StringUtils.isBlank(uniqueToken)) {
// System.out.println("请登录...");
returnErrorResponse(response, IMOOCJSONResult.errorMsg("请登录..."));
return false;
} else {
if (!uniqueToken.equals(userToken)) {
// System.out.println("账号在异地登录...");
returnErrorResponse(response, IMOOCJSONResult.errorMsg("账号在异地登录..."));
return false;
}
}
} else {
// System.out.println("请登录...");
returnErrorResponse(response, IMOOCJSONResult.errorMsg("请登录..."));
return false;
}
return true;
}
public void returnErrorResponse(HttpServletResponse response,
IMOOCJSONResult result) {
OutputStream out = null;
try {
response.setCharacterEncoding("utf-8");
response.setContentType("text/json");
out = response.getOutputStream();
out.write(JsonUtils.objectToJson(result).getBytes("utf-8"));
out.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 请求访问controller之后，渲染视图之前
* @param request
* @param response
* @param handler
* @param modelAndView
* @throws Exception
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
/**
* 请求访问controller之后，渲染视图之后
* @param request
* @param response
* @param handler
* @param ex
* @throws Exception
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
4、Cookie共享测试
找到前端项目app.js，开启如下代码，设置你的对应域名，需要和SwitchHosts相互对应：
如下图，可以看到，不论是在 shop 或是 center中，两个站点都能够在用户登录后共享用户信息。
如此一来，cookie中的信息被携带至后端，而后端又实现了分布式会话，那么如此一来，单点登录就实现了，用户无需再跨站点登录了。上述过程我们通过下图的展示，只要前端网页都在同一个顶级域名下，就能实现cookie与session的共享：
那么目前我们的系统在经过Redis分布式会话的完成之后，外加cookie设置的配合，就已经能够达到相同顶级域名下的单点登录了！
二、不同顶级域名的单点登录【使用CAS（Central Authentication Service）“中央认证服务”实现】【CAS系统内部：Redis+Cookie】【类似微信登陆授权模型】
上一节单点登录是基于相同顶级域名做的，那么如果顶级域名都不一样，咋办？比如 www.imooc.com 要和 www.mukewang.com 的会话实现共享。
下图，这个时候的cookie由于顶级域名不同，就不能实现cookie跨域了，每个站点各自请求到服务端，cookie无法同步。比如，www.imooc.com下的用户发起请求后会有cookie，但是他又访问了www.abc.com，由于cookie无法携带，所以会要你二次登录。
那么遇到顶级域名不同却又要实现单点登录该如何实现呢？我们来参考下面一张图：
如上图所示，多个系统之间的登录会通过一个独立的登录系统去做验证，它就相当千是—个中介公司，整合了所有人，你要看房经过中介允许草钥匙就行，实现了统—的登录。那么这个就称之为CAS系统，CAS全称为Central Authentication Service即中央认证服务，是—个单点登录的解决方案，可以用于不同顶级域名之间的单点登录。那么在咱们课程中呢目前的项目结构源码不需要去破坏，我们只需要构建两个静态站点来测试使用即可。
在CAS中的具体的流程参考如下时序图：
假设在CAS登陆系统中，有3个系统：
- 子网站A（www.whxmtv.com）
- 子网站B（www.whxmusic.com）
- CAS网站（www.whxcas.com）
在同一台设备上，当用户初次登陆子网站A的时候，由于用户从来没有在此设备上登陆过系统，所以会进行以下步骤：
- 用户初次登陆子网站A
- 转跳到CAS网站进行验证/登录，
- CAS后台生成全局token、临时token；
- CAS后台将全局token分别保存在CAS网站的cookie中、redis中
- CAS后台将带有全局token的cookie返回给CAS的前端（CAS的前端的cookie是保存全局凭证的地方）
- CAS后台将临时token返回给子网站A的前端，网站A会再次去CAS系统验证此临时token，如果此临时token有效，则登陆子网站A
- 转跳到CAS网站进行验证/登录，
- 用户初次登陆子网站B
- 转跳到CAS网站进行验证/登录，
- 如果在CAS网站的前端cookie中发现有cookie，则拿着此cookie中的token去CAS后台去验证此token的有效性，如果有效，则CAS后台生成一个临时token返回给子网站B的前端，网站B会再次去CAS系统验证此临时token，如果此临时token有效，则登陆子网站B
package com.whx.controller;
import com.whx.pojo.Users;
import com.whx.pojo.vo.UsersVO;
import com.whx.service.UserService;
import com.whx.utils.IMOOCJSONResult;
import com.whx.utils.JsonUtils;
import com.whx.utils.MD5Utils;
import com.whx.utils.RedisOperator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;
@Controller
public class SSOController {
@Autowired
private UserService userService;
@Autowired
private RedisOperator redisOperator;
public static final String REDIS_USER_TOKEN = "redis_user_token";
public static final String REDIS_USER_TICKET = "redis_user_ticket";
public static final String REDIS_TMP_TICKET = "redis_tmp_ticket";
public static final String COOKIE_USER_TICKET = "cookie_user_ticket";
@GetMapping("/login")
public String login(String returnUrl, Model model, HttpServletRequest request, HttpServletResponse response) {
model.addAttribute("returnUrl", returnUrl);
// 1. 获取userTicket门票，如果cookie中能够获取到，证明用户登录过，此时签发一个一次性的临时票据并且回跳
String userTicket = getCookie(request, COOKIE_USER_TICKET);
boolean isVerified = verifyUserTicket(userTicket);
if (isVerified) {
String tmpTicket = createTmpTicket();
return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
}
// 2. 用户从未登录过，第一次进入则跳转到CAS的统一登录页面
return "login";
}
/**
* 校验CAS全局用户门票
*
* @param userTicket
* @return
*/
private boolean verifyUserTicket(String userTicket) {
// 0. 验证CAS门票不能为空
if (StringUtils.isBlank(userTicket)) {
return false;
}
// 1. 验证CAS门票是否有效
String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
if (StringUtils.isBlank(userId)) {
return false;
}
// 2. 验证门票对应的user会话是否存在
String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
if (StringUtils.isBlank(userRedis)) {
return false;
}
return true;
}
/**
* CAS的统一登录接口
* 目的：
* 1. 登录后创建用户的全局会话 -> uniqueToken
* 2. 创建用户全局门票，用以表示在CAS端是否登录 -> userTicket
* 3. 创建用户的临时票据，用于回跳回传 -> tmpTicket
*/
@PostMapping("/doLogin")
public String doLogin(String username, String password, String returnUrl, Model model, HttpServletRequest request, HttpServletResponse response) throws Exception {
model.addAttribute("returnUrl", returnUrl);
// 0. 判断用户名和密码必须不为空
if (StringUtils.isBlank(username) ||
StringUtils.isBlank(password)) {
model.addAttribute("errmsg", "用户名或密码不能为空");
return "login";
}
// 1. 实现登录
Users userResult = userService.queryUserForLogin(username,
MD5Utils.getMD5Str(password));
if (userResult == null) {
model.addAttribute("errmsg", "用户名或密码不正确");
return "login";
}
// 2. 实现用户的redis会话
String uniqueToken = UUID.randomUUID().toString().trim();
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(userResult, usersVO);
usersVO.setUserUniqueToken(uniqueToken);
redisOperator.set(REDIS_USER_TOKEN + ":" + userResult.getId(),
JsonUtils.objectToJson(usersVO));
// 3. 生成ticket门票，全局门票，代表用户在CAS端登录过
String userTicket = UUID.randomUUID().toString().trim();
// 3.1 用户全局门票需要放入CAS端的cookie中
setCookie(COOKIE_USER_TICKET, userTicket, response);
// 4. userTicket关联用户id，并且放入到redis中，代表这个用户有门票了，可以在各个景区游玩
redisOperator.set(REDIS_USER_TICKET + ":" + userTicket, userResult.getId());
// 5. 生成临时票据，回跳到调用端网站，是由CAS端所签发的一个一次性的临时ticket
String tmpTicket = createTmpTicket();
/**
* userTicket: 用于表示用户在CAS端的一个登录状态：已经登录
* tmpTicket: 用于颁发给用户进行一次性的验证的票据，有时效性
*/
/**
* 举例：
* 我们去动物园玩耍，大门口买了一张统一的门票，这个就是CAS系统的全局门票和用户全局会话。
* 动物园里有一些小的景点，需要凭你的门票去领取一次性的票据，有了这张票据以后就能去一些小的景点游玩了。
* 这样的一个个的小景点其实就是我们这里所对应的一个个的站点。
* 当我们使用完毕这张临时票据以后，就需要销毁。
*/
// return "login";
return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
}
@PostMapping("/verifyTmpTicket")
@ResponseBody
public IMOOCJSONResult verifyTmpTicket(String tmpTicket, HttpServletRequest request, HttpServletResponse response) throws Exception {
// 使用一次性临时票据来验证用户是否登录，如果登录过，把用户会话信息返回给站点
// 使用完毕后，需要销毁临时票据
String tmpTicketValue = redisOperator.get(REDIS_TMP_TICKET + ":" + tmpTicket);
if (StringUtils.isBlank(tmpTicketValue)) {
return IMOOCJSONResult.errorUserTicket("用户票据异常");
}
// 0. 如果临时票据OK，则需要销毁，并且拿到CAS端cookie中的全局userTicket，以此再获取用户会话
if (!tmpTicketValue.equals(MD5Utils.getMD5Str(tmpTicket))) {
return IMOOCJSONResult.errorUserTicket("用户票据异常");
} else {
// 销毁临时票据
redisOperator.del(REDIS_TMP_TICKET + ":" + tmpTicket);
}
// 1. 验证并且获取用户的userTicket
String userTicket = getCookie(request, COOKIE_USER_TICKET);
String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
if (StringUtils.isBlank(userId)) {
return IMOOCJSONResult.errorUserTicket("用户票据异常");
}
// 2. 验证门票对应的user会话是否存在
String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
if (StringUtils.isBlank(userRedis)) {
return IMOOCJSONResult.errorUserTicket("用户票据异常");
}
// 验证成功，返回OK，携带用户会话
return IMOOCJSONResult.ok(JsonUtils.jsonToPojo(userRedis, UsersVO.class));
}
@PostMapping("/logout")
@ResponseBody
public IMOOCJSONResult logout(String userId, HttpServletRequest request, HttpServletResponse response) throws Exception {
// 0. 获取CAS中的用户门票
String userTicket = getCookie(request, COOKIE_USER_TICKET);
// 1. 清除userTicket票据，redis/cookie
deleteCookie(COOKIE_USER_TICKET, response);
redisOperator.del(REDIS_USER_TICKET + ":" + userTicket);
// 2. 清除用户全局会话（分布式会话）
redisOperator.del(REDIS_USER_TOKEN + ":" + userId);
return IMOOCJSONResult.ok();
}
/**
* 创建临时票据
*
* @return
*/
private String createTmpTicket() {
String tmpTicket = UUID.randomUUID().toString().trim();
try {
redisOperator.set(REDIS_TMP_TICKET + ":" + tmpTicket,
MD5Utils.getMD5Str(tmpTicket), 600);
} catch (Exception e) {
e.printStackTrace();
}
return tmpTicket;
}
private void setCookie(String key, String val, HttpServletResponse response) {
Cookie cookie = new Cookie(key, val);
cookie.setDomain("sso.com");
cookie.setPath("/");
response.addCookie(cookie);
}
private void deleteCookie(String key, HttpServletResponse response) {
Cookie cookie = new Cookie(key, null);
cookie.setDomain("sso.com");
cookie.setPath("/");
cookie.setMaxAge(-1);
response.addCookie(cookie);
}
private String getCookie(HttpServletRequest request, String key) {
Cookie[] cookieList = request.getCookies();
if (cookieList == null || StringUtils.isBlank(key)) {
return null;
}
String cookieValue = null;
for (int i = 0; i < cookieList.length; i++) {
if (cookieList[i].getName().equals(key)) {
cookieValue = cookieList[i].getValue();
break;
}
}
return cookieValue;
}
}
扫一扫
4176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
