Java架构师-分布式（二）：单点登录SSO【相同顶级域名：Redis+Cookie分布式会话；不同顶级域名：CAS系统（中央认证服务，独立的登陆系统；参考微信授权登陆）】

最新推荐文章于 2023-10-25 11:36:39 发布

u013250861

最新推荐文章于 2023-10-25 11:36:39 发布

阅读量982

点赞数

分类专栏： Java架构

本文链接：https://blog.csdn.net/u013250861/article/details/117454632

版权

Java架构专栏收录该内容

41 篇文章 9 订阅

订阅专栏

单点登录又称之为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
1. 转跳到CAS网站进行验证/登录，
2. CAS后台生成全局token、临时token；
3. CAS后台将全局token分别保存在CAS网站的cookie中、redis中
4. CAS后台将带有全局token的cookie返回给CAS的前端（CAS的前端的cookie是保存全局凭证的地方）
5. CAS后台将临时token返回给子网站A的前端，网站A会再次去CAS系统验证此临时token，如果此临时token有效，则登陆子网站A
用户初次登陆子网站B
1. 转跳到CAS网站进行验证/登录，
2. 如果在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;
    }

}

u013250861

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
3
评论
Java架构师-分布式（二）：单点登录SSO【相同顶级域名：Redis+Cookie分布式会话；不同顶级域名：CAS系统（中央认证服务，独立的登陆系统；参考微信授权登陆）】

Java架构师-分布式（一）：分布式会话与单点登录SSO
复制链接

扫一扫