• 公司产品太多了，怎么实现一次登录产品互通？

    最近开发新产品，然后老板说我们现在系统太多了，每次切换系统登录太麻烦了，能不能做个优化，同一账号互通掉。作为一个资深架构狮，老板的要求肯定要满足，安排！

    一个公司产品矩阵比较丰富的时候，用户在不同系统之间来回切换，固然对产品用户体验上较差，并且增加用户密码管理成本。也没有很好地利用内部流量进行用户打通，并且每个产品的独立体系会导致产品安全度下降。因此实现集团产品的单点登录对用户使用体验以及效率提升有很大的帮助。那么如何实现统一认证呢？我们先了解一下传统的身份验证方式。

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

    Cookie与服务器的交互

    Cookie与服务器的交互众所周知，http是无状态的协议，因此客户每次通过浏览器访问web页面，请求到服务端时，服务器都会新建线程，打开新的会话，而且服务器也不会自动维护客户的上下文信息。比如我们现在要实现一个电商内的购物车功能，要怎么才能知道哪些购物车请求对应的是来自同一个客户的请求呢？

    因此出现了session这个概念，session 就是一种保存上下文信息的机制，他是面向用户的，每一个SessionID 对应着一个用户，并且保存在服务端中。session主要 以 cookie 或 URL 重写为基础的来实现的，默认使用 cookie 来实现，系统会创造一个名为JSESSIONID的变量输出到cookie中。

    JSESSIONID 是存储于浏览器内存中的，并不是写到硬盘上的，如果我们把浏览器的cookie 禁止，则 web 服务器会采用 URL 重写的方式传递 Sessionid，我们就可以在地址栏看到 sessionid=KWJHUG6JJM65HS2K6 之类的字符串。

    通常 JSESSIONID 是不能跨窗口使用的，当你新开了一个浏览器窗口进入相同页面时，系统会赋予你一个新的sessionid，这样我们信息共享的目的就达不到了。

    服务器端的session的机制

    当服务端收到客户端的请求时候，首先判断请求里是否包含了JSESSIONID的sessionId，如果存在说明已经创建过了，直接从内存中拿出来使用，如果查询不到，说明是无效的。如果客户请求不包含sessionid，则为此客户创建一个session并且生成一个与此session相关联的sessionid，这个sessionid将在本次响应中返回给客户端保存。对每次http请求，都经历以下步骤处理：

    • 服务端首先查找对应的cookie的值（sessionid）。

    • 根据sessionid，从服务器端session存储中获取对应id的session数据，进行返回。

    • 如果找不到sessionid，服务器端就创建session，生成sessionid对应的cookie，写入到响应头中。

    session是由服务端生成的，并且以散列表的形式保存在内存中

    基于 session 的身份认证流程

    基于seesion的身份认证主要流程如下：

    因为 http 请求是无状态请求，所以在 Web 领域，大部分都是通过这种方式解决。但是这么做有什么问题呢？我们接着看

    集群环境下的 Session 困境及解决方案

    ​集群环境下的 Session 困境及解决方案随着技术的发展，用户流量增大，单个服务器已经不能满足系统的需要了，分布式架构开始流行。通常都会把系统部署在多台服务器上，通过负载均衡把请求分发到其中的一台服务器上，这样很可能同一个用户的请求被分发到不同的服务器上，因为 session 是保存在服务器上的，那么很有可能第一次请求访问的 A 服务器，创建了 session，但是第二次访问到了 B 服务器，这时就会出现取不到 session 的情况。

    我们知道，Session 一般是用来存会话全局的用户信息（不仅仅是登陆方面的问题），用来简化/加速后续的业务请求。

    传统的 session 由服务器端生成并存储，当应用进行分布式集群部署的时候，如何保证不同服务器上 session 信息能够共享呢？

    Session共享方案

    Session共享一般有两种思路

    • session复制

    • session集中存储

    session复制

    session复制即将不同服务器上 session 数据进行复制，用户登录，修改，注销时，将session信息同时也复制到其他机器上面去。

    ​session复制

    这种实现的问题就是实现成本高，维护难度大，并且会存在延迟登问题。

    session集中存储

    ​session集中存储集中存储就是将获取session单独放在一个服务中进行存储，所有获取session的统一来这个服务中去取。这样就避免了同步和维护多套session的问题。一般我们都是使用redis进行集中式存储session。

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

    SSO的产生背景

    如果企业做大了之后，一般都有很多的业务支持系统为其提供相应的管理和 IT 服务，按照传统的验证方式访问多系统，每个单独的系统都会有自己的安全体系和身份认证系统。进入每个系统都需要进行登录，获取session，再通过session访问对应系统资源。这样的局面不仅给管理上带来了很大的困难，对客户来说也极不友好，那么如何让客户只需登陆一次，就可以进入多个系统，而不需要重新登录呢？

    ​

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

    SSO的底层原理 CAS

    CAS实现单点登录流程

    我们知道对于完全不同域名的系统，cookie 是无法跨域名共享的，因此 sessionId 在页面端也无法共享，因此需要实现单店登录，就需要启用一个专门用来登录的域名如（ouath.com）来提供所有系统的sessionId。当业务系统被打开时，借助中心授权系统进行登录，整体流程如下：

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

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

    3. ouath.com登陆成功，种 cookie 到ouath.com域名下

    4. 把 sessionid 放入后台redis，存放数据结构，然后页面重定向到A系统

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

    6. 当b.com用ticket 值，到 redis 里查到 sessionid，并做 session 同步，然后种cookie给自己，页面原地重定向

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

    整个交互流程图如下：

    ​

    单点登录流程演示

    CAS登录服务demo核心代码

    1、用户实体类

    1. public class UserForm implements Serializable{
    2.   private static final long serialVersionUID = 1L;
    3.  
    4.   private String username;
    5.   private String password;
    6.   private String backurl;
    7.  
    8.   public String getUsername() {
    9.       return username;
    10.   }
    11.  
    12.   public void setUsername(String username) {
    13.       this.username = username;
    14.   }
    15.  
    16.   public String getPassword() {
    17.       return password;
    18.   }
    19.  
    20.   public void setPassword(String password) {
    21.       this.password = password;
    22.   }
    23.  
    24.   public String getBackurl() {
    25.       return backurl;
    26.   }
    27.  
    28.   public void setBackurl(String backurl) {
    29.       this.backurl = backurl;
    30.   }
    31. }

    2、登录控制器

    1. @Controller
    2. public class IndexController {
    3.     @Autowired
    4.     private RedisTemplate redisTemplate;
    5.  
    6.   @GetMapping("/toLogin")
    7.   public String toLogin(Model model,HttpServletRequest request) {
    8.       Object userInfo = request.getSession().getAttribute(LoginFilter.USER_INFO);
    9.       //不为空，则是已登陆状态
    10.       if (null != userInfo){
    11.           String ticket = UUID.randomUUID().toString();
    12.           redisTemplate.opsForValue().set(ticket,userInfo,2, TimeUnit.SECONDS);
    13.           return "redirect:"+request.getParameter("url")+"?ticket="+ticket;
    14.       }
    15.       UserForm user = new UserForm();
    16.       user.setUsername("laowang");
    17.       user.setPassword("laowang");
    18.       user.setBackurl(request.getParameter("url"));
    19.       model.addAttribute("user", user);
    20.  
    21.       return "login";
    22.   }
    23.  
    24.   @PostMapping("/login")
    25.   public void login(@ModelAttribute UserForm user,HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException {
    26.       System.out.println("backurl:"+user.getBackurl());
    27.       request.getSession().setAttribute(LoginFilter.USER_INFO,user);
    28.  
    29.       //登陆成功，创建用户信息票据
    30.       String ticket = UUID.randomUUID().toString();
    31.       redisTemplate.opsForValue().set(ticket,user,20, TimeUnit.SECONDS);
    32.       //重定向，回原url  ---a.com
    33.       if (null == user.getBackurl() || user.getBackurl().length()==0){
    34.           response.sendRedirect("/index");
    35.       } else {
    36.           response.sendRedirect(user.getBackurl()+"?ticket="+ticket);
    37.       }
    38.   }
    39.  
    40.   @GetMapping("/index")
    41.   public ModelAndView index(HttpServletRequest request) {
    42.       ModelAndView modelAndView = new ModelAndView();
    43.       Object user = request.getSession().getAttribute(LoginFilter.USER_INFO);
    44.       UserForm userInfo = (UserForm) user;
    45.       modelAndView.setViewName("index");
    46.       modelAndView.addObject("user", userInfo);
    47.       request.getSession().setAttribute("test","123");
    48.       return modelAndView;
    49.   }
    50. }

    3、登录过滤器

    1. public class LoginFilter implements Filter {
    2.     public static final String USER_INFO = "user";
    3.     @Override
    4.     public void init(FilterConfig filterConfig) throws ServletException {}
    5.  
    6.   @Override
    7.   public void doFilter(ServletRequest servletRequest,
    8.                        ServletResponse servletResponse, FilterChain filterChain)
    9.           throws IOException, ServletException {
    10.  
    11.       HttpServletRequest request = (HttpServletRequest) servletRequest;
    12.        HttpServletResponse response = (HttpServletResponse)servletResponse;
    13.  
    14.       Object userInfo = request.getSession().getAttribute(USER_INFO);;
    15.  
    16.       //如果未登陆，则拒绝请求，转向登陆页面
    17.       String requestUrl = request.getServletPath();
    18.       if (!"/toLogin".equals(requestUrl)//不是登陆页面
    19.               && !requestUrl.startsWith("/login")//不是去登陆
    20.               && null == userInfo) {//不是登陆状态
    21.  
    22.           request.getRequestDispatcher("/toLogin").forward(request,response);
    23.           return ;
    24.       }
    25.  
    26.       filterChain.doFilter(request,servletResponse);
    27.   }
    28.  
    29.   @Override
    30.   public void destroy() {
    31.  
    32.   }
    33. }

    4、配置过滤器

    1. @Configuration
    2. public class LoginConfig {
    3.  
    4. //配置filter生效
    5. @Bean
    6. public FilterRegistrationBean sessionFilterRegistration() {
    7.  
    8.     FilterRegistrationBean registration = new FilterRegistrationBean();
    9.     registration.setFilter(new LoginFilter());
    10.     registration.addUrlPatterns("/*");
    11.     registration.addInitParameter("paramName", "paramValue");
    12.     registration.setName("sessionFilter");
    13.     registration.setOrder(1);
    14.     return registration;
    15. }
    16. }

    5、登录页面

    1. HTML>
    2. <html xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <title>enjoy logintitle>
    5.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    6. head>
    7. <body>
    8. <div text-align="center">
    9.     <h1>请登陆h1>
    10.     <form action="#" th:action="@{/login}" th:object="${user}" method="post">
    11.         <p>用户名: <input type="text" th:field="*{username}" />p>
    12.         <p>密  码: <input type="text" th:field="*{password}" />p>
    13.         <p><input type="submit" value="Submit" /> <input type="reset" value="Reset" />p>
    14.         <input type="text" th:field="*{backurl}" hidden="hidden" />
    15.     form>
    16. div>
    17. body>
    18. html>

    web系统demo核心代码

    过滤器

    1. public class SSOFilter implements Filter {
    2.     private RedisTemplate redisTemplate;
    3.  
    4.     public static final String USER_INFO = "user";
    5.  
    6.     public SSOFilter(RedisTemplate redisTemplate){
    7.         this.redisTemplate = redisTemplate;
    8.     }
    9.     @Override
    10.     public void init(FilterConfig filterConfig) throws ServletException {
    11.  
    12.     }
    13.  
    14.     @Override
    15.     public void doFilter(ServletRequest servletRequest,
    16.                          ServletResponse servletResponse, FilterChain filterChain)
    17.             throws IOException, ServletException {
    18.  
    19.         HttpServletRequest request = (HttpServletRequest) servletRequest;
    20.         HttpServletResponse response = (HttpServletResponse)servletResponse;
    21.  
    22.         Object userInfo = request.getSession().getAttribute(USER_INFO);;
    23.  
    24.         //如果未登陆，则拒绝请求，转向登陆页面
    25.         String requestUrl = request.getServletPath();
    26.         if (!"/toLogin".equals(requestUrl)//不是登陆页面
    27.                 && !requestUrl.startsWith("/login")//不是去登陆
    28.                 && null == userInfo) {//不是登陆状态
    29.  
    30.             String ticket = request.getParameter("ticket");
    31.             //有票据,则使用票据去尝试拿取用户信息
    32.             if (null != ticket){
    33.                 userInfo = redisTemplate.opsForValue().get(ticket);
    34.             }
    35.             //无法得到用户信息，则去登陆页面
    36.             if (null == userInfo){
    37.                 response.sendRedirect("http://127.0.0.1:8080/toLogin?url="+request.getRequestURL().toString());
    38.                 return ;
    39.             }
    40.  
    41.             /**
    42.              * 将用户信息，加载进session中
    43.              */
    44.             UserForm user = (UserForm) userInfo;
    45.             request.getSession().setAttribute(SSOFilter.USER_INFO,user);
    46.             redisTemplate.delete(ticket);
    47.         }
    48.  
    49.         filterChain.doFilter(request,servletResponse);
    50.     }
    51.  
    52.     @Override
    53.     public void destroy() {
    54.  
    55.     }
    56. }

    控制器

    1. @Controller
    2. public class IndexController {
    3.     @Autowired
    4.     private RedisTemplate redisTemplate;
    5.  
    6.     @GetMapping("/index")
    7.     public ModelAndView index(HttpServletRequest request) {
    8.         ModelAndView modelAndView = new ModelAndView();
    9.         Object userInfo = request.getSession().getAttribute(SSOFilter.USER_INFO);
    10.         UserForm user = (UserForm) userInfo;
    11.         modelAndView.setViewName("index");
    12.         modelAndView.addObject("user", user);
    13.  
    14.         request.getSession().setAttribute("test","123");
    15.         return modelAndView;
    16.     }
    17. }

    首页

    1. HTML>
    2. <html xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <title>enjoy indextitle>
    5.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    6. head>
    7. <body>
    8. <div th:object="${user}">
    9.     <h1>cas-website：欢迎你">h1>
    10. div>
    11. body>
    12. html>

    CAS的单点登录和OAuth2的区别

    • OAuth2: 三方授权协议，允许用户在不提供账号密码的情况下，通过信任的应用进行授权，使其客户端可以访问权限范围内的资源。

    • CAS: 中央认证服务（Central Authentication Service），一个基于Kerberos票据方式实现SSO单点登录的框架，为Web 应用系统提供一种可靠的单点登录解决方法（属于 Web SSO ）。

    1. CAS的单点登录时保障客户端的用户资源的安全 ；OAuth2则是保障服务端的用户资源的安全 。

    2. CAS客户端要获取的最终信息是，这个用户到底有没有权限访问我（CAS客户端）的资源；OAuth2获取的最终信息是，我（oauth2服务提供方）的用户的资源到底能不能让你（oauth2的客户端）访问。

    因此，需要统一的账号密码进行身份认证，用CAS；需要授权第三方服务使用我方资源，使用OAuth2。

  • 相关阅读:
    HTTP 协议的定义,工作原理,Fiddler的原理和使用,请求的内容
    科研学习|研究方法——Python计量Logit模型
    【Java集合】集合是什么？为什么要用集合？
    @Requestbody注解
    Codeforces 1172C1. Nauuo and Pictures (easy version)(期望DP)
    编译安装LAMP架构搭建wordpress个人博客和discuz论坛——编译安装基于 FASTCGI 模式LAMP架构多虚拟主机WEB应用
    Vue原理
    栈与队列：设计循环队列
    SpringBoot-28-springSecurity注销和权限控制
    JAVA基础系列_0
  • 原文地址：https://blog.csdn.net/Park33/article/details/126082150