• SpringBoot+JWT实现单点登录解决方案

    一、什么是单点登录?

    单点登录是一种统一认证和授权机制，指在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的系统，不需要重新登录验证。

    单点登录一般用于互相授信的系统，实现单一位置登录，其他信任的应用直接免登录的方式，在多个应用系统中，只需要登录一次，就可以访问其他互相信任的应用系统。

    随着时代的演进，大型web系统早已从单体应用架构发展为如今的多系统分布式应用群。但无论系统内部多么复杂，对用户而言，都是一个统一的整体，访问web系统的整个应用群要和访问单个系统一样，登录/注销只要一次就够了，不可能让一个用户在每个业务系统上都进行一次登录验证操作，这时就需要独立出一个单独的认证系统，它就是单点登录系统。

    二、单点登录的优点

    1.方便用户使用。用户不需要多次登录系统，不需要记住多个密码，方便用户操作。

    2.提高开发效率。单点登录为开发人员提供类一个通用的验证框架。

    3.简化管理。如果在应用程序中加入了单点登录的协议，管理用户账户的负担就会减轻。

    三、JWT 机制

    JWT(JSON Web Token)它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证JWTToken的正确性，只要正确就通过验证。

    数据结构:

    JWT包含三个部分:Header头部，Payload负载和Signature签名。三个部门用“.”分割。校验也是JWT内部自己实现的 ,并且可以将你存储时候的信息从token中取出来无须查库。

    JWT执行流程:

    JWT的请求流程也特别简单，首先使用账号登录获取Token，然后后面的各种请求，都带上这个Token即可。具体流程如下：

    1. 客户端发起登录请求，传入账号密码；

    2. 服务端使用私钥创建一个Token；

    3. 服务器返回Token给客户端；

    4. 客户端向服务端发送请求，在请求头中携带Token；

    5. 服务器验证该Token；

    6. 返回结果。

    四.创建Maven父项目

     2.指定打包类型为pom

     五.创建认证模块sso

     1.添加依赖，完整的pom文件如下:

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <parent>
    6.         <groupId>org.springframework.bootgroupId>
    7.         <artifactId>spring-boot-starter-parentartifactId>
    8.         <version>2.7.13version>
    9.         <relativePath/> 
    10.     parent>
    11.     <groupId>com.examplegroupId>
    12.     <artifactId>ssoartifactId>
    13.     <version>0.0.1-SNAPSHOTversion>
    14.     <name>ssoname>
    15.     <description>ssodescription>
    16.     <properties>
    17.         <java.version>1.8java.version>
    18.     properties>
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.springframework.bootgroupId>
    22.             <artifactId>spring-boot-starter-webartifactId>
    23.         dependency>
    24.         
    25.         <dependency>
    26.             <groupId>org.projectlombokgroupId>
    27.             <artifactId>lombokartifactId>
    28.         dependency>
    29.         
    30.         <dependency>
    31.             <groupId>com.auth0groupId>
    32.             <artifactId>java-jwtartifactId>
    33.             <version>3.8.2version>
    34.         dependency>
    35.         
    36.         <dependency>
    37.             <groupId>org.springframework.bootgroupId>
    38.             <artifactId>spring-boot-starter-thymeleafartifactId>
    39.         dependency>
    40.         <dependency>
    41.             <groupId>org.springframework.bootgroupId>
    42.             <artifactId>spring-boot-starter-testartifactId>
    43.             <scope>testscope>
    44.         dependency>
    45.     dependencies>
    46.  
    47.     <build>
    48.         <plugins>
    49.             <plugin>
    50.                 <groupId>org.springframework.bootgroupId>
    51.                 <artifactId>spring-boot-maven-pluginartifactId>
    52.             plugin>
    53.         plugins>
    54.     build>
    55.  
    56. project>

    2添加jwt相关配置

     3.创建JWT配置类和JWT工具类

    示例代码如下:

    1. package com.example.sso.bean;
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5. import org.springframework.boot.context.properties.ConfigurationProperties;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9.  * @author qx
    10.  * @date 2023/7/4
    11.  * @des Jwt配置类
    12.  */
    13. @Component
    14. @ConfigurationProperties(prefix = "jwt")
    15. @Getter
    16. @Setter
    17. public class JwtProperties {
    18.  
    19.     /**
    20.      * 过期时间-分钟
    21.      */
    22.     private Integer expireTime;
    23.  
    24.     /**
    25.      * refreshToken时间
    26.      */
    27.     private Integer refreshTime;
    28.  
    29.     /**
    30.      * 密钥
    31.      */
    32.     private String secret;
    33. }
    1. package com.example.sso.util;
    2.  
    3. import com.auth0.jwt.JWT;
    4. import com.auth0.jwt.JWTVerifier;
    5. import com.auth0.jwt.algorithms.Algorithm;
    6. import com.auth0.jwt.interfaces.Claim;
    7. import com.auth0.jwt.interfaces.DecodedJWT;
    8. import com.example.sso.bean.JwtProperties;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Component;
    11.  
    12. import java.util.Date;
    13. import java.util.HashMap;
    14. import java.util.Map;
    15.  
    16. /**
    17.  * @author qx
    18.  * @date 2023/7/4
    19.  * @des JWT工具类
    20.  */
    21. @Component
    22. public class JwtUtil {
    23.  
    24.     @Autowired
    25.     private JwtProperties jwtProperties;
    26.  
    27.     /**
    28.      * 生成一个jwt字符串
    29.      *
    30.      * @param username 用户名
    31.      * @return jwt字符串
    32.      */
    33.     public String sign(String username) {
    34.         Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
    35.         return JWT.create()
    36.                 // 设置过期时间1个小时
    37.                 .withExpiresAt(new Date(System.currentTimeMillis() + jwtProperties.getExpireTime() * 60 * 1000))
    38.                 // 设置负载
    39.                 .withClaim("username", username).sign(algorithm);
    40.     }
    41.  
    42.     /**
    43.      * 生成refreshToken
    44.      *
    45.      * @param username 用户名
    46.      * @return
    47.      */
    48.     public String refreshToken(String username) {
    49.         Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
    50.         return JWT.create()
    51.                 // 设置更新时间2个小时
    52.                 .withExpiresAt(new Date(System.currentTimeMillis() + jwtProperties.getRefreshTime() * 60 * 1000))
    53.                 // 设置负载
    54.                 .withClaim("username", username).sign(algorithm);
    55.     }
    56.  
    57.  
    58.     public static void main(String[] args) {
    59.         Algorithm algorithm = Algorithm.HMAC256("KU5TjMO6zmh03bU3");
    60.         String username = "admin";
    61.         String token = JWT.create()
    62.                 // 设置过期时间1个小时
    63.                 .withExpiresAt(new Date(System.currentTimeMillis() + 60 * 60 * 1000))
    64.                 // 设置负载
    65.                 .withClaim("username", username).sign(algorithm);
    66.         System.out.println(token);
    67.     }
    68.  
    69.     /**
    70.      * 校验token是否正确
    71.      *
    72.      * @param token token值
    73.      */
    74.     public boolean verify(String token) {
    75.         if (token == null || token.length() == 0) {
    76.             throw new RuntimeException("token为空");
    77.         }
    78.         try {
    79.             Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
    80.             JWTVerifier jwtVerifier = JWT.require(algorithm).build();
    81.             DecodedJWT decodedJWT = jwtVerifier.verify(token);
    82.             Map map = decodedJWT.getClaims();
    83.             System.out.println("claims:" + map.get("username").asString());
    84.             return true;
    85.         } catch (Exception e) {
    86.             e.printStackTrace();
    87.             return false;
    88.         }
    89.  
    90.     }
    91.  
    92.     /**
    93.      * 重新生成token和refreshToken
    94.      *
    95.      * @param refreshToken refreshToken
    96.      * @return 返回token和refreshToken
    97.      */
    98.     public Map refreshJwt(String refreshToken) {
    99.         if (refreshToken == null || refreshToken.length() == 0) {
    100.             throw new RuntimeException("refreshToken为空");
    101.         }
    102.         Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
    103.         JWTVerifier jwtVerifier = JWT.require(algorithm).build();
    104.         DecodedJWT decodedJWT = jwtVerifier.verify(refreshToken);
    105.         Map map = decodedJWT.getClaims();
    106.         // 获取用户名
    107.         String username = map.get("username").asString();
    108.         Map resultMap = new HashMap<>();
    109.         // 重新生成token和refreshToken
    110.         resultMap.put("token", sign(username));
    111.         resultMap.put("refreshToken", refreshToken(username));
    112.         return resultMap;
    113.     }
    114. }

    4.创建服务层

    1. package com.example.sso.service;
    2.  
    3. import com.example.sso.util.JwtUtil;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Service;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. /**
    11.  * @author qx
    12.  * @date 2023/7/4
    13.  * @des 登录服务层
    14.  */
    15. @Service
    16. public class LoginService {
    17.  
    18.  
    19.     @Autowired
    20.     private JwtUtil jwtUtil;
    21.  
    22.     /**
    23.      * 登录
    24.      *
    25.      * @param username 用户名
    26.      * @param password 密码
    27.      * @return token值
    28.      */
    29.     public Map login(String username, String password) {
    30.         Map map = new HashMap<>();
    31.         if ("".equals(username) || "".equals(password)) {
    32.             throw new RuntimeException("用户名或密码不能为空");
    33.         }
    34.         // 为了测试方便 不去数据库比较密码
    35.         if ("123".equals(password)) {
    36.             // 返回生成的token
    37.             map.put("token", jwtUtil.sign(username));
    38.             map.put("refreshToken", jwtUtil.refreshToken(username));
    39.         }
    40.         return map;
    41.     }
    42.  
    43.     /**
    44.      * 校验jwt是否成功
    45.      *
    46.      * @param token token值
    47.      * @return 校验是否超过
    48.      */
    49.     public boolean checkJwt(String token) {
    50.         return jwtUtil.verify(token);
    51.     }
    52.  
    53.     /**
    54.      * 重新生成token和refreshToken
    55.      *
    56.      * @param refreshToken refreshToken
    57.      * @return token和refreshToken
    58.      */
    59.     public Map refreshJwt(String refreshToken) {
    60.         return jwtUtil.refreshJwt(refreshToken);
    61.     }
    62. }

    5.创建控制层

    1. package com.example.sso.controller;
    2.  
    3. import com.example.sso.service.LoginService;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.ui.ModelMap;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.PostMapping;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11.  
    12. import java.util.Map;
    13.  
    14. /**
    15.  * @author qx
    16.  * @date 2023/7/4
    17.  * @des 验证控制层
    18.  */
    19. @Controller
    20. @RequestMapping("/sso")
    21. public class AuthController {
    22.  
    23.     @Autowired
    24.     private LoginService loginService;
    25.  
    26.     /**
    27.      * 登录页面
    28.      */
    29.     @GetMapping("/login")
    30.     public String toLogin() {
    31.         return "login";
    32.     }
    33.  
    34.     /**
    35.      * 登录
    36.      *
    37.      * @param username 用户名
    38.      * @param password 密码
    39.      * @return token值
    40.      */
    41.     @PostMapping("/login")
    42.     @ResponseBody
    43.     public Map login(String username, String password) {
    44.         return loginService.login(username, password);
    45.     }
    46.  
    47.     /**
    48.      * 验证jwt
    49.      *
    50.      * @param token token
    51.      * @return 验证jwt是否合法
    52.      */
    53.     @RequestMapping("/checkJwt")
    54.     @ResponseBody
    55.     public boolean checkJwt(String token) {
    56.         return loginService.checkJwt(token);
    57.     }
    58.  
    59.  
    60.     /**
    61.      * 重新生成token和refreshToken
    62.      *
    63.      * @param refreshToken refreshToken
    64.      * @return token和refreshToken
    65.      */
    66.     @RequestMapping("/refreshJwt")
    67.     @ResponseBody
    68.     public Map refreshJwt(String refreshToken) {
    69.         return loginService.refreshJwt(refreshToken);
    70.     }
    71.  
    72. }

    6.创建一个登录页面login.html

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>登录title>
    6. head>
    7. <body>
    8.     <form method="post" action="/sso/login">
    9.         用户名:<input type="text" name="username"/><br/>
    10.         密码:<input type="password" name="password"/><br/>
    11.         <button type="submit">登录button>
    12.     form>
    13. body>
    14. html>

    六、创建应用系统projectA 

     1.项目pom文件如下所示

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     <parent>
    7.         <groupId>org.examplegroupId>
    8.         <artifactId>my-ssoartifactId>
    9.         <version>1.0-SNAPSHOTversion>
    10.     parent>
    11.  
    12.     <artifactId>projectAartifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>8maven.compiler.source>
    16.         <maven.compiler.target>8maven.compiler.target>
    17.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    18.     properties>
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.springframework.bootgroupId>
    22.             <artifactId>spring-boot-starter-webartifactId>
    23.             <version>2.7.13version>
    24.         dependency>
    25.         
    26.         <dependency>
    27.             <groupId>com.squareup.okhttp3groupId>
    28.             <artifactId>okhttpartifactId>
    29.             <version>4.10.0version>
    30.         dependency>
    31.     dependencies>
    32. project>

     2.修改配置文件

     3.创建过滤器

    1. package com.example.projectA.filter;
    2.  
    3. import okhttp3.OkHttpClient;
    4. import okhttp3.Request;
    5. import okhttp3.Response;
    6. import org.springframework.beans.factory.annotation.Value;
    7. import org.springframework.stereotype.Component;
    8.  
    9. import javax.servlet.*;
    10. import javax.servlet.annotation.WebFilter;
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13. import java.io.IOException;
    14.  
    15. /**
    16.  * @author qx
    17.  * @date 2023/7/4
    18.  * @des 登录过滤器
    19.  */
    20. @Component
    21. @WebFilter(urlPatterns = "/**")
    22. public class LoginFilter implements Filter {
    23.  
    24.     @Value("${sso_server}")
    25.     private String serverHost;
    26.  
    27.     @Override
    28.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    29.         HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
    30.         String token = httpServletRequest.getParameter("token");
    31.         if (this.check(token)) {
    32.             filterChain.doFilter(servletRequest, servletResponse);
    33.         } else {
    34.             // token过期后再使用refreshToken处理
    35.             String refreshToken = httpServletRequest.getHeader("refreshToken");
    36.             if (check(refreshToken)) {
    37.                 // 重新生成token和refreshtoken给客户端保存 下次传递token参数的时候使用这个重新生成的
    38.                 System.out.println("更新后的token和refreshToken:" + refreshToken(refreshToken));
    39.                 filterChain.doFilter(servletRequest, servletResponse);
    40.             }
    41.             // 如果refreshToken也过期 那么需要重新登录
    42.             HttpServletResponse response = (HttpServletResponse) servletResponse;
    43.             String redirect = serverHost + "/login";
    44.             response.sendRedirect(redirect);
    45.         }
    46.     }
    47.  
    48.     /**
    49.      * 验证token
    50.      *
    51.      * @param token
    52.      * @return
    53.      * @throws IOException
    54.      */
    55.     private boolean check(String token) throws IOException {
    56.         if (token == null || token.trim().length() == 0) {
    57.             return false;
    58.         }
    59.         OkHttpClient client = new OkHttpClient();
    60.         // 请求验证token的合法性
    61.         String url = serverHost + "/checkJwt?token=" + token;
    62.         Request request = new Request.Builder().url(url).build();
    63.         Response response = client.newCall(request).execute();
    64.         return Boolean.parseBoolean(response.body().string());
    65.     }
    66.  
    67.     /**
    68.      * 重新获取token和refreshToken
    69.      *
    70.      * @param refreshToken
    71.      * @return
    72.      * @throws IOException
    73.      */
    74.     private String refreshToken(String refreshToken) throws IOException {
    75.         if (refreshToken == null || refreshToken.trim().length() == 0) {
    76.             return null;
    77.         }
    78.         OkHttpClient client = new OkHttpClient();
    79.         // 请求重新获取token和refreshToken
    80.         String url = serverHost + "/refreshJwt?refreshToken=" + refreshToken;
    81.         Request request = new Request.Builder().url(url).build();
    82.         Response response = client.newCall(request).execute();
    83.         return response.body().string();
    84.  
    85.     }
    86. }

    4.创建测试控制层

    1. package com.example.projectA.controller;
    2.  
    3. import org.springframework.web.bind.annotation.GetMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6. /**
    7.  * @author qx
    8.  * @date 2023/7/4
    9.  * @des 测试A
    10.  */
    11. @RestController
    12. public class IndexController {
    13.  
    14.     @GetMapping("/testA")
    15.     public String testA() {
    16.         return "输出testA";
    17.     }
    18. }

    5.启动类

    1. package com.example.projectA;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.boot.web.servlet.ServletComponentScan;
    6.  
    7. /**
    8.  * @author qx
    9.  * @date 2023/7/4
    10.  * @des Projecta启动类
    11.  */
    12. @SpringBootApplication
    13. @ServletComponentScan
    14. public class ProjectaApplication {
    15.  
    16.     public static void main(String[] args) {
    17.         SpringApplication.run(ProjectaApplication.class,args);
    18.     }
    19. }

    6.启动项目测试

    我们访问http://localhost:8081/testA 系统跳转到了验证模块的登录页面

    我们输入账号密码登录成功后返回token

     如何我们复制这段数据，把数据传递到token参数。

     我们看到正确获取到了数据。

    当我们的token过期之后，我们使用refreshToken重新获取到新的token和refreshToken。

     由于我们的项目中refreshToken的更新时间为2分钟，我们等这个时间过期之后我们再次请求接口，那么这个时候就要去重新登录了。

    一般的我们的refreshToken时间设置要比token的过期时间要长。

    客户端登录后，将 token和refreshToken 保存在客户端本地，每次访问将 token 传给服务端。服务端校验 accessToken 的有效性，如果过期的话，就将 refreshToken 传给服务端。如果 refreshToken 有效，服务端就生成新的 accessToken 给客户端。否则，客户端就重新登录即可。

    七、创建应用系统projectB

    我们再次模仿projectA创建projectB子模块。

     

     启动模块B

    我们直接测试带上token参数

    通过之前的token，无需登录即可成功进入了应用系统B。说明我们的单点登录系统搭建成功。

  • 相关阅读:
    【Flutter系列】第一期——初识Dart语言
    OpenHarmony自定义组件的生命周期
    VCS 和 SCM
    Excel 插入和提取超链接
    Linux驱动开发笔记（四）：设备驱动介绍、熟悉杂项设备驱动和ubuntu开发杂项设备Demo
    01-10-Hadoop-HA-概述
    【C++】类和对象 从入门到超神 (上)
    JavaScript中获取屏幕，窗口和网页大小
    408真题-2021
    js+vue,前端关于页面滚动让头部菜单淡入淡出实现原理
  • 原文地址：https://blog.csdn.net/qinxun2008081/article/details/131533908