SpringSecurity 整合SpringBoot结合jwt与rsa实现分布式认证授权

基于springsecurity整合springboot实现简单认证授权进行修改实现分布式认证，即我们常说的单点登录，简称SSO，指的是在多应用系统的项目中，用户只需要登录一次，就可以访问所有互相信任的应用系统。

1. 单点登录

总结一下，单点登录的实现分两大环节： 用户认证：这一环节主要是用户向认证服务器发起认证请求，认证服务器给用户返回一个成功的令牌 token， 主要在认证服务器中完成，即图中的A系统，注意A系统只能有一个。 身份校验：这一环节是用户携带 token去访问其他服务器时，在其他服务器中要对token的真伪进行检验，主 要在资源服务器中完成，即图中的B系统，这里B系统可以有很多个。

2. jwt和rsa

1. 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方所用的盐不一致的安全效果！

2. 非对称加密 RSA介绍

• 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
  • 私钥加密，持有私钥或公钥才可以解密
  • 公钥加密，持有私钥才可解密
• 优点：安全，难以破解
• 缺点：算法比较耗时，为了安全，可以接受

3. 创建项目

1. 创建父工程

pom.xml如下

1<?xml version="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.0</modelVersion>
5    <packaging>pom</packaging>
6    <modules>
7        <module>common</module>
8        <module>server_auth</module>
9        <module>server_resource</module>
10    </modules>
11    <parent>
12        <groupId>org.springframework.boot</groupId>
13        <artifactId>spring-boot-starter-parent</artifactId>
14        <version>2.2.2.RELEASE</version>
15        <relativePath/> <!-- lookup parent from repository -->
16    </parent>
17    <groupId>com.example</groupId>
18    <artifactId>springboot_security_jwt_rsa_parent</artifactId>
19    <version>0.0.1-SNAPSHOT</version>
20    <name>springboot_security_jwt_rsa_parent</name>
21    <description>Demo project for Spring Boot</description>
22
23    <properties>
24        <java.version>1.8</java.version>
25    </properties>
26
27
28
29</project>
30

2. 创建工具模块

pom.xml如下

1<?xml version="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    <parent>
6        <artifactId>springboot_security_jwt_rsa_parent</artifactId>
7        <groupId>com.example</groupId>
8        <version>0.0.1-SNAPSHOT</version>
9    </parent>
10    <modelVersion>4.0.0</modelVersion>
11
12    <groupId>com.example</groupId>
13    <artifactId>common</artifactId>
14    <version>0.0.1-SNAPSHOT</version>
15
16    <dependencies>
17        <dependency>
18            <groupId>io.jsonwebtoken</groupId>
19            <artifactId>jjwt-api</artifactId>
20            <version>0.10.7</version>
21        </dependency>
22        <dependency>
23            <groupId>io.jsonwebtoken</groupId>
24            <artifactId>jjwt-impl</artifactId>
25            <version>0.10.7</version>
26            <scope>runtime</scope>
27        </dependency>
28        <dependency>
29            <groupId>io.jsonwebtoken</groupId>
30            <artifactId>jjwt-jackson</artifactId>
31            <version>0.10.7</version>
32            <scope>runtime</scope>
33        </dependency>
34        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-logging -->
35        <dependency>
36            <groupId>org.springframework.boot</groupId>
37            <artifactId>spring-boot-starter-logging</artifactId>
38        </dependency>
39
40        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
41        <dependency>
42            <groupId>com.fasterxml.jackson.core</groupId>
43            <artifactId>jackson-databind</artifactId>
44            <version>2.10.1</version>
45        </dependency>
46
47        <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
48        <dependency>
49            <groupId>joda-time</groupId>
50            <artifactId>joda-time</artifactId>
51            <version>2.10.5</version>
52        </dependency>
53        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
54        <dependency>
55            <groupId>org.projectlombok</groupId>
56            <artifactId>lombok</artifactId>
57            <version>1.18.10</version>
58            <scope>provided</scope>
59        </dependency>
60        <dependency>
61            <groupId>org.springframework.boot</groupId>
62            <artifactId>spring-boot-starter-test</artifactId>
63        </dependency>
64
65    </dependencies>
66
67</project>

1. JsonUtils

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

2. JwtUtils

1package com.example.utils;
2
3import com.example.domain.Payload;
4import io.jsonwebtoken.Claims;
5import io.jsonwebtoken.Jws;
6import io.jsonwebtoken.Jwts;
7import io.jsonwebtoken.SignatureAlgorithm;
8import org.joda.time.DateTime;
9
10import java.security.PrivateKey;
11import java.security.PublicKey;
12import java.util.Base64;
13import java.util.UUID;
14
15/**
16 * @author: 黑马程序员
17 * 生成token以及校验token相关方法
18 */
19public 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}

3. RsaUtils

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

4. pojo类Payload

1package com.example.domain;
2
3import lombok.Data;
4
5import java.util.Date;
6
7/**
8 * @author john
9 * @date 2020/1/12 - 9:15
10 */
11@Data
12public class Payload<T> {
13    private String id;
14    private T userInfo;
15    private Date expiration;
16}

5. 测试生成rsa签名的公钥和私钥

1package com.example.utils;
2
3import org.junit.jupiter.api.Test;
4
5import static org.junit.jupiter.api.Assertions.*;
6
7/**
8 * @author john
9 * @date 2020/1/12 - 9:35
10 */
11class RsaUtilsTest {
12    private String privateFilePath = "D:\\imooc\\study\\springboot_security_jwt_rsa_parent\\key\\private.key";
13    private String publicFilePath = "D:\\imooc\\study\\springboot_security_jwt_rsa_parent\\key\\rsa_public.pub";
14
15    @Test
16    void getPublicKey() throws Exception {
17        System.out.println(RsaUtils.getPublicKey(publicFilePath));
18    }
19
20    @Test
21    void getPrivateKey() throws Exception {
22        System.out.println(RsaUtils.getPrivateKey(privateFilePath));
23    }
24
25    @Test
26    void generateKey() throws Exception {
27        RsaUtils.generateKey(publicFilePath, privateFilePath, "saltss", 2048);
28    }
29}

效果如图所示

3. 创建认证模块

pom.xml如下

1<?xml version="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    <parent>
6        <artifactId>springboot_security_jwt_rsa_parent</artifactId>
7        <groupId>com.example</groupId>
8        <version>0.0.1-SNAPSHOT</version>
9    </parent>
10    <modelVersion>4.0.0</modelVersion>
11
12    <groupId>com.example</groupId>
13    <artifactId>server_auth</artifactId>
14    <version>0.0.1-SNAPSHOT</version>
15
16    <dependencies>
17        <dependency>
18            <groupId>org.springframework.boot</groupId>
19            <artifactId>spring-boot-starter-web</artifactId>
20        </dependency>
21        <dependency>
22            <groupId>org.springframework.boot</groupId>
23            <artifactId>spring-boot-starter-security</artifactId>
24        </dependency>
25        <dependency>
26            <groupId>org.springframework.boot</groupId>
27            <artifactId>spring-boot-starter-test</artifactId>
28        </dependency>
29        <dependency>
30            <groupId>com.example</groupId>
31            <artifactId>common</artifactId>
32            <version>0.0.1-SNAPSHOT</version>
33        </dependency>
34        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
35        <dependency>
36            <groupId>mysql</groupId>
37            <artifactId>mysql-connector-java</artifactId>
38            <version>5.1.48</version>
39        </dependency>
40        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
41        <dependency>
42            <groupId>org.mybatis.spring.boot</groupId>
43            <artifactId>mybatis-spring-boot-starter</artifactId>
44            <version>2.1.1</version>
45        </dependency>
46        <dependency>
47            <groupId>org.projectlombok</groupId>
48            <artifactId>lombok</artifactId>
49            <version>1.18.10</version>
50            <scope>provided</scope>
51        </dependency>
52    </dependencies>
53</project>

1. application.yml

1server:
2  port: 8081
3spring:
4  datasource:
5    driver-class-name: com.mysql.jdbc.Driver
6    password: root
7    username: root
8    url: jdbc:mysql:///test
9mybatis:
10  type-aliases-package: com.example.domain
11  configuration:
12    map-underscore-to-camel-case: true
13logging:
14  level:
15    com.example: debug
16rsa:
17  key:
18    privateKeyFile: D:\test\auth\id_rsa_private_pkcs
19    publicKeyFile: D:\test\auth\id_rsa_public.pub

2. 提供解析公钥和私钥的配置类

1@ConfigurationProperties(prefix = "rsa.key")
2@Data
3public class RsaKeyProperties {
4    private String publicKeyFile;
5    private String privateKeyFile;
6
7    private PublicKey publicKey;
8    private PrivateKey privateKey;
9
10    @PostConstruct
11    public void createRsaKey() throws Exception {
12        publicKey = RsaUtils.getPublicKey(publicKeyFile);
13        privateKey = RsaUtils.getPrivateKey(privateKeyFile);
14    }
15}
16

3. 创建认证服务启动类

1@SpringBootApplication
2@MapperScan("com.example.mapper")
3@EnableConfigurationProperties(RsaKeyProperties.class)
4public class AuthServerApplication {
5    public static void main(String[] args) {
6        SpringApplication.run(AuthServerApplication.class, args);
7    }
8}

4. 编写认证过滤器

1public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {
2    private AuthenticationManager authenticationManager;
3    private RsaKeyProperties prop;
4
5    public JwtLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
6        this.authenticationManager = authenticationManager;
7        this.prop = prop;
8    }
9
10    //重写springsecurity获取用户名和密码操作
11    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
12        try {
13            //从输入流中获取用户名和密码，而不是表单
14            SysUser sysUser = new ObjectMapper().readValue(request.getInputStream(), SysUser.class);
15            UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword());
16            return authenticationManager.authenticate(authRequest);
17        } catch (Exception e) {
18            try {
19                //处理失败请求
20                response.setContentType("application/json;charset=utf-8");
21                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
22                PrintWriter out = response.getWriter();
23                Map map = new HashMap<>();
24                map.put("code", HttpServletResponse.SC_UNAUTHORIZED);
25                map.put("msg", "用户名或者密码错误");
26                out.write(new ObjectMapper().writeValueAsString(map));
27                out.flush();
28                out.close();
29            } catch (Exception e1) {
30                e1.printStackTrace();
31            }
32
33            throw new RuntimeException(e);
34        }
35    }
36
37    //重写用户名密码授权成功操作----返回token凭证
38    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
39        //从authResult获取认证成功的用户信息
40        SysUser resultUser = new SysUser();
41        SysUser authUser = (SysUser) authResult.getPrincipal();
42        resultUser.setUsername(authUser.getUsername());
43        resultUser.setId(authUser.getId());
44        resultUser.setStatus(authUser.getStatus());
45        resultUser.setRoles((List<SysRole>) authResult.getAuthorities());
46        String token = JwtUtils.generateTokenExpireInMinutes(resultUser, prop.getPrivateKey(), 3600*24);
47        //将token写入header
48        response.addHeader("Authorization", "Bearer " + token);
49        try {
50            //登录成功時，返回json格式进行提示
51            response.setContentType("application/json;charset=utf-8");
52            response.setStatus(HttpServletResponse.SC_OK);
53            PrintWriter out = response.getWriter();
54            Map<String, Object> map = new HashMap<String, Object>();
55            map.put("code", HttpServletResponse.SC_OK);
56            map.put("message", "登陆成功！");
57            out.write(new ObjectMapper().writeValueAsString(map));
58            out.flush();
59            out.close();
60        } catch (Exception e1) {
61            e1.printStackTrace();
62        }
63    }
64}
65

5. 编写检验token过滤器

1public class JwtVerifyFilter extends BasicAuthenticationFilter {
2    private RsaKeyProperties prop;
3
4    public JwtVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
5        super(authenticationManager);
6        this.prop = prop;
7    }
8
9    /**
10     * 过滤请求
11     */
12    @Override
13    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
14                                    FilterChain chain) {
15        try {
16            //请求体的头中是否包含Authorization
17            String header = request.getHeader("Authorization");
18            //Authorization中是否包含Bearer，不包含直接返回
19            if (header == null || !header.startsWith("Bearer ")) {
20                chain.doFilter(request, response);
21                responseJson(response);
22                return;
23            }
24            //获取权限失败，会抛出异常
25            UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
26            //获取后，将Authentication写入SecurityContextHolder中供后序使用
27            SecurityContextHolder.getContext().setAuthentication(authentication);
28            chain.doFilter(request, response);
29        } catch (Exception e) {
30            responseJson(response);
31            e.printStackTrace();
32        }
33    }
34
35    /**
36     * 未登录提示
37     *
38     * @param response
39     */
40    private void responseJson(HttpServletResponse response) {
41        try {
42            //未登录提示
43            response.setContentType("application/json;charset=utf-8");
44            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
45            PrintWriter out = response.getWriter();
46            Map<String, Object> map = new HashMap<String, Object>();
47            map.put("code", HttpServletResponse.SC_FORBIDDEN);
48            map.put("message", "请登录！");
49            out.write(new ObjectMapper().writeValueAsString(map));
50            out.flush();
51            out.close();
52        } catch (Exception e1) {
53            e1.printStackTrace();
54        }
55    }
56
57    /**
58     * 通过token，获取用户信息
59     *
60     * @param request
61     * @return
62     */
63    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
64        String token = request.getHeader("Authorization");
65        if (token != null) {
66            //通过token解析出载荷信息
67            Payload<SysUser> payload = JwtUtils.getInfoFromToken(token.replace("Bearer ", ""),
68                    prop.getPublicKey(), SysUser.class);
69            SysUser user = payload.getUserInfo();
70            //不为null，返回
71            if (user != null) {
72                return new UsernamePasswordAuthenticationToken(user, null, user.getRoles());
73            }
74            return null;
75        }
76        return null;
77    }
78}

6. 编写SpringSecurity配置类

1@Configuration
2@EnableWebSecurity
3@EnableGlobalMethodSecurity(securedEnabled = true)
4public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
5    @Autowired
6    private UserService userService;
7    @Autowired
8    private BCryptPasswordEncoder bCryptPasswordEncoder;
9    @Autowired
10    private RsaKeyProperties prop;
11
12    @Bean
13    public BCryptPasswordEncoder myPasswordEncoder() {
14        return new BCryptPasswordEncoder();
15    }
16
17    @Override
18    protected void configure(HttpSecurity http) throws Exception {
19        http
20                //关闭跨站请求防护
21                .cors()
22                .and()
23                .csrf()
24                .disable()
25                //允许不登陆就可以访问的方法，多个用逗号分隔
26                .authorizeRequests()
27                .antMatchers("/product").hasAnyRole("ROLE_USER")
28                //其他的需要授权后访问
29                .anyRequest().authenticated()
30                .and()
31                //增加自定义认证过滤器
32                .addFilter(new JwtLoginFilter(authenticationManager(), prop))
33                //增加自定义验证认证过滤器
34                .addFilter(new JwtVerifyFilter(authenticationManager(), prop))
35                // 前后端分离是无状态的，不用session了，直接禁用。
36                .sessionManagement()
37                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
38    }
39
40    @Override
41    public void configure(AuthenticationManagerBuilder auth) throws Exception {
42        //UserDetailsService类
43        auth.userDetailsService(userService)
44                //加密策略
45                .passwordEncoder(bCryptPasswordEncoder);
46    }
47}

7. 启动测试认证服务

认证成功会返回token

4. 资源模块

资源服务可以有很多个，这里只拿产品服务为例，记住，资源服务中只能通过公钥验证认证。不能签发token！

pom.xml如下

1<?xml version="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    <parent>
6        <artifactId>springboot_security_jwt_rsa_parent</artifactId>
7        <groupId>com.example</groupId>
8        <version>0.0.1-SNAPSHOT</version>
9    </parent>
10    <modelVersion>4.0.0</modelVersion>
11
12    <groupId>com.example</groupId>
13    <artifactId>server_resource</artifactId>
14    <version>0.0.1-SNAPSHOT</version>
15
16    <dependencies>
17        <dependency>
18            <groupId>org.springframework.boot</groupId>
19            <artifactId>spring-boot-starter-web</artifactId>
20        </dependency>
21        <dependency>
22            <groupId>org.springframework.boot</groupId>
23            <artifactId>spring-boot-starter-security</artifactId>
24        </dependency>
25        <dependency>
26            <groupId>com.example</groupId>
27            <artifactId>common</artifactId>
28            <version>0.0.1-SNAPSHOT</version>
29        </dependency>
30        <dependency>
31            <groupId>mysql</groupId>
32            <artifactId>mysql-connector-java</artifactId>
33            <version>5.1.47</version>
34        </dependency>
35        <dependency>
36            <groupId>org.mybatis.spring.boot</groupId>
37            <artifactId>mybatis-spring-boot-starter</artifactId>
38            <version>2.1.0</version>
39        </dependency>
40        <dependency>
41            <groupId>org.projectlombok</groupId>
42            <artifactId>lombok</artifactId>
43            <version>1.18.10</version>
44            <scope>provided</scope>
45        </dependency>
46    </dependencies>
47</project>

1. 配置application.yml

1server:
2  port: 8082
3spring:
4  datasource:
5    driver-class-name: com.mysql.jdbc.Driver
6    password: root
7    username: root
8    url: jdbc:mysql:///test
9mybatis:
10  type-aliases-package: com.example.domain
11  configuration:
12    map-underscore-to-camel-case: true
13logging:
14  level:
15    com.example: debug
16rsa:
17  key:
18    publicKeyFile: D:\test\auth\id_rsa_public.pub

2. 编写读取公钥的配置类

1@ConfigurationProperties(prefix = "rsa.key")
2@Data
3public class RsaKeyProperties {
4    private String publicKeyFile;
5
6    private PublicKey publicKey;
7
8    @PostConstruct
9    public void createRsaKey() throws Exception {
10        publicKey = RsaUtils.getPublicKey(publicKeyFile);
11    }
12}

3. 编写启动类

1@SpringBootApplication
2@MapperScan("com.example.mapper")
3@EnableConfigurationProperties(RsaKeyProperties.class)
4public class ProductApplication {
5    public static void main(String[] args) {
6        SpringApplication.run(ProductApplication.class, args);
7    }
8}

4. 编写检验token过滤器

1public class JwtVerifyFilter extends BasicAuthenticationFilter {
2    private RsaKeyProperties prop;
3
4    public JwtVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
5        super(authenticationManager);
6        this.prop = prop;
7    }
8
9    /**
10     * 过滤请求
11     */
12    @Override
13    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
14                                    FilterChain chain) {
15        try {
16            //请求体的头中是否包含Authorization
17            String header = request.getHeader("Authorization");
18            //Authorization中是否包含Bearer，不包含直接返回
19            if (header == null || !header.startsWith("Bearer ")) {
20                chain.doFilter(request, response);
21                responseJson(response);
22                return;
23            }
24            //获取权限失败，会抛出异常
25            UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
26            //获取后，将Authentication写入SecurityContextHolder中供后序使用
27            SecurityContextHolder.getContext().setAuthentication(authentication);
28            chain.doFilter(request, response);
29        } catch (Exception e) {
30            responseJson(response);
31            e.printStackTrace();
32        }
33    }
34
35    /**
36     * 未登录提示
37     *
38     * @param response
39     */
40    private void responseJson(HttpServletResponse response) {
41        try {
42            //未登录提示
43            response.setContentType("application/json;charset=utf-8");
44            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
45            PrintWriter out = response.getWriter();
46            Map<String, Object> map = new HashMap<String, Object>();
47            map.put("code", HttpServletResponse.SC_FORBIDDEN);
48            map.put("message", "请登录！");
49            out.write(new ObjectMapper().writeValueAsString(map));
50            out.flush();
51            out.close();
52        } catch (Exception e1) {
53            e1.printStackTrace();
54        }
55    }
56
57    /**
58     * 通过token，获取用户信息
59     *
60     * @param request
61     * @return
62     */
63    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
64        String token = request.getHeader("Authorization");
65        if (token != null) {
66            //通过token解析出载荷信息
67            Payload<SysUser> payload = JwtUtils.getInfoFromToken(token.replace("Bearer ", ""),
68                    prop.getPublicKey(), SysUser.class);
69            SysUser user = payload.getUserInfo();
70            //不为null，返回
71            if (user != null) {
72                return new UsernamePasswordAuthenticationToken(user, null, user.getRoles());
73            }
74            return null;
75        }
76        return null;
77    }
78}

5. 编写SpringSecurity配置类

1@Configuration
2@EnableWebSecurity
3@EnableGlobalMethodSecurity(securedEnabled = true)
4public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
5    @Autowired
6    private UserService userService;
7    @Autowired
8    private BCryptPasswordEncoder bCryptPasswordEncoder;
9    @Autowired
10    private RsaKeyProperties prop;
11
12    @Bean
13    public BCryptPasswordEncoder myPasswordEncoder() {
14        return new BCryptPasswordEncoder();
15    }
16
17    @Override
18    protected void configure(HttpSecurity http) throws Exception {
19        http
20                //关闭跨站请求防护
21                .cors()
22                .and()
23                .csrf()
24                .disable()
25                //允许不登陆就可以访问的方法，多个用逗号分隔
26                .authorizeRequests()
27                .antMatchers("/product").hasAnyRole("ROLE_USER")
28                //其他的需要授权后访问
29                .anyRequest().authenticated()
30                .and()
31                //增加自定义验证认证过滤器
32                .addFilter(new JwtVerifyFilter(authenticationManager(), prop))
33                // 前后端分离是无状态的，不用session了，直接禁用。
34                .sessionManagement()
35                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
36    }
37
38    @Override
39    public void configure(AuthenticationManagerBuilder auth) throws Exception {
40        //UserDetailsService类
41        auth.userDetailsService(userService)
42                //加密策略
43                .passwordEncoder(bCryptPasswordEncoder);
44    }
45}