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

Spring Security_2024 最新springsecurity 搭建

作者：Cpp五条 | 2024-05-01 09:41:47

赞

踩

2024 最新springsecurity 搭建

0.简介
        

1. 介绍
springsecurity是安全框架，准确来说是安全管理框架。相比与另外一个安全框架Shiro，springsecurity提供了更丰富的功能，社区资源也比Shiro丰富
springsecurity框架用于Web应用的需要进行认证和授权
认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权：经过认证后判断当前用户是否有权限进行某个操作。认证和授权也是SpringSecurity作为安全框架的核心功能
认证和授权也是SpringSecurity作为安全框架的核心功能

该笔记对标的视频是 BV1mm4y1X7Hc，拿着这个BV号在b站搜，就能搜到课程视频
 

1.快速入门


        第一步 修改pom.xml文件为如下

  1.     <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.5.0</version>
  5.     </parent>
  6.     <dependencies>
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-web</artifactId>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.projectlombok</groupId>
  13.             <artifactId>lombok</artifactId>
  14.             <optional>true</optional>
  15.         </dependency>
  16.     </dependencies>

第二步: 在idea修改maven的相关设置，然后刷新maven
        

第三步: 在 src/main/java 目录新建 com.huanf.SpringsecurityDome01Application类，作为项目的引导类，也叫启动类。在SpringsecurityDome01Application类写入如下

  1. package com.huanf;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. @SpringBootApplication
  7. public class SpringsecurityDome01Application {
  8.  
  9.     public static void main(String[] args) {
  10.  
  11.         SpringApplication.run(SpringsecurityDome01Application.class, args);
  12.     }
  13.  
  14. }

第四步: 在 src/main/java/com.huanf 目录新建controller.HelloController类，写入如下

  1. package com.huanf.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7. /**
  8.  * @Author：豆浆
  9.  * @name :HelloController
  10.  * @Date：2024/4/16 11:15
  11.  */
  12. @RestController
  13. public class HelloController {
  14.     @RequestMapping("/hello")
  15.     public String hello(){
  16.         return "hello";
  17.     }
  18.  
  19. }

第五步: 运行SpringsecurityDome01Application引导类，然后浏览器访问如下，测试SpringBoot工程有没有搭建成功

http://localhost:8080/hello

2. Boot整合Security


第一步: 在pom.xml添加如下

  1. <!--SpringSecurity启动器-->
  2. <dependency>
  3. 	<groupId>org.springframework.boot</groupId>
  4. 	<artifactId>spring-boot-starter-security</artifactId>
  5. </dependency>


引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登录页面，默认用户名是user,密码会输出在控制台。必须登录之后才能对接口进行访问
第二步: 重新运行SpringsecurityDome01Application引导类，浏览器访问如下


访问时会自动被下面的链接拦截
第三步: 在idea控制台查看登录的密码，用户名是user


登录之后，就会自动跳到并访问下面的地址
第四步: 默认的退出登录接口如下


3.认证


springsecurity的权限管理，是先授权后认证，所以我们先学习认证这一部分
流程图如下，注意下图的jwt指的是 json web token，jwt是登录校验的时候用的技术，可以根据指定的算法进行信息的加密和解密


1. spring security原理


Spring Security的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。例如快速入门案例里面使用到的三种过滤器，如下图
监听器 -> 过滤器链 -> dispatcherservlet(前置拦截器 -> mapperHandle -> 后置拦截器 -> 最终拦截器)


一、UsernamePasswordAuthenticationFilter: 负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责
二、ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException
三、FilterSecurityInterceptor：负责权限校验的过滤器


注意上图，橙色部分表示认证，黄色部分表示异常处理，红色部分表示授权
如何查看security提供的过滤器有哪几个，或者叫哪几种，如下


2. 认证流程


我们来详细学一下上面 '1. springsecurity原理' 的橙色部分，也就是认证那部分的知识
一、Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息
二、AuthenticationManager接口：定义了认证Authentication的方法
三、UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法
四、UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中

 


3. 自定义security的思路


        在 '快速入门' 中，我们在Boot项目里面引入了Security依赖，实现了当我们访问某个业务接口时，会被Security的login接口拦截，但是如果我们不想使用Security默认的登录页面，那么怎么办呢，还有，springsecurity的校验，我们希望是根据数据库来做校验，那么怎么实现呢。我们需要实现如下
【登录-未实现】
①、自定义登录接口。用于调用ProviderManager的方法进行认证 如果认证通过生成jwt，然后把用户信息存入redis中
②、自定义UserDetailsService接口的实现类。在这个实现类中去查询数据库
【校验-未实现】
①、定义Jwt认证过滤器。用于获取token，然后解析token获取其中的userid，还需要从redis中获取用户信息，然后存入SecurityContextHolder


4. 自定义security的搭建


注意: 这次搭建的项目，会在下面所有的笔记中都学习，不管是 '认证' 还是 '授权'，反正下面谈到什么目录、什么类，说的都是这个项目
第四步: 打开idea，新建maven项目


第五步: 修改pom.xml文件为如下

  1.     <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.5.0</version>
  5.     </parent>
  6.  
  7.     <dependencies>
  8.  
  9.         <!--还要引入这个，不然后面javax.servlet依赖找不到-->
  10.         <dependency>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-web</artifactId>
  13.         </dependency>
  14.  
  15.         <!--springboot整合springsecurity-->
  16.         <dependency>
  17.             <groupId>org.springframework.boot</groupId>
  18.             <artifactId>spring-boot-starter-security</artifactId>
  19.         </dependency>
  20.  
  21.         <!--redis依赖-->
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-data-redis</artifactId>
  25.         </dependency>
  26.  
  27.         <!--fastjson依赖-->
  28.         <dependency>
  29.             <groupId>com.alibaba</groupId>
  30.             <artifactId>fastjson</artifactId>
  31.             <version>1.2.33</version>
  32.         </dependency>
  33.  
  34.         <!--jwt依赖-->
  35.         <dependency>
  36.             <groupId>io.jsonwebtoken</groupId>
  37.             <artifactId>jjwt</artifactId>
  38.             <version>0.9.0</version>
  39.         </dependency>
  40.         
  41.         <!--引入Lombok依赖，方便实体类开发-->
  42.         <dependency>
  43.             <groupId>org.projectlombok</groupId>
  44.             <artifactId>lombok</artifactId>
  45.         </dependency>
  46.     </dependencies>


第七步: 在 src/main/java 目录新建 com.huanf.TokenApplication 类，写入如下

  1. package com.sangeng;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. /**
  7.  * @Author：豆浆
  8.  * @name :TokenApplication
  9.  * @Date：2024/4/16 12:12
  10.  */
  11. @SpringBootApplication
  12. public class TokenApplication {
  13.  
  14.  
  15.     public static void main(String[] args) {
  16.         SpringApplication.run(TokenApplication.class,args);
  17.     }
  18. }


第八步: 在 src/main/java/com.huanf 目录新建 controller.HelloController 类，写入如下

  1. package com.sangeng.controller;
  2.  
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. /**
  7.  * @Author：豆浆
  8.  * @name :HelloController
  9.  * @Date：2024/4/16 12:13
  10.  */
  11. @RestController
  12. public class HelloController {
  13.     @RequestMapping("/hello")
  14.     public String hello(){
  15.         return "hello";
  16.     }
  17. }


5. 自定义security的代码


第一步: 在 src/main/java/com.huanf 目录新建 utils.FastJsonRedisSerializer 类，写入如下

  1. package com.huanf.utils;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.serializer.SerializerFeature;
  5. import com.fasterxml.jackson.databind.JavaType;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import com.fasterxml.jackson.databind.type.TypeFactory;
  8. import org.springframework.data.redis.serializer.RedisSerializer;
  9. import org.springframework.data.redis.serializer.SerializationException;
  10. import com.alibaba.fastjson.parser.ParserConfig;
  11. import org.springframework.util.Assert;
  12. import java.nio.charset.Charset;
  13.  
  14.  
  15. //Redis使用FastJson序列化
  16. public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
  17.  
  18.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  19.  
  20.     private Class<T> clazz;
  21.  
  22.     static
  23.     {
  24.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  25.     }
  26.  
  27.     public FastJsonRedisSerializer(Class<T> clazz)
  28.     {
  29.         super();
  30.         this.clazz = clazz;
  31.     }
  32.  
  33.     @Override
  34.     public byte[] serialize(T t) throws SerializationException
  35.     {
  36.         if (t == null)
  37.         {
  38.             return new byte[0];
  39.         }
  40.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  41.     }
  42.  
  43.     @Override
  44.     public T deserialize(byte[] bytes) throws SerializationException
  45.     {
  46.         if (bytes == null || bytes.length <= 0)
  47.         {
  48.             return null;
  49.         }
  50.         String str = new String(bytes, DEFAULT_CHARSET);
  51.  
  52.         return JSON.parseObject(str, clazz);
  53.     }
  54.  
  55.  
  56.     protected JavaType getJavaType(Class<?> clazz)
  57.     {
  58.         return TypeFactory.defaultInstance().constructType(clazz);
  59.     }
  60. }


第二步: 在 src/main/java/com.huanf 目录新建 config.RedisConfig 类，写入如下

  1. package com.sangeng.config;
  2.  
  3. import com.sangeng.utils.FastJsonRedisSerializer;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9.  
  10.  
  11. @Configuration
  12. public class RedisConfig {
  13.  
  14.     @Bean
  15.     @SuppressWarnings(value = { "unchecked", "rawtypes" })
  16.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  17.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  18.         template.setConnectionFactory(connectionFactory);
  19.  
  20.         FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
  21.  
  22.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
  23.         template.setKeySerializer(new StringRedisSerializer());
  24.         template.setValueSerializer(serializer);
  25.  
  26.         // Hash的key也采用StringRedisSerializer的序列化方式
  27.         template.setHashKeySerializer(new StringRedisSerializer());
  28.         template.setHashValueSerializer(serializer);
  29.  
  30.         template.afterPropertiesSet();
  31.         return template;
  32.     }
  33. }


第三步: 在 src/main/java/com.huanf 目录新建 domain.ResponseResult 类，写入如下

  1. package com.sangeng.domain;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonInclude;
  4.  
  5.  
  6. //响应类
  7. @JsonInclude(JsonInclude.Include.NON_NULL)
  8. public class ResponseResult<T> {
  9.     /**
  10.      * 状态码
  11.      */
  12.     private Integer code;
  13.     /**
  14.      * 提示信息，如果有错误时，前端可以获取该字段进行提示
  15.      */
  16.     private String msg;
  17.     /**
  18.      * 查询到的结果数据，
  19.      */
  20.     private T data;
  21.  
  22.     public ResponseResult(Integer code, String msg) {
  23.         this.code = code;
  24.         this.msg = msg;
  25.     }
  26.  
  27.     public ResponseResult(Integer code, T data) {
  28.         this.code = code;
  29.         this.data = data;
  30.     }
  31.  
  32.     public Integer getCode() {
  33.         return code;
  34.     }
  35.  
  36.     public void setCode(Integer code) {
  37.         this.code = code;
  38.     }
  39.  
  40.     public String getMsg() {
  41.         return msg;
  42.     }
  43.  
  44.     public void setMsg(String msg) {
  45.         this.msg = msg;
  46.     }
  47.  
  48.     public T getData() {
  49.         return data;
  50.     }
  51.  
  52.     public void setData(T data) {
  53.         this.data = data;
  54.     }
  55.  
  56.     public ResponseResult(Integer code, String msg, T data) {
  57.         this.code = code;
  58.         this.msg = msg;
  59.         this.data = data;
  60.     }
  61. }


第四步: 在 utile 目录新建 JwtUtil 类，写入如下

  1. package com.sangeng.utils;
  2.  
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.JwtBuilder;
  5. import io.jsonwebtoken.Jwts;
  6. import io.jsonwebtoken.SignatureAlgorithm;
  7. import javax.crypto.SecretKey;
  8. import javax.crypto.spec.SecretKeySpec;
  9. import java.util.Base64;
  10. import java.util.Date;
  11. import java.util.UUID;
  12.  
  13.  
  14. //JWT工具类
  15. public class JwtUtil {
  16.  
  17.     //有效期为
  18.     public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000  一个小时
  19.     //设置秘钥明文, 注意长度必须大于等于6位
  20.     public static final String JWT_KEY = "huanfqc";
  21.  
  22.     public static String getUUID(){
  23.         String token = UUID.randomUUID().toString().replaceAll("-", "");
  24.         return token;
  25.     }
  26.  
  27.     /**
  28.      * 生成jtw
  29.      * @param subject token中要存放的数据（json格式）
  30.      * @return
  31.      */
  32.     public static String createJWT(String subject) {
  33.         JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
  34.         return builder.compact();
  35.     }
  36.  
  37.     /**
  38.      * 生成jtw
  39.      * @param subject token中要存放的数据（json格式）
  40.      * @param ttlMillis token超时时间
  41.      * @return
  42.      */
  43.     public static String createJWT(String subject, Long ttlMillis) {
  44.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
  45.         return builder.compact();
  46.     }
  47.  
  48.     private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
  49.         SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
  50.         SecretKey secretKey = generalKey();
  51.         long nowMillis = System.currentTimeMillis();
  52.         Date now = new Date(nowMillis);
  53.         if(ttlMillis==null){
  54.             ttlMillis=JwtUtil.JWT_TTL;
  55.         }
  56.         long expMillis = nowMillis + ttlMillis;
  57.         Date expDate = new Date(expMillis);
  58.         return Jwts.builder()
  59.                 .setId(uuid)              //唯一的ID
  60.                 .setSubject(subject)   // 主题  可以是JSON数据
  61.                 .setIssuer("huanf")     // 签发者
  62.                 .setIssuedAt(now)      // 签发时间
  63.                 .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
  64.                 .setExpiration(expDate);
  65.     }
  66.  
  67.     /**
  68.      * 创建token
  69.      * @param id
  70.      * @param subject
  71.      * @param ttlMillis
  72.      * @return
  73.      */
  74.     public static String createJWT(String id, String subject, Long ttlMillis) {
  75.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
  76.         return builder.compact();
  77.     }
  78.  
  79.     public static void main(String[] args) throws Exception {
  80.         String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
  81.         Claims claims = parseJWT(token);
  82.         System.out.println(claims);
  83.     }
  84.  
  85.     /**
  86.      * 生成加密后的秘钥 secretKey
  87.      * @return
  88.      */
  89.     public static SecretKey generalKey() {
  90.         byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
  91.         SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
  92.         return key;
  93.     }
  94.  
  95.     /**
  96.      * 解析
  97.      *
  98.      * @param jwt
  99.      * @return
  100.      * @throws Exception
  101.      */
  102.     public static Claims parseJWT(String jwt) throws Exception {
  103.         SecretKey secretKey = generalKey();
  104.         return Jwts.parser()
  105.                 .setSigningKey(secretKey)
  106.                 .parseClaimsJws(jwt)
  107.                 .getBody();
  108.     }
  109.  
  110. }


第五步: 在 utile 目录新建 RedisCache 类，写入如下

  1. package com.sangeng.utils;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.BoundSetOperations;
  5. import org.springframework.data.redis.core.HashOperations;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.ValueOperations;
  8. import org.springframework.stereotype.Component;
  9. import java.util.*;
  10. import java.util.concurrent.TimeUnit;
  11.  
  12.  
  13. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  14. @Component
  15. //redis工具类
  16. public class RedisCache {
  17.     @Autowired
  18.     public RedisTemplate redisTemplate;
  19.  
  20.     /**
  21.      * 缓存基本的对象，Integer、String、实体类等
  22.      *
  23.      * @param key 缓存的键值
  24.      * @param value 缓存的值
  25.      */
  26.     public <T> void setCacheObject(final String key, final T value)
  27.     {
  28.         redisTemplate.opsForValue().set(key, value);
  29.     }
  30.  
  31.     /**
  32.      * 缓存基本的对象，Integer、String、实体类等
  33.      *
  34.      * @param key 缓存的键值
  35.      * @param value 缓存的值
  36.      * @param timeout 时间
  37.      * @param timeUnit 时间颗粒度
  38.      */
  39.     public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
  40.     {
  41.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  42.     }
  43.  
  44.     /**
  45.      * 设置有效时间
  46.      *
  47.      * @param key Redis键
  48.      * @param timeout 超时时间
  49.      * @return true=设置成功；false=设置失败
  50.      */
  51.     public boolean expire(final String key, final long timeout)
  52.     {
  53.         return expire(key, timeout, TimeUnit.SECONDS);
  54.     }
  55.  
  56.     /**
  57.      * 设置有效时间
  58.      *
  59.      * @param key Redis键
  60.      * @param timeout 超时时间
  61.      * @param unit 时间单位
  62.      * @return true=设置成功；false=设置失败
  63.      */
  64.     public boolean expire(final String key, final long timeout, final TimeUnit unit)
  65.     {
  66.         return redisTemplate.expire(key, timeout, unit);
  67.     }
  68.  
  69.     /**
  70.      * 获得缓存的基本对象。
  71.      *
  72.      * @param key 缓存键值
  73.      * @return 缓存键值对应的数据
  74.      */
  75.     public <T> T getCacheObject(final String key)
  76.     {
  77.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  78.         return operation.get(key);
  79.     }
  80.  
  81.     /**
  82.      * 删除单个对象
  83.      *
  84.      * @param key
  85.      */
  86.     public boolean deleteObject(final String key)
  87.     {
  88.         return redisTemplate.delete(key);
  89.     }
  90.  
  91.     /**
  92.      * 删除集合对象
  93.      *
  94.      * @param collection 多个对象
  95.      * @return
  96.      */
  97.     public long deleteObject(final Collection collection)
  98.     {
  99.         return redisTemplate.delete(collection);
  100.     }
  101.  
  102.     /**
  103.      * 缓存List数据
  104.      *
  105.      * @param key 缓存的键值
  106.      * @param dataList 待缓存的List数据
  107.      * @return 缓存的对象
  108.      */
  109.     public <T> long setCacheList(final String key, final List<T> dataList)
  110.     {
  111.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  112.         return count == null ? 0 : count;
  113.     }
  114.  
  115.     /**
  116.      * 获得缓存的list对象
  117.      *
  118.      * @param key 缓存的键值
  119.      * @return 缓存键值对应的数据
  120.      */
  121.     public <T> List<T> getCacheList(final String key)
  122.     {
  123.         return redisTemplate.opsForList().range(key, 0, -1);
  124.     }
  125.  
  126.     /**
  127.      * 缓存Set
  128.      *
  129.      * @param key 缓存键值
  130.      * @param dataSet 缓存的数据
  131.      * @return 缓存数据的对象
  132.      */
  133.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
  134.     {
  135.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  136.         Iterator<T> it = dataSet.iterator();
  137.         while (it.hasNext())
  138.         {
  139.             setOperation.add(it.next());
  140.         }
  141.         return setOperation;
  142.     }
  143.  
  144.     /**
  145.      * 获得缓存的set
  146.      *
  147.      * @param key
  148.      * @return
  149.      */
  150.     public <T> Set<T> getCacheSet(final String key)
  151.     {
  152.         return redisTemplate.opsForSet().members(key);
  153.     }
  154.  
  155.     /**
  156.      * 缓存Map
  157.      *
  158.      * @param key
  159.      * @param dataMap
  160.      */
  161.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
  162.     {
  163.         if (dataMap != null) {
  164.             redisTemplate.opsForHash().putAll(key, dataMap);
  165.         }
  166.     }
  167.  
  168.     /**
  169.      * 获得缓存的Map
  170.      *
  171.      * @param key
  172.      * @return
  173.      */
  174.     public <T> Map<String, T> getCacheMap(final String key)
  175.     {
  176.         return redisTemplate.opsForHash().entries(key);
  177.     }
  178.  
  179.     /**
  180.      * 往Hash中存入数据
  181.      *
  182.      * @param key Redis键
  183.      * @param hKey Hash键
  184.      * @param value 值
  185.      */
  186.     public <T> void setCacheMapValue(final String key, final String hKey, final T value)
  187.     {
  188.         redisTemplate.opsForHash().put(key, hKey, value);
  189.     }
  190.  
  191.     /**
  192.      * 获取Hash中的数据
  193.      *
  194.      * @param key Redis键
  195.      * @param hKey Hash键
  196.      * @return Hash中的对象
  197.      */
  198.     public <T> T getCacheMapValue(final String key, final String hKey)
  199.     {
  200.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  201.         return opsForHash.get(key, hKey);
  202.     }
  203.  
  204.     /**
  205.      * 删除Hash中的数据
  206.      *
  207.      * @param key
  208.      * @param hkey
  209.      */
  210.     public void delCacheMapValue(final String key, final String hkey)
  211.     {
  212.         HashOperations hashOperations = redisTemplate.opsForHash();
  213.         hashOperations.delete(key, hkey);
  214.     }
  215.  
  216.     /**
  217.      * 获取多个Hash中的数据
  218.      *
  219.      * @param key Redis键
  220.      * @param hKeys Hash键集合
  221.      * @return Hash对象集合
  222.      */
  223.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
  224.     {
  225.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  226.     }
  227.  
  228.     /**
  229.      * 获得缓存的基本对象列表
  230.      *
  231.      * @param pattern 字符串前缀
  232.      * @return 对象列表
  233.      */
  234.     public Collection<String> keys(final String pattern)
  235.     {
  236.         return redisTemplate.keys(pattern);
  237.     }
  238. }


第六步: 在 utile 目录新建 WebUtils 类，写入如下

  1. package com.sangeng.utils;
  2.  
  3. import javax.servlet.http.HttpServletResponse;
  4. import java.io.IOException;
  5.  
  6.  
  7. public class WebUtils {
  8.     /**
  9.      * 将字符串渲染到客户端
  10.      *
  11.      * @param response 渲染对象
  12.      * @param string 待渲染的字符串
  13.      * @return null
  14.      */
  15.     public static String renderString(HttpServletResponse response, String string) {
  16.         try
  17.         {
  18.             response.setStatus(200);
  19.             response.setContentType("application/json");
  20.             response.setCharacterEncoding("utf-8");
  21.             response.getWriter().print(string);
  22.         }
  23.         catch (IOException e)
  24.         {
  25.             e.printStackTrace();
  26.         }
  27.         return null;
  28.     }
  29. }


第七步: 在 domain目录新建 User类，写入如下

  1. package com.sangeng.domain;
  2.  
  3. import com.baomidou.mybatisplus.annotation.TableId;
  4. import com.baomidou.mybatisplus.annotation.TableName;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  8. import java.io.Serializable;
  9. import java.util.Date;
  10.  
  11.  
  12. //用户表(User)实体类
  13. @Data
  14. @AllArgsConstructor
  15. @NoArgsConstructor
  16. @TableName("sys_user")
  17. public class User implements Serializable {
  18.     private static final long serialVersionUID = -40356785423868312L;
  19.  
  20.     /**
  21.      * 主键
  22.      */
  23.     @TableId
  24.     private Long id;
  25.     /**
  26.      * 用户名
  27.      */
  28.     private String userName;
  29.     /**
  30.      * 昵称
  31.      */
  32.     private String nickName;
  33.     /**
  34.      * 密码
  35.      */
  36.     private String password;
  37.     /**
  38.      * 账号状态（0正常 1停用）
  39.      */
  40.     private String status;
  41.     /**
  42.      * 邮箱
  43.      */
  44.     private String email;
  45.     /**
  46.      * 手机号
  47.      */
  48.     private String phonenumber;
  49.     /**
  50.      * 用户性别（0男，1女，2未知）
  51.      */
  52.     private String sex;
  53.     /**
  54.      * 头像
  55.      */
  56.     private String avatar;
  57.     /**
  58.      * 用户类型（0管理员，1普通用户）
  59.      */
  60.     private String userType;
  61.     /**
  62.      * 创建人的用户id
  63.      */
  64.     private Long createBy;
  65.     /**
  66.      * 创建时间
  67.      */
  68.     private Date createTime;
  69.     /**
  70.      * 更新人
  71.      */
  72.     private Long updateBy;
  73.     /**
  74.      * 更新时间
  75.      */
  76.     private Date updateTime;
  77.     /**
  78.      * 删除标志（0代表未删除，1代表已删除）
  79.      */
  80.     private Integer delFlag;
  81. }

上面的代码总体如下图所示


6. 自定义security的数据库

第一步: 数据库校验用户。从之前的分析我们可以知道，我们自定义了一个UserDetailsService，让SpringSecurity使用我们的UserDetailsService。我们自己的UserDetailsService可以从数据库中查询用户名和密码。我们先创建一个用户表， 建表语句如下：
注意: 要想让用户的密码是明文存储，需要在密码前加{noop}，作用是例如等下在浏览器登陆的时候就可以用huanf作为用户名，112233作为密码来登陆了

  1. create database if not exists huanf_security;
  2. use huanf_security;
  3.  
  4. CREATE TABLE `sys_user` (
  5.   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  6.   `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  7.   `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  8.   `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  9.   `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
  10.   `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
  11.   `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
  12.   `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
  13.   `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
  14.   `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
  15.   `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
  16.   `create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
  17.   `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
  18.   `update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
  19.   `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
  20.   PRIMARY KEY (`id`)
  21. ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
  22.  
  23. insert into sys_user values (1,'admin','管理员','{noop}123456','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);
  24. insert into sys_user values (2,'huanf','豆浆','{noop}112233','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'1',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);


第二步: 在pom.xml添加如下

  1. <!--引入MybatisPuls依赖-->
  2. <dependency>
  3. 	<groupId>com.baomidou</groupId>
  4. 	<artifactId>mybatis-plus-boot-starter</artifactId>
  5. 	<version>3.4.3</version>
  6. </dependency>
  7.  
  8. <!--引入mysql驱动的依赖-->
  9. <dependency>
  10. 	<groupId>mysql</groupId>
  11. 	<artifactId>mysql-connector-java</artifactId>
  12. </dependency>


第三步: 在 src/main/resources 目录新建File，文件名为application.yml，写入如下

  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://localhost:3306/huanf_security?characterEncoding=utf-8&serverTimezone=UTC
  4.     username: root
  5.     password: 228675
  6.     driver-class-name: com.mysql.cj.jdbc.Driver


第四步: 在 src/main/java/com.huanf 目录新建 mapper.UserMapper 接口，写入如下

  1. package com.huanf.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.huanf.domain.User;
  5.  
  6.  
  7. @Service
  8. public interface UserMapper extends BaseMapper<User> {
  9. }


第五步: 在TokenApplication引导类添加如下

@MapperScan("com.huanf.mapper")


第六步: 在pom.xml添加如下

  1. <!--引入Junit，用于测试-->
  2. <dependency>
  3. 	<groupId>org.springframework.boot</groupId>
  4. 	<artifactId>spring-boot-starter-test</artifactId>
  5. </dependency>


第七步: 在 src/test/java 目录新建 com.huanf.MapperTest类，写入如下。作用是测试mybatis-plus是否正常

  1. package com.sangeng;
  2.  
  3. import com.sangeng.domain.User;
  4. import com.sangeng.mapper.UserMapper;
  5. import org.junit.jupiter.api.Test;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import java.util.List;
  9.  
  10.  
  11. /**
  12.  * @Author：豆浆
  13.  * @name :MapperTest
  14.  * @Date：2024/4/23 15:59
  15.  */
  16.  
  17.  
  18.  
  19.  
  20. @SpringBootTest
  21. public class MapperTest {
  22.  
  23.     @Autowired
  24.     private UserMapper userMapper;
  25.  
  26.     @Test
  27.     public void testUserMapper(){
  28.         //查询所有用户
  29.         List<User> users = userMapper.selectList(null);
  30.         System.out.println(users);
  31.     }
  32.  
  33. }

第八步: 运行MapperTest类的testUserMapper方法，看是否能查到数据库的所有用户。到此，可以确定数据库是没问题的，环境到此就准备好了


7. 自定义security的认证实现


上面我们已经把准备工作做好了，包括搭建、代码、数据库。接下来我们会实现让security在认证的时候，根据我们数据库的用户和密码进行认证，也就是被security拦截业务接口，出现登录页面之后，我们需要通过输入数据库里的用户和密码来登录，而不是使用security默认的用户和密码进行登录
思路: 只需要新建一个实现类，在这个实现类里面实现Security官方的UserDetailsService接口，然后重写里面的loadUserByUsername方法
注意: 重写好loadUserByUsername方法之后，我们需要把拿到 '数据库与用户输入的数据' 进行比对的结果，也就是user对象这个结果封装成能被 'Security官方的UserDetailsService接口' 接收的类型，例如可以封装成我们下面写的LoginUser类型。然后才能伪装好数据，给Security官方的认证机制去对比user对象与数据库的结果是否匹配。Security官方的认证机制会拿LoginUser类的方法数据(数据库拿，不再用默认的)，跟我们封装过去的user对象进行匹配，要使匹配一致，就证明认证通过，也就是用户在浏览器页面输入的用户名和密码能被Security认证通过，就不再拦截该用户去访问我们的业务接口
第一步: 在domain目录新建LoginUser类，作为UserDetails接口(Security官方提供的接口)的实现类

  1. package com.huanf.domain;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import org.springframework.security.core.GrantedAuthority;
  7. import org.springframework.security.core.userdetails.UserDetails;
  8.  
  9. import java.util.Collection;
  10.  
  11.  
  12. @Data //get和set方法
  13. @NoArgsConstructor //无参构造
  14. @AllArgsConstructor  //带参构造
  15. //实现UserDetails接口之后，要重写UserDetails接口里面的7个方法
  16. public class LoginUser implements UserDetails {
  17.     
  18.     private User xxuser;
  19.     
  20.     @Override
  21.     //用于返回权限信息。现在我们正在学'认证'，'权限'后面才学。所以返回null即可
  22.     public Collection<? extends GrantedAuthority> getAuthorities() {
  23.         return null;
  24.     }
  25.  
  26.     @Override
  27.     //用于获取用户密码。由于使用的实体类是User，所以获取的是数据库的用户密码
  28.     public String getPassword() {
  29.         return xxuser.getPassword();
  30.     }
  31.  
  32.     @Override
  33.     //用于获取用户名。由于使用的实体类是User，所以获取的是数据库的用户名
  34.     public String getUsername() {
  35.         return xxuser.getUserName();
  36.     }
  37.  
  38.     @Override
  39.     //判断登录状态是否过期。把这个改成true，表示永不过期
  40.     public boolean isAccountNonExpired() {
  41.         return true;
  42.     }
  43.  
  44.     @Override
  45.     //判断账号是否被锁定。把这个改成true，表示未锁定，不然登录的时候，不让你登录
  46.     public boolean isAccountNonLocked() {
  47.         return true;
  48.     }
  49.  
  50.     @Override
  51.     //判断登录凭证是否过期。把这个改成true，表示永不过期
  52.     public boolean isCredentialsNonExpired() {
  53.         return true;
  54.     }
  55.  
  56.     @Override
  57.     //判断用户是否可用。把这个改成true，表示可用状态
  58.     public boolean isEnabled() {
  59.         return true;
  60.     }
  61. }


第二步: 在 src/main/java/com.huanf 目录新建 service.impl.MyUserDetailServiceImpl 类，写入如下

  1. package com.huanf.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.huanf.domain.LoginUser;
  5. import com.huanf.domain.User;
  6. import com.huanf.mapper.UserMapper;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.security.core.userdetails.UserDetails;
  9. import org.springframework.security.core.userdetails.UserDetailsService;
  10. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  11. import org.springframework.stereotype.Service;
  12.  
  13. import java.util.Objects;
  14.  
  15.  
  16. @Service
  17. public class MyUserDetailServiceImpl implements UserDetailsService {
  18.  
  19.     @Autowired
  20.     private UserMapper userMapper;
  21.  
  22.     @Override
  23.     //UserDetails是Security官方提供的接口
  24.     public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
  25.  
  26.         //查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
  27.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  28.         //eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
  29.         queryWrapper.eq(User::getUserName,xxusername);
  30.         User user = userMapper.selectOne(queryWrapper);
  31.         //如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
  32.         if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
  33.             throw new RuntimeException("用户名或者密码错误");
  34.         }
  35.  
  36.         //把查询到的user结果，封装成UserDetails类型，然后返回。
  37.         //但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
  38.         return new LoginUser(user);
  39.     }
  40. }

第三步: 测试。运行TokenApplication引导类，浏览器输入如下，然后我们输入一下登录的用户名和密码，看是不是根据数据库来进行认证

http://localhost:8080/hello


8. 密码加密校验问题

上面我们实现了自定义Security的认证机制，让Security根据数据库的数据，来认证用户输入的数据是否正确。但是当时存在一个问题，就是我们在数据库存入用户表的时候，插入的huanf用户的密码是 {noop}112233，为什么用112233不行呢
原因: SpringSecurity默认使用的PasswordEncoder要求数据库中的密码格式为：{加密方式}密码。对应的就是{noop}112233，实际表示的是112233
但是我们在数据库直接暴露112233为密码，会造成安全问题，所以我们需要把加密后的1234的密文当作密码，此时用户在浏览器登录时输入1234，我们如何确保用户能够登录进去呢，答案是SpringSecurity默认的密码校验，替换为SpringSecurity为我们提供的BCryptPasswordEncoder
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。
【首先是 '加密'，如何实现，如下】
第一步: 在config目录新建 SecurityConfig 类，写入如下。作用是根据原文，生成一个密文

  1. package com.sangeng.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  6. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  7. import org.springframework.security.crypto.password.PasswordEncoder;
  8.  
  9. /**
  10.  * @Author：豆浆
  11.  * @name :SecurityConfig
  12.  * @Date：2024/4/23 16:50
  13.  */
  14. @Configuration
  15. //实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
  16. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  17.  
  18.     @Bean
  19.     //把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
  20.     //注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
  21.     public PasswordEncoder passwordEncoder(){
  22.         return new BCryptPasswordEncoder();
  23.     }
  24.  
  25. }

第二步: 测试。在MapperTest类，添加如下，然后运行 xxTestBCryptPasswordEncoder 方法

  1. @Test
  2. public void xxTestBCryptPasswordEncoder(){
  3.     
  4. 	//如果不想在下面那行new的话，那么就在该类注入PasswordEncoder，例如如下
  5.     /**
  6.      * @Autowired
  7.      * private PasswordEncoder passwordEncoder;
  8.      */
  9.     BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
  10.         
  11. 	//模拟用户输入的密码
  12. 	String encode1 = passwordEncoder.encode("1234");
  13. 	//再模拟一次用户输入的密码
  14. 	String encode2 = passwordEncoder.encode("1234");
  15. 	//虽然这两次的密码都是一样的，但是加密后是不一样的。每次运行，对同一原文都会有不同的加密结果
  16. 	//原因:会添加随机的盐，加密结果=盐+原文+加密。达到每次加密后的密文都不相同的效果
  17. 	System.out.println(encode1);
  18. 	System.out.println(encode2);
  19. }


【然后是 '校验'，如何实现，如下】
第一步(已做可跳过): 在config目录新建 SecurityConfig 类，写入如下。作用是根据原文，生成一个密文

  1. package com.sangeng.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  6. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  7. import org.springframework.security.crypto.password.PasswordEncoder;
  8.  
  9. /**
  10.  * @Author：豆浆
  11.  * @name :SecurityConfig
  12.  * @Date：2024/4/23 16:50
  13.  */
  14. @Configuration
  15. //实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
  16. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  17.  
  18.     @Bean
  19.     //把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
  20.     //注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
  21.     public PasswordEncoder passwordEncoder(){
  22.         return new BCryptPasswordEncoder();
  23.     }
  24.  
  25. }

第二步: 测试。在MapperTest类，添加如下，然后运行 yyTestBCryptPasswordEncoder 方法

  1. @Test
  2. public void yyTestBCryptPasswordEncoder(){
  3. 	BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
  4.  
  5. 	//模拟用户输入了1234(第一个参数)，然后我们去跟数据库的密文进行比较(第二个参数)
  6. 	boolean result = passwordEncoder.matches("1234", "$2a$10$zOitKu6UNk.b/iPFTtIj2u80sH/dfJI9vFr57qhDGteuXj/Wl8uSy");
  7.  
  8. 	//看一下比对结果
  9. 	System.out.println(result);
  10.  
  11. }

9. jwt工具类实现加密校验


刚刚我们在测试类学习了密码的加密和校验，我们下面会先学如何使用jwt工具类实现密码的加密解密
首先是在pom.xml添加如下(已做可跳过)

  1. <!--jwt依赖-->
  2. <dependency>
  3. 	<groupId>io.jsonwebtoken</groupId>
  4. 	<artifactId>jjwt</artifactId>
  5. 	<version>0.9.0</version>
  6. </dependency>

然后我们在上面的 '认证' 的 '5. 自定义security的代码' 已经创建了大量的类，写了大量的代码，但是还没有使用到，例如jwt的工具类，我们在utils目录创建的JwtUtil类还没有使用过，下面就来使用。如下
【加密】
第一步: 把JwtUtil类的main方法修改为如下，作用是使用createJWT方法生成指定字符串的密文J

  1. public static void main(String[] args) throws Exception {
  2. 	//加密指定字符串，xxjwt是123456加密后的密文
  3. 	String xxjwt = createJWT("123456");
  4. 	System.out.println(xxjwt);
  5. }

第二步: 运行JwtUtil类的main方法


【校验】
第一步: 把JwtUtil类的main方法修改为如下，作用是使用createJWT方法生成指定字符串的密文

  1. public static void main(String[] args) throws Exception {
  2. 	Claims xxclaims = parseJWT("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIyYWMxODhlZjJmMDE0YTU5YjU1YzM4MWNmMjMzNjA1MiIsInN1YiI6IjEyMzQ1NiIsImlzcyI6InNnIiwiaWF0IjoxNjg5MTMwMTE3LCJleHAiOjE2ODkxMzM3MTd9.RxI0dlCrDhYspi4VoIlblk7J9tvOO8Sd5p8bbFrd0mg");
  3. 	//把上面那行的密文解密(校验)为原文
  4. 	String yysubject = xxclaims.getSubject();
  5. 	//输出解密后的原文
  6. 	System.out.println(yysubject);
  7. }

第二步: 运行JwtUtil类的main方法


10. 登录接口的分析

在上面学习的 '认证' 的 '3. 自定义security的思路' 当中，我们有一个功能需求是自定义登录接口，这个功能还没有实现，我们需要实现这个功能，但是，实现这个功能需要使用到jwt，我们刚刚也学习了使用jwt来实现加密校验，那么下面就正式学习如何实现这个登录接口，首先是分析，如下

①我们需要自定义登陆接口，也就是在controller目录新建LoginController类，在controller方法里面去调用service接口，在service接口实现AuthenticationManager去进行用户的认证，注意，我们定义的controller方法要让SpringSecurity对这个接口放行(如果不放行的话，会被SpringSecurity拦截)，让用户访问这个接口的时候不用登录也能访问。
②在service接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器
③认证成功的话要生成一个jwt，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。


11. redis下载安装启动


Redis是一款key-value存储结构的内存级NoSQL数据库，也就是运行在内存上的数据库
●支持多种数据存储格式
●支持持久化
●支持集群
Redis下载(windows版-Redis-x64-5.0.14.msi)

https://github.com/tporadowski/redis/releases

为方便学习，可拿我在用的redis，如下网盘有软件包

安装完成之后，打开安装目录

 


redis的服务端启动命令

redis-server.exe redis.windows.conf


redis的客户端启动命令

redis-cli.exe


具体启动步骤如下。注意: 如果你的redis启动后控制台没蜂窝图案，那么请认真按照下面第二张图的步骤，数字表示命令的先后顺序


12. 登录接口的实现


第一步: 修改数据库的huanf用户的密码，把112233明文修改为对应的密文。密文可以用jwt工具类加密112233看一下，或者直接复制我给出的

UPDATE sys_user SET password = '$2a$10$YPnG.IYUk0mMechaxSibBuKmNeTzvuHdcxkqvoxizsll6WCQG9CHG' WHERE id = 2;


第二步: 在 SecurityConfig 类添加如下

  1. @Bean
  2. @Override
  3. public AuthenticationManager authenticationManagerBean() throws Exception {
  4. 	return super.authenticationManagerBean();
  5. }
  6.  
  7. @Override
  8. protected void configure(HttpSecurity http) throws Exception {
  9. 	http
  10. 		//由于是前后端分离项目，所以要关闭csrf
  11. 		.csrf().disable()
  12. 		//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
  13. 		.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  14. 		.and()
  15. 		//指定让spring security放行登录接口的规则
  16. 		.authorizeRequests()
  17. 		// 对于登录接口 anonymous表示允许匿名访问
  18. 		.antMatchers("/user/login").anonymous()
  19. 		// 除上面外的所有请求全部需要鉴权认证
  20. 		.anyRequest().authenticated();
  21. }


第三步: 在service目录新建 LoginService 接口，写入如下

  1. package com.huanf.service;
  2.  
  3. import com.huanf.domain.ResponseResult;
  4. import com.huanf.domain.User;
  5. import org.springframework.stereotype.Service;
  6.  
  7.  
  8. @Service
  9. public interface LoginService {
  10.     ResponseResult login(User user);
  11. }


第四步: 在service目录新建 impl.LoginServiceImpl 类，写入如下

  1. package com.huanf.service.impl;
  2.  
  3. import com.huanf.domain.LoginUser;
  4. import com.huanf.domain.ResponseResult;
  5. import com.huanf.domain.User;
  6. import com.huanf.service.LoginService;
  7. import com.huanf.utils.JwtUtil;
  8. import com.huanf.utils.RedisCache;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.security.authentication.AuthenticationManager;
  11. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  12. import org.springframework.security.core.Authentication;
  13. import org.springframework.stereotype.Service;
  14. import java.util.HashMap;
  15. import java.util.Map;
  16. import java.util.Objects;
  17.  
  18.  
  19. @Service
  20. //写登录的核心代码
  21. public class LoginServiceImpl implements LoginService {
  22.  
  23.     @Autowired
  24.     //先在SecurityConfig，使用@Bean注解重写官方的authenticationManagerBean类，然后这里才能注入成功
  25.     private AuthenticationManager authenticationManager;
  26.  
  27.     @Autowired
  28.     //RedisCache是我们在utils目录写好的类
  29.     private RedisCache redisCache;
  30.  
  31.     @Override
  32.     //ResponseResult和user是我们在domain目录写好的类
  33.     public ResponseResult login(User user) {
  34.  
  35.         //用户在登录页面输入的用户名和密码
  36.         UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
  37.  
  38.         //获取AuthenticationManager的authenticate方法来进行用户认证
  39.         Authentication authenticate = authenticationManager.authenticate(authenticationToken);
  40.  
  41.         //判断上面那行的authenticate是否为null，如果是则认证没通过，就抛出异常
  42.         if(Objects.isNull(authenticate)){
  43.             throw new RuntimeException("登录失败");
  44.         }
  45.  
  46.         //如果认证通过，就使用userid生成一个jwt，然后把jwt存入ResponseResult后返回
  47.         LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
  48.         String userid = loginUser.getXxuser().getId().toString();
  49.         String jwt = JwtUtil.createJWT(userid);
  50.  
  51.         //把完整的用户信息存入redis，其中userid作为key，注意存入redis的时候加了前缀 login:
  52.         Map<String, String> map = new HashMap<>();
  53.         map.put("token",jwt);
  54.         redisCache.setCacheObject("login:"+userid,loginUser);
  55.         return new ResponseResult(200,"登录成功",map);
  56.     }
  57. }


第五步: 在controller目录新建 LoginController 类，写入如下

  1. package com.huanf.controller;
  2.  
  3. import com.huanf.domain.ResponseResult;
  4. import com.huanf.domain.User;
  5. import com.huanf.service.LoginService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11.  
  12. @RestController
  13. public class LoginController {
  14.  
  15.     @Autowired
  16.     //LoginService是我们在service目录写好的接口
  17.     private LoginService loginService;
  18.  
  19.     @PostMapping("/user/login")
  20.     //ResponseResult和user是我们在domain目录写好的类
  21.     public ResponseResult xxlogin(@RequestBody User user){
  22.         //登录
  23.         return loginService.login(user);
  24.     }
  25.  
  26. }


第六步: 在application.yml添加如下，作用是添加redis的连接信息

  1. redis:
  2.     host: 127.0.0.1
  3.     port: 6379


第七步: 本地打开你的redis

  1. d:
  2. cd /redis
  3. redis-server.exe redis.windows.conf


第八步: 运行TokenApplication引导类
第九步: 测试。打开你的postman，发送下面的POST请求

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"huanf",
  3.     "password":"112233"
  4. }


13. 认证过滤器


在上面学习的 '认证' 的 '3. 自定义security的思路' 当中，我们有一个功能需求是定义Jwt认证过滤器，这个功能还没有实现，下面就正式学习如何实现这个功能。要实现Jwt认证过滤器，我们需要获取token，然后解析token获取其中的userid，还需要从redis中获取用户信息，然后存入SecurityContextHolder
为什么要有redis参与: 是为了防止过了很久之后，浏览器没有关闭，拿着token也能访问，这样不安全
认证过滤器的作用是什么: 上面我们实现登录接口的时，当某个用户登录之后，该用户就会有一个token值，我们可以通过认证过滤器，由于有token值，并且token值认证通过，也就是证明是这个用户的token值，那么该用户访问我们的业务接口时，就不会被Security拦截。简单理解作用就是登录过的用户可以访问我们的业务接口，拿到对应的资源


第一步: 定义过滤器。在 src/main/java/com.huanf 目录新建 filter.JwtAuthenticationTokenFilter 类，写入如下

  1. package com.huanf.filter;
  2.  
  3. import com.huanf.domain.LoginUser;
  4. import com.huanf.utils.JwtUtil;
  5. import com.huanf.utils.RedisCache;
  6. import io.jsonwebtoken.Claims;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  9. import org.springframework.security.core.context.SecurityContextHolder;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.util.StringUtils;
  12. import org.springframework.web.filter.OncePerRequestFilter;
  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.util.Objects;
  19.  
  20.  
  21. @Component
  22. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
  23.  
  24.     @Autowired
  25.     private RedisCache redisCache;
  26.  
  27.     @Override
  28.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  29.         //获取token，指定你要获取的请求头叫什么
  30.         String xxtoken = request.getHeader("token");
  31.         //判空，不一定所有的请求都有请求头，所以上面那行的xxtoken可能为空
  32.         //!StringUtils.hasText()方法用于检查给定的字符串是否为空或仅包含空格字符
  33.         if (!StringUtils.hasText(xxtoken)) {
  34.             //如果请求没有携带token，那么就不需要解析token，不需要获取用户信息，直接放行就可以
  35.             filterChain.doFilter(request, response);
  36.             //return之后，就不会走下面那些代码
  37.             return;
  38.         }
  39.         //解析token
  40.         String userid; //把userid定义在外面，才能同时用于下面的46行和52行
  41.         try {
  42.             Claims claims = JwtUtil.parseJWT(xxtoken);
  43.             userid = claims.getSubject();
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.             throw new RuntimeException("token非法");
  47.         }
  48.         //从redis中获取用户信息
  49.         String redisKey = "login:" + userid;
  50.         //LoginUser是我们在domain目录写的实体类
  51.         LoginUser loginUser = redisCache.getCacheObject(redisKey);
  52.         //判断获取到的用户信息是否为空，因为redis里面可能并不存在这个用户信息，例如缓存过期了
  53.         if(Objects.isNull(loginUser)){
  54.             //抛出一个异常
  55.             throw new RuntimeException("用户未登录");
  56.         }
  57.  
  58.         //把最终的LoginUser用户信息，通过setAuthentication方法，存入SecurityContextHolder
  59.         //TODO 获取权限信息封装到Authentication中
  60.         UsernamePasswordAuthenticationToken authenticationToken =
  61.                 //第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
  62.                 new UsernamePasswordAuthenticationToken(loginUser,null,null);
  63.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
  64.  
  65.         //全部做完之后，就放行
  66.         filterChain.doFilter(request, response);
  67.     }
  68. }


第二步: 修改SecurityConfig类为如下，其实也就是在configure方法加了一点代码、并且注入了JwtAuthenticationTokenFilter类

  1. package com.huanf.config;
  2.  
  3. import com.huanf.filter.JwtAuthenticationTokenFilter;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  9. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  10. import org.springframework.security.config.http.SessionCreationPolicy;
  11. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  12. import org.springframework.security.crypto.password.PasswordEncoder;
  13. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  14.  
  15.  
  16. @Configuration
  17. //实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
  18. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  19.  
  20.     @Bean
  21.     //把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
  22.     //注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
  23.     public PasswordEncoder passwordEncoder(){
  24.         return new BCryptPasswordEncoder();
  25.     }
  26.  
  27.     //---------------------------认证过滤器的实现----------------------------------
  28.  
  29.     @Autowired
  30.     //注入我们在filter目录写好的类
  31.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  32.  
  33.     //---------------------------登录接口的实现----------------------------------
  34.  
  35.     @Bean
  36.     @Override
  37.     public AuthenticationManager authenticationManagerBean() throws Exception {
  38.         return super.authenticationManagerBean();
  39.     }
  40.  
  41.     @Override
  42.     protected void configure(HttpSecurity http) throws Exception {
  43.         http
  44.                 //由于是前后端分离项目，所以要关闭csrf
  45.                 .csrf().disable()
  46.                 //由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
  47.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  48.                 .and()
  49.                 //指定让spring security放行登录接口的规则
  50.                 .authorizeRequests()
  51.                 // 对于登录接口 anonymous表示允许匿名访问
  52.                 .antMatchers("/user/login").anonymous()
  53.                 // 除上面外的所有请求全部需要鉴权认证
  54.                 .anyRequest().authenticated();
  55.  
  56.         //---------------------------认证过滤器的实现----------------------------------
  57.  
  58.         //把token校验过滤器添加到过滤器链中
  59.         //第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
  60.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  61.  
  62.  
  63.     }
  64. }


第三步: 本地打开你的redis

redis-server.exe redis.windows.conf


第四步: 运行TokenApplication引导类
第五步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"huanf",
  3.     "password":"112233"
  4. }


第六步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看会不会被Security拦截，如果不会拦截，那么就说明认证过滤器生效了，使用场景就是简单理解就是登录过的用户可以访问我们的业务接口，拿到对应的资源


注意，由于token值我们是存在redis，所以是有默认过期时间的。注意在请求头那里，key要写token，value要写你复制的token值，然后点击发送请求。这个token值实际上就是使用jwt工具类把112233密码加密后的密文，不信你翻一下前面笔记看当时112233的密文，长得是不是跟现在的token值格式一样


14. 退出登录


上面我们既测试了登录认证，又实现了基于密文的token认证，到此就完整地实现了我们在 '认证' 的 '3. 自定义security的思路' 里面的【登录】和【校验】的功能
那么，我们怎么退出登录呢，也就是让某个用户的登录状态消失，也就是让token失效 ?
实现起来也比较简单，只需要定义一个登陆接口，然后获取SecurityContextHolder中的认证信息，删除redis中对应的数据即可
注意: 我们的token其实就是用户密码的密文，token是存在redis里面
第一步: 把LoginService接口修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方

  1. package com.huanf.service;
  2.  
  3. import com.huanf.domain.ResponseResult;
  4. import com.huanf.domain.User;
  5. import org.springframework.stereotype.Service;
  6.  
  7.  
  8. @Service
  9. public interface LoginService {
  10.     ResponseResult login(User user);
  11.  
  12.     //-----------------------------------退出登录--------------------------------
  13.  
  14.     ResponseResult yylogout();
  15. }


第二步: 把LoginServiceImpl实现类修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方

  1. package com.huanf.service.impl;
  2.  
  3. import com.huanf.domain.LoginUser;
  4. import com.huanf.domain.ResponseResult;
  5. import com.huanf.domain.User;
  6. import com.huanf.service.LoginService;
  7. import com.huanf.utils.JwtUtil;
  8. import com.huanf.utils.RedisCache;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.security.authentication.AuthenticationManager;
  11. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  12. import org.springframework.security.core.Authentication;
  13. import org.springframework.security.core.context.SecurityContextHolder;
  14. import org.springframework.stereotype.Service;
  15. import java.util.HashMap;
  16. import java.util.Map;
  17. import java.util.Objects;
  18.  
  19.  
  20. @Service
  21. //写登录的核心代码
  22. public class LoginServiceImpl implements LoginService {
  23.  
  24.     @Autowired
  25.     //先在SecurityConfig，使用@Bean注解重写官方的authenticationManagerBean类，然后这里才能注入成功
  26.     private AuthenticationManager authenticationManager;
  27.  
  28.     @Autowired
  29.     //RedisCache是我们在utils目录写好的类
  30.     private RedisCache redisCache;
  31.  
  32.     @Override
  33.     //ResponseResult和user是我们在domain目录写好的类
  34.     public ResponseResult login(User user) {
  35.  
  36.         //用户在登录页面输入的用户名和密码
  37.         UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
  38.  
  39.         //获取AuthenticationManager的authenticate方法来进行用户认证
  40.         Authentication authenticate = authenticationManager.authenticate(authenticationToken);
  41.  
  42.         //判断上面那行的authenticate是否为null，如果是则认证没通过，就抛出异常
  43.         if(Objects.isNull(authenticate)){
  44.             throw new RuntimeException("登录失败");
  45.         }
  46.  
  47.         //如果认证通过，就使用userid生成一个jwt，然后把jwt存入ResponseResult后返回
  48.         LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
  49.         String userid = loginUser.getXxuser().getId().toString();
  50.         String jwt = JwtUtil.createJWT(userid);
  51.  
  52.         //把完整的用户信息存入redis，其中userid作为key，注意存入redis的时候加了前缀 login:
  53.         Map<String, String> map = new HashMap<>();
  54.         map.put("token",jwt);
  55.         redisCache.setCacheObject("login:"+userid,loginUser);
  56.         return new ResponseResult(200,"登录成功",map);
  57.     }
  58.  
  59.     //-----------------------------------退出登录的具体代码--------------------------------
  60.  
  61.     @Override
  62.     public ResponseResult yylogout() {
  63.  
  64.         //获取我们在JwtAuthenticationTokenFilter类写的SecurityContextHolder对象中的用户id
  65.         UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
  66.         //loginUser是我们在domain目录写好的实体类
  67.         LoginUser loginUser = (LoginUser) authentication.getPrincipal();
  68.         //获取用户id
  69.         Long userid = loginUser.getXxuser().getId();
  70.  
  71.         //根据用户id，删除redis中的token值，注意我们的key是被 login: 拼接过的，所以下面写完整key的时候要带上 longin:
  72.         redisCache.deleteObject("login:"+userid);
  73.  
  74.         return new ResponseResult(200,"注销成功");
  75.     }
  76. }


第三步: 把LoginController类修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方

  1. package com.huanf.controller;
  2.  
  3. import com.huanf.domain.ResponseResult;
  4. import com.huanf.domain.User;
  5. import com.huanf.service.LoginService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  11.  
  12.  
  13. @RestController
  14. public class LoginController {
  15.  
  16.     @Autowired
  17.     //LoginService是我们在service目录写好的接口
  18.     private LoginService loginService;
  19.  
  20.     @PostMapping("/user/login")
  21.     //ResponseResult和user是我们在domain目录写好的类
  22.     public ResponseResult xxlogin(@RequestBody User user){
  23.         //登录
  24.         return loginService.login(user);
  25.     }
  26.  
  27.  
  28.     //-----------------------------------退出登录--------------------------------
  29.  
  30.     @RequestMapping("/user/logout")
  31.     //ResponseResult是我们在domain目录写好的实体类
  32.     public ResponseResult xxlogout(){
  33.         return loginService.yylogout();
  34.     }
  35.  
  36. }


第四步: 本地打开你的redis

redis-server.exe redis.windows.conf


第五步: 运行TokenApplication引导类
第六步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"huanf",
  3.     "password":"112233"
  4. }


第七步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问

http://localhost:8080/hello


注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框


第八步: 测试。继续在你的postman，发送如下GET请求，作用是退出登录，然后去访问我们的业务接口，看在没有登录状态的情况下，能不能访问

 这个用户对应的token值

localhost:8080/user/logout

注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框

授权


1. 权限系统的作用


为什么要设计权限系统 ?
        例如要设计一个图书管理系统，普通学生账号的权限不能使用书籍编辑、删除的功能，普通学生能使用的功能仅仅是浏览页面，但是，如果是图书管理员用户，那么就能使用所有权限。简单理解就是我们需要不同的用户使用不同的功能，这就是权限系统要实现的效果
        虽然前端也可以去判断用户的权限来选择是否显示某些功能的页面或组件，但是不安全，因为如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作，所以我们还需要在后端进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作


前端防君子，后端防小人


2. 授权的基本流程


        在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限


        所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication，然后设置我们的资源所需要的权限即可


3. 自定义访问路径的权限


SpringSecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限
第一步: 在SecurityConfig配置类添加如下，作用是开启相关配置

@EnableGlobalMethodSecurity(prePostEnabled = true)


第二步: 开启了相关配置之后，就能使用@PreAuthorize等注解了。在HelloController类的hello方法，添加如下注解，其中test表示自定义权限的名字

@PreAuthorize("hasAuthority('test')")


4. 带权限访问的实现


权限信息: 有特殊含义的字符串
我们前面在登录时，会调用到MyUserDetailServiceImpl类的loadUserByUsername方法，当时我们写loadUserByUsername方法时，只写了查询用户数据信息的代码，还差查询用户权限信息的代码。在登录完之后，因为携带了token，所以需要在JwtAuthenticationTokenFilter类添加 '获取权限信息封装到Authentication中' 的代码，添加到UsernamePasswordAuthenticationToken的第三个参数里面，我们当时第三个参数传的是null。
第一步: 在上面的'3. 自定义访问路径的权限'，我们给HelloController类的 /hello 路径添加了权限限制，只有用户具有叫test的权限，才能访问这个路径


第二步: 把MyUserDetailServiceImpl类修改为如下，主要是增加了查询用户权限信息的代码，我会把增加的代码用红框框起来

  1. package com.huanf.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.huanf.domain.LoginUser;
  5. import com.huanf.domain.User;
  6. import com.huanf.mapper.UserMapper;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.security.core.userdetails.UserDetails;
  9. import org.springframework.security.core.userdetails.UserDetailsService;
  10. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  11. import org.springframework.stereotype.Service;
  12.  
  13. import java.util.ArrayList;
  14. import java.util.Arrays;
  15. import java.util.List;
  16. import java.util.Objects;
  17.  
  18.  
  19. @Service
  20. public class MyUserDetailServiceImpl implements UserDetailsService {
  21.  
  22.     @Autowired
  23.     private UserMapper userMapper;
  24.  
  25.     @Override
  26.     //UserDetails是Security官方提供的接口
  27.     public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
  28.  
  29.         //查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
  30.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  31.         //eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
  32.         queryWrapper.eq(User::getUserName,xxusername);
  33.         User user = userMapper.selectOne(queryWrapper);
  34.         //如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
  35.         if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
  36.             throw new RuntimeException("用户名或者密码错误");
  37.         }
  38.  
  39.         //--------------------------------查询用户权限信息---------------------------------
  40.  
  41.         //由于我们自定义了3个权限，所以用List集合存储。注意权限实际就是'有特殊含义的字符串'，所以下面的三个字符串就是自定义的
  42.         //下面那行就是我们的权限集合，等下还要在LoginUser类做权限集合的转换
  43.         List<String> list = new ArrayList<>(Arrays.asList("test","adminAuth","huanfAuth"));
  44.  
  45.         //------------------------------------------------------------------------------
  46.  
  47.         //把查询到的user结果，封装成UserDetails类型，然后返回。
  48.         //但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
  49.         return new LoginUser(user,list); //这里传了第二个参数，表示的是权限信息
  50.     }
  51. }


第三步: 封装权限信息。把LoginUser类修改为如下，主要是增加了把用户权限字符串的集合，转换封装在authorities变量里面

  1. package com.huanf.domain;
  2.  
  3. import com.alibaba.fastjson.annotation.JSONField;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  7. import org.springframework.security.core.GrantedAuthority;
  8. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  9. import org.springframework.security.core.userdetails.UserDetails;
  10. import java.util.Collection;
  11. import java.util.List;
  12. import java.util.stream.Collectors;
  13.  
  14.  
  15. @Data //get和set方法
  16. @NoArgsConstructor //无参构造
  17. //@AllArgsConstructor //在下面封装权限信息时，由于我们自己写有参构造，所以这个注解需要注释掉
  18. //实现UserDetails接口之后，要重写UserDetails接口里面的7个方法
  19. public class LoginUser implements UserDetails {
  20.  
  21.     //查询用户的用户名和密码等数据信息
  22.     private User xxuser;
  23.  
  24.     //查询用户权限信息
  25.     private List<String> xxpermissions;
  26.  
  27.     public LoginUser(User xxuser, List<String> permissions) {
  28.         this.xxuser = xxuser;
  29.         this.xxpermissions = permissions;
  30.     }
  31.  
  32.     //我们把这个List写到外面这里了，注意成员变量名一定要是authorities，不然会出现奇奇怪怪的问题
  33.     @JSONField(serialize = false) //这个注解的作用是不让下面那行的成员变量序列化存入redis，避免redis不支持而报异常
  34.     private List<SimpleGrantedAuthority> authorities;
  35.  
  36.     @Override
  37.     //用于返回权限信息。现在我们正在学'认证'，'权限'后面才学。所以返回null即可
  38.     //当要查询用户信息的时候，我们不能单纯返回null，要重写这个方法，作用是封装权限信息
  39.     public Collection<? extends GrantedAuthority> getAuthorities() { //重写GrantedAuthority接口的getAuthorities方法
  40.  
  41.         /* 第一种权限集合的转换写法如下，传统的方式
  42.         //把xxpermissions中的String类型的权限信息(也就是"test","adminAuth","huanfAuth")封装成SimpleGrantedAuthority对象
  43.         //List<GrantedAuthority> authorities = new ArrayList<>(); //简化这行如下一行，我们把authorities成员变量写到外面了
  44.         authorities = new ArrayList<>();
  45.         for (String yypermission : xxpermissions) {
  46.             SimpleGrantedAuthority yyauthority = new SimpleGrantedAuthority(yypermission);
  47.             authorities.add(yyauthority);
  48.         }
  49.         */
  50.  
  51.        /* 第二种权限集合的转换写法如下，函数式编程 + stream流 的方式，双引号表示方法引用 */
  52.         //当authorities集合为空，就说明是第一次，就需要转换，当不为空就说明不是第一次，就不需要转换直接返回
  53.         if(authorities != null){ //严谨来说这个if判断是避免整个调用链中security本地线程变量在获取用户时的重复解析，和redis存取无关
  54.             return authorities;
  55.         }
  56.         //为空的话就会执行下面的转换代码
  57.         //List<SimpleGrantedAuthority> authorities = xxpermissions //简化这行如下一行，我们把authorities成员变量写到外面了
  58.         authorities = xxpermissions
  59.                 .stream()
  60.                 .map(SimpleGrantedAuthority::new)
  61.                 .collect(Collectors.toList());
  62.  
  63.         //最终返回转换结果
  64.         return authorities;
  65.     }
  66.  
  67.     @Override
  68.     //用于获取用户密码。由于使用的实体类是User，所以获取的是数据库的用户密码
  69.     public String getPassword() {
  70.         return xxuser.getPassword();
  71.     }
  72.  
  73.     @Override
  74.     //用于获取用户名。由于使用的实体类是User，所以获取的是数据库的用户名
  75.     public String getUsername() {
  76.         return xxuser.getUserName();
  77.     }
  78.  
  79.     @Override
  80.     //判断登录状态是否过期。把这个改成true，表示永不过期
  81.     public boolean isAccountNonExpired() {
  82.         return true;
  83.     }
  84.  
  85.     @Override
  86.     //判断账号是否被锁定。把这个改成true，表示未锁定
  87.     public boolean isAccountNonLocked() {
  88.         return true;
  89.     }
  90.  
  91.     @Override
  92.     //判断登录凭证是否过期。把这个改成true，表示永不过期
  93.     public boolean isCredentialsNonExpired() {
  94.         return true;
  95.     }
  96.  
  97.     @Override
  98.     //判断用户是否可用。把这个改成true，表示可用状态
  99.     public boolean isEnabled() {
  100.         return true;
  101.     }
  102. }


第四步: 把JwtAuthenticationTokenFilter类修改为如下，主要是补充了前面没写的第三个参数，写成第三步封装好的权限信息

  1. package com.huanf.filter;
  2.  
  3. import com.huanf.domain.LoginUser;
  4. import com.huanf.utils.JwtUtil;
  5. import com.huanf.utils.RedisCache;
  6. import io.jsonwebtoken.Claims;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  9. import org.springframework.security.core.context.SecurityContextHolder;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.util.StringUtils;
  12. import org.springframework.web.filter.OncePerRequestFilter;
  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.util.Objects;
  19.  
  20.  
  21. @Component
  22. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
  23.  
  24.     @Autowired
  25.     private RedisCache redisCache;
  26.  
  27.     @Override
  28.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  29.         //获取token，指定你要获取的请求头叫什么
  30.         String xxtoken = request.getHeader("token");
  31.         //判空，不一定所有的请求都有请求头，所以上面那行的xxtoken可能为空
  32.         //!StringUtils.hasText()方法用于检查给定的字符串是否为空或仅包含空格字符
  33.         if (!StringUtils.hasText(xxtoken)) {
  34.             //如果请求没有携带token，那么就不需要解析token，不需要获取用户信息，直接放行就可以
  35.             filterChain.doFilter(request, response);
  36.             //return之后，就不会走下面那些代码
  37.             return;
  38.         }
  39.         //解析token
  40.         String userid; //把userid定义在外面，才能同时用于下面的46行和52行
  41.         try {
  42.             Claims claims = JwtUtil.parseJWT(xxtoken);
  43.             userid = claims.getSubject();
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.             throw new RuntimeException("token非法");
  47.         }
  48.         //从redis中获取用户信息
  49.         String redisKey = "login:" + userid;
  50.         //LoginUser是我们在domain目录写的实体类
  51.         LoginUser loginUser = redisCache.getCacheObject(redisKey);
  52.         //判断获取到的用户信息是否为空，因为redis里面可能并不存在这个用户信息，例如缓存过期了
  53.         if(Objects.isNull(loginUser)){
  54.             //抛出一个异常
  55.             throw new RuntimeException("用户未登录");
  56.         }
  57.  
  58.         //把最终的LoginUser用户信息，通过setAuthentication方法，存入SecurityContextHolder
  59.         UsernamePasswordAuthenticationToken authenticationToken =
  60.                 //第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
  61.                 //在学习封装权限信息时，就要把下面的第三个参数补充完整，getAuthorities是我们在loginUser写的方法
  62.                 new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities());
  63.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
  64.  
  65.         //全部做完之后，就放行
  66.         filterChain.doFilter(request, response);
  67.     }
  68. }


第五步: 本地打开你的redis

redis-server.exe redis.windows.conf


第六步: 运行TokenApplication引导类
第七步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"huanf",
  3.     "password":"112233"
  4. }


第八步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问

http://localhost:8080/hello


注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框


第九步: 测试。修改HelloController类的@PreAuthorize注解的权限字符串，我们把test改为xxtest。然后重新运行Application引导类
第十步: 测试。把第八步的测试再做一遍，看还能访问吗

授权-RBAC权限模型


1. 介绍


刚刚我们实现了只有当用户具备某种权限，才能访问我们的某个业务接口。但是存在一个问题，我们在给用户设置权限的时候，是写死的，在真正的开发中，我们是需要从数据库查询权限信息，下面就来学习如何从数据库查询权限信息，然后封装给用户。这个功能需要先准备好数据库和java代码，所以，下面的 '授权-RBAC权限模型' 都是在围绕这个功能进行学习，直到实现这个功能


RBAC权限模型 (Role-Based Access Control) ，是权限系统用到的经典模型，基于角色的权限控制。该模型由以下五个主要组成部分构成:
一、用户: 在系统中代表具体个体的实体，可以是人员、程序或其他实体。用户需要访问系统资源
二、角色: 角色是权限的集合，用于定义一组相似权限的集合。角色可以被赋予给用户，从而授予用户相应的权限
三、权限: 权限表示系统中具体的操作或功能，例如读取、写入、执行等。每个权限定义了对系统资源的访问规则
四、用户-角色映射: 用户-角色映射用于表示用户与角色之间的关系。通过为用户分配适当的角色，用户可以获得与角色相关联的权限
五、角色-权限映射: 角色-权限映射表示角色与权限之间的关系。每个角色都被分配了一组权限，这些权限决定了角色可执行的操作
截止目前，我们数据库只有1张表，在上面 '认证' 的 '6. 自定义security的数据库' 里面创建的 sys_user 用户表，下面我们会新增4张表，分别是权限表(每条数据是单个'粒度细的权限')、角色表(每条数据是多个'粒度细的权限')、角色表与权限表的中间表、用户表与角色表的中间表。总共5张表，组成了RBAC模型，中间表的作用是维护两张表的多对多关系


2.数据库表的创建


第一步: 在你数据库的huanf_security 库，新建 sys_menu权限表、sys_role角色表、sys_role_menu中间表、sys_user_role中间表，并插入数据

  1. create database if not exists huanf_security;
  2. use huanf_security;
  3. CREATE TABLE `sys_menu` (
  4.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  5.   `menu_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
  6.   `path` varchar(200) DEFAULT NULL COMMENT '路由地址',
  7.   `component` varchar(255) DEFAULT NULL COMMENT '组件路径',
  8.   `visible` char(1) DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
  9.   `status` char(1) DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
  10.   `perms` varchar(100) DEFAULT NULL COMMENT '权限标识',
  11.   `icon` varchar(100) DEFAULT '#' COMMENT '菜单图标',
  12.   `create_by` bigint(20) DEFAULT NULL,
  13.   `create_time` datetime DEFAULT NULL,
  14.   `update_by` bigint(20) DEFAULT NULL,
  15.   `update_time` datetime DEFAULT NULL,
  16.   `del_flag` int(11) DEFAULT '0' COMMENT '是否删除（0未删除 1已删除）',
  17.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  18.   PRIMARY KEY (`id`)
  19. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='权限表';
  20.  
  21. CREATE TABLE `sys_role` (
  22.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  23.   `name` varchar(128) DEFAULT NULL,
  24.   `role_key` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
  25.   `status` char(1) DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
  26.   `del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
  27.   `create_by` bigint(200) DEFAULT NULL,
  28.   `create_time` datetime DEFAULT NULL,
  29.   `update_by` bigint(200) DEFAULT NULL,
  30.   `update_time` datetime DEFAULT NULL,
  31.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  32.   PRIMARY KEY (`id`)
  33. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';
  34.  
  35. CREATE TABLE `sys_role_menu` (
  36.   `role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
  37.   `menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单id',
  38.   PRIMARY KEY (`role_id`,`menu_id`)
  39. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
  40.  
  41. CREATE TABLE `sys_user_role` (
  42.   `user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  43.   `role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
  44.   PRIMARY KEY (`user_id`,`role_id`)
  45. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
  46.  
  47. insert into sys_user_role values (2,1);
  48. insert into sys_role values
  49. (1,'经理','ceo',0,0,default,default,default,default,default),
  50. (2,'程序员','coder',0,0,default,default,default,default,default);
  51. insert into sys_role_menu values (1,1),(1,2);
  52. insert into sys_menu values
  53. (1,'部门管理','dept','system/dept/index',0,0,'system:dept:list','#',default,default,default,default,default,default),
  54. (2,'测试','test','system/test/index',0,0,'system:test:list','#',default,default,default,default,default,default)

注意: 没有huanf_security数据库 和 sys_user用户表 的话，请去上面笔记的 '认证' 的 '6. 自定义security的数据库' 里面进行创建。或者我给你写出来了，如下

  1. create database if not exists huanf_security;
  2. use huanf_security;
  3. CREATE TABLE `sys_user` (
  4.   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  5.   `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  6.   `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  7.   `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  8.   `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
  9.   `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
  10.   `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
  11.   `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
  12.   `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
  13.   `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
  14.   `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
  15.   `create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
  16.   `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
  17.   `update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
  18.   `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
  19.   PRIMARY KEY (`id`)
  20. ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
  21.  
  22. insert into sys_user values (1,'admin','管理员','{noop}123456','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);
  23. insert into sys_user values (2,'huanf','涣沷a靑惷','$2a$10$YPnG.IYUk0mMechaxSibBuKmNeTzvuHdcxkqvoxizsll6WCQG9CHG','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'1',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);


第二步: 测试SQL语句，也就是确认一下你的建表、插入数据是否达到要求

  1. # 通过用户id去查询这个用户具有的权限列表。也就是根据userid查询perms，并且限制条件为role和menu都必须正常状态么也就是等于0
  2. SELECT 
  3. 	DISTINCT m.`perms`
  4. FROM
  5. 	sys_user_role ur
  6. 	LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
  7. 	LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
  8. 	LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
  9. WHERE
  10. 	user_id = 2
  11. 	AND r.`status` = 0
  12. 	AND m.`status` = 0


注意: 可以查到两条数据，这两条数据就是等下数据库返回给我们的权限字符串


3. 查询数据库的权限信息


第一步: 在 domain 目录新建 Menu 实体类，写入如下

  1. package com.huanf.domain;
  2. import com.baomidou.mybatisplus.annotation.TableId;
  3. import com.baomidou.mybatisplus.annotation.TableName;
  4. import com.fasterxml.jackson.annotation.JsonInclude;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  8. import java.io.Serializable;
  9. import java.util.Date;
  10.  
  11.  
  12. //权限表(也叫菜单表)的实体类
  13. @TableName(value="sys_menu") //指定表名，避免等下mybatisplus的影响
  14. @Data
  15. @AllArgsConstructor
  16. @NoArgsConstructor
  17. @JsonInclude(JsonInclude.Include.NON_NULL)
  18. //Serializable是官方提供的，作用是将对象转化为字节序列
  19. public class Menu implements Serializable {
  20.     private static final long serialVersionUID = -54979041104113736L;
  21.  
  22.     @TableId
  23.     private Long id;
  24.     /**
  25.      * 菜单名
  26.      */
  27.     private String menuName;
  28.     /**
  29.      * 路由地址
  30.      */
  31.     private String path;
  32.     /**
  33.      * 组件路径
  34.      */
  35.     private String component;
  36.     /**
  37.      * 菜单状态（0显示 1隐藏）
  38.      */
  39.     private String visible;
  40.     /**
  41.      * 菜单状态（0正常 1停用）
  42.      */
  43.     private String status;
  44.     /**
  45.      * 权限标识
  46.      */
  47.     private String perms;
  48.     /**
  49.      * 菜单图标
  50.      */
  51.     private String icon;
  52.  
  53.     private Long createBy;
  54.  
  55.     private Date createTime;
  56.  
  57.     private Long updateBy;
  58.  
  59.     private Date updateTime;
  60.     /**
  61.      * 是否删除（0未删除 1已删除）
  62.      */
  63.     private Integer delFlag;
  64.     /**
  65.      * 备注
  66.      */
  67.     private String remark;
  68. }


第二步: 在 mapper 目录新建 MenuMapper 接口。作用是定义mapper，其中提供一个方法可以根据userid查询权限信息

  1. package com.huanf.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.huanf.domain.Menu;
  5. import java.util.List;
  6. import org.springframework.stereotype.Service;
  7.  
  8.  
  9. @Service
  10. //BaseMapper是mybatisplus官方提供的接口，里面提供了很多单表查询的方法
  11. public interface MenuMapper extends BaseMapper<Menu> {
  12.     //由于是多表联查，mybatisplus的BaseMapper接口没有提供，我们需要自定义方法，所以需要创建对应的mapper文件，定义对应的sql语句
  13.     List<String> selectPermsByUserId(Long id);
  14. }


第三步: 在 resources 目录新建 mapper目录，接着在这个mapper目录新建File，名字叫 MenuMapper.xml，写入如下

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.huanf.mapper.MenuMapper">
  4.  
  5.     <select id="selectPermsByUserId" resultType="java.lang.String">
  6.         SELECT
  7.             DISTINCT m.`perms`
  8.         FROM
  9.             sys_user_role ur
  10.                 LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
  11.                 LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
  12.                 LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
  13.         WHERE
  14.             user_id = #{userid}
  15.           AND r.`status` = 0
  16.           AND m.`status` = 0
  17.     </select>
  18.  
  19. </mapper>


第四步: 把application.yml修改为如下，作用是告诉mybatisplus，刚刚写的MenuMapper.xml文件是在哪个地方

  1. mybatis-plus:
  2.   # 配置MenuMapper.xml文件的路径
  3.   # 也可以不写，因为默认就是在类加载路径(resouces)下的mapper目录的任意层级的后缀为xml的文件，都会被扫描到
  4.   mapper-locations: classpath*:/mapper/**/*.xml


第五步: 测试。这里只是检查mybatismlus能不能拿到数据库的权限字符串。在MapperTest类添加如下

  1. @Autowired
  2. private MenuMapper menuMapper;
  3.  
  4. @Test
  5. public void testSelectPermsByUserId(){
  6. 	//L表示Long类型
  7. 	List<String> list = menuMapper.selectPermsByUserId(2L);
  8. 	System.out.println(list);
  9. }


4. RBAC权限模型的实现


不要把RBAC模型想得很难，其实难的话只是数据库表的设计和SQL语句的编写，需要5张表。数据库设计好之后就很简单了，使用mybatis-plus去查询数据库表的权限字符串(例如我们的权限字符串是放在sys_menu表)，然后把你查到的数据去替换死数据就好了。我们只剩最后一步，就是替换死数据，如下
第一步: 把MyUserDetailServiceImpl类修改为如下，我们只是增加了查询来自数据库的权限信息的代码

  1. package com.huanf.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.huanf.domain.LoginUser;
  5. import com.huanf.domain.User;
  6. import com.huanf.mapper.MenuMapper;
  7. import com.huanf.mapper.UserMapper;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.security.core.userdetails.UserDetails;
  10. import org.springframework.security.core.userdetails.UserDetailsService;
  11. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  12. import org.springframework.stereotype.Service;
  13.  
  14. import java.util.ArrayList;
  15. import java.util.Arrays;
  16. import java.util.List;
  17. import java.util.Objects;
  18.  
  19.  
  20. @Service
  21. public class MyUserDetailServiceImpl implements UserDetailsService {
  22.  
  23.     @Autowired
  24.     private UserMapper userMapper;
  25.  
  26.     @Autowired
  27.     //MenuMapper是我们在mapper目录写好的接口，作用是查询来自数据库的权限信息
  28.     private MenuMapper menuMapper;
  29.  
  30.     @Override
  31.     //UserDetails是Security官方提供的接口
  32.     public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
  33.  
  34.         //查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
  35.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  36.         //eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
  37.         queryWrapper.eq(User::getUserName,xxusername);
  38.         User user = userMapper.selectOne(queryWrapper);
  39.         //如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
  40.         if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
  41.             throw new RuntimeException("用户名或者密码错误");
  42.         }
  43.  
  44.         //--------------------------------查询用户权限信息----------------------------------
  45.  
  46.         //由于我们自定义了3个权限，所以用List集合存储。注意权限实际就是'有特殊含义的字符串'，所以下面的三个字符串就是自定义的
  47.         //下面那行就是我们的权限集合，等下还要在LoginUser类做权限集合的转换
  48.         //List<String> list = new ArrayList<>(Arrays.asList("test","adminAuth","huanfAuth"));
  49.         //上面那行的list就不用死数据啦，我们用下面那行的list，是数据库获取到的权限字符串信息的数据
  50.  
  51.         //-------------------------------查询来自数据库的权限信息--------------------------------
  52.  
  53.         List<String> list = menuMapper.selectPermsByUserId(user.getId());
  54.  
  55.         //-------------------------------------------------------------------------------
  56.  
  57.         //把查询到的user结果，封装成UserDetails类型，然后返回。
  58.         //但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
  59.         return new LoginUser(user,list); //这里传了第二个参数，表示的是权限信息
  60.     }
  61. }


第二步: 测试。由于我们知道数据库传过来的权限字符串是 system:dept:list 和 system:test:list，所以我们要把HelloController类的权限字符串修改为如下

system:test:list


或

system:dept:list


第三步: 本地打开你的redis

redis-server.exe redis.windows.conf


第四步: 运行TokenApplication引导类
第五步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"huanf",
  3.     "password":"112233"
  4. }


第六步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问

http://localhost:8080/hello


注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框


第七步: 测试。修改HelloController类的@PreAuthorize注解的权限字符串，我们改为 xxxsystem:test:list。然后重新运行Application引导类
第八步: 测试。把第八步的测试再做一遍，看还能访问吗


自定义异常处理


上面的我们学习了 '认证' 和 '授权'，实现了基本的权限管理，然后也学习了从数据库获取授权的 '授权-RBAC权限模型'，实现了从数据库获取用户具备的权限字符串。到此，我们完整地实现了权限管理的功能，但是，当认证或授权出现报错时，我们希望响应回来的json数据有实体类的code、msg、data这三个字段，怎么实现呢
我们需要学习Spring Security的异常处理机制，就可以在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理


在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到，如上图。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常，其中有如下两种情况
一、如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。
二、如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。
总结: 如果我们需要自定义异常处理，我们只需要创建AuthenticationEntryPoint和AccessDeniedHandler的实现类对象，然后配置给SpringSecurity即可
第一步: 在 src/main/java/com.huanf 目录新建 handler.AuthenticationEntryPointImpl类，写入如下，作用是自定义认证的实现类

  1. package com.huanf.handler;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.huanf.domain.ResponseResult;
  5. import com.huanf.utils.WebUtils;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.security.core.AuthenticationException;
  8. import org.springframework.security.web.AuthenticationEntryPoint;
  9. import org.springframework.stereotype.Component;
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15.  
  16. @Component
  17. //这个类只处理认证异常，不处理授权异常
  18. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
  19.     @Override
  20.     //第一个参数是请求对象，第二个参数是响应对象，第三个参数是异常对象。把异常封装成授权的对象，然后封装到handle方法
  21.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
  22.         //ResponseResult是我们在domain目录写好的实体类。HttpStatus是spring提供的枚举类，UNAUTHORIZED表示401状态码
  23.         ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "用户认证失败，请重新登录");
  24.         //把上面那行拿到的result对象转换为JSON字符串
  25.         String json = JSON.toJSONString(result);
  26.         //WebUtils是我们在utils目录写好的类
  27.         WebUtils.renderString(response,json);
  28.     }
  29. }


第二步: 在handler目录新建 AccessDeniedHandlerImpl 类，写入如下，作用是自定义授权的实现类

  1. package com.huanf.handler;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.huanf.domain.ResponseResult;
  5. import com.huanf.utils.WebUtils;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.security.access.AccessDeniedException;
  8. import org.springframework.security.web.access.AccessDeniedHandler;
  9. import org.springframework.stereotype.Component;
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15.  
  16. @Component
  17. //这个类只处理授权异常，不处理认证异常
  18. public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
  19.     @Override
  20.     //第一个参数是请求对象，第二个参数是响应对象，第三个参数是异常对象。把异常封装成认证的对象，然后封装到handle方法
  21.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
  22.         //ResponseResult是我们在domain目录写好的实体类。HttpStatus是spring提供的枚举类，FORBIDDEN表示403状态码
  23.         ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "您没有权限进行访问");
  24.         //把上面那行拿到的result对象转换为JSON字符串
  25.         String json = JSON.toJSONString(result);
  26.         //WebUtils是我们在utils目录写好的类
  27.         WebUtils.renderString(response,json);
  28.  
  29.     }
  30. }


第三步: 把 SecurityConfig 类修改为如下，作用是把刚刚两个异常处理的实现类配置在Spring Security里面

  1. package com.huanf.config;
  2.  
  3. import com.huanf.filter.JwtAuthenticationTokenFilter;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  9. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  10. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  11. import org.springframework.security.config.http.SessionCreationPolicy;
  12. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  13. import org.springframework.security.crypto.password.PasswordEncoder;
  14. import org.springframework.security.web.AuthenticationEntryPoint;
  15. import org.springframework.security.web.access.AccessDeniedHandler;
  16. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  17.  
  18.  
  19. @Configuration
  20. @EnableGlobalMethodSecurity(prePostEnabled = true)
  21. //实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
  22. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  23.  
  24.     @Bean
  25.     //把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
  26.     //注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
  27.     public PasswordEncoder passwordEncoder(){
  28.         return new BCryptPasswordEncoder();
  29.     }
  30.  
  31.     //---------------------------认证过滤器的实现----------------------------------
  32.  
  33.     @Autowired
  34.     //注入我们在filter目录写好的类
  35.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  36.  
  37.     //---------------------------登录接口的实现----------------------------------
  38.  
  39.     @Bean
  40.     @Override
  41.     public AuthenticationManager authenticationManagerBean() throws Exception {
  42.         return super.authenticationManagerBean();
  43.     }
  44.  
  45.     @Override
  46.     protected void configure(HttpSecurity http) throws Exception {
  47.         http
  48.                 //由于是前后端分离项目，所以要关闭csrf
  49.                 .csrf().disable()
  50.                 //由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
  51.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  52.                 .and()
  53.                 //指定让spring security放行登录接口的规则
  54.                 .authorizeRequests()
  55.                 // 对于登录接口 anonymous表示允许匿名访问
  56.                 .antMatchers("/user/login").anonymous()
  57.                 // 除上面外的所有请求全部需要鉴权认证
  58.                 .anyRequest().authenticated();
  59.  
  60.         //---------------------------认证过滤器的实现----------------------------------
  61.  
  62.         //把token校验过滤器添加到过滤器链中
  63.         //第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
  64.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  65.  
  66.         //---------------------------异常处理的相关配置-------------------------------
  67.         
  68.         http.exceptionHandling()
  69.                 //配置认证失败的处理器
  70.                 .authenticationEntryPoint(authenticationEntryPoint)
  71.                 //配置授权失败的处理器
  72.                 .accessDeniedHandler(accessDeniedHandler);
  73.     }
  74.         
  75.     @Autowired
  76.     //注入Security提供的认证失败的处理器，这个处理器里面的AuthenticationEntryPointImpl实现类，用的不是官方的了，
  77.     //而是用的是我们在handler目录写好的AuthenticationEntryPointImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
  78.     private AuthenticationEntryPoint authenticationEntryPoint;
  79.  
  80.     @Autowired
  81.     //注入Security提供的授权失败的处理器，这个处理器里面的AccessDeniedHandlerImpl实现类，用的不是官方的了，
  82.     //而是用的是我们在handler目录写好的AccessDeniedHandlerImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
  83.     private AccessDeniedHandler accessDeniedHandler;
  84.  
  85.     //--------------------------------------------------------------------------
  86.  
  87. }


第四步: 本地打开你的redis


第五步: 运行TokenApplication引导类
第六步: 测试认证异常。打开你的postman，发送如下的POST请求，作用是登录一个不存在的用户，模拟认证异常

localhost:8080/user/login


注意还要带上如下JSON类型的Body数据

  1. {
  2.     "userName":"xxhuanf",
  3.     "password":"112233"
  4. }


第七步: 测试授权异常。先在HelloController类修改PreAuthorize注解的权限字符串，修改成huanf用户不存在的权限字符串，接着重新运行TokenApplication引导类，然后去正常登录一个用户并访问 /hello 业务接口，必然会报权限异常，然后我们看一下响应回来的数据格式，是不是我们定义的json格式


跨域


我这里跟教程视频的不一致，教程视频大概想讲的是只有同时配置springboot和security的跨域，那么外界用户才能访问我们的接口，但是我实际操作的却不一致，不清楚是不是版本的问题，总之都学一下吧，我的操作证明出来的是security的跨域写了跟没写都无效，只要是boot配置了跨域，那么跨域问题就解决了


1. 跨域的后端解决


由于我们的SpringSecurity负责所有请求和资源的管理，当请求经过SpringSecurity时，如果SpringSecurity不允许跨域，那么也是会被拦截，所以下面我们将学习并解决跨域问题。前面我们在测试时，是在postman测试，因此没有出现跨域问题的情况，postman只是负责发请求跟浏览器没关系
浏览器出于安全的考虑，使用 XMLHttpRequest 对象发起HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。 前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题
我们要实现如下两个需求 (我实际做出的效果跟教程视频不一致，第二个需求其实没必要存在，boot解决了跨域就都解决了):
1、开启SpringBoot的允许跨域访问
2、开启SpringSecurity的允许跨域访问
第一步: 开启SpringBoot的允许跨域访问。在 config 目录新建 CorsConfig 类，写入如下

  1. package com.huanf.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.config.annotation.CorsRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  6.  
  7.  
  8. @Configuration
  9. public class CorsConfig implements WebMvcConfigurer {
  10.  
  11.     @Override
  12.     //重写spring提供的WebMvcConfigurer接口的addCorsMappings方法
  13.     public void addCorsMappings(CorsRegistry registry) {
  14.         // 设置允许跨域的路径
  15.         registry.addMapping("/**")
  16.                 // 设置允许跨域请求的域名
  17.                 .allowedOriginPatterns("*")
  18.                 // 是否允许cookie
  19.                 .allowCredentials(true)
  20.                 // 设置允许的请求方式
  21.                 .allowedMethods("GET", "POST", "DELETE", "PUT")
  22.                 // 设置允许的header属性
  23.                 .allowedHeaders("*")
  24.                 // 跨域允许时间
  25.                 .maxAge(3600);
  26.     }
  27. }


第二步: 开启SpringSecurity的允许跨域访问。在把 SecurityConfig 修改为如下。增加了一点代码，我会用红框框出来

  1. package com.huanf.config;
  2.  
  3. import com.huanf.filter.JwtAuthenticationTokenFilter;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  9. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  10. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  11. import org.springframework.security.config.http.SessionCreationPolicy;
  12. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  13. import org.springframework.security.crypto.password.PasswordEncoder;
  14. import org.springframework.security.web.AuthenticationEntryPoint;
  15. import org.springframework.security.web.access.AccessDeniedHandler;
  16. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  17.  
  18.  
  19. @Configuration
  20. @EnableGlobalMethodSecurity(prePostEnabled = true)
  21. //实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
  22. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  23.  
  24.     @Bean
  25.     //把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
  26.     //注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
  27.     public PasswordEncoder passwordEncoder(){
  28.         return new BCryptPasswordEncoder();
  29.     }
  30.  
  31.     //---------------------------认证过滤器的实现----------------------------------
  32.  
  33.     @Autowired
  34.     //注入我们在filter目录写好的类
  35.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  36.  
  37.     //---------------------------登录接口的实现------------------------------------
  38.  
  39.     @Bean
  40.     @Override
  41.     public AuthenticationManager authenticationManagerBean() throws Exception {
  42.         return super.authenticationManagerBean();
  43.     }
  44.  
  45.     @Override
  46.     protected void configure(HttpSecurity http) throws Exception {
  47.         http
  48.                 //由于是前后端分离项目，所以要关闭csrf
  49.                 .csrf().disable()
  50.                 //由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
  51.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  52.                 .and()
  53.                 //指定让spring security放行登录接口的规则
  54.                 .authorizeRequests()
  55.                 // 对于登录接口 anonymous表示允许匿名访问
  56.                 .antMatchers("/user/login").anonymous()
  57.                 // 除上面外的所有请求全部需要鉴权认证
  58.                 .anyRequest().authenticated();
  59.  
  60.         //---------------------------认证过滤器的实现-------------------------------
  61.  
  62.         //把token校验过滤器添加到过滤器链中
  63.         //第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
  64.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  65.  
  66.         //---------------------------
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/518169
    推荐阅读
    相关标签

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