分布式会话与单点登录SSO系统CAS，包含完整示例代码实现

已于 2022-05-12 08:49:57 修改
阅读量1.6k 收藏 7
点赞数 4
分类专栏： 高可用架构 文章标签： 分布式 java 架构 web安全 安全架构
于 2022-05-06 14:02:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45405982/article/details/124608782
版权

往期文章一览

【7W字长文】使用LVS+Keepalived实现Nginx高可用，一文搞懂Nginx

【15W字长文】主从复制高可用Redis集群，完整包含Redis所有知识点

分布式会话与单点登录SSO

分布式会话介绍与实现

什么是会话

会话Session代表的是客户端与服务器的一次交互过程，这个过程可以是连续也可以是时断时续的。会话较多用于网络上，TCP的三次握手就创建了一个会话，TCP关闭连接就是关闭会话。会话Session代表的是客户端与服务器的一次交互过程，这个过程可以是连续也可以是时断时续的。曾经的Servlet时代（jsp），一旦用户与服务端交互，服务器用户创建一个session，同时前端会有一个jsessionid，每次交互都会携带。如此一来，服务器只要在接到用户请求时候，就可以拿到jsessionid，并根据这个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";
}

无状态会话

HTTP请求是无状态的，用户向服务端发起多个请求，服务端并不会知道这多次请求都是来自同一用户，这个就是无状态的 。cookie的出现就是为了有状态的记录用户。

常见的前后端分离交互，小程序与服务端交互，安卓与服务端交互，他们都是通过http请求来调用接口，每次交互服务端都不会拿到客户端的状态，我们一般会在每次请求的时候都携带userId或者token，这样后台就可以根据用户ID或者token来获取响应的请求，这样每个用户的下一次请求都能被服务端识别来自同一个用户。

有状态会话

有状态的会话也是基于无状态会话的，Tomcat的会话，就是有状态的。一旦用户和服务器交互，就有会话，会话保存了用户的信息，这样用户就有状态了。服务端会和每个客户端都保持着这样的一层关系，这个由容器来管理，这个session会话是保存到内存空间的，如此一来，当不同的用户访问服务端，那么就能通过会话知道是谁了。tomcat会话的出现也是为了让http请求变得有状态。如果用户不再和服务端交互，那么会话就会超时而消失，结束了他的生命周期，如此一来，每个用户其实都会有一个会话被维护，这就是有状态的会话。

  • 注：tomcat会话可以通过手段实现多系统之间的状态同步，但是会损耗一定的时间，一旦发生同步那么用户请求就会等待，这种做法不可取

单Tomcat会话

先来看一下单个tomcat会话，这个就有状态的，用户首次访问服务端，这个时候会话产生，并且会设置jsessionid放入cookie，后续每次请求都会携带jsessionid以保持会话状态

在这里插入图片描述

动静分离会话

用户请求服务端，由于前后端分离，前端发起http请求，不会携带任何状态，当用户第一次请求后，我们手动设置一个token，作为会话，放入Redis中，如此作为Redis-session，并且这个token设置后放入前端的cookie中，如此后续的交互，前端只需要传递token给后端，后端就能识别这个用户来自谁了。

在这里插入图片描述

集群分布系统会话

集群或者分布式系统本质是多个系统，假设这个里有两个服务器节点，分别是AB系统，一开始用户和A系统交互，那么这个时候的用户状态，我们可以保存到Redis中，作为A系统的会话信息，随后用户的请求进入B系统，那么B系统中的会话我也同样和Redis关联，如此AB系统的session就统一了。当然cookie是会随着用户的访问携带的。这个其实就是分布式会话，通过Redis来保存用户的状态

在这里插入图片描述

当我们后端 Web 应用扩展到多台后，我们就会碰到分布式一致性 Session 的问题，主流解决方案有四种：

  • Session 复制：利用 Tomcat 等 Web 容器同步复制功能（节点一多，复制时占用带宽大，每个节点都要维护所有的会话，占用内存大，不推荐）

  • Session 前端存储：利用用户浏览器中 Cookie 保存 Session 信息，即前端存储用户信息（需要考虑加密，容易被篡改，不安全，不推荐）

  • Session 粘滞方案：利用 Nginx 可以做四层 根据IP Hash 或七层 Hash 的特性，保证用户的请求都落在同一台机器上（同一个IP只会到同一个节点上，可以做临时方案）

  • Session 后端集中存储方案：利用 Redis 集中存储会话，Web 应用重启或扩容，Session 也不会丢失（主流方案，推荐）。

参考链接：

分布式会话和基于TOKEN的分布式会话

小白对话：4种分布式Session的实现方式

基于Redis分布式会话（推荐）

  1. 修改登录接口，在用户登录完成之后，保存用户信息（基本信息，角色，权限信息等）到Redis中，设置会话过期时间，若有操作则刷新过期时间，长时间不操作系统自动清除会话，key为UserId或者UUID，并返回给前端，前端请求接口时需携带此信息（使用UUID代表当前用户会话）。

    前端请求方式

    • 前端请求只携带UserId

      这时key是UserId，可以在登录的时候判断Redis中是否已经存在这个UserId，若有可以阻止登录，保证了一个账号同一时间只能有同一个人登录系统；

    • 前端请求只携带UUID

      这时key是UUID，代表系统允许一个账号多个用户登录，因为每次登录请求过来时，都会生成一个UUID作为key，Redis中同样会再存一份相同的用户信息。

    • 前端请求携带UserId和UUID

      这时key为UserId，登录时生成的UUID和其他信息一同保存到Redis中。在验证时取出可以对比前端传的UUID和Redis中的UUID，相同则说明是同一个人操作登录的；若不同，则说明由另外的人在异地登录，可以做一个提示，让当前用户重新登录

  2. 修改退出登录接口，退出登录时需要删除Redis中保存的用户信息

  3. 修改用户信息或角色权限等信息时也要同时修改Redis中的信息

基于SpringSession分布式会话

  1. 引入session和security的依赖，因为session依赖了security的一些内容，所以必须导入security依赖

    <dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-Redis</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

  2. 修改配置文件指定session存储的介质

    spring:
  session:
    store-type: Redis

  3. 启动类上开启session功能

    @EnableRedisHttpSession  // 开启通过Redis管理用户会话
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class}) // 移除security依赖中自带的登录，若项目中本身就使用到了security则不需要配置
public class StartApplication {
    public static void main(String[] args) {
        SpringApplication.run(StartApplication.class, args);
    }
}

  4. 在controller层使用HttpServletRequest的getSession()就能获取到HttpSession对象进行赋值和取值了，与原来的使用方式相同。不同点的是原来是由springboot内置的tomcat管理，现在是由Redis统一管理。在分布式环境下，Redis就可以统一管理所有的Session了。

    在这里插入图片描述

CAS系统简单实现

CAS是Central Authentication Service的缩写，中央认证服务，一种独立开放指令协议。CAS 是 耶鲁大学（Yale University）发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点登录方法，CAS 在 2004 年 12 月正式成为 JA-SIG 的一个项目。

协议特点

  1. 开源的企业级单点登录解决方案。
  2. CAS Server 为需要独立部署的 Web 应用。
  3. CAS Client 支持非常多的客户端(这里指单点登录系统中的各个 Web 应用)，包括 Java, .Net, PHP, Perl, Apache, uPortal, Ruby 等语言编写的各种web应用。
  4. CAS属于Apache 2.0许可证，允许代码修改，再发布（作为开源或商业软件）。

优点

  1. 多个系统中只需要登录一次，就可以用已登录的身份访问所有相互信任的多个系统。
  2. 解决子系统登录问题，直接在父系统统一进行登录。
  3. 企业级业务系统通用账号，只需登录一次。

原理和协议

从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS Client 负责处理对客户端受保护资源的访问请求，需要登录时，重定向到 CAS Server。图1是CAS最基本的协议过程：

在这里插入图片描述

CAS Client 与受保护的客户端应用部署在一起，以 Filter 方式保护受保护的资源。

对于访问受保护资源的每个 Web 请求，CAS Client 会分析该请求的 Http 请求中是否包含 Service Ticket，如果没有，则说明当前用户尚未登录，于是将请求重定向到指定好的 CAS Server 登录地址，并传递 Service （也就是要访问的目的资源地址），以便登录成功过后转回该地址。

用户在第 3 步中输入认证信息，如果登录成功，CAS Server 随机产生一个相当长度、唯一、不可伪造的 Service Ticket，并缓存以待将来验证，之后系统自动重定向到 Service 所在地址，并为客户端浏览器设置一个 Ticket Granted Cookie（TGC），CAS Client 在拿到 Service 和新产生的 Ticket 过后，在第 5，6 步中与 CAS Server 进行身份核实，以确保 Service Ticket 的合法性。

在该协议中，所有与 CAS 的交互均采用 SSL 协议，确保，ST 和 TGC 的安全性。协议工作过程中会有 2 次重定向的过程，但是 CAS Client 与 CAS Server 之间进行 Ticket 验证的过程对于用户是透明的。

另外，CAS 协议中还提供了 Proxy （代理）模式，以适应更加高级、复杂的应用场景，具体介绍可以参考 CAS 官方网站上的相关文档。

什么是单点登录

单点登录又称之为Single Sign On，简称SSO，单点登录可以通过基于用户会话的共享。利用单点登录可以实现用户只登录一次就可以访问几个不同的网站。用户自始至终只在某一个网站下登录后，那么他所产生的会话，就共享给了其他的网站，实现了单点网站登录后，同时间接登录了其他的网站，那么这个其实就是单点登录，他们的会话是共享的，都是同一个用户会话。

例如：登录了qq，那么qq音乐，qq视频之类的就都不用登录了，可以直接访问。

相同顶级域名的单点登录解决方案

因为是相同的顶级域名，顶级域名和下级域名之间cookie是共享的，这样通过cookie+Redis就可以实现单点登录。

如果分布式会话后端是基于Redis的，此会话可以在后端的任意系统都能获取到缓存中的用户数据信息，前端通过使用cookie，可以保证在同域名的一级二级站点下获取，那么这样一来，cookie中的信息userid和token是可以在发送请求的时候携带上的，这样从前端请求后端后是可以获取拿到的，这样一来，其实用户在某一端登录注册以后，其实cookie和Redis中都会带有用户信息，只要用户不退出，那么就能在任意一个站点实现登录了。

那么这个原理主要也是cookie和网站的依赖关系，顶级域名 和下级域名的cookie值是可以共享的，可以被携带至后端的。

二级域名自己的独立cookie是不能共享的，不能被其他二级域名获取，比如：a.abc.com的cookie是不能被b.abc.com共享，两者互不影响，要共享必须设置为.abc.com。

不同顶级域名的单点登录解决方案

这个时候的cookie由于顶级域名不同，就不能实现cookie跨域了，每个站点各自请求到服务端,cookie无法同步。比如，www.aaa.com下的用户发起请求后会有cookie，但是他又访问了www.bbb.com，由于cookie无法携带，所以会要你二次登录。

因为不同顶级域名，cookie直接是不共享的，所以就不能用cookid+reids这种方式来做单点登录了，这个时候我们可以用CAS来实现单点登录。

各个系统之间的登录会通过一个独立的登录系统去做验证，它就相当于是一个中介公司，整合了所有人，你要看房经过中介允许拿钥匙就行，实现了统一的登录。那么这个就称之为CAS系统，CAS全称为Central Authentication Service即中央认证服务，是一个单点登录的解决方案，可以用于不同顶级域名之间的单点登录。

CAS系统详解

CAS全称为Central Authentication Service即中央认证服务，是一个单点登录的解决方案，可以用于不同顶级域名之间的单点登录。

CAS登录流程图

在这里插入图片描述

核心票据
用户会话（分布式会话）

TGT(Ticket Grangting Ticket)：TGT是CAS为用户签发的登录票据，有TGT就表明用户在CAS上成功登录过。用户在CAS认证成功后，会生成一个TGT对象，放入自己的缓存中(Session)，同时生成TGC以cookie的形式写入浏览器。当再次访问CAS时，会先看cookie中是否存在TGC，如果存在则通过TGC获取TGT，如果获取到了TGT则代表用户之前登录过，通过TGT及访问来源生成针对来源的ST，用户就不用再次登录，以此来实现单点登录。

全局门票

TGC(Ticket-granting cookie)：TGC就是TGT的唯一标识，以cookie的形式存在在CAS Server三级域名下，是CAS Server 用来明确用户身份的凭证。

临时门票

ST(Service Ticket)：ST是CAS为用户签发的访问某一客户端的服务票据。用户访问service时，service发现用户没有ST，就会重定向到 CAS Server 去获取ST。CAS Server 接收到请求后，会先看cookie中是否存在TGC，如果存在则通过TGC获取TGT，如果获取到了TGT则代表用户之前登录过，通过TGT及访问来源生成针对来源的ST。用户凭借ST去访问service，service拿ST 去CAS Server 上进行验证，验证通过service 生成 用户session，并返回资源。

初次登录流程解析

  1. 当用户访问到A网站的时候，网站会首先判断他是否在CAS系统登录过，主要是在cookie中看是否有登录信息。如果没有登录，网站会携带上自己的url去访问CAS系统登录接口。

  2. 当CAS系统接受到这样一个请求会，会查看自己是否有cookie，如果没有会弹出登录窗口让用户登录。

  3. 如果用户登录成功后，CAS系统会进行三步处理

    1. 创建用户会话，把用户的信息作为值，把用户的id作为健存入到Redis或者其他数据库中，用来在用户登录进来后获取用户信息

    2. 创建用户全局门票，把用户id作为值，随机数当作健存入Redis和cookie中，用以表示在CAS端是否登录

    3. 创建临时门票，把随机数当作健值存入Redis中，用于回跳回传

  4. 将临时票据作为参数回调回A网站

  5. 当A网站有临时票据后会把拿着这个票据访问CAS的兑换票据接口

  6. CAS兑换票据接口会做这样几件事

    1. CAS会先判断这个票据是否是合法票据
    2. 如果是合法票据，就把这个临时票据销毁，然后通过CAS中的cookie信息去获取到用户id
    3. 在通过用户id获取到全局会话，把会话传递会A界面

  7. 当A界面获取到会话后，存入自己的cookie中，这样以后就不用再去请求CAS了

二次访问流程

  1. 当用户访问到B网站后，B网站也会判断他是否在CAS系统登录过，如果没有cookie信息（注意：这个时候会有两个cooklie信息，一个是用户的全局会话，一个是CAS的全局门票，这里说的没有cookie信息，说的是没有全局会话），网站会携带上自己的url去访问CAS系统登录接口。

  2. 因为这个时候CAS系统发现有cookie信息，证明用户已经登录过了，那就只要在创建一个临时票据回传给B网站就好了。

  3. 其他剩下操作与第一次访问相同。

参考链接：

一篇文章教你学会单点登录与CAS

CAS 中央认证服务 实现 单点登录（SSO）

代码实现

CAS系统简单实现，service层代码是随便写的，主要起一个抛砖引玉的作用

项目结构

在这里插入图片描述

Gradle依赖
plugins {
    id 'java'
    id 'org.springframework.boot' version '2.6.7'

}

apply plugin: 'io.spring.dependency-management'

group 'cn.maolinyuan'
version '1.0-build'

sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    maven {
        url 'https://maven.aliyun.com/repository/central'
    }
    maven {
        url 'https://maven.aliyun.com/repository/public'
    }
    maven {
        url 'https://maven.aliyun.com/repository/jcenter'
    }
    maven {
        url 'https://maven.aliyun.com/repository/google'
    }
    maven {
        url 'https://maven.aliyun.com/repository/spring'
    }
    maven {
        url 'https://maven.aliyun.com/repository/spring-plugin'
    }
    maven {
        url 'https://maven.aliyun.com/repository/grails-core'
    }
    maven {
        url 'https://maven.aliyun.com/repository/apache-snapshots'
    }
    maven {
        url 'https://maven.aliyun.com/repository/gradle-plugin'
    }
    mavenCentral()
}


dependencies {
    implementation(
            "junit:junit:4.12",
            "org.springframework.boot:spring-boot-starter",
            "org.springframework.boot:spring-boot-starter-web",
            "org.springframework.boot:spring-boot-starter-aop",
            "org.springframework.boot:spring-boot-starter-data-redis",
            "org.springframework.boot:spring-boot-starter-thymeleaf"
    )
    testImplementation(
            "org.springframework.boot:spring-boot-starter-test"

    )

    annotationProcessor(
            "org.projectlombok:lombok:1.18.24"
    )

    compileOnly(
            "org.projectlombok:lombok:1.18.24",
            "org.springframework.boot:spring-boot-dependencies:2.6.7"

    )
}
配置文件

application.yml

server:
  port: 8989
  servlet:
    context-path: /sso
spring:
  thymeleaf:
    mode: HTML
    encoding: UTF-8
    prefix: classpath:/templates/
    suffix: .html
  profiles:
    include: redis

application-redis.yml

spring:
  # redis 配置
  redis:
    # 地址
    host: 192.168.5.223
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password: imooc
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
资源文件

templates/login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>SSO LOGIN</title>
</head>
<body>
    <h1>CENTRAL AUTHENTICATION SERVICE</h1>
    <form action="doLogin" method="post">
        <label>
            <input type="text" name="username" placeholder="请输入用户名"/>
        </label>
        <label>
            <input type="password" name="password" placeholder="请输入密码"/>
        </label>
        <input type="hidden" name="returnUrl" th:value="${returnUrl}"/>
        <input type="submit" value="提交登录"/>
    </form>
    <span style="color: red" th:text="${errmsg}"></span>
</body>
</html>
controller

SSOController

package cn.maolinyuan.controller;

import cn.maolinyuan.po.User;
import cn.maolinyuan.service.IUserService;
import cn.maolinyuan.vo.UserVo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.data.redis.core.RedisTemplate;
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.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * sso 认证服务
 *
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/5 16:27
 */
@Controller
@RequestMapping("/auth")
public class SSOController {

    @Resource
    private IUserService service;

    @Resource
    private RedisTemplate<Object, Object> redisTemplate;

    private final String REDIS_USER_TOKEN = "redis_user_token";

    private final String REDIS_USER_TICKET = "redis_user_ticket";

    private final String REDIS_TMP_TICKET = "redis_tmp_ticket";

    private final String COOKIE_USER_TICKET = "cookie_user_ticket";

    private final ObjectMapper objectMapper = new ObjectMapper();


    @GetMapping("/login")
    public String login(String returnUrl,
                        Model model,
                        HttpServletRequest request,
                        HttpServletResponse response) {


        model.addAttribute("returnUrl", returnUrl);

        // 获取userTicket门票，如果cookie中能够获取说明用户登录过，此时签发一个一次性的临时门票
        String userTicket = getCookie(COOKIE_USER_TICKET, request);
        boolean isVerified = verifyUserTicket(userTicket);
        if (isVerified) {
            String tmpTicket = createTmpTicket();
            return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
        }

        // 用户从未登录过跳转到CAS的统一认证页面
        return "login";
    }

    /**
     * 验证用户全局门票是否有效
     *
     * @param userTicket
     * @return
     */
    private boolean verifyUserTicket(String userTicket) {
        if (null == userTicket || "".equals(userTicket)) {
            return false;
        }
        // 获取用户会话
        String userId = String.valueOf(redisTemplate.opsForValue().get(REDIS_USER_TICKET + ":" + userTicket));
        if (null == userId || "".equals(userId)) {
            return false;
        }
        String userVoStr = String.valueOf(redisTemplate.opsForValue().get(REDIS_USER_TOKEN + ":" + userId));
        return null != userVoStr && !"".equals(userVoStr);
    }


    /**
     * CAS的统一登录接口
     * 1. 登陆后创建用户全局会话 uniqueToken
     * 2. 创建用户全局门票，用以表示在CAS端是否登录 userTicket
     * 3. 创建用户的临时门票，用于会跳回传 tmpTicket
     * 用临时票据加上cookie的全局门票才可以获取到用户会话信息
     *
     * @param username
     * @param password
     * @param returnUrl
     * @param model
     * @param request
     * @param response
     * @return
     * @throws JsonProcessingException
     */
    @PostMapping("/doLogin")
    public String doLogin(String username,
                          String password,
                          String returnUrl,
                          Model model,
                          HttpServletRequest request,
                          HttpServletResponse response) throws JsonProcessingException {

        model.addAttribute("returnUrl", returnUrl);

        // 判断参数不能为空
        if (null != username && !"".equals(username) && null != password && !"".equals(password)) {
            model.addAttribute("errmsg", "用户名和密码不能为空");
            return "login";
        }

        // 判断用户
        User user = service.findUserByUsername(username);
        assert password != null;
        if (!password.equals(user.getPassword())) {
            model.addAttribute("errmsg", "用户名或密码错误");
            return "login";
        }

        // redis用户会话 用uuid来标识 使用用户id关联用户信息和创建用户会话的uuid
        String uniqueToken = UUID.randomUUID().toString().trim();
        UserVo userVo = new UserVo();
        BeanUtils.copyProperties(user, userVo);
        userVo.setUniqueToken(uniqueToken);
        redisTemplate.opsForValue().set(REDIS_USER_TOKEN + ":" + user.getId(), objectMapper.writeValueAsString(userVo));


        // 生成ticket门票，全局门票，代表用户在CAS端登录过
        String userTicket = UUID.randomUUID().toString().trim();

        // 用户全局门票需要放入CAS端的cookie中
        setCookie(COOKIE_USER_TICKET, userTicket, response);

        // userTicket关联用户id，并且放入redis中，代表用户有门票了，可以访问各个网站
        redisTemplate.opsForValue().set(REDIS_USER_TICKET + ":" + userTicket, user.getId());

        // 生成临时票据，会跳到调用端网站，是由CAS签发的一个一次性的临时ticket
        String tmpTicket = createTmpTicket();


        return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;

    }


    /**
     * 验证临时票据，返回值可以使用统一返回类包装。
     *
     * @param tmpTicket
     * @param request
     * @param response
     * @return
     */
    @PostMapping("/verifyTmpTicket")
    @ResponseBody
    public UserVo verifyTmpTicket(String tmpTicket,
                                  HttpServletRequest request,
                                  HttpServletResponse response) throws JsonProcessingException {

        // 使用一次性票据来验证用户是否登陆过，如果登录过，把用户会话返回给站点，使用完毕后销毁临时票据
        String tempTicketValue = String.valueOf(redisTemplate.opsForValue().get(REDIS_TMP_TICKET + ":" + tmpTicket));
        if (null == tempTicketValue || "".equals(tempTicketValue)) {
            // 用户票据异常 不返回用户会话信息
            return null;
        }

        // 如果临时票据有效，则需要销毁，并且拿到CAS端cookie中的全局userTicket，以此再获取用户的全局会话信息
        // 如果value值经过加密的，需要将value解密，或者将tmpTicket加密之后进行对比
        if (!tempTicketValue.equals(tmpTicket)) {
            // 用户票据异常
            return null;
        } else {
            // 销毁临时票据
            redisTemplate.delete(REDIS_TMP_TICKET + ":" + tmpTicket);
        }

        // 验证并且从cookie中获取用户的userTicket
        String userTicket = getCookie(COOKIE_USER_TICKET, request);

        // 获取用户会话
        String userId = String.valueOf(redisTemplate.opsForValue().get(REDIS_USER_TICKET + ":" + userTicket));
        if (null == userId || "".equals(userId)) {
            // 用户票据异常
            return null;
        }
        String userVoStr = String.valueOf(redisTemplate.opsForValue().get(REDIS_USER_TOKEN + ":" + userId));
        if (null == userVoStr || "".equals(userVoStr)) {
            // 用户会话信息异常
            return null;
        }

        // 返回用户会话信息到前端，前端需要保存此信息
        return objectMapper.readValue(userVoStr, UserVo.class);

    }

    /**
     * 退出登录
     *
     * 当a网站点击了退出登录之后，会清除a网站本地的用户信息和服务器的分布式会话信息，
     * 而其他网站的所保存的本地用户会话信息还存在，所以，当所有网站请求后端服务时都
     * 要做拦截器统一校验分布式会话是否存在，不存在则需要提示前端让他重新登录。
     * @param userId
     * @param request
     * @param response
     */
    @PostMapping("/logout")
    @ResponseBody
    public void logout(String userId,
                       HttpServletRequest request,
                       HttpServletResponse response) {
        // 获取CAS中的用户门票
        String userTicket = getCookie(COOKIE_USER_TICKET, request);

        // 清除redis和cookie中的userTicket用户票据和会话信息
        deleteCookie(COOKIE_USER_TICKET,response);
        redisTemplate.delete(REDIS_USER_TICKET + ":" + userTicket);
        redisTemplate.delete(REDIS_USER_TOKEN + ":" + userId);

    }


    /**
     * 创建临时票据
     *
     * @return
     */
    private String createTmpTicket() {
        String tmpTicket = UUID.randomUUID().toString().trim();
        // 其中value值可以进行加密后再保存
        redisTemplate.opsForValue().set(REDIS_TMP_TICKET + ":" + tmpTicket, tmpTicket, 600, TimeUnit.SECONDS);
        return tmpTicket;
    }


    /**
     * 设置CAS的cookie
     *
     * @param key
     * @param val
     * @param response
     */
    private void setCookie(String key, String val, HttpServletResponse response) {
        Cookie cookie = new Cookie(key, val);
        // 重要：设置CAS服务的域名或者ip，只有这样浏览器在访问CAS的时候才会自动带上 userTicket
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        response.addCookie(cookie);
    }

    /**
     * 删除CAS的cookie
     *
     * @param key
     * @param response
     */
    private void deleteCookie(String key, HttpServletResponse response) {
        Cookie cookie = new Cookie(key, null);
        // 重要：设置CAS服务的域名或者ip，只有这样浏览器在访问CAS的时候才会自动带上 userTicket
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        cookie.setMaxAge(-1);
        response.addCookie(cookie);
    }


    /**
     * 获取请求中的cookie
     *
     * @param key
     * @param request
     * @return
     */
    private String getCookie(String key, HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (null == cookies || cookies.length == 0 || null == key) {
            return null;
        }
        for (Cookie cookie : cookies) {
            if (cookie.getName().equals(key)) {
                return cookie.getValue();
            }
        }
        return null;
    }

}
service

IUserService

package cn.maolinyuan.service;

import cn.maolinyuan.po.User;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/5 16:52
 */
public interface IUserService {

    /**
     * 根据username获取用户
     * @param username
     * @return
     */
    User findUserByUsername(String username);

}

UserServiceImpl

package cn.maolinyuan.service.impl;

import cn.maolinyuan.po.User;
import cn.maolinyuan.service.IUserService;
import org.springframework.stereotype.Service;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/5 16:52
 */
@Service
public class UserServiceImpl implements IUserService {
    /**
     * 根据username获取用户
     *
     * @param username
     * @return
     */
    @Override
    public User findUserByUsername(String username) {
        User user = new User();
        user.setId(1L);
        user.setUsername("root");
        user.setPassword("admin");
        user.setState("0");
        return user;
    }
}
po

User

package cn.maolinyuan.po;

import lombok.Data;

import java.io.Serializable;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/5 16:54
 */
@Data
public class User implements Serializable {

    private Long id;

    private String username;

    private String password;

    private String state;

}
vo
package cn.maolinyuan.vo;

import lombok.Data;

import java.io.Serializable;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/6 9:34
 */
@Data
public class UserVo implements Serializable {

    private Long id;

    private String username;

    private String password;

    private String state;

    private String uniqueToken;

}
filter

CrossFilter

package cn.maolinyuan.filter;

import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2021/2/1 13:49
 */
@Component
@WebFilter("/*")
public class CrossFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //都允许跨域
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE, PATCH");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Headers", "Origin, No-Cache, X-Requested-With, If-Modified-Since, Pragma, Last-Modified, Cache-Control, Expires, Content-Type, X-E4M-With, Authentication , authentication, token, Token");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        //如果是OPTIONS请求就return 往后执行会到业务代码中 他不带参数会产生异常
        if ("OPTIONS".equals(request.getMethod())) {
            return;
        }
        //第二次就是POST请求 之前设置了跨域就能正常执行代码了
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}
config
package cn.maolinyuan.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis配置
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}
启动类

CasStart

package cn.maolinyuan;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author maolinyuan
 * @version 1.0
 * @date 2022/5/5 16:21
 */
@SpringBootApplication
public class CasStart {
    public static void main(String[] args) {
        SpringApplication.run(CasStart.class,args);
    }
}
maolinyuan
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php实现的SSO单点登录系统接入功能示例分析
01-21
本文实例讲述了php实现的SSO单点登录系统接入功能。分享给大家供大家参考，具体如下： SSO英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一,下面我们来看看吧。 简单讲一下 SSO 单点登录系统的接入的原理，前提是系统本身有完善的用户认证功能，即基本的用户登录功能，那做起来就很方便了。 SSO 登录请求接口往往是接口加上一个回调地址，访问这个地址会跳转到回调地址并带上一个 ticket 参数，拿着这个
【架构设计】单点登录实现技术方案
热门推荐
颜淡慕潇
06-12 1万+
单点登录（Single Sign-On，简称SSO）是一种身份认证的解决方案，它允许用户只需一次登录即可访问多个应用程序或系统。在一个典型的SSO系统中，用户只需通过一次身份认证，就可以获得访问多个应用程序的授权，而不需要在每个应用程序中单独进行身份验证。
分布式服务CAS单点登陆详解及Spring-Security整合CAS实现单点登陆
weixin_44232093的博客
02-07 1086
分布式系统存在诸多子系统，而这些子系统是分别部署在不同的服务器中，那么使用传统方式的session是无法解决的，我们需要使用相关的单点登录技术来解决 1. 什么是单点登陆 单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统 2. 什么是CAS CAS 是 Ya...
浅谈单点登录SSO实现方案 | StartDT Tech Lab 06
StartDT的博客
06-30 513
核心解决了一个问题：用户只需要登录一次，就可以访问所有相互信任的应用系统。
单点登录方案知多少
洪晓鸿
04-12 422
这些框架和工具都提供了丰富的安全功能和单点登录的实现方式，可以根据具体应用场景和需求选择合适的框架来实现单点登录
应用系统基于CAS实现单点登录的解决方案
01-29 2270
单点登录 (SingleSign-On，SSO) ，是一种帮助用户快捷访问网络中多个站点的安全通信技术。单点登录系统基于一种安全的通信协议，该协议通过多个系统之间的用户身份信息的交换来实现单点登录。使用单点登录系统时，用户只需要登录一次，就可以访问多个系统，不需要记忆多个口令密码。
单点登录CAS实现
weixin_46894136的博客
06-04 6041
当用户尝试访问其他应用程序或系统时，这些应用程序或系统会向身份提供者发送身份验证请求，并使用之前获得的授权令牌进行授权。单点登录（Single Sign-On，简称SSO）是一种身份验证技术，它允许用户使用一组凭据（如用户名和密码）登录到多个应用程序或系统中，而无需在每个应用程序或系统中单独登录。当用户尝试访问其他应用程序或系统时，这些应用程序或系统会检查Cookie中的身份验证信息，并使用该信息进行身份验证和授权。使用单点登录技术，员工可以在这些应用程序之间无缝地切换，而无需在每个应用程序中单独登录。
CAS（Central Authentication Service）是一个开源的认证系统，它主要用于为Web应用程序创建和维护单点登录会话
BLOG域名:programb.blog.csdn.net
12-18 1293
它充当了一个中心认证服务器，负责验证用户的身份，并生成会话令牌，该令牌可以由其他应用程序用于验证用户的身份。这样，用户只需要在一个应用程序中登录，就可以在其他应用程序中无缝地访问，而无需再次输入用户名和密码。CAS还提供了多种认证机制，包括基于令牌的认证、基于密码的认证和多因素认证等。此外，它还支持多种协议，如CAS、OAuth、SAML等，这使得它可以与各种不同的Web应用程序集成。总的来说，CAS是一个功能强大、易于使用的开源认证系统，它可以帮助开发人员构建更安全、更易用的Web应用程序。
实战springboot+CAS单点登录系统
weixin_54106682的博客
06-20 2919
cas单点登录
JavaWeb - SSO单点登录原理之基于CAS（二）
牧码的博客
10-21 809
一、不落俗套的开始 1、背景介绍 单点登录：Single Sign On,简称SSO，SSO使得在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。 CAS框架：CAS（Central Authentication Service）是实现SSO单点登录的框架。 2、盗一张学习CAS绝大多都看过的图以及执行部分分析 注：已分不清原创，此处就不给出地址了。 从结构上看...
spring + shiro + cas 实现sso单点登录的示例代码
08-29
本篇文章主要介绍了spring + shiro + cas 实现sso单点登录的示例代码，具有一定的参考价值，有兴趣的可以了解一下
SpringCloud实现SSO 单点登录的示例代码
08-26
作为分布式项目，单点登录是必不可少的，这篇文章主要介绍了SpringCloud实现SSO 单点登录的示例代码，非常具有实用价值，需要的朋友可以参考下
Java进阶SSO单点登录技术CAS-快速上手与原理探究视频教程
06-09
本课程主要通过CAS来实现SSO，本教程会从最基本的基础知识讲起，由浅入深再到实战，完成多应用的单点登录功能。 本课程内容如下： 1、 什么是SSO和CAS 2、 CAS Server服务端和客户端的搭建和配置 3、 单点登录和单...
pytest-xdist：远程多主机 - 分布式运行自动化测试
最新发布
we chat：玩转测试开发
04-26 581
需要特别注意的是rsync功能被弃用，因为它的实现在远程工作者中再现开发环境方面存在缺陷，而且没有明确的解决方案。出于这个原因，rsync计划在4.0版中删除，让团队专注于一组较小的功能。请注意，SSH和套接字服务器不是计划删除的，因为它们是execnet功能集的一部分。：pytest-xdist插件使用新的测试执行模式扩展了pytest，最常用的是在多个CPU之间分发测试以加快测试执行，即。：在远程服务器端会生成一份相应的项目数据，因为我们使用的是 ./ 即 把当前项目远程拷贝到目标服务器执行。
内容分发网络CDN分布式部署加速原理
gulu230220的博客
04-24 537
哈喽，大家好，淼淼又来和大家见面啦，大家应该也知道，在应用开发市场中，软件产品的内测阶段对于确保产品质量与市场接受度至关重要，但是传统的内测分发方式往往面临地域分布广泛、网络环境各异的挑战，可能导致分发速度慢、用户体验不佳。随后，同一区域或邻近地区的用户请求该应用时，CDN节点直接从缓存中响应，无需再次回源，大幅减轻了源服务器的压力，同时节省了宝贵的网络带宽。预取与预热：对于即将大规模分发的内容，CDN可以提前将内容推送到边缘节点，确保用户请求时内容已经就绪，减少首次访问时的延迟。1.地理分布的边缘节点。
分布式与一致性协议之拜占庭将军问题(三)
Cover_sky的博客
04-23 776
CFT算法解决的是分布式系统中存在故障，但不存在恶意节点的场景下的共识问题。也就是说，这个场景可能会丢失消息或者有消息重复，但不存在错误消息或者伪造消息的情况，常见的CFT算法有Paxos算法、Raft算法、ZAB协议。需要注意的是，拜占庭将军问题描述的是最困难，也是最复杂的一种分布式故障场景，该场景除了存在故障行为，还存在恶意行为。在存在恶意行为的场景中(比如在数字货币的区块链技术中)，我们必须使用拜占庭容错算法还有PBFT算法、POW算法。反之则推荐使用拜占庭容错算法，例如区块链中使用Pow算法。
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 337
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1443
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 605
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
rest sso 和_SSO企业单点登录系统——CAS REST认证方式
05-19
CAS REST认证方式是通过RESTful API实现单点登录的一种方式，与REST SSO类似。用户在认证服务器上登录后，会得到一个加密的token，这个token会被存储在浏览器cookie中，当用户访问其他系统时，这个token会被发送给...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值