SSO单点登录

---

想学习架构师构建流程请跳转：Java架构师系统架构设计

1 单点登录

为什么要使用单点登录系统？
以前实现的登录和注册是在同一个tomcat内部完成，我们现在的系统架构是每一个系统都是由一个团队进行维护，每个系统都是单独部署运行一个单独的tomcat，所以，不能将用户的登录信息保存到session中（多个tomcat的session是不能共享的），所以我们需要一个单独的系统来维护用户的登录信息。

由上图可以看出：

• 客户端需要通过SSO系统才能获取到token；
• 客户端在请求服务系统时，服务系统需要通过SSO系统进行对token进行校验；
• SSO系统在整个系统架构中处于核心位置；
• 总结:用户想要使用就先给一个用户信息如:账号密码,给你生成一个token之后你那这这个token就能访问我其他服务了,其他服务也是token验证解析即可.其实非常的安全,只要盐值不泄露就算攻破也拿不到用户信息.

2 SSO讲解

在多个应用系统中，只需要登录一次，就可以访问其他相互信任的应用系统。

用户能够做到一次登录多次使用，无需记录多套用户名和密码，省心。

新系统开发时只需直接对接统一的账号中心即可，简化开发流程，省时。

比如：淘宝网（www.taobao.com），天猫网（www.tmall.com），聚划算（ju.taobao.com），飞猪网（www.fliggy.com）等，这些都是阿里巴巴集团的网站。在这些网站中，我们在其中一个网站登录了，再访问其他的网站时，就无需再进行登录，这就是 SSO 的主要用途。

登录流程：

虚线:系统响应
实线:游览器请求

退出流程：

当销毁时,会调用请求退出接口,会将所有系统对应的token去销毁.

3 代码实现

3.1 基于cookie和redis的单点登录

3.2 单点登陆实现思想：

1. 用户登录时，随机生成一个uuid，当成 Value 存到客户端cookie里，再将uuid作为Key，把去掉敏感信息（密码，电话，邮箱等）的用户对象转换成的 json串当作value，存进redis里，为以后校验用
2. 当用户在子页面之间进行切换时，先拿到页面的cookie，再从redis里查询cookie是否存在，不存在就重定向到登陆界面，存在则正常执行程序，实现单点登录

3.2.1 注册

1. 校验用户名、手机号、邮箱等

$.ajax({
            	url : "http://sso.jt.com/user/check/"+escape(pin)+"/1?r=" + Math.random(),
            	dataType : "jsonp",
            	success : function(data) {
                    checkpin = data.data?"1":"0";
                    if (data.status == 200){
                        if (!data.data) {
                            validateSettings.succeed.run(option);
                            namestate = true;
                        }else {
                            validateSettings.error.run(option, "该用户名已占用！");
                            namestate = false;
                        }
                    }else {
                        validateSettings.error.run(option, "服务器正忙，请稍候！");
                        namestate = false;
                    }

                }
            });

    /**   
    
     * 需求:实现用户信息校验
     * 校验步骤:  需要接收用户的请求,之后利用RestFul获取数据,
     *            实现数据库校验,按照JSONP的方式返回数据.
     * url地址:   http://sso.jt.com/user/check/admin123/1?r=0.8&callback=jsonp16
     * 参数:      restFul方式获取
     * 返回值:    JSONPObject
     */                                     //============注册校验用户名、手机号============//
    @RequestMapping("/check/{param}/{type}")//http://sso.jt.com/user/check/admin123/1?r=0.014981746295906095&callback=jsonp1607342205428&_=1607342388059
    public JSONPObject checkUser(@PathVariable String param,//admin123
                                 @PathVariable Integer type,//1
                                 String callback){
        //只需要校验数据库中是否有结果
        boolean flag = userService.checkUser(param,type);  //  flag = true/false
        SysResult sysResult = SysResult.success(flag);
                    //跨域请求返回 JSONPObject 对象
        return new JSONPObject(callback, sysResult);
    }

    //**************jt-sso*********************
boolean checkUser(String param, Integer type);

//**************jt-sso*********************
 /**
     *  校验数据库中是否有数据....
     *  Sql: select count(*) from tb_user where username="admin123";
     *  要求:返回数据true用户已存在，false用户不存在
     */
    @Override
    public boolean checkUser(String param, Integer type) {
        String column = paramMap.get(type);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(column,param);
        int count = userMapper.selectCount(queryWrapper);
        return count>0?true:false;
        //return count>0;
        //**************jt-sso*********************
    }

2. 执行注册

$.ajax({
			type : "POST",
			url : "/user/doRegister",
			contentType : "application/x-www-form-urlencoded; charset=utf-8",
			data : {password:_password,username:_username,phone:_phone},
			dataType : 'json',
			success : function(result) {
				if(result.status == "200"){
					// 注册成功，去登录页
					showMessage('注册成功，请登录！');
					verc();
					$("#registsubmit").removeAttr("disabled").removeClass()
							.addClass("btn-img btn-regist");
					isSubmit = false;
					return;
				}else{
					showMessage('注册失败,请联系管理员!');
				}		
			}
		});

dubbo远程调用

    /**
     * 注册
     * 参数：password: qwer123
     * username: yjjekejuej
     * phone: 13111111111
     * <p>
     * http://www.jt.com/user/doRegister
     */
    @RequestMapping("doRegister")
    @ResponseBody
    public SysResult saveUser(User user) {
        dubboUserService.saveUser(user);
        return SysResult.success("注册成功");
    }
    //***********************jt-web******************************

    @Transactional
    void saveUser(User user);
    //*********************************jt-common*****************************
123
    @Override
    public void saveUser(User user) {
        //密码MD5加密
        String password = user.getPassword();
        
        String md5Pass= DigestUtils.md5DigestAsHex(password.getBytes());
        user.setEmail(user.getPhone()).setPassword(md5Pass);
        userMapper.insert(user);
    }
    //*****************jt-sso**************************

3.2.2 登陆

1. 执行登陆–执行单点登录操作

        $.ajax({
            type: "POST",
            url: "/user/doLogin?r=" + Math.random(),
            contentType: "application/x-www-form-urlencoded; charset=utf-8",
            data: {username:_username,password:_password},
            dataType : "json",
            error: function () {
                $("#nloginpwd").attr({ "class": "text highlight2" });
                $("#loginpwd_error").html("网络超时，请稍后再试").show().attr({ "class": "error" });
                $("#loginsubmit").removeAttr("disabled");
                $this.removeAttr("disabled");
            },
            success: function (result) {
                if (result) {
                    var obj = eval(result);
                    if (obj.status == 200) {
                    	obj.success = "http://www.jt.com";
                        var isIE = !-[1,];
                        if (isIE) {
                            var link = document.createElement("a");
                            link.href = obj.success;
                            link.style.display = 'none';
                            document.body.appendChild(link);
                            link.click();
                        } else {
                            window.location = obj.success;
                        }
                        return;
                    }else{
                    $("#loginsubmit").removeAttr("disabled");
                    verc();
                      $("#nloginpwd").attr({ "class": "text highlight2" });
                      $("#loginpwd_error").html("账号或密码错误!").show().attr({ "class": "error" });
                    	
                    }
                }
            }
        });

dubbo远程调用

    @RequestMapping("doLogin")
    @ResponseBody
    public SysResult doLogin(User user, HttpServletResponse response){
        String uuid = dubboUserService.doLogin(user);
        if(StringUtils.isEmpty(uuid)){
            return SysResult.fail();
        }
        Cookie cookie = new Cookie("JT_TICKET", uuid);
        cookie.setMaxAge(30*24*60*60);
        cookie.setPath("/");//同一服务器内的cookie共享方法：setPath()
//        cookie.setDomain("www.jt.com");---只在www.jt.com有效
        cookie.setDomain("jt.com");//跨域共享cookie的方法:setDomain()
        response.addCookie(cookie);
        return SysResult.success();
    }
    //************************jt-web*******************

String doLogin(User user);
//************************jt-common*******************
 @Override
    public String doLogin(User user) {
        String md5Pass = DigestUtils.md5DigestAsHex(user.getPassword().getBytes());
        user.setPassword(md5Pass);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);//u/p不能
        //根据对象中不为空的属性,充当where条件.
        User userDB = userMapper.selectOne(queryWrapper);
        if(userDB == null){
            //根据用户名和密码错误
            return null;
        }
        //开始进行单点登录业务操作
        String uuid = UUID.randomUUID()
                .toString()
                .replace("-", "");
        userDB.setPassword("123456你信不?");   //去除有效信息.
        String userJSON = ObjectMapperUtil.toJSON(userDB);
        jedisCluster.setex(uuid, 30*24*60*60, userJSON);

        return uuid;
    }
    //*******************jt-sso***********************

3.2.3 拦截器实现

1.实现拦截器

@Component
public class UserInterceptor implements HandlerInterceptor {

    @Autowired
    private JedisCluster jedisCluster;

    /**
     *
     * @param request  用户请求对象
     * @param response  服务区响应对象
     * @param handler   当前处理器本身
     * @return  true--放行  false--拦截 一般配合重定向使用
     * @throws Exception
     * 需求：不登录时访问购物车，重定向到登陆界面
     * 判断是否登陆：1.cookie  2.redis
     */
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        //1.判断cookie中是否有记录
        String ticket = null ;
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length>0){
            for (Cookie cookie : cookies){
                if ("JT_TICKET".equals(cookie.getName())){
                    ticket = cookie.getValue();
                    break;
                }
            }
        }
        //2.判断cookie是否有效
        if (!StringUtils.isEmpty(ticket)){
            if (jedisCluster.exists(ticket)){
                String userJSON = jedisCluster.get(ticket);
                User user = ObjectMapperUtil.toObject(userJSON, User.class);
                UserThreadLocal.set(user);
//                request.setAttribute("JT_USER", user);
                return true;
            }
        }


        //重定向到用户的登录页面
        response.sendRedirect("/user/login.html");
        return false;
    }


    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        request.removeAttribute("JT_USER");
        UserThreadLocal.remove();

    }
}

2.配置拦截器策略

实例：

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);
    }
}

	@Autowired
	private UserInterceptor userInterceptor;
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(userInterceptor)
				.addPathPatterns("/cart/**","/order/**");
	}

***3.执行页面跳转，并保留状态- dubbo远程调用 ***

    @RequestMapping("/show")
    public String show(Model model, HttpServletRequest request){
//        User user = (User) request.getAttribute("JT_USER");
//        Long userId = user.getId();
        Long userId = UserThreadLocal.get().getId();//从当前USER线程中获取用户id
        List<Cart> cartList =cartService.findItemCartByUserId(userId);
        model.addAttribute("cartList",cartList);
        return "cart";
    }
    //*********************************-jt-web

List<Cart> findItemCartByUserId(Long userId);
//*********************jt-common
12
    @Override
    public List<Cart> findItemCartByUserId(Long userId) {
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("user_id", userId);

        return dubboCartMapper.selectList(queryWrapper);
    }
    //********************jt-cart

4 Cookie共享测试

找到前端项目app.js，开启如下代码，设置你的对应域名，需要和SwitchHosts相互对应：

如下图，可以看到，不论是在 shop 或是 center中，两个站点都能够在用户登录后共享用户信息。

如此一来，cookie中的信息被携带至后端，而后端又实现了分布式会话，那么如此一来，单点登录就实现了，用户无需再跨站点登录了。上述过程我们通过下图的展示，只要前端网页都在同一个顶级域名下，就能实现cookie与session的共享：

那么目前我们的系统在经过Redis分布式会话的完成之后，外加cookie设置的配合，就已经能够达到相同顶级域名下的单点登录了！

5 不同顶级域名的单点登录临时票据与全局票据

使用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;
    }

}