SpringSecurity学习

快速入门

添加依赖

不要再因为写错单词而找一天的bug了，spring-boot-starter-security中的security,不是securtiy,以后要下载依赖尽量不要自己手写，记得去maven仓库copy

  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.         <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-security -->
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-security</artifactId>
  20.         </dependency>
  21.     </dependencies>

创建启动类

  1. package gdut.edu;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class MyApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(MyApplication.class, args);
  10.     }
  11. }

创建controller

  1. package gdut.edu.controller;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. @RestController
  7. public class HelloController {
  9.     @GetMapping("/hello")
  10.     public String hello() {
  11.         return "hello";
  12.     }
  13. }

认证

登录校验流程

前端发请求登录，后端查询数据库对比用户账号密码是否正确，正确则加密用户信息，返回jwt给前端，前端将token信息保存到本地，之后每次发送请求都携带token，后端对token解密，查看用户是否有权限访问，授予用户访问权限。

认证流程

image-20211214151515385.png

思路分析

登录

  • 自定义登录接口
    • 调用ProviderManager的方法进行验证，验证通过生成jwt将用户信息保存到redis
  • 自定义UserDetailsService
    • 在这个实现类中去查询数据库

校验

  • 定义jwt认证过滤器
    • 获取token,解析token后获取其中的userId,从redis中获取用户信息，存入SecurityContextHolder

准备工作

  1. 添加依赖
  1.         <!--redis依赖-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.         </dependency>
  6.         <!--fastjson依赖-->
  7.         <dependency>
  8.             <groupId>com.alibaba</groupId>
  9.             <artifactId>fastjson</artifactId>
  10.             <version>1.2.33</version>
  11.         </dependency>
  12.         <!--jwt依赖-->
  13.         <dependency>
  14.             <groupId>io.jsonwebtoken</groupId>
  15.             <artifactId>jjwt</artifactId>
  16.             <version>0.9.0</version>
  17.         </dependency>
  1. 添加redis相关配置
  2. import com.alibaba.fastjson.JSON;
  3. import com.alibaba.fastjson.serializer.SerializerFeature;
  4. import com.fasterxml.jackson.databind.JavaType;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import com.fasterxml.jackson.databind.type.TypeFactory;
  7. import org.springframework.data.redis.serializer.RedisSerializer;
  8. import org.springframework.data.redis.serializer.SerializationException;
  9. import com.alibaba.fastjson.parser.ParserConfig;
  10. import org.springframework.util.Assert;
  11. import java.nio.charset.Charset;
  13. /**
  14.  * Redis使用FastJson序列化
  15.  */
  16. public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
  17. {
  19.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  21.     private Class<T> clazz;
  23.     static
  24.     {
  25.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  26.     }
  28.     public FastJsonRedisSerializer(Class<T> clazz)
  29.     {
  30.         super();
  31.         this.clazz = clazz;
  32.     }
  34.     @Override
  35.     public byte[] serialize(T t) throws SerializationException
  36.     {
  37.         if (t == null)
  38.         {
  39.             return new byte[0];
  40.         }
  41.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  42.     }
  44.     @Override
  45.     public T deserialize(byte[] bytes) throws SerializationException
  46.     {
  47.         if (bytes == null || bytes.length <= 0)
  48.         {
  49.             return null;
  50.         }
  51.         String str = new String(bytes, DEFAULT_CHARSET);
  53.         return JSON.parseObject(str, clazz);
  54.     }
  57.     protected JavaType getJavaType(Class<?> clazz)
  58.     {
  59.         return TypeFactory.defaultInstance().constructType(clazz);
  60.     }
  61. }
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.data.redis.connection.RedisConnectionFactory;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.serializer.StringRedisSerializer;
  8. @Configuration
  9. public class RedisConfig {
  11.     @Bean
  12.     @SuppressWarnings(value = { "unchecked", "rawtypes" })
  13.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
  14.     {
  15.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  16.         template.setConnectionFactory(connectionFactory);
  18.         FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
  20.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
  21.         template.setKeySerializer(new StringRedisSerializer());
  22.         template.setValueSerializer(serializer);
  24.         // Hash的key也采用StringRedisSerializer的序列化方式
  25.         template.setHashKeySerializer(new StringRedisSerializer());
  26.         template.setHashValueSerializer(serializer);
  28.         template.afterPropertiesSet();
  29.         return template;
  30.     }
  31. }
  1. 响应类
  2. import com.fasterxml.jackson.annotation.JsonInclude;
  4. @JsonInclude(JsonInclude.Include.NON_NULL)
  5. public class ResponseResult<T> {
  6.     /**
  7.      * 状态码
  8.      */
  9.     private Integer code;
  10.     /**
  11.      * 提示信息，如果有错误时，前端可以获取该字段进行提示
  12.      */
  13.     private String msg;
  14.     /**
  15.      * 查询到的结果数据，
  16.      */
  17.     private T data;
  19.     public ResponseResult(Integer code, String msg) {
  20.         this.code = code;
  21.         this.msg = msg;
  22.     }
  24.     public ResponseResult(Integer code, T data) {
  25.         this.code = code;
  26.         this.data = data;
  27.     }
  29.     public Integer getCode() {
  30.         return code;
  31.     }
  33.     public void setCode(Integer code) {
  34.         this.code = code;
  35.     }
  37.     public String getMsg() {
  38.         return msg;
  39.     }
  41.     public void setMsg(String msg) {
  42.         this.msg = msg;
  43.     }
  45.     public T getData() {
  46.         return data;
  47.     }
  49.     public void setData(T data) {
  50.         this.data = data;
  51.     }
  53.     public ResponseResult(Integer code, String msg, T data) {
  54.         this.code = code;
  55.         this.msg = msg;
  56.         this.data = data;
  57.     }
  58. }
  1. 工具类
  2. import io.jsonwebtoken.Claims;
  3. import io.jsonwebtoken.JwtBuilder;
  4. import io.jsonwebtoken.Jwts;
  5. 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;
  13. /**
  14.  * JWT工具类
  15.  */
  16. public class JwtUtil {
  18.     //有效期为
  19.     public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000  一个小时
  20.     //设置秘钥明文
  21.     public static final String JWT_KEY = "sangeng";
  23.     public static String getUUID(){
  24.         String token = UUID.randomUUID().toString().replaceAll("-", "");
  25.         return token;
  26.     }
  28.     /**
  29.      * 生成jtw
  30.      * @param subject token中要存放的数据（json格式）
  31.      * @return
  32.      */
  33.     public static String createJWT(String subject) {
  34.         JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
  35.         return builder.compact();
  36.     }
  38.     /**
  39.      * 生成jtw
  40.      * @param subject token中要存放的数据（json格式）
  41.      * @param ttlMillis token超时时间
  42.      * @return
  43.      */
  44.     public static String createJWT(String subject, Long ttlMillis) {
  45.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
  46.         return builder.compact();
  47.     }
  49.     private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
  50.         SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
  51.         SecretKey secretKey = generalKey();
  52.         long nowMillis = System.currentTimeMillis();
  53.         Date now = new Date(nowMillis);
  54.         if(ttlMillis==null){
  55.             ttlMillis=JwtUtil.JWT_TTL;
  56.         }
  57.         long expMillis = nowMillis + ttlMillis;
  58.         Date expDate = new Date(expMillis);
  59.         return Jwts.builder()
  60.                 .setId(uuid)              //唯一的ID
  61.                 .setSubject(subject)   // 主题  可以是JSON数据
  62.                 .setIssuer("sg")     // 签发者
  63.                 .setIssuedAt(now)      // 签发时间
  64.                 .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
  65.                 .setExpiration(expDate);
  66.     }
  68.     /**
  69.      * 创建token
  70.      * @param id
  71.      * @param subject
  72.      * @param ttlMillis
  73.      * @return
  74.      */
  75.     public static String createJWT(String id, String subject, Long ttlMillis) {
  76.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
  77.         return builder.compact();
  78.     }
  80.     public static void main(String[] args) throws Exception {
  81.         String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
  82.         Claims claims = parseJWT(token);
  83.         System.out.println(claims);
  84.     }
  86.     /**
  87.      * 生成加密后的秘钥 secretKey
  88.      * @return
  89.      */
  90.     public static SecretKey generalKey() {
  91.         byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
  92.         SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
  93.         return key;
  94.     }
  96.     /**
  97.      * 解析
  98.      *
  99.      * @param jwt
  100.      * @return
  101.      * @throws Exception
  102.      */
  103.     public static Claims parseJWT(String jwt) throws Exception {
  104.         SecretKey secretKey = generalKey();
  105.         return Jwts.parser()
  106.                 .setSigningKey(secretKey)
  107.                 .parseClaimsJws(jwt)
  108.                 .getBody();
  109.     }
  112. }
  2. import java.util.*;
  3. import java.util.concurrent.TimeUnit;
  5. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  6. @Component
  7. public class RedisCache
  8. {
  9.     @Autowired
  10.     public RedisTemplate redisTemplate;
  12.     /**
  13.      * 缓存基本的对象，Integer、String、实体类等
  14.      *
  15.      * @param key 缓存的键值
  16.      * @param value 缓存的值
  17.      */
  18.     public <T> void setCacheObject(final String key, final T value)
  19.     {
  20.         redisTemplate.opsForValue().set(key, value);
  21.     }
  23.     /**
  24.      * 缓存基本的对象，Integer、String、实体类等
  25.      *
  26.      * @param key 缓存的键值
  27.      * @param value 缓存的值
  28.      * @param timeout 时间
  29.      * @param timeUnit 时间颗粒度
  30.      */
  31.     public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
  32.     {
  33.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  34.     }
  36.     /**
  37.      * 设置有效时间
  38.      *
  39.      * @param key Redis键
  40.      * @param timeout 超时时间
  41.      * @return true=设置成功；false=设置失败
  42.      */
  43.     public boolean expire(final String key, final long timeout)
  44.     {
  45.         return expire(key, timeout, TimeUnit.SECONDS);
  46.     }
  48.     /**
  49.      * 设置有效时间
  50.      *
  51.      * @param key Redis键
  52.      * @param timeout 超时时间
  53.      * @param unit 时间单位
  54.      * @return true=设置成功；false=设置失败
  55.      */
  56.     public boolean expire(final String key, final long timeout, final TimeUnit unit)
  57.     {
  58.         return redisTemplate.expire(key, timeout, unit);
  59.     }
  61.     /**
  62.      * 获得缓存的基本对象。
  63.      *
  64.      * @param key 缓存键值
  65.      * @return 缓存键值对应的数据
  66.      */
  67.     public <T> T getCacheObject(final String key)
  68.     {
  69.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  70.         return operation.get(key);
  71.     }
  73.     /**
  74.      * 删除单个对象
  75.      *
  76.      * @param key
  77.      */
  78.     public boolean deleteObject(final String key)
  79.     {
  80.         return redisTemplate.delete(key);
  81.     }
  83.     /**
  84.      * 删除集合对象
  85.      *
  86.      * @param collection 多个对象
  87.      * @return
  88.      */
  89.     public long deleteObject(final Collection collection)
  90.     {
  91.         return redisTemplate.delete(collection);
  92.     }
  94.     /**
  95.      * 缓存List数据
  96.      *
  97.      * @param key 缓存的键值
  98.      * @param dataList 待缓存的List数据
  99.      * @return 缓存的对象
  100.      */
  101.     public <T> long setCacheList(final String key, final List<T> dataList)
  102.     {
  103.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  104.         return count == null ? 0 : count;
  105.     }
  107.     /**
  108.      * 获得缓存的list对象
  109.      *
  110.      * @param key 缓存的键值
  111.      * @return 缓存键值对应的数据
  112.      */
  113.     public <T> List<T> getCacheList(final String key)
  114.     {
  115.         return redisTemplate.opsForList().range(key, 0, -1);
  116.     }
  118.     /**
  119.      * 缓存Set
  120.      *
  121.      * @param key 缓存键值
  122.      * @param dataSet 缓存的数据
  123.      * @return 缓存数据的对象
  124.      */
  125.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
  126.     {
  127.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  128.         Iterator<T> it = dataSet.iterator();
  129.         while (it.hasNext())
  130.         {
  131.             setOperation.add(it.next());
  132.         }
  133.         return setOperation;
  134.     }
  136.     /**
  137.      * 获得缓存的set
  138.      *
  139.      * @param key
  140.      * @return
  141.      */
  142.     public <T> Set<T> getCacheSet(final String key)
  143.     {
  144.         return redisTemplate.opsForSet().members(key);
  145.     }
  147.     /**
  148.      * 缓存Map
  149.      *
  150.      * @param key
  151.      * @param dataMap
  152.      */
  153.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
  154.     {
  155.         if (dataMap != null) {
  156.             redisTemplate.opsForHash().putAll(key, dataMap);
  157.         }
  158.     }
  160.     /**
  161.      * 获得缓存的Map
  162.      *
  163.      * @param key
  164.      * @return
  165.      */
  166.     public <T> Map<String, T> getCacheMap(final String key)
  167.     {
  168.         return redisTemplate.opsForHash().entries(key);
  169.     }
  171.     /**
  172.      * 往Hash中存入数据
  173.      *
  174.      * @param key Redis键
  175.      * @param hKey Hash键
  176.      * @param value 值
  177.      */
  178.     public <T> void setCacheMapValue(final String key, final String hKey, final T value)
  179.     {
  180.         redisTemplate.opsForHash().put(key, hKey, value);
  181.     }
  183.     /**
  184.      * 获取Hash中的数据
  185.      *
  186.      * @param key Redis键
  187.      * @param hKey Hash键
  188.      * @return Hash中的对象
  189.      */
  190.     public <T> T getCacheMapValue(final String key, final String hKey)
  191.     {
  192.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  193.         return opsForHash.get(key, hKey);
  194.     }
  196.     /**
  197.      * 删除Hash中的数据
  198.      * 
  199.      * @param key
  200.      * @param hkey
  201.      */
  202.     public void delCacheMapValue(final String key, final String hkey)
  203.     {
  204.         HashOperations hashOperations = redisTemplate.opsForHash();
  205.         hashOperations.delete(key, hkey);
  206.     }
  208.     /**
  209.      * 获取多个Hash中的数据
  210.      *
  211.      * @param key Redis键
  212.      * @param hKeys Hash键集合
  213.      * @return Hash对象集合
  214.      */
  215.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
  216.     {
  217.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  218.     }
  220.     /**
  221.      * 获得缓存的基本对象列表
  222.      *
  223.      * @param pattern 字符串前缀
  224.      * @return 对象列表
  225.      */
  226.     public Collection<String> keys(final String pattern)
  227.     {
  228.         return redisTemplate.keys(pattern);
  229.     }
  230. }
  2. import javax.servlet.http.HttpServletResponse;
  3. import java.io.IOException;
  5. public class WebUtils
  6. {
  7.     /**
  8.      * 将字符串渲染到客户端
  9.      * 
  10.      * @param response 渲染对象
  11.      * @param string 待渲染的字符串
  12.      * @return null
  13.      */
  14.     public static String renderString(HttpServletResponse response, String string) {
  15.         try
  16.         {
  17.             response.setStatus(200);
  18.             response.setContentType("application/json");
  19.             response.setCharacterEncoding("utf-8");
  20.             response.getWriter().print(string);
  21.         }
  22.         catch (IOException e)
  23.         {
  24.             e.printStackTrace();
  25.         }
  26.         return null;
  27.     }
  28. }
  1. 实体类
  1. import java.io.Serializable;
  2. import java.util.Date;
  5. /**
  6.  * 用户表(User)实体类
  7.  */
  8. @Data
  9. @AllArgsConstructor
  10. @NoArgsConstructor
  11. public class User implements Serializable {
  12.     private static final long serialVersionUID = -40356785423868312L;
  14.     /**
  15.     * 主键
  16.     */
  17.     private Long id;
  18.     /**
  19.     * 用户名
  20.     */
  21.     private String userName;
  22.     /**
  23.     * 昵称
  24.     */
  25.     private String nickName;
  26.     /**
  27.     * 密码
  28.     */
  29.     private String password;
  30.     /**
  31.     * 账号状态（0正常 1停用）
  32.     */
  33.     private String status;
  34.     /**
  35.     * 邮箱
  36.     */
  37.     private String email;
  38.     /**
  39.     * 手机号
  40.     */
  41.     private String phonenumber;
  42.     /**
  43.     * 用户性别（0男，1女，2未知）
  44.     */
  45.     private String sex;
  46.     /**
  47.     * 头像
  48.     */
  49.     private String avatar;
  50.     /**
  51.     * 用户类型（0管理员，1普通用户）
  52.     */
  53.     private String userType;
  54.     /**
  55.     * 创建人的用户id
  56.     */
  57.     private Long createBy;
  58.     /**
  59.     * 创建时间
  60.     */
  61.     private Date createTime;
  62.     /**
  63.     * 更新人
  64.     */
  65.     private Long updateBy;
  66.     /**
  67.     * 更新时间
  68.     */
  69.     private Date updateTime;
  70.     /**
  71.     * 删除标志（0代表未删除，1代表已删除）
  72.     */
  73.     private Integer delFlag;
  74. }

实现

数据库校验用户

自定义UserDetailsService,让SpringSecurity使用我们的UserDetailsService,使用自定义的UserDetailsService可以从数据库查询用户名和密码

准备工作
  1. 新建用户表
  1. CREATE TABLE `sys_user` (
  2.   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  3.   `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  4.   `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  5.   `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  6.   `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
  7.   `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
  8.   `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
  9.   `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
  10.   `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
  11.   `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
  12.   `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
  13.   `create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
  14.   `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
  15.   `update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
  16.   `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
  17.   PRIMARY KEY (`id`)
  18. ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'
  1. 引入MybatisPlus和Mysql驱动依赖
  1.         <dependency>
  2.             <groupId>com.baomidou</groupId>
  3.             <artifactId>mybatis-plus-boot-starter</artifactId>
  4.             <version>3.4.3</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>mysql</groupId>
  8.             <artifactId>mysql-connector-java</artifactId>
  9.         </dependency>
  1. 配置数据库连接
  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://localhost:3306/springsecurity?characterEncoding=utf-8&serverTimezone=UTC
  4.     username: root
  5.     password: 5247
  6.     driver-class-name: com.mysql.cj.jdbc.Driver
  1. 修改实体类User
  1. 定义UserMapper接口
  1. public interface UserMapper extends BaseMapper<User> {
  2. }
  1. 配置Mapper扫描
  1. package gdut.edu;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. @SpringBootApplication
  8. @MapperScan("gdut.edu.Mapper")
  9. public class MyApplication {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(MyApplication.class,args);
  12.     }
  13. }
  1. 添加junit测试依赖
  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-test</artifactId>
  4.         </dependency>
  1. 测试MP是否可以正常使用
  1. @SpringBootTest
  2. public class UserMapperTest {
  4.     @Autowired
  5.     private UserMapper userMapper;
  7.     @Test
  8.     public void testInsert(){
  9.         User user = new User();
  10.         user.setNickName("name1");
  11.         user.setSex("1");
  12.         user.setUserName("张三");
  13.         int res = userMapper.insert(user);
  14.         System.out.println(res);
  15.     }
  16. }

核心代码实现
  1. 创建一个UserDetailsServiceImpl实现UserDetailsService接口，并重写其中的方法，根据用户名从数据库查询用户信息
  2. @Service
  3. public class UserDetailsServiceImpl implements UserDetailsService {
  5.     @Autowired
  6.     private UserMapper userMapper;
  8.     @Override
  9.     public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
  10. //        根据用户名查询用户信息
  11.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  12.         queryWrapper.eq(User::getUserName,"dt");
  13.         User user = userMapper.selectOne(queryWrapper);
  14.         if(Objects.isNull(user)){
  15.             throw new RuntimeException("用户名或密码错误");
  16.         }
  17. //        TODO 根据用户查询权限信息，添加到LoginUser中
  18. //        封装成UserDetails对象返回
  21.         return new UserLogin(user);
  22.     }
  23. }
  1. 因为UserDetailsService返回值是UserDetails类型，所以定义一个UserLogin类，实现该接口，把用户信息封装在里面
  2. @Data
  3. @NoArgsConstructor
  4. @AllArgsConstructor
  5. public class UserLogin implements UserDetails {
  6.     private User user;
  8.     @Override
  9.     public Collection<? extends GrantedAuthority> getAuthorities() {
  10.         return null;
  11.     }
  13.     @Override
  14.     public String getPassword() {
  15.         return user.getPassword();
  16.     }
  18.     @Override
  19.     public String getUsername() {
  20.         return user.getUserName();
  21.     }
  23.     @Override
  24.     public boolean isAccountNonExpired() {
  25.         return true;
  26.     }
  28.     @Override
  29.     public boolean isAccountNonLocked() {
  30.         return true;
  31.     }
  33.     @Override
  34.     public boolean isCredentialsNonExpired() {
  35.         return true;
  36.     }
  38.     @Override
  39.     public boolean isEnabled() {
  40.         return true;
  41.     }
  42. }
  • 注意：如果要测试，需要插入数据到数据库，如果想要明文存储密码，需要在密码的前面加上{noop},例如

1656049760108.png

  • 这样登录的时候就可以用dt作为用户名，1234作为密码了

密码加密存储

实际项目中我们不会把密码明文存储在数据库中。

  1. 默认使用的PasswordEncoder要求数据库中的密码格式为：{id}password 。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换PasswordEncoder。
  3. 我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
  5. 我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。
  7. 我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。
  1. @Configuration
  2. public class SecurityConfig {
  4.     @Bean
  5.     public PasswordEncoder passwordEncoder() {
  6.         return new BCryptPasswordEncoder();
  7.     }
  9. }
  • 测试
  1.     @Autowired
  2.     private PasswordEncoder passwordEncoder;
  4.     @Test
  5.     public void encodeTest() {
  6.         String password = "1234";
  7.         password = passwordEncoder.encode(password);
  8.         System.out.println(password);
  9.         System.out.println(passwordEncoder.matches("1234", password));
  11.     }

Jwt测试

  1.     @Test
  2.     public void jwtTest() throws Exception {
  3.         String jwt = JwtUtil.createJWT("1234");
  4.         System.out.println(jwt);
  5.         Claims claims = JwtUtil.parseJWT(jwt);
  6.         System.out.println(claims.getSubject());
  7.     }

登录接口

接下我们需要自定义登陆接口，然后让SpringSecurity对这个接口放行,让用户访问这个接口的时候不用登录也能访问。

  1. 在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器。
  3. 认证成功的话要生成一个jwt，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。
  • 登录接口
  1. @RestController
  2. public class LoginController {
  4.     @Autowired
  5.     private LoginService loginService;
  7.     @PostMapping("/user/login")
  8.     public ResponseResult login(@RequestBody User user) {
  9.         System.out.println(user);
  10.         return loginService.login(user);
  11.     }
  12. }
  • SecurityConfig配置，注入AuthenticationManager到容器，放行/user/login接口
  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  4.     @Bean
  5.     public PasswordEncoder passwordEncoder() {
  6.         return new BCryptPasswordEncoder();
  7.     }
  9.     @Override
  10.     protected void configure(HttpSecurity http) throws Exception {
  11.         http
  12.                 //关闭csrf
  13.                 .csrf().disable()
  14.                 //不通过Session获取SecurityContext
  15.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  16.                 .and()
  17.                 .authorizeRequests()
  18.                 // 对于登录接口 允许匿名访问
  19.                 .antMatchers("/user/login").anonymous()
  20.                 // 除上面外的所有请求全部需要鉴权认证
  21.                 .anyRequest().authenticated();
  22.     }
  24.     @Bean
  25.     @Override
  26.     public AuthenticationManager authenticationManagerBean() throws Exception {
  27.         return super.authenticationManagerBean();
  28.     }
  29. }
  • 认证成功生成jwt，并放入响应中返回给前端保存到本地,将用户信息保存到redis
  1. @Service
  2. public class LoginServiceImpl extends ServiceImpl<UserMapper, User> implements LoginService {
  4.     @Autowired
  5.     private AuthenticationManager authenticationManager;
  7.     @Autowired
  8.     private RedisCache redisCache;
  10.     public ResponseResult login(User user) {
  11. //        AuthenticationManager authenticate 进行用户认证
  12.         UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
  13.         Authentication authenticate = authenticationManager.authenticate(authenticationToken);
  15. //        如果认证没有通过，给出用户提示
  16.         if (Objects.isNull(authenticate)){
  17.             throw new RuntimeException("登录失败");
  18.         }
  19. //        认证通过，使用userid生成一个jwt，jwt存入ResponseResult返回
  20.         UserLogin userLogin = (UserLogin) authenticate.getPrincipal();
  21.         String userId = userLogin.getUser().getId().toString();
  22.         String jwt = JwtUtil.createJWT(userId);
  25. //        把完整的用户信息存入redis，userid为key
  26.         redisCache.setCacheObject("login:"+userId,userLogin);
  27.         HashMap<String, String> map = new HashMap<>();
  28.         map.put("token",jwt);
  29.         return new ResponseResult(200,"登录成功",map);
  30.     }
  31. }

认证过滤器

我们需要自定义一个过滤器，这个过滤器会去获取请求头中的token，对token进行解析取出其中的userid。使用userid去redis中获取对应的UserLogin对象。然后封装Authentication对象存入SecurityContextHolder。

  • 自定义JwtAuthenticationTokenFilter过滤器（注意：继承的是OncePerRequestFilter）
  1. /**
  2.  * @Description token认证的过滤器
  3.  * @Author JiaFu
  4.  * @Date 2022/7/5 15:49
  5.  */
  6. @Component
  7. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
  8.     @Autowired
  9.     private RedisCache redisCache;
  11.     @Override
  12.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  13. //        获取token
  14.         String token = request.getHeader("token");
  15.         if (!StringUtils.hasText(token)) {
  16. //            放行
  17.             filterChain.doFilter(request,response);
  18. //            这里需要return防止走完后面的过滤器之后又接着执行下面解析token的代码
  19.             return;
  20.         }
  21. //        解析token
  22.         String userId;
  23.         try {
  24.             Claims claims = JwtUtil.parseJWT(token);
  25.             userId = claims.getSubject();
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.             throw new RuntimeException("token非法");
  29.         }
  30. //        从redis中获取用户信息
  31.         String redisKey = "login:" + userId;
  32.         UserLogin userLogin = redisCache.getCacheObject(redisKey);
  33.         if (Objects.isNull(userLogin)){
  34.             throw new RuntimeException("用户未登录");
  35.         }
  36. //        将用户信息存入SecurityContextHolder
  37.         UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(userLogin, null, null);
  38.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
  39. //        放行
  40.         filterChain.doFilter(request,response);
  41.     }
  42. }
  • 将自定义的过滤器添加到过滤器链当中，添加到UsernamePasswordAuthenticationFilter的前面
  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  4.     @Autowired
  5.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  6.     @Bean
  7.     public PasswordEncoder passwordEncoder() {
  8.         return new BCryptPasswordEncoder();
  9.     }
  11.     @Override
  12.     protected void configure(HttpSecurity http) throws Exception {
  13.         http
  14.                 //关闭csrf
  15.                 .csrf().disable()
  16.                 //不通过Session获取SecurityContext
  17.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  18.                 .and()
  19.                 .authorizeRequests()
  20.                 // 对于登录接口 允许匿名访问
  21.                 .antMatchers("/user/login").anonymous()
  22.                 // 除上面外的所有请求全部需要鉴权认证
  23.                 .anyRequest().authenticated();
  24. //        把token校验过滤器添加到过滤器链当中
  25.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  26.     }
  28.     @Bean
  29.     @Override
  30.     public AuthenticationManager authenticationManagerBean() throws Exception {
  31.         return super.authenticationManagerBean();
  32.     }
  33. }

推出登录

我们只需要定义一个推出登录接口/user/logout，然后获取SecurityContextHolder中的认证信息，删除redis中对应的数据即可。

  • 接口
  1. @RestController
  2. public class LoginController {
  4.     @Autowired
  5.     private LoginService loginService;
  7.     @PostMapping("/user/login")
  8.     public ResponseResult login(@RequestBody User user) {
  9.         System.out.println(user);
  10.         return loginService.login(user);
  11.     }
  13.     @GetMapping("/user/logout")
  14.     public ResponseResult logout(){
  15.         return loginService.logout();
  16.     }
  17. }
  • 推出登录的实现
  1. @Service
  2. public class LoginServiceImpl extends ServiceImpl<UserMapper, User> implements LoginService {
  4.     @Autowired
  5.     private AuthenticationManager authenticationManager;
  7.     @Autowired
  8.     private RedisCache redisCache;
  10.     public ResponseResult login(User user) {
  11. //        AuthenticationManager authenticate 进行用户认证
  12.         UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
  13.         Authentication authenticate = authenticationManager.authenticate(authenticationToken);
  15. //        如果认证没有通过，给出用户提示
  16.         if (Objects.isNull(authenticate)){
  17.             throw new RuntimeException("登录失败");
  18.         }
  19. //        认证通过，使用userid生成一个jwt，jwt存入ResponseResult返回
  20.         UserLogin userLogin = (UserLogin) authenticate.getPrincipal();
  21.         String userId = userLogin.getUser().getId().toString();
  22.         String jwt = JwtUtil.createJWT(userId);
  25. //        把完整的用户信息存入redis，userid为key
  26.         redisCache.setCacheObject("login:"+userId,userLogin);
  27.         HashMap<String, String> map = new HashMap<>();
  28.         map.put("token",jwt);
  29.         return new ResponseResult(200,"登录成功",map);
  30.     }
  32.     @Override
  33.     public ResponseResult logout() {
  34. //        获取SecurityContextHolder中的userId
  35.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  36.         UserLogin userLogin = (UserLogin) authentication.getPrincipal();
  37.         Long userId = userLogin.getUser().getId();
  38. //        删除redis中user的信息
  39.         redisCache.deleteObject("login:"+userId);
  40.         return new ResponseResult(200,"注销成功");
  41.     }
  42. }

SpringSecurity的一些配置(api的访问)

  1.     @Override
  2.     protected void configure(HttpSecurity http) throws Exception {
  3.         http
  4.                 //关闭csrf
  5.                 .csrf().disable()
  6.                 //不通过Session获取SecurityContext
  7.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  8.                 .and()
  9.                 .authorizeRequests()
  10.                 // 对于登录接口 允许匿名访问，注意：只有在没有登录的情况下可以访问，已登录了则不可以访问
  11.                 .antMatchers("/user/login").anonymous()
  12.                 .antMatchers("/hello").permitAll()//允许用户登录或不登录都可以访问
  13.                 // 除上面外的所有请求全部需要鉴权认证
  14.                 .anyRequest().authenticated();
  15. //        把token校验过滤器添加到过滤器链当中
  16.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  17.     }

授权

授权的作用

例如一个学校图书馆的管理系统，如果是普通学生登录就能看到借书还书相关的功能，不可能让他看到并且去使用添加书籍信息，删除书籍信息等功能。但是如果是一个图书馆管理员的账号登录了，应该就能看到并使用添加书籍信息，删除书籍信息等功能。

  1. 总结起来就是**不同的用户可以使用不同的功能**。这就是权限系统要去实现的效果。
  3. 我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。
  5. 所以我们还需要在后台进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作。

授权的基本流程

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

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

授权的实现

限制访问资源所需权限

SpringSecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限。

  1. 但是要使用它我们需要先开启相关配置。`@EnableGlobalMethodSecurity(prePostEnabled = true)`
  1. @Configuration
  2. @EnableGlobalMethodSecurity(prePostEnabled = true)
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  5.     @Autowired
  6.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  7.     @Bean
  8.     public PasswordEncoder passwordEncoder() {
  9.         return new BCryptPasswordEncoder();
  10.     }
  12.     @Override
  13.     protected void configure(HttpSecurity http) throws Exception {
  14.         http
  15.                 //关闭csrf
  16.                 .csrf().disable()
  17.                 //不通过Session获取SecurityContext
  18.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  19.                 .and()
  20.                 .authorizeRequests()
  21.                 // 对于登录接口 允许匿名访问，注意：只有在没有登录的情况下可以访问，已登录了则不可以访问
  22.                 .antMatchers("/user/login").anonymous()
  23.                 .antMatchers("/hello").permitAll()//允许用户登录或不登录都可以访问
  24.                 // 除上面外的所有请求全部需要鉴权认证
  25.                 .anyRequest().authenticated();
  26. //        把token校验过滤器添加到过滤器链当中
  27.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  28.     }
  30.     @Bean
  31.     @Override
  32.     public AuthenticationManager authenticationManagerBean() throws Exception {
  33.         return super.authenticationManagerBean();
  34.     }
  35. }

然后就可以使用对应的注解。@PreAuthorize 

  1. @RestController
  2. public class HelloController {
  4.     @GetMapping("/hello")
  5.     @PreAuthorize("hasAuthority('test')")
  6.     public String hello(){
  7.         return "hello";
  8.     }
  9. }

封装权限信息

我们前面在写UserDetailsServiceImpl的时候说过，在查询出用户后还要获取对应的权限信息，封装到UserDetails中返回。

  1. 我们先直接把权限信息写死封装到UserDetails中进行测试。
  3. 我们之前定义了UserDetails的实现类LoginUser，想要让其能封装权限信息就要对其进行修改。
  1. @Data
  2. @NoArgsConstructor
  3. public class UserLogin implements UserDetails {
  4.     private User user;
  6. //    存储权限信息
  7.     private List<String> permissions;
  9. //    存储SpringSecurity所需的权限信息的集合
  10.     @JSONField(serialize = false)
  11.     private List<GrantedAuthority> authorities;
  13.     public UserLogin(User user, List<String> permissions) {
  14.         this.user = user;
  15.         this.permissions = permissions;
  16.     }
  18.     @Override
  19.     public Collection<? extends GrantedAuthority> getAuthorities() {
  20.         if (authorities != null){
  21.             return authorities;
  22.         }
  23. //        for (String permission : permissions) {
  24. //            SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(permission);
  25. //            authorities.add(simpleGrantedAuthority);
  26. //        }
  27.         //把permissions中字符串类型的权限信息转换成GrantedAuthority对象存入authorities中
  28.         authorities = permissions.stream()
  29.                 .map(SimpleGrantedAuthority::new)
  30.                 .collect(Collectors.toList());
  31.         return authorities;
  32.     }
  34.     @Override
  35.     public String getPassword() {
  36.         return user.getPassword();
  37.     }
  39.     @Override
  40.     public String getUsername() {
  41.         return user.getUserName();
  42.     }
  44.     @Override
  45.     public boolean isAccountNonExpired() {
  46.         return true;
  47.     }
  49.     @Override
  50.     public boolean isAccountNonLocked() {
  51.         return true;
  52.     }
  54.     @Override
  55.     public boolean isCredentialsNonExpired() {
  56.         return true;
  57.     }
  59.     @Override
  60.     public boolean isEnabled() {
  61.         return true;
  62.     }
  63. }

LoginUser修改完后我们就可以在UserDetailsServiceImpl中去把权限信息封装到LoginUser中了。我们写死权限进行测试，后面我们再从数据库中查询权限信息。

  1. @Service
  2. public class UserDetailsServiceImpl implements UserDetailsService {
  4.     @Autowired
  5.     private UserMapper userMapper;
  7.     @Override
  8.     public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
  9. //        根据用户名查询用户信息
  10.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  11.         queryWrapper.eq(User::getUserName,"dt");
  12.         User user = userMapper.selectOne(queryWrapper);
  13.         if(Objects.isNull(user)){
  14.             throw new RuntimeException("用户名或密码错误");
  15.         }
  16. //        TODO 根据用户查询权限信息，添加到LoginUser中
  17.         ArrayList<String> list = new ArrayList<>(Arrays.asList("test","admin"));
  18. //        封装成UserDetails对象返回
  19.         return new UserLogin(user,list);
  20.     }
  22. }

自定义失败处理

我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道SpringSecurity的异常处理机制。

  1. 在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。
  3. 如果是认证过程中出现的异常会被封装成AuthenticationException然后调用**AuthenticationEntryPoint**对象的方法去进行异常处理。
  5. 如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用**AccessDeniedHandler**对象的方法去进行异常处理。
  7. 所以如果我们需要自定义异常处理，我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可。
  • 自定义实现类
  1. /**
  2.  * @Description 权限异常处理器
  3.  * @Author JiaFu
  4.  * @Date 2022/7/5 21:07
  5.  */
  6. @Component
  7. public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
  8.     @Override
  9.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
  10.         ResponseResult<Object> responseResult = new ResponseResult<>(HttpStatus.UNAUTHORIZED.value(), "权限不足");
  11.         String json = JSON.toJSONString(responseResult);
  12.         WebUtils.renderString(response,json);
  13.     }
  14. }
  1. /**
  2.  * @Description 认证异常处理器
  3.  * @Author JiaFu
  4.  * @Date 2022/7/5 21:12
  5.  */
  6. @Component
  7. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
  8.     @Override
  9.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
  10.         ResponseResult<Object> responseResult = new ResponseResult<>(HttpStatus.FORBIDDEN.value(), "认证失败，请重新登录");
  11.         String json = JSON.toJSONString(responseResult);
  12.         WebUtils.renderString(response,json);
  13.     }
  14. }
  • 配置给SpringSecurity

注入对应的处理器

  1.     @Autowired
  2.     private AccessDeniedHandler accessDeniedHandler;
  4.     @Autowired
  5.     private AuthenticationEntryPoint authenticationEntryPoint;

然后使用HttpSecurity对象的方法去配置

  1. //        配置异常处理器
  2.         http
  3.                 .exceptionHandling()
  4.                 .accessDeniedHandler(accessDeniedHandler)
  5.                 .authenticationEntryPoint(authenticationEntryPoint);

跨域

浏览器出于安全的考虑，使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。

  1. 前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题。
  3. 所以我们就要处理一下，让前端能进行跨域请求。(解决跨域问题的实质是给响应头设置一些字段及值)
  • 先对SpringBoot配置，运行跨域请求
  1. /**
  2.  * @Description 跨域配置
  3.  * @Author JiaFu
  4.  * @Date 2022/7/5 21:45
  5.  */
  6. @Configuration
  7. public class CorsConfig implements WebMvcConfigurer {
  8.     @Override
  9.     public void addCorsMappings(CorsRegistry registry) {
  10. //        设置允许跨域的路径
  11.         registry
  12.                 .addMapping("/**")
  13. //                设置允许跨域请求的域名
  14.                 .allowedOriginPatterns("*")
  15. //                是否允许cookie
  16.                 .allowCredentials(true)
  17. //                设置允许的请求方式
  18.                 .allowedMethods("GET", "POST", "DELETE", "PUT")
  19. //                设置允许的header的属性
  20.                 .allowedHeaders("*")
  21. //                设置允许跨域的时间
  22.                 .maxAge(3600);
  24.     }
  25. }
  • 开启SpringSecurity的跨域访问,由于我们的资源都会收到SpringSecurity的保护，所以想要跨域访问还要让SpringSecurity运行跨域访问。配置securityconfig
  1.     @Override
  2.     protected void configure(HttpSecurity http) throws Exception {
  3.         http
  4.                 //关闭csrf
  5.                 .csrf().disable()
  6.                 //不通过Session获取SecurityContext
  7.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  8.                 .and()
  9.                 .authorizeRequests()
  10.                 // 对于登录接口 允许匿名访问，注意：只有在没有登录的情况下可以访问，已登录了则不可以访问
  11.                 .antMatchers("/user/login").anonymous()
  12. //                .antMatchers("/hello").permitAll()//允许用户登录或不登录都可以访问
  13.                 // 除上面外的所有请求全部需要鉴权认证
  14.                 .anyRequest().authenticated();
  15. //        把token校验过滤器添加到过滤器链当中
  16.         http
  17.                 .addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  18. //        配置异常处理器
  19.         http
  20.           /**
  21.  * @Description 自定义权限
  22.  * @Author JiaFu
  23.  * @Date 2022/7/6 9:41
  24.  */
  25. @Component("ex")
  26. public class JFExpressionRoot {
  27.     public boolean hasAuthority(String authority){
  28. //        获取当前用户权限
  29.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  30.         UserLogin userLogin = (UserLogin) authentication.getPrincipal();
  31.         List<String> permissions = userLogin.getPermissions();
  32. //        判断权限集合中是否存在authority
  33.         return permissions.contains(authority);
  34.     }
  35. }
  36.       .exceptionHandling()
  37.                 .accessDeniedHandler(accessDeniedHandler)
  38.                 .authenticationEntryPoint(authenticationEntryPoint);
  39. //        允许跨域
  40.         http.cors();
  42.     }

自定义权限校验

我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。

  1. /**
  2.  * @Description 自定义权限
  3.  * @Author JiaFu
  4.  * @Date 2022/7/6 9:41
  5.  */
  6. @Component("ex")
  7. public class JFExpressionRoot {
  8.     public boolean hasAuthority(String authority){
  9. //        获取当前用户权限
  10.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  11.         UserLogin userLogin = (UserLogin) authentication.getPrincipal();
  12.         List<String> permissions = userLogin.getPermissions();
  13. //        判断权限集合中是否存在authority
  14.         return permissions.contains(authority);
  15.     }
  16. }

在SPEL表达式中使用 @ex相当于获取容器中bean的名字未ex的对象。然后再调用这个对象的hasAuthority方法

  1.     @GetMapping("/hello")
  2. //    @PreAuthorize("hasAuthority('test')")
  3.     @PreAuthorize("@ex.hasAuthority('test')")
  4.     public String hello(){
  5.         return "hello";
  6.     }

基于配置的权限控制

http.antMatchers("/hello").hasAuthority("test")

  1.     @Override
  2.     protected void configure(HttpSecurity http) throws Exception {
  3.         http
  4.                 //关闭csrf
  5.                 .csrf().disable()
  6.                 //不通过Session获取SecurityContext
  7.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  8.                 .and()
  9.                 .authorizeRequests()
  10.                 // 对于登录接口 允许匿名访问，注意：只有在没有登录的情况下可以访问，已登录了则不可以访问
  11.                 .antMatchers("/user/login").anonymous()
  12. //                .antMatchers("/hello").permitAll()//允许用户登录或不登录都可以访问
  13.                 .antMatchers("/hello").hasAuthority("test")//用户需要有test权限才可以访问
  14.                 // 除上面外的所有请求全部需要鉴权认证
  15.                 .anyRequest().authenticated();
  16. //        把token校验过滤器添加到过滤器链当中
  17.         http
  18.                 .addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  19. //        配置异常处理器
  20.         http
  21.                 .exceptionHandling()
  22.                 .accessDeniedHandler(accessDeniedHandler)
  23.                 .authenticationEntryPoint(authenticationEntryPoint);
  24. //        允许跨域
  25.         http.cors();
  27.     }