devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot+SpringSecurity+JWT整合实现单点登录SSO史上最全详解

作者：Guff_9hys | 2024-07-26 14:30:59

赞

踩

springboot3+springsecurity+jwt+vue实现单点登录

作者：波波烤鸭

blog.csdn.net/qq_38526573/article/details/103409430

一、什么是单点登陆

单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统

二、简单的运行机制

单点登录的机制其实是比较简单的，用一个现实中的例子做比较。某公园内部有许多独立的景点，游客可以在各个景点门口单独买票。对于需要游玩所有的景点的游客，这种买票方式很不方便，需要在每个景点门口排队买票，钱包拿 进拿出的，容易丢失，很不安全。于是绝大多数游客选择在大门口买一张通票（也叫套票），就可以玩遍所有的景点而不需要重新再买票。他们只需要在每个景点门 口出示一下刚才买的套票就能够被允许进入每个独立的景点。单点登录的机制也一样，如下图所示，

用户认证：这一环节主要是用户向认证服务器发起认证请求，认证服务器给用户返回一个成功的令牌token，主要在认证服务器中完成，即图中的认证系统，注意认证系统只能有一个。身份校验：这一环节是用户携带token去访问其他服务器时，在其他服务器中要对token的真伪进行检验，主要在资源服务器中完成，即图中的应用系统2 3

三、JWT介绍

概念说明

从分布式认证流程中，我们不难发现，这中间起最关键作用的就是token，token的安全与否，直接关系到系统的健壮性，这里我们选择使用JWT来实现token的生成和校验。  JWT，全称JSON Web Token，官网地址https://jwt.io，是一款出色的分布式身份校验方案。可以生成token，也可以解析检验token。

JWT生成的token由三部分组成：

头部：主要设置一些规范信息，签名部分的编码格式就在头部中声明。载荷：token中存放有效信息的部分，比如用户名，用户角色，过期时间等，但是不要放密码，会泄露！签名：将头部与载荷分别采用base64编码后，用“.”相连，再加入盐，最后使用头部声明的编码类型进行编码，就得到了签名。

JWT生成token的安全性分析

从JWT生成的token组成上来看，要想避免token被伪造，主要就得看签名部分了，而签名部分又有三部分组成，其中头部和载荷的base64编码，几乎是透明的，毫无安全性可言，那么最终守护token安全的重担就落在了加入的盐上面了！试想：如果生成token所用的盐与解析token时加入的盐是一样的。岂不是类似于中国人民银行把人民币防伪技术公开了？大家可以用这个盐来解析token，就能用来伪造token。这时，我们就需要对盐采用非对称加密的方式进行加密，以达到生成token与校验token方所用的盐不一致的安全效果！

非对称加密RSA介绍

基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端私钥加密，持有私钥或公钥才可以解密公钥加密，持有私钥才可解密 优点：安全，难以破解 缺点：算法比较耗时，为了安全，可以接受 历史：三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：RSA。

四、SpringSecurity整合JWT

1.认证思路分析

SpringSecurity主要是通过过滤器来实现功能的！我们要找到SpringSecurity实现认证和校验身份的过滤器！

回顾集中式认证流程

用户认证：  使用UsernamePasswordAuthenticationFilter过滤器中attemptAuthentication方法实现认证功能，该过滤器父类中successfulAuthentication方法实现认证成功后的操作。身份校验：  使用BasicAuthenticationFilter过滤器中doFilterInternal方法验证是否登录，以决定能否进入后续过滤器。

分析分布式认证流程

用户认证：  由于分布式项目，多数是前后端分离的架构设计，我们要满足可以接受异步post的认证请求参数，需要修改UsernamePasswordAuthenticationFilter过滤器中attemptAuthentication方法，让其能够接收请求体。  另外，默认successfulAuthentication方法在认证通过后，是把用户信息直接放入session就完事了，现在我们需要修改这个方法，在认证通过后生成token并返回给用户。身份校验：  原来BasicAuthenticationFilter过滤器中doFilterInternal方法校验用户是否登录，就是看session中是否有用户信息，我们要修改为，验证用户携带的token是否合法，并解析出用户信息，交给SpringSecurity，以便于后续的授权功能可以正常使用。

2.具体实现

为了演示单点登录的效果，我们设计如下项目结构

2.1父工程创建

因为本案例需要创建多个系统，所以我们使用maven聚合工程来实现，首先创建一个父工程，导入springboot的父依赖即可

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.1.3.RELEASE</version>
  5.     <relativePath/>
  6. </parent>
  7. 123456
2.2公共工程创建

然后创建一个common工程，其他工程依赖此系统导入JWT相关的依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>io.jsonwebtoken</groupId>
  4.         <artifactId>jjwt-api</artifactId>
  5.         <version>0.10.7</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>io.jsonwebtoken</groupId>
  9.         <artifactId>jjwt-impl</artifactId>
  10.         <version>0.10.7</version>
  11.         <scope>runtime</scope>
  12.     </dependency>
  13.     <dependency>
  14.         <groupId>io.jsonwebtoken</groupId>
  15.         <artifactId>jjwt-jackson</artifactId>
  16.         <version>0.10.7</version>
  17.         <scope>runtime</scope>
  18.     </dependency>
  19.     <!--jackson包-->
  20.     <dependency>
  21.         <groupId>com.fasterxml.jackson.core</groupId>
  22.         <artifactId>jackson-databind</artifactId>
  23.         <version>2.9.9</version>
  24.     </dependency>
  25.     <!--日志包-->
  26.     <dependency>
  27.         <groupId>org.springframework.boot</groupId>
  28.         <artifactId>spring-boot-starter-logging</artifactId>
  29.     </dependency>
  30.     <dependency>
  31.         <groupId>joda-time</groupId>
  32.         <artifactId>joda-time</artifactId>
  33.     </dependency>
  34.     <dependency>
  35.         <groupId>org.projectlombok</groupId>
  36.         <artifactId>lombok</artifactId>
  37.     </dependency>
  38.     <dependency>
  39.         <groupId>org.springframework.boot</groupId>
  40.         <artifactId>spring-boot-starter-test</artifactId>
  41.     </dependency>
  42. </dependencies>
  43. 123456789101112131415161718192021222324252627282930313233343536373839404142

创建相关的工具类

Payload

  1. /**
  2.  * @program: springboot-54-security-jwt-demo
  3.  * @description:
  4.  * @author: 波波烤鸭
  5.  * @create: 2019-12-03 10:28
  6.  */
  7. @Data
  8. public class Payload <T>{
  9.     private String id;
  10.     private T userInfo;
  11.     private Date expiration;
  12. }
  13. 123456789101112

JsonUtils

  1. package com.dpb.utils;
  2.  
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.core.type.TypeReference;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8.  
  9. import java.io.IOException;
  10. import java.util.List;
  11. import java.util.Map;
  12.  
  13. /**
  14.  * @author: 波波烤鸭
  15.  **/
  16. public class JsonUtils {
  17.  
  18.     public static final ObjectMapper mapper = new ObjectMapper();
  19.  
  20.     private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);
  21.  
  22.     public static String toString(Object obj) {
  23.         if (obj == null) {
  24.             return null;
  25.         }
  26.         if (obj.getClass() == String.class) {
  27.             return (String) obj;
  28.         }
  29.         try {
  30.             return mapper.writeValueAsString(obj);
  31.         } catch (JsonProcessingException e) {
  32.             logger.error("json序列化出错：" + obj, e);
  33.             return null;
  34.         }
  35.     }
  36.  
  37.     public static <T> T toBean(String json, Class<T> tClass) {
  38.         try {
  39.             return mapper.readValue(json, tClass);
  40.         } catch (IOException e) {
  41.             logger.error("json解析出错：" + json, e);
  42.             return null;
  43.         }
  44.     }
  45.  
  46.     public static <E> List<E> toList(String json, Class<E> eClass) {
  47.         try {
  48.             return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
  49.         } catch (IOException e) {
  50.             logger.error("json解析出错：" + json, e);
  51.             return null;
  52.         }
  53.     }
  54.  
  55.     public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
  56.         try {
  57.             return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
  58.         } catch (IOException e) {
  59.             logger.error("json解析出错：" + json, e);
  60.             return null;
  61.         }
  62.     }
  63.  
  64.     public static <T> T nativeRead(String json, TypeReference<T> type) {
  65.         try {
  66.             return mapper.readValue(json, type);
  67.         } catch (IOException e) {
  68.             logger.error("json解析出错：" + json, e);
  69.             return null;
  70.         }
  71.     }
  72. }
  73. 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172

JwtUtils

  1. package com.dpb.utils;
  2.  
  3. import com.dpb.domain.Payload;
  4. import io.jsonwebtoken.Claims;
  5. import io.jsonwebtoken.Jws;
  6. import io.jsonwebtoken.Jwts;
  7. import io.jsonwebtoken.SignatureAlgorithm;
  8. import org.joda.time.DateTime;
  9.  
  10. import java.security.PrivateKey;
  11. import java.security.PublicKey;
  12. import java.util.Base64;
  13. import java.util.UUID;
  14.  
  15. /**
  16.  * @author: 波波烤鸭
  17.  * 生成token以及校验token相关方法
  18.  */
  19. public class JwtUtils {
  20.  
  21.     private static final String JWT_PAYLOAD_USER_KEY = "user";
  22.  
  23.     /**
  24.      * 私钥加密token
  25.      *
  26.      * @param userInfo   载荷中的数据
  27.      * @param privateKey 私钥
  28.      * @param expire     过期时间，单位分钟
  29.      * @return JWT
  30.      */
  31.     public static String generateTokenExpireInMinutes(Object userInfo, PrivateKey privateKey, int expire) {
  32.         return Jwts.builder()
  33.                 .claim(JWT_PAYLOAD_USER_KEY, JsonUtils.toString(userInfo))
  34.                 .setId(createJTI())
  35.                 .setExpiration(DateTime.now().plusMinutes(expire).toDate())
  36.                 .signWith(privateKey, SignatureAlgorithm.RS256)
  37.                 .compact();
  38.     }
  39.  
  40.     /**
  41.      * 私钥加密token
  42.      *
  43.      * @param userInfo   载荷中的数据
  44.      * @param privateKey 私钥
  45.      * @param expire     过期时间，单位秒
  46.      * @return JWT
  47.      */
  48.     public static String generateTokenExpireInSeconds(Object userInfo, PrivateKey privateKey, int expire) {
  49.         return Jwts.builder()
  50.                 .claim(JWT_PAYLOAD_USER_KEY, JsonUtils.toString(userInfo))
  51.                 .setId(createJTI())
  52.                 .setExpiration(DateTime.now().plusSeconds(expire).toDate())
  53.                 .signWith(privateKey, SignatureAlgorithm.RS256)
  54.                 .compact();
  55.     }
  56.  
  57.     /**
  58.      * 公钥解析token
  59.      *
  60.      * @param token     用户请求中的token
  61.      * @param publicKey 公钥
  62.      * @return Jws<Claims>
  63.      */
  64.     private static Jws<Claims> parserToken(String token, PublicKey publicKey) {
  65.         return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
  66.     }
  67.  
  68.     private static String createJTI() {
  69.         return new String(Base64.getEncoder().encode(UUID.randomUUID().toString().getBytes()));
  70.     }
  71.  
  72.     /**
  73.      * 获取token中的用户信息
  74.      *
  75.      * @param token     用户请求中的令牌
  76.      * @param publicKey 公钥
  77.      * @return 用户信息
  78.      */
  79.     public static <T> Payload<T> getInfoFromToken(String token, PublicKey publicKey, Class<T> userType) {
  80.         Jws<Claims> claimsJws = parserToken(token, publicKey);
  81.         Claims body = claimsJws.getBody();
  82.         Payload<T> claims = new Payload<>();
  83.         claims.setId(body.getId());
  84.         claims.setUserInfo(JsonUtils.toBean(body.get(JWT_PAYLOAD_USER_KEY).toString(), userType));
  85.         claims.setExpiration(body.getExpiration());
  86.         return claims;
  87.     }
  88.  
  89.     /**
  90.      * 获取token中的载荷信息
  91.      *
  92.      * @param token     用户请求中的令牌
  93.      * @param publicKey 公钥
  94.      * @return 用户信息
  95.      */
  96.     public static <T> Payload<T> getInfoFromToken(String token, PublicKey publicKey) {
  97.         Jws<Claims> claimsJws = parserToken(token, publicKey);
  98.         Claims body = claimsJws.getBody();
  99.         Payload<T> claims = new Payload<>();
  100.         claims.setId(body.getId());
  101.         claims.setExpiration(body.getExpiration());
  102.         return claims;
  103.     }
  104. }
  105. 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104

RsaUtils

  1. package com.dpb.utils;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.nio.file.Files;
  6. import java.security.*;
  7. import java.security.spec.InvalidKeySpecException;
  8. import java.security.spec.PKCS8EncodedKeySpec;
  9. import java.security.spec.X509EncodedKeySpec;
  10. import java.util.Base64;
  11.  
  12. /**
  13.  * @author 波波烤鸭
  14.  */
  15. public class RsaUtils {
  16.  
  17.     private static final int DEFAULT_KEY_SIZE = 2048;
  18.     /**
  19.      * 从文件中读取公钥
  20.      *
  21.      * @param filename 公钥保存路径，相对于classpath
  22.      * @return 公钥对象
  23.      * @throws Exception
  24.      */
  25.     public static PublicKey getPublicKey(String filename) throws Exception {
  26.         byte[] bytes = readFile(filename);
  27.         return getPublicKey(bytes);
  28.     }
  29.  
  30.     /**
  31.      * 从文件中读取密钥
  32.      *
  33.      * @param filename 私钥保存路径，相对于classpath
  34.      * @return 私钥对象
  35.      * @throws Exception
  36.      */
  37.     public static PrivateKey getPrivateKey(String filename) throws Exception {
  38.         byte[] bytes = readFile(filename);
  39.         return getPrivateKey(bytes);
  40.     }
  41.  
  42.     /**
  43.      * 获取公钥
  44.      *
  45.      * @param bytes 公钥的字节形式
  46.      * @return
  47.      * @throws Exception
  48.      */
  49.     private static PublicKey getPublicKey(byte[] bytes) throws Exception {
  50.         bytes = Base64.getDecoder().decode(bytes);
  51.         X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
  52.         KeyFactory factory = KeyFactory.getInstance("RSA");
  53.         return factory.generatePublic(spec);
  54.     }
  55.  
  56.     /**
  57.      * 获取密钥
  58.      *
  59.      * @param bytes 私钥的字节形式
  60.      * @return
  61.      * @throws Exception
  62.      */
  63.     private static PrivateKey getPrivateKey(byte[] bytes) throws NoSuchAlgorithmException, InvalidKeySpecException {
  64.         bytes = Base64.getDecoder().decode(bytes);
  65.         PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
  66.         KeyFactory factory = KeyFactory.getInstance("RSA");
  67.         return factory.generatePrivate(spec);
  68.     }
  69.  
  70.     /**
  71.      * 根据密文，生存rsa公钥和私钥,并写入指定文件
  72.      *
  73.      * @param publicKeyFilename  公钥文件路径
  74.      * @param privateKeyFilename 私钥文件路径
  75.      * @param secret             生成密钥的密文
  76.      */
  77.     public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret, int keySize) throws Exception {
  78.         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
  79.         SecureRandom secureRandom = new SecureRandom(secret.getBytes());
  80.         keyPairGenerator.initialize(Math.max(keySize, DEFAULT_KEY_SIZE), secureRandom);
  81.         KeyPair keyPair = keyPairGenerator.genKeyPair();
  82.         // 获取公钥并写出
  83.         byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
  84.         publicKeyBytes = Base64.getEncoder().encode(publicKeyBytes);
  85.         writeFile(publicKeyFilename, publicKeyBytes);
  86.         // 获取私钥并写出
  87.         byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
  88.         privateKeyBytes = Base64.getEncoder().encode(privateKeyBytes);
  89.         writeFile(privateKeyFilename, privateKeyBytes);
  90.     }
  91.  
  92.     private static byte[] readFile(String fileName) throws Exception {
  93.         return Files.readAllBytes(new File(fileName).toPath());
  94.     }
  95.  
  96.     private static void writeFile(String destPath, byte[] bytes) throws IOException {
  97.         File dest = new File(destPath);
  98.         if (!dest.exists()) {
  99.             dest.createNewFile();
  100.         }
  101.         Files.write(dest.toPath(), bytes);
  102.     }
  103. }
  104. 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103

在通用子模块中编写测试类生成rsa公钥和私钥

  1. /**
  2.  * @program: springboot-54-security-jwt-demo
  3.  * @description:
  4.  * @author: 波波烤鸭
  5.  * @create: 2019-12-03 11:08
  6.  */
  7. public class JwtTest {
  8.     private String privateKey = "c:/tools/auth_key/id_key_rsa";
  9.  
  10.     private String publicKey = "c:/tools/auth_key/id_key_rsa.pub";
  11.  
  12.     @Test
  13.     public void test1() throws Exception{
  14.         RsaUtils.generateKey(publicKey,privateKey,"dpb",1024);
  15.     }
  16.  
  17. }
  18. 1234567891011121314151617

2.3认证系统创建

接下来我们创建我们的认证服务。

导入相关的依赖
  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-security</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <artifactId>security-jwt-common</artifactId>
  12.         <groupId>com.dpb</groupId>
  13.         <version>1.0-SNAPSHOT</version>
  14.     </dependency>
  15.     <dependency>
  16.         <groupId>mysql</groupId>
  17.         <artifactId>mysql-connector-java</artifactId>
  18.         <version>5.1.47</version>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.mybatis.spring.boot</groupId>
  22.         <artifactId>mybatis-spring-boot-starter</artifactId>
  23.         <version>2.1.0</version>
  24.     </dependency>
  25.     <dependency>
  26.         <groupId>com.alibaba</groupId>
  27.         <artifactId>druid</artifactId>
  28.         <version>1.1.10</version>
  29.     </dependency>
  30.     <dependency>
  31.         <groupId>org.springframework.boot</groupId>
  32.         <artifactId>spring-boot-configuration-processor</artifactId>
  33.         <optional>true</optional>
  34.     </dependency>
  35. </dependencies>
  36. 1234567891011121314151617181920212223242526272829303132333435
创建配置文件
  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/srm
  5.     username: root
  6.     password: 123456
  7.     type: com.alibaba.druid.pool.DruidDataSource
  8. mybatis:
  9.   type-aliases-package: com.dpb.domain
  10.   mapper-locations: classpath:mapper/*.xml
  11. logging:
  12.   level:
  13.     com.dpb: debug
  14. rsa:
  15.   key:
  16.     pubKeyFile: c:\tools\auth_key\id_key_rsa.pub
  17.     priKeyFile: c:\tools\auth_key\id_key_rsa
  18. 1234567891011121314151617
提供公钥私钥的配置类
  1. package com.dpb.config;
  2.  
  3. import com.dpb.utils.RsaUtils;
  4. import lombok.Data;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. import javax.annotation.PostConstruct;
  9. import java.security.PrivateKey;
  10. import java.security.PublicKey;
  11.  
  12. /**
  13.  * @program: springboot-54-security-jwt-demo
  14.  * @description:
  15.  * @author: 波波烤鸭
  16.  * @create: 2019-12-03 11:25
  17.  */
  18. @Data
  19. @ConfigurationProperties(prefix = "rsa.key")
  20. public class RsaKeyProperties {
  21.  
  22.     private String pubKeyFile;
  23.     private String priKeyFile;
  24.  
  25.     private PublicKey publicKey;
  26.     private PrivateKey privateKey;
  27.  
  28.     /**
  29.      * 系统启动的时候触发
  30.      * @throws Exception
  31.      */
  32.     @PostConstruct
  33.     public void createRsaKey() throws Exception {
  34.         publicKey = RsaUtils.getPublicKey(pubKeyFile);
  35.         privateKey = RsaUtils.getPrivateKey(priKeyFile);
  36.     }
  37.  
  38. }
  39. 1234567891011121314151617181920212223242526272829303132333435363738
创建启动类
  1. /**
  2.  * @program: springboot-54-security-jwt-demo
  3.  * @description: 启动类
  4.  * @author: 波波烤鸭
  5.  * @create: 2019-12-03 11:23
  6.  */
  7. @SpringBootApplication
  8. @MapperScan("com.dpb.mapper")
  9. @EnableConfigurationProperties(RsaKeyProperties.class)
  10. public class App {
  11.  
  12.     public static void main(String[] args) {
  13.         SpringApplication.run(App.class,args);
  14.     }
  15. }
  16. 123456789101112131415
完成数据认证的逻辑

pojo

  1. package com.dpb.domain;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  4. import lombok.Data;
  5. import org.springframework.security.core.GrantedAuthority;
  6.  
  7. /**
  8.  * @program: springboot-54-security-jwt-demo
  9.  * @description:
  10.  * @author: 波波烤鸭
  11.  * @create: 2019-12-03 15:21
  12.  */
  13. @Data
  14. public class RolePojo implements GrantedAuthority {
  15.  
  16.     private Integer id;
  17.     private String roleName;
  18.     private String roleDesc;
  19.  
  20.     @JsonIgnore
  21.     @Override
  22.     public String getAuthority() {
  23.         return roleName;
  24.     }
  25. }
  26. 12345678910111213141516171819202122232425
  27. package com.dpb.domain;
  28.  
  29. import com.fasterxml.jackson.annotation.JsonIgnore;
  30. import lombok.Data;
  31. import org.springframework.security.core.GrantedAuthority;
  32. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  33. import org.springframework.security.core.userdetails.UserDetails;
  34.  
  35. import java.util.ArrayList;
  36. import java.util.Collection;
  37. import java.util.List;
  38.  
  39. /**
  40.  * @program: springboot-54-security-jwt-demo
  41.  * @description:
  42.  * @author: 波波烤鸭
  43.  * @create: 2019-12-03 11:33
  44.  */
  45. @Data
  46. public class UserPojo implements UserDetails {
  47.  
  48.     private Integer id;
  49.  
  50.     private String username;
  51.  
  52.     private String password;
  53.  
  54.     private Integer status;
  55.  
  56.     private List<RolePojo> roles;
  57.  
  58.     @JsonIgnore
  59.     @Override
  60.     public Collection<? extends GrantedAuthority> getAuthorities() {
  61.         List<SimpleGrantedAuthority> auth = new ArrayList<>();
  62.         auth.add(new SimpleGrantedAuthority("ADMIN"));
  63.         return auth;
  64.     }
  65.  
  66.     @Override
  67.     public String getPassword() {
  68.         return this.password;
  69.     }
  70.  
  71.     @Override
  72.     public String getUsername() {
  73.         return this.username;
  74.     }
  75.     @JsonIgnore
  76.     @Override
  77.     public boolean isAccountNonExpired() {
  78.         return true;
  79.     }
  80.     @JsonIgnore
  81.     @Override
  82.     public boolean isAccountNonLocked() {
  83.         return true;
  84.     }
  85.     @JsonIgnore
  86.     @Override
  87.     public boolean isCredentialsNonExpired() {
  88.         return true;
  89.     }
  90.     @JsonIgnore
  91.     @Override
  92.     public boolean isEnabled() {
  93.         return true;
  94.     }
  95. }
  96. 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869

Mapper接口

  1. public interface UserMapper {
  2.     public UserPojo queryByUserName(@Param("userName") String userName);
  3. }
  4. 123

Mapper映射文件

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.dpb.mapper.UserMapper">
  6.     <select id="queryByUserName" resultType="UserPojo">
  7.         select * from t_user where username = #{userName}
  8.     </select>
  9. </mapper>
  10. 123456789

Service

  1. public interface UserService extends UserDetailsService {
  2.  
  3. }
  4. 123
  5. @Service
  6. @Transactional
  7. public class UserServiceImpl implements UserService {
  8.  
  9.     @Autowired
  10.     private UserMapper mapper;
  11.  
  12.     @Override
  13.     public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
  14.         UserPojo user = mapper.queryByUserName(s);
  15.  
  16.         return user;
  17.     }
  18. }
  19. 1234567891011121314
自定义认证过滤器
  1. package com.dpb.filter;
  2.  
  3. import com.dpb.config.RsaKeyProperties;
  4. import com.dpb.domain.RolePojo;
  5. import com.dpb.domain.UserPojo;
  6. import com.dpb.utils.JwtUtils;
  7. import com.fasterxml.jackson.databind.ObjectMapper;
  8. import net.bytebuddy.agent.builder.AgentBuilder;
  9. import org.springframework.security.authentication.AuthenticationManager;
  10. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  11. import org.springframework.security.core.Authentication;
  12. import org.springframework.security.core.AuthenticationException;
  13. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  14. import org.springframework.security.core.userdetails.User;
  15. import org.springframework.security.core.userdetails.UserDetails;
  16. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  17.  
  18. import javax.servlet.FilterChain;
  19. import javax.servlet.ServletException;
  20. import javax.servlet.http.HttpServletRequest;
  21. import javax.servlet.http.HttpServletResponse;
  22. import java.io.IOException;
  23. import java.io.PrintWriter;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;
  28.  
  29. /**
  30.  * @program: springboot-54-security-jwt-demo
  31.  * @description:
  32.  * @author: 波波烤鸭
  33.  * @create: 2019-12-03 11:57
  34.  */
  35. public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
  36.  
  37.     private AuthenticationManager authenticationManager;
  38.     private RsaKeyProperties prop;
  39.  
  40.     public TokenLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
  41.         this.authenticationManager = authenticationManager;
  42.         this.prop = prop;
  43.     }
  44.  
  45.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
  46.         try {
  47.             UserPojo sysUser = new ObjectMapper().readValue(request.getInputStream(), UserPojo.class);
  48.  
  49.             UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword());
  50.             return authenticationManager.authenticate(authRequest);
  51.         }catch (Exception e){
  52.             try {
  53.                 response.setContentType("application/json;charset=utf-8");
  54.                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
  55.                 PrintWriter out = response.getWriter();
  56.                 Map resultMap = new HashMap();
  57.                 resultMap.put("code", HttpServletResponse.SC_UNAUTHORIZED);
  58.                 resultMap.put("msg", "用户名或密码错误！");
  59.                 out.write(new ObjectMapper().writeValueAsString(resultMap));
  60.                 out.flush();
  61.                 out.close();
  62.             }catch (Exception outEx){
  63.                 outEx.printStackTrace();
  64.             }
  65.             throw new RuntimeException(e);
  66.         }
  67.     }
  68.  
  69.     public void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
  70.         UserPojo user = new UserPojo();
  71.         user.setUsername(authResult.getName());
  72.         user.setRoles((List<RolePojo>)authResult.getAuthorities());
  73.         String token = JwtUtils.generateTokenExpireInMinutes(user, prop.getPrivateKey(), 24 * 60);
  74.         response.addHeader("Authorization", "Bearer "+token);
  75.         try {
  76.             response.setContentType("application/json;charset=utf-8");
  77.             response.setStatus(HttpServletResponse.SC_OK);
  78.             PrintWriter out = response.getWriter();
  79.             Map resultMap = new HashMap();
  80.             resultMap.put("code", HttpServletResponse.SC_OK);
  81.             resultMap.put("msg", "认证通过！");
  82.             out.write(new ObjectMapper().writeValueAsString(resultMap));
  83.             out.flush();
  84.             out.close();
  85.         }catch (Exception outEx){
  86.             outEx.printStackTrace();
  87.         }
  88.     }
  89. }
  90. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
自定义校验token的过滤器
  1. package com.dpb.filter;
  2.  
  3. import com.dpb.config.RsaKeyProperties;
  4. import com.dpb.domain.Payload;
  5. import com.dpb.domain.UserPojo;
  6. import com.dpb.utils.JwtUtils;
  7. import com.fasterxml.jackson.databind.ObjectMapper;
  8. import org.springframework.security.authentication.AuthenticationManager;
  9. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  10. import org.springframework.security.core.context.SecurityContextHolder;
  11. import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
  12.  
  13. import javax.servlet.FilterChain;
  14. import javax.servlet.ServletException;
  15. import javax.servlet.http.HttpServletRequest;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.io.IOException;
  18. import java.io.PrintWriter;
  19. import java.util.HashMap;
  20. import java.util.Map;
  21.  
  22. /**
  23.  * @program: springboot-54-security-jwt-demo
  24.  * @description:
  25.  * @author: 波波烤鸭
  26.  * @create: 2019-12-03 12:39
  27.  */
  28. public class TokenVerifyFilter  extends BasicAuthenticationFilter {
  29.     private RsaKeyProperties prop;
  30.  
  31.     public TokenVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
  32.         super(authenticationManager);
  33.         this.prop = prop;
  34.     }
  35.  
  36.     public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
  37.         String header = request.getHeader("Authorization");
  38.         if (header == null || !header.startsWith("Bearer ")) {
  39.             //如果携带错误的token，则给用户提示请登录！
  40.             chain.doFilter(request, response);
  41.             response.setContentType("application/json;charset=utf-8");
  42.             response.setStatus(HttpServletResponse.SC_FORBIDDEN);
  43.             PrintWriter out = response.getWriter();
  44.             Map resultMap = new HashMap();
  45.             resultMap.put("code", HttpServletResponse.SC_FORBIDDEN);
  46.             resultMap.put("msg", "请登录！");
  47.             out.write(new ObjectMapper().writeValueAsString(resultMap));
  48.             out.flush();
  49.             out.close();
  50.         } else {
  51.             //如果携带了正确格式的token要先得到token
  52.             String token = header.replace("Bearer ", "");
  53.             //验证tken是否正确
  54.             Payload<UserPojo> payload = JwtUtils.getInfoFromToken(token, prop.getPublicKey(), UserPojo.class);
  55.             UserPojo user = payload.getUserInfo();
  56.             if(user!=null){
  57.                 UsernamePasswordAuthenticationToken authResult = new UsernamePasswordAuthenticationToken(user.getUsername(), null, user.getAuthorities());
  58.                 SecurityContextHolder.getContext().setAuthentication(authResult);
  59.                 chain.doFilter(request, response);
  60.             }
  61.         }
  62.     }
  63.  
  64. }
  65. 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

###编写SpringSecurity的配置类

  1. package com.dpb.config;
  2.  
  3. import com.dpb.filter.TokenLoginFilter;
  4. import com.dpb.filter.TokenVerifyFilter;
  5. import com.dpb.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  10. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  11. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  12. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  13. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  14. import org.springframework.security.config.http.SessionCreationPolicy;
  15. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  16.  
  17. /**
  18.  * @program: springboot-54-security-jwt-demo
  19.  * @description:
  20.  * @author: 波波烤鸭
  21.  * @create: 2019-12-03 12:41
  22.  */
  23. @Configuration
  24. @EnableWebSecurity
  25. @EnableGlobalMethodSecurity(securedEnabled=true)
  26. public class WebSecurityConfig   extends WebSecurityConfigurerAdapter {
  27.  
  28.     @Autowired
  29.     private UserService userService;
  30.  
  31.     @Autowired
  32.     private RsaKeyProperties prop;
  33.  
  34.     @Bean
  35.     public BCryptPasswordEncoder passwordEncoder(){
  36.         return new BCryptPasswordEncoder();
  37.     }
  38.  
  39.     //指定认证对象的来源
  40.     public void configure(AuthenticationManagerBuilder auth) throws Exception {
  41.         auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
  42.     }
  43.     //SpringSecurity配置信息
  44.     public void configure(HttpSecurity http) throws Exception {
  45.         http.csrf()
  46.                 .disable()
  47.                 .authorizeRequests()
  48.                 .antMatchers("/user/query").hasAnyRole("ADMIN")
  49.                 .anyRequest()
  50.                 .authenticated()
  51.                 .and()
  52.                 .addFilter(new TokenLoginFilter(super.authenticationManager(), prop))
  53.                 .addFilter(new TokenVerifyFilter(super.authenticationManager(), prop))
  54.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
  55.     }
  56. }
  57. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
启动服务测试

启动服务

通过Postman来访问测试

根据token信息我们访问其他资源

2.4资源系统创建

说明资源服务可以有很多个，这里只拿产品服务为例，记住，资源服务中只能通过公钥验证认证。不能签发token！创建产品服务并导入jar包根据实际业务导包即可，咱们就暂时和认证服务一样了。

接下来我们再创建一个资源服务

导入相关的依赖
  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-security</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <artifactId>security-jwt-common</artifactId>
  12.         <groupId>com.dpb</groupId>
  13.         <version>1.0-SNAPSHOT</version>
  14.     </dependency>
  15.     <dependency>
  16.         <groupId>mysql</groupId>
  17.         <artifactId>mysql-connector-java</artifactId>
  18.         <version>5.1.47</version>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.mybatis.spring.boot</groupId>
  22.         <artifactId>mybatis-spring-boot-starter</artifactId>
  23.         <version>2.1.0</version>
  24.     </dependency>
  25.     <dependency>
  26.         <groupId>com.alibaba</groupId>
  27.         <artifactId>druid</artifactId>
  28.         <version>1.1.10</version>
  29.     </dependency>
  30.     <dependency>
  31.         <groupId>org.springframework.boot</groupId>
  32.         <artifactId>spring-boot-configuration-processor</artifactId>
  33.         <optional>true</optional>
  34.     </dependency>
  35. </dependencies>
  36. 1234567891011121314151617181920212223242526272829303132333435
编写产品服务配置文件

切记这里只能有公钥地址！

  1. server:
  2.   port: 9002
  3. spring:
  4.   datasource:
  5.     driver-class-name: com.mysql.jdbc.Driver
  6.     url: jdbc:mysql://localhost:3306/srm
  7.     username: root
  8.     password: 123456
  9.     type: com.alibaba.druid.pool.DruidDataSource
  10. mybatis:
  11.   type-aliases-package: com.dpb.domain
  12.   mapper-locations: classpath:mapper/*.xml
  13. logging:
  14.   level:
  15.     com.dpb: debug
  16. rsa:
  17.   key:
  18.     pubKeyFile: c:\tools\auth_key\id_key_rsa.pub
  19. 123456789101112131415161718
编写读取公钥的配置类
  1. package com.dpb.config;
  2.  
  3. import com.dpb.utils.RsaUtils;
  4. import lombok.Data;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6.  
  7. import javax.annotation.PostConstruct;
  8. import java.security.PrivateKey;
  9. import java.security.PublicKey;
  10.  
  11. /**
  12.  * @program: springboot-54-security-jwt-demo
  13.  * @description:
  14.  * @author: 波波烤鸭
  15.  * @create: 2019-12-03 11:25
  16.  */
  17. @Data
  18. @ConfigurationProperties(prefix = "rsa.key")
  19. public class RsaKeyProperties {
  20.  
  21.     private String pubKeyFile;
  22.  
  23.     private PublicKey publicKey;
  24.  
  25.     /**
  26.      * 系统启动的时候触发
  27.      * @throws Exception
  28.      */
  29.     @PostConstruct
  30.     public void createRsaKey() throws Exception {
  31.         publicKey = RsaUtils.getPublicKey(pubKeyFile);
  32.     }
  33.  
  34. }
  35. 12345678910111213141516171819202122232425262728293031323334
编写启动类
  1. package com.dpb;
  2.  
  3. import com.dpb.config.RsaKeyProperties;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  8.  
  9. /**
  10.  * @program: springboot-54-security-jwt-demo
  11.  * @description:
  12.  * @author: 波波烤鸭
  13.  * @create: 2019-12-03 17:23
  14.  */
  15. @SpringBootApplication
  16. @MapperScan("com.dpb.mapper")
  17. @EnableConfigurationProperties(RsaKeyProperties.class)
  18. public class App {
  19.  
  20.     public static void main(String[] args) {
  21.         SpringApplication.run(App.class,args);
  22.     }
  23. }
  24. 1234567891011121314151617181920212223
复制认证服务中，用户对象，角色对象和校验认证的接口

复制认证服务中的相关内容即可

复制认证服务中SpringSecurity配置类做修改
  1. package com.dpb.config;
  2.  
  3. import com.dpb.filter.TokenVerifyFilter;
  4. import com.dpb.service.UserService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  9. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  10. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  11. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  12. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  13. import org.springframework.security.config.http.SessionCreationPolicy;
  14. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  15.  
  16. /**
  17.  * @program: springboot-54-security-jwt-demo
  18.  * @description:
  19.  * @author: 波波烤鸭
  20.  * @create: 2019-12-03 12:41
  21.  */
  22. @Configuration
  23. @EnableWebSecurity
  24. @EnableGlobalMethodSecurity(securedEnabled=true)
  25. public class WebSecurityConfig   extends WebSecurityConfigurerAdapter {
  26.  
  27.     @Autowired
  28.     private UserService userService;
  29.  
  30.     @Autowired
  31.     private RsaKeyProperties prop;
  32.  
  33.     @Bean
  34.     public BCryptPasswordEncoder passwordEncoder(){
  35.         return new BCryptPasswordEncoder();
  36.     }
  37.  
  38.     //指定认证对象的来源
  39.     public void configure(AuthenticationManagerBuilder auth) throws Exception {
  40.         auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
  41.     }
  42.     //SpringSecurity配置信息
  43.     public void configure(HttpSecurity http) throws Exception {
  44.         http.csrf()
  45.                 .disable()
  46.                 .authorizeRequests()
  47.                 //.antMatchers("/user/query").hasAnyRole("USER")
  48.                 .anyRequest()
  49.                 .authenticated()
  50.                 .and()
  51.                 .addFilter(new TokenVerifyFilter(super.authenticationManager(), prop))
  52.                 // 禁用掉session
  53.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
  54.     }
  55. }
  56.  
  57. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556

去掉“增加自定义认证过滤器”即可！

编写产品处理器
  1. package com.dpb.controller;
  2.  
  3. import org.springframework.security.access.annotation.Secured;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7. /**
  8.  * @program: springboot-54-security-jwt-demo
  9.  * @description:
  10.  * @author: 波波烤鸭
  11.  * @create: 2019-12-03 11:55
  12.  */
  13. @RestController
  14. @RequestMapping("/user")
  15. public class UserController {
  16.  
  17.     @RequestMapping("/query")
  18.     public String query(){
  19.         return "success";
  20.     }
  21.  
  22.     @RequestMapping("/update")
  23.     public String update(){
  24.         return "update";
  25.     }
  26. }
  27. 1234567891011121314151617181920212223242526
测试

搞定~

  1.  
  2.  
  3.  
  4.  
  5. Redis、Kafka或RabbitMQ，哪个更和微服务更般配？
  6. JDK 16 即将发布，看完这些新特性，我感觉已经学不动了..
  7. Redis 分布式锁使用不当，超卖了100瓶飞天茅台！！！
  8. SQL优化最干货总结（2021最新版）Redis 分布式锁使用不当，超卖了100瓶飞天茅台！！！为什么MySQL不推荐使用 UUID 或者雪花id作为主键？
  9. 今天，又被Java8的时间库恶心到了，有同感的举手...
  10. Docker从入门到干活，看这一篇足矣
  11.  
  12.  
  13. 好文章，我在看
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/885783
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号