【Spring Boot 3】的安全防线：整合 【Spring Security 6】

简介

Spring Security 是 Spring 家属中的一个安全管理框架。相比与别的一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。
一般来说中大型的项目都是使用SpringSecurity 来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。
一般Web应用的需要举行认证和授权。
认证：验证当前访问系统的是不是本系统的用户，而且要确认详细是哪个用户
授权：经过认证后判定当前用户是否有权限举行某个使用
而认证和授权也是SpringSecurity作为安全框架的核心功能。
1.快速入门

1.1.引入依赖

1. <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-security -->
2. <dependency>
3.     <groupId>org.springframework.boot</groupId>
4.     <artifactId>spring-boot-starter-security</artifactId>
5.     <version>3.1.8</version>
6. </dependency>

复制代码

如果是gradle则使用

1. // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-security
2. implementation group: 'org.springframework.boot', name: 'spring-boot-starter-security', version: '3.1.8'

复制代码

引入SpringSecurity依赖后，再次输入所在，都会统一调转到一个登录界面，登录用户名是user,密码是在项目启动时，输出在控制台

2.SpringBoot整合Redis

   我是在Windos环境下安装Redis，这里在Windows下启动Redis 需要进入到安装目次库
  输入 redis-server.exe redis.windows.conf
  

2.1.引入依赖

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-data-redis</artifactId>
4.     <version>3.1.8</version>
5. </dependency>

复制代码

1. implementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis', version: '3.1.8'

复制代码

2.2.设置Redis

   在设置文件中对redis举行设置

1. # redis相关配置
2. spring:
3.   data:
4.     redis:
5.       port: 6379
6.       host: 127.0.0.1

复制代码

2.3.使用Redis Template

2.3.1.将Redis Template注入到Spring容器中

   主要是为了 统一管理

1. @Configuration
2. public class RedisTemplateConfig {
3.     @Bean("sysMyRedisTemplate")
4.     public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
5.         RedisTemplate<String, T> redisTemplate = new RedisTemplate<>();
6.         redisTemplate.setConnectionFactory(redisConnectionFactory);
7.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
8.         ObjectMapper om = new ObjectMapper();
9.         // 持久化改动.设置可见性,
10.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
11.         // 持久化改动.非final类型的对象，把对象类型也序列化进去，以便反序列化推测正确的类型
12.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
13.         // 持久化改动.null字段不显示
14.         om.setSerializationInclusion(JsonInclude.Include.NON_NULL);
15.         // 持久化改动.POJO无public属性或方法时不报错
16.         om.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
17.         // 持久化改动.setObjectMapper方法移除.使用构造方法传入ObjectMapper
18.         GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(om);
19.         redisTemplate.setKeySerializer(redisSerializer);
20.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
21.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
22.         redisTemplate.setHashKeySerializer(redisSerializer);
23.         redisTemplate.afterPropertiesSet();
24.         return redisTemplate;
25.     }
26. }

复制代码

2.3.2.RedisTemplate工具类

   为了方便使用，可以封装一下工具类进使用用

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

复制代码

2.3.3.测试

   测试是否能正常使用

1.         @RequestMapping("/redis")
2.         public String redis(){
3.                 redisCache.setCacheObject("test", "test");
4.                 return redisCache.getCacheObject("test").toString();
5.         }

复制代码

3.SpringBoot整合JJWT

3.1.引入依赖

1. <!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
2. <dependency>
3.     <groupId>io.jsonwebtoken</groupId>
4.     <artifactId>jjwt</artifactId>
5.     <version>0.12.5</version>
6. </dependency>

复制代码

1. implementation group: 'io.jsonwebtoken', name: 'jjwt', version: '0.12.5'

复制代码

3.2.JJW工具类

   为了方便使用，我们将其封装成一个工具类
由于使用的版本是新版本的JDK 以及 JJWT所以网 这里的工具类 写法会有些出入

1. /**
2. * JWT Token工具类，用于生成和解析JWT Token
3. *
4. * @Author: Tiam
5. * @Date: 2023/10/23 16:38
6. */
7. public class TokenUtil {
8.     /**
9.      * 过期时间(单位:秒)
10.      */
11.     public static final int ACCESS_EXPIRE = 60 * 60 * 60;
13.     /**
14.      * 加密算法
15.      */
16.     private final static SecureDigestAlgorithm<SecretKey, SecretKey> ALGORITHM = Jwts.SIG.HS256;
18.     /**
19.      * 私钥 / 生成签名的时候使用的秘钥secret，一般可以从本地配置文件中读取。
20.      * 切记：秘钥不能外露，在任何场景都不应该流露出去。
21.      * 应该大于等于 256位(长度32及以上的字符串)，并且是随机的字符串
22.      */
23.     public final static String SECRET = "secrasdddddddddddddddddddddddddddddddddwqeqeqwewqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqetKey";
25.     /**
26.      * 秘钥实例
27.      */
28.     public static final SecretKey KEY = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
30.     /**
31.      * jwt签发者
32.      */
33.     private final static String JWT_ISS = "Tiam";
35.     /**
36.      * jwt主题
37.      */
38.     private final static String SUBJECT = "Peripherals";
40.     /**
41.      * 生成访问令牌
42.      *
43.      * @param username 用户名
44.      * @return 访问令牌
45.      */
46.     public static String genAccessToken(String username) {
47.         // 生成令牌ID
48.         String uuid = UUID.randomUUID().toString();
49.         // 设置过期时间
50.         Date expireDate = Date.from(Instant.now().plusSeconds(ACCESS_EXPIRE));
52.         return Jwts.builder()
53.                 // 设置头部信息
54.                 .header()
55.                 .add("typ", "JWT")
56.                 .add("alg", "HS256")
57.                 .and()
58.                 // 设置自定义负载信息
59.                 .claim("username", username)
60.                 .id(uuid) // 令牌ID
61.                 .expiration(expireDate) // 过期日期
62.                 .issuedAt(new Date()) // 签发时间
63.                 .subject(SUBJECT) // 主题
64.                 .issuer(JWT_ISS) // 签发者
65.                 .signWith(KEY, ALGORITHM) // 签名
66.                 .compact();
67.     }
71.     /**
72.      * 获取payload中的用户信息
73.      *
74.      * @param token JWT Token
75.      * @return 用户信息
76.      */
77.     public static String getUserFromToken(String token) {
78.         String user = "";
79.         Claims claims = parseClaims(token);
80.         if (claims != null) {
81.             user = (String) claims.get("username");
82.         }
83.         return user;
84.     }
86.     /**
87.      * 获取JWT令牌的过期时间
88.      *
89.      * @param token JWT令牌
90.      * @return 过期时间的毫秒级时间戳
91.      */
92.     public static long getExpirationTime(String token) {
94.         Claims claims = parseClaims(token);
95.         if (claims != null) {
96.             return claims.getExpiration().getTime();
97.         }
98.         return 0L;
99.     }
100.     /**
101.      * 解析token
102.      *
103.      * @param token token
104.      * @return Jws<Claims>
105.      */
106.     public static Jws<Claims> parseClaim(String token) {
107.         return Jwts.parser()
108.                 .verifyWith(KEY)
109.                 .build()
110.                 .parseSignedClaims(token);
111.     }
113.     /**
114.      * 解析token的头部信息
115.      *
116.      * @param token token
117.      * @return token的头部信息
118.      */
119.     public static JwsHeader parseHeader(String token) {
120.         return parseClaim(token).getHeader();
121.     }
123.     /**
124.      * 解析token的载荷信息
125.      *
126.      * @param token token
127.      * @return token的载荷信息
128.      */
129.     public static Claims parsePayload(String token) {
130.         return parseClaim(token).getPayload();
131.     }
134.     /**
135.      * 解析JWT Token中的Claims
136.      *
137.      * @param token JWT Token
138.      * @return Claims
139.      */
140.     public static Claims parseClaims(String token) {
141.         try {
142.             return Jwts.parser()
143.                     .setSigningKey(KEY)
144.                     .build()
145.                     .parseClaimsJws(token)
146.                     .getBody();
147.         } catch (Exception e) {
148.             return null;
149.         }
150.     }
151. }

复制代码

3.3.测试

1.         @RequestMapping("/jjwt")
2.         public Map<String, String> jjwt(){
3.                 Map<String, String> map = new HashMap<>();
4.                 String tokenByKey = TokenUtil.genAccessToken("hrfan");
5.                 map.put("encoding", tokenByKey);
6.                 return map;
7.         }

复制代码

4.实战

配景
   在企业开辟中，一个安全的登录授权系统是至关重要的，它不仅可以保护用户的隐私信息，还能够确保只有经过授权的用户才气够访问特定的资源和功能。这样的系统不仅仅是为了满足用户的安全需求，也是为了保护企业的敏感数据和资源免受未经授权的访问和恶意攻击。
  起首，一个安全的登录授权系统必须具备可靠的身份验证机制。用户需要能够通过输入凭据（通常是用户名和密码）来验证其身份。这个过程需要包管用户的密码被安全地存储，而且在传输过程中使用加密技能保障用户凭据的安全性。
其次，授权系统需要根据用户的身份和角色来管理用户对资源和功能的访问权限。不同的用户可能具有不同的角色和权限，比方普通用户、管理员、审计员等。系统需要根据用户的角色和权限来限制他们对资源的访问，以确保敏感数据不会被未经授权的用户获取。
下面使用SpringSecurity来实现一个简易的登录认证
用户身份验证

• 登录页面: 我们需要一个登录页面，用户可以在该页面输入他们的凭据以举行身份验证。登录页面应该友爱且易于明确。
  
• 身份验证: 用户的用户名和密码应该被验证，只有在验证通过后才气进入系统。密码应该以安全的方式存储，比方使用哈希算法加密存储。
  
• 认证失败处理: 如果用户提供的凭据无效，则系统应该向用户提供相应的错误消息，并允许他们再次尝试登录。
  

访问控制

• 受保护资源: 我们的系统将有一些受保护的资源和功能，比方管理课程、学生信息等。只有经过身份验证的用户才气访问这些资源。
  
• 角色和权限: 不同类型的用户应该有不同的角色和权限。比方，管理员可能具有管理课程和学生的权限，而普通用户可能只能访问课程内容。
  
• 未经授权的访问: 如果用户尝试访问他们没有权限的资源，则系统应该拒绝访问，并向用户表现适当的错误消息。
  

安全性

• 防范攻击: 我们的系统应该能够防范常见的安全攻击，如跨站脚本攻击、SQL注入等。
  
• 密码安全: 用户的密码不应以明文形式存储在数据库中，而应该使用安全的加密算法举行存储。
  

4.1.创建数据库表

4.1.1.创建用户表

   Spring Security要求实现UserDetails接口是为了统一表现用户身份和权限信息，以便于在认证和授权过程中使用。UserDetails提供了标准化的用户信息模子，包罗用户名、密码、权限等，使得Spring Security能够与不同的用户信息源集成，同时提供机动性和可定制性。
  RBCA模子先容
RBAC（Role-Based Access Control）模子是一种访问控制模子，它基于角色来管理对资源的访问权限。在RBAC模子中，用户被分配到不同的角色，而每个角色具有特定的权限。这种模子使得权限管理更加机动和可扩展，同时低落了管理的复杂性。

• user表代表系统中的用户。
  
• role表代表系统中的角色。
  
• permission表代表系统中的权限。
  
• user_role表用于关联用户与角色。
  
• role_permission表用于关联角色与权限。
  

1. CREATE TABLE "hr_manager"."t_sys_my_user" (
2.         "sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default" NOT NULL,
3.         "user_no" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
4.         "user_name" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
5.         "password" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
6.         "nick_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
7.         "phone_number" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
8.         "email" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
9.         "department_id" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
10.         "department_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
11.         "is_admin" VARCHAR ( 1 ) COLLATE "pg_catalog"."default",
12.         "sex" VARCHAR ( 1 ) COLLATE "pg_catalog"."default",
13.         "post_id" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
14.         "post_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
15.         "is_account_non_expired" bool,
16.         "is_account_non_locked" bool,
17.         "is_credentials_non_expired" bool,
18.         "is_enabled" bool,
19.         "insert_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
20.         "insert_time" DATE,
21.         "update_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
22.         "update_time" DATE,
23.         "license_code" VARCHAR ( 20 ) COLLATE "pg_catalog"."default",
24.         CONSTRAINT "t_sys_my_user_pkey" PRIMARY KEY ( "sid" )
25. );
26. ALTER TABLE "hr_manager"."t_sys_my_user" OWNER TO "postgres";
27. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."sid" IS '主键SID';
28. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."user_no" IS '用户登录账号';
29. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."user_name" IS '用户名称';
30. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."password" IS '用户密码';
31. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."nick_name" IS '用户昵称';
32. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."phone_number" IS '手机号码';
33. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."email" IS '邮箱';
34. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."department_id" IS '部门ID';
35. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."department_name" IS '部门名称';
36. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."is_admin" IS '是否为管理员 0 否 1 是';
37. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."sex" IS '性别 0 男 1 女';
38. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."post_id" IS '岗位ID';
39. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."post_name" IS '岗位名称';
40. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."is_account_non_expired" IS '账户是否过期';
41. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."is_account_non_locked" IS '账户是否被锁定';
42. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."is_credentials_non_expired" IS '密码是否过期';
43. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."is_enabled" IS '账户是否可用';
44. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."insert_user" IS '创建人';
45. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."insert_time" IS '创建时间';
46. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."update_user" IS '更新人';
47. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."update_time" IS '更新时间';
48. COMMENT ON COLUMN "hr_manager"."t_sys_my_user"."license_code" IS '许可标识';

复制代码

4.1.2.创建权限表

1. CREATE TABLE "hr_manager"."t_sys_my_permission" (
2.         "sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default" NOT NULL,
3.         "parent_id" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
4.         "parent_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
5.         "permission_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
6.         "permission_code" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
7.         "router_path" VARCHAR ( 255 ) COLLATE "pg_catalog"."default",
8.         "router_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
9.         "auth_url" VARCHAR ( 255 ) COLLATE "pg_catalog"."default",
10.         "order_no" int4,
11.         "type" VARCHAR ( 1 ) COLLATE "pg_catalog"."default",
12.         "icon" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
13.         "remark" VARCHAR ( 255 ) COLLATE "pg_catalog"."default",
14.         "insert_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
15.         "insert_time" DATE,
16.         "update_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
17.         "update_time" DATE,
18.         "license_code" VARCHAR ( 20 ) COLLATE "pg_catalog"."default",
19.         CONSTRAINT "t_sys_my_permission_pkey" PRIMARY KEY ( "sid" )
20. );
21. ALTER TABLE "hr_manager"."t_sys_my_permission" OWNER TO "postgres";
22. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."sid" IS '主键SID';
23. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."parent_id" IS '父节点ID';
24. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."parent_name" IS '父节点名称';
25. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."permission_name" IS '权限名称';
26. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."permission_code" IS '授权标识符';
27. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."router_path" IS '路由地址';
28. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."router_name" IS '路由名称';
29. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."auth_url" IS '授权路径（对应文件在项目的地址）';
30. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."order_no" IS '序号（用于排序）';
31. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."type" IS '类型 0 目录 1 菜单 2 按钮';
32. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."icon" IS '图标';
33. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."remark" IS '备注';
34. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."insert_user" IS '创建人';
35. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."insert_time" IS '创建时间';
36. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."update_user" IS '更新人';
37. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."update_time" IS '更新时间';
38. COMMENT ON COLUMN "hr_manager"."t_sys_my_permission"."license_code" IS '许可标识';

复制代码

4.1.3.创建角色表

1. CREATE TABLE "hr_manager"."t_sys_my_role" (
2.         "sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default" NOT NULL,
3.         "role_name" VARCHAR ( 100 ) COLLATE "pg_catalog"."default",
4.         "remark" VARCHAR ( 255 ) COLLATE "pg_catalog"."default",
5.         "insert_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
6.         "insert_time" DATE,
7.         "update_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
8.         "update_time" DATE,
9.         "status" VARCHAR ( 255 ) COLLATE "pg_catalog"."default",
10.         CONSTRAINT "t_sys_my_role_pkey" PRIMARY KEY ( "sid" )
11. );
12. ALTER TABLE "hr_manager"."t_sys_my_role" OWNER TO "postgres";
13. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."sid" IS '主键SID';
14. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."role_name" IS '角色名称';
15. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."remark" IS '备注';
16. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."insert_user" IS '创建人';
17. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."insert_time" IS '创建时间';
18. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."update_user" IS '更新人';
19. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."update_time" IS '更新时间';
20. COMMENT ON COLUMN "hr_manager"."t_sys_my_role"."status" IS '是否使用 0 禁用 1 使用';

复制代码

4.1.4.创建用户角色表

1. CREATE TABLE "hr_manager"."t_sys_my_user_role" (
2.         "sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default" NOT NULL,
3.         "role_sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
4.         "user_sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
5.         "insert_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
6.         "insert_time" DATE,
7.         CONSTRAINT "t_sys_my_user_role_pkey" PRIMARY KEY ( "sid" )
8. );
9. ALTER TABLE "hr_manager"."t_sys_my_user_role" OWNER TO "postgres";
10. COMMENT ON COLUMN "hr_manager"."t_sys_my_user_role"."sid" IS '主键SID';
11. COMMENT ON COLUMN "hr_manager"."t_sys_my_user_role"."role_sid" IS '角色SID';
12. COMMENT ON COLUMN "hr_manager"."t_sys_my_user_role"."user_sid" IS '用户SID';
13. COMMENT ON COLUMN "hr_manager"."t_sys_my_user_role"."insert_user" IS '创建人';
14. COMMENT ON COLUMN "hr_manager"."t_sys_my_user_role"."insert_time" IS '创建时间';

复制代码

4.1.5.创建角色权限表

1. CREATE TABLE "hr_manager"."t_sys_my_role_permission" (
2.         "sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default" NOT NULL,
3.         "role_sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
4.         "permission_sid" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
5.         "insert_user" VARCHAR ( 50 ) COLLATE "pg_catalog"."default",
6.         "insert_time" DATE,
7.         CONSTRAINT "t_sys_my_role_permission_pkey" PRIMARY KEY ( "sid" )
8. );
9. ALTER TABLE "hr_manager"."t_sys_my_role_permission" OWNER TO "postgres";
10. COMMENT ON COLUMN "hr_manager"."t_sys_my_role_permission"."sid" IS '主键SID';
11. COMMENT ON COLUMN "hr_manager"."t_sys_my_role_permission"."role_sid" IS '角色SID';
12. COMMENT ON COLUMN "hr_manager"."t_sys_my_role_permission"."permission_sid" IS '权限SID';
13. COMMENT ON COLUMN "hr_manager"."t_sys_my_role_permission"."insert_user" IS '创建人';
14. COMMENT ON COLUMN "hr_manager"."t_sys_my_role_permission"."insert_time" IS '创建时间';

复制代码

4.2.创建实体类

4.2.1.创建用户实体类

1. @Data
2. public class SysMyUser implements Serializable, UserDetails {
4.     private static final long serialVersionUID = 1L;
6.     @TableId
7.     /**
8.      * sid
9.      */
10.     private String sid;
12.     /**
13.      * user_no
14.      */
15.     private String userNo;
17.     /**
18.      * user_name
19.      */
20.     private String userName;
22.     /**
23.      * password
24.      */
25.     private String password;
27.     /**
28.      * nick_name
29.      */
30.     private String nickName;
32.     /**
33.      * phone_number
34.      */
35.     private String phoneNumber;
37.     /**
38.      * email
39.      */
40.     private String email;
42.     /**
43.      * department_id
44.      */
45.     private String departmentId;
47.     /**
48.      * department_name
49.      */
50.     private String departmentName;
52.     /**
53.      * is_admin
54.      */
55.     private String isAdmin;
57.     /**
58.      * sex
59.      */
60.     private String sex;
62.     /**
63.      * post_id
64.      */
65.     private String postId;
67.     /**
68.      * post_name
69.      */
70.     private String postName;
72.     /**
73.      * is_account_non_expired
74.      */
75.     private Boolean isAccountNonExpired;
77.     /**
78.      * is_account_non_locked
79.      */
80.     private Boolean isAccountNonLocked;
82.     /**
83.      * is_credentials_non_expired
84.      */
85.     private Boolean isCredentialsNonExpired;
87.     /**
88.      * is_enabled
89.      */
90.     private Boolean isEnabled;
92.     /**
93.      * insert_user
94.      */
95.     private String insertUser;
97.     /**
98.      * insert_time
99.      */
100.     private String insertTime;
102.     /**
103.      * update_user
104.      */
105.     private String updateUser;
107.     /**
108.      * update_time
109.      */
110.     private String updateTime;
112.     /**
113.      * license_code
114.      */
115.     private String licenseCode;
121.     /**
122.      * 权限列表 就是菜单列表
123.      */
124.     @TableField(exist = false)
125.     private List<SysMyPermission> permissionList;
126.     /**
127.      * 认证信息 就是用户配置code
128.      */
129.     @TableField(exist = false)
130.     Collection<? extends GrantedAuthority> authorities;
132.     /**
133.      * 用户权限信息
134.      */
135.     @TableField(exist = false)
136.     private List<String> roles;
140.     @Override
141.     public Collection<? extends GrantedAuthority> getAuthorities() {
142.         return authorities;
143.     }
145.     @Override
146.     public String getUsername() {
147.         return this.userNo;
148.     }
149.     @Override
150.     public String getPassword() {
151.         return this.password;
152.     }
154.     @Override
155.     public boolean isAccountNonExpired() {
156.         return this.isAccountNonExpired;
157.     }
159.     @Override
160.     public boolean isAccountNonLocked() {
161.         return this.isAccountNonLocked;
162.     }
164.     @Override
165.     public boolean isCredentialsNonExpired() {
166.         return this.isCredentialsNonExpired;
167.     }
169.     @Override
170.     public boolean isEnabled() {
171.         return this.isEnabled;
172.     }
173. }

复制代码

4.2.2.创建权限实体类

1. @Data
2. public class SysMyPermission implements Serializable {
4.     private static final long serialVersionUID = 1L;
6.     @TableId
7.     /**
8.     * sid
9.     */
10.     private String sid;
12.     /**
13.     * parent_id
14.     */
15.     private String parentId;
17.     /**
18.     * parent_name
19.     */
20.     private String parentName;
22.     /**
23.     * permission_name
24.     */
25.     private String permissionName;
27.     /**
28.     * permission_code
29.     */
30.     private String permissionCode;
32.     /**
33.     * router_path
34.     */
35.     private String routerPath;
37.     /**
38.     * router_name
39.     */
40.     private String routerName;
42.     /**
43.     * auth_url
44.     */
45.     private String authUrl;
47.     /**
48.     * order_no
49.     */
50.     private String orderNo;
52.     /**
53.     * type
54.     */
55.     private String type;
57.     /**
58.     * icon
59.     */
60.     private String icon;
62.     /**
63.     * remark
64.     */
65.     private String remark;
67.     /**
68.     * insert_user
69.     */
70.     private String insertUser;
72.     /**
73.     * insert_time
74.     */
75.     private String insertTime;
77.     /**
78.     * update_user
79.     */
80.     private String updateUser;
82.     /**
83.     * update_time
84.     */
85.     private String updateTime;
87.     /**
88.     * license_code
89.     */
90.     private String licenseCode;
93.     /**
94.      * 菜单的子集合
95.      */
96.     @TableField(exist = false)
97.     @JsonInclude(JsonInclude.Include.NON_NULL)
98.     private List<SysMyPermission> children = new ArrayList<>();
99. }

复制代码

4.3.创建Service和Dao

   这里就不过多先容了，直接贴上代码
  4.3.1.UserService

1. @Service
2. public class SysMyUserService {
4.     @Resource
5.     private SysMyUserMapper userMapper;
8.     /**
9.      * 根据用户id获取用户信息（包含用户具备的权限信息）
10.      * @param username 用户信息
11.      * @return
12.      */
13.     public SysMyUser getUserInfoByUserId(String username) {
14.         // 获取用户的基础信息
15.         SysMyUser userInfo = userMapper.getUserInfoByUserId(username);
16.         Assert.notNull(userInfo, "用户不存在");
17.         // 根据用户id对应的权限信息
18.         List<String> autorizedList = userMapper.getAutorizedListByUserId(userInfo.getSid());;
19.         userInfo.setRoles(autorizedList);
20.         return userInfo;
21.     }
24.     /**
25.      * 获取加密后的密码 ,使用BCryptPasswordEncoder加密 10次 生成密码
26.      * @param password 密码
27.      * @return 加密后的密码
28.      */
29.     public String getEncoderPassword(String password) {
30.         BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(10);
31.         String encodePassword = encoder.encode(password);
32.         return encodePassword;
33.     }
34. }

复制代码

4.3.2.UserMapper

1. @Repository
2. public interface SysMyUserMapper extends BaseMapper<SysMyUser> {
3.         /**
4.          * 根据用户名账号获取用户信息
5.          * @param username 用户信息
6.          * @return 用户信息
7.          */
8.         SysMyUser getUserInfoByUserId(@Param("username") String username);
10.         /**
11.          * 根据用户id获取用户具备的权限信息
12.          * @param sid 用户id
13.          * @return 用户具备的权限信息
14.          */
15.         List<String> getAutorizedListByUserId(@Param("sid") String sid);
16. }

复制代码

4.3.3.UserMapper.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">
4. <mapper namespace="com.sys.my.core.user.dao.SysMyUserMapper">
7.     <!-- 根据用户名账号获取用户信息 -->
8.     <select id="getUserInfoByUserId" resultType="com.sys.my.core.user.model.SysMyUser">
9.         select * from t_sys_my_user u where u.user_no = #{username};
10.     </select>
12.     <!-- 根据用户id获取用户具备的权限信息 -->
13.     <select id="getAutorizedListByUserId" resultType="java.lang.String">
14.         select
15.             p.permission_code
16.         from t_sys_my_role r
17.                  left join t_sys_my_user_role ur on ur.role_sid = r.sid
18.                  left join t_sys_my_role_permission rp on rp.role_sid = r.sid
19.                  left join t_sys_my_permission p on p.sid = rp.permission_sid
20.                  left join t_sys_my_user u on u.sid = ur.user_sid
21.         where p.status = '1' and r.status = '1' and u.sid = #{sid};
22.     </select>
23. </mapper>

复制代码

4.3.4.SysMyPermissionService

1. @Service
2. public class SysMyPermissionService {
3.         private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
5.     @Resource
6.     private SysMyPermissionMapper sysMyPermissionMapper;
8.     /**
9.      * 根据用户id查询对应的权限
10.      * @param userId 用户id
11.      * @return 权限列表
12.      */
13.     public List<SysMyPermission> getPermissionListByUserId(String userId){
14.         // 根据用户ID获取用户对应的权限
15.         return sysMyPermissionMapper.getMenuListByUserId(userId);
16.     }
17. }

复制代码

4.3.5.SysMyPermissionMapper

1. @Repository
2. public interface SysMyPermissionMapper extends BaseMapper<SysMyPermission> {
4.         /**
5.          * 根据用户ID获取用户对应的权限
6.          * @param userId 用户ID
7.          * @return 权限列表
8.          */
9.         List<SysMyPermission> getMenuListByUserId(@Param("userId") String userId);
10. }

复制代码

4.3.6.SysMyPermissionMapper.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">
4. <mapper namespace="com.sys.my.core.permission.dao.SysMyPermissionMapper">
9.     <!-- 根据用户id获取用户具备的权限信息 -->
10.     <select id="getMenuListByUserId" resultType="com.sys.my.core.permission.model.SysMyPermission">
11.         select
12.             p.*
13.         from t_sys_my_role r
14.                  left join t_sys_my_user_role ur on ur.role_sid = r.sid
15.                  left join t_sys_my_role_permission rp on rp.role_sid = r.sid
16.                  left join t_sys_my_permission p on p.sid = rp.permission_sid
17.                  left join t_sys_my_user u on u.sid = ur.user_sid
18.         where p.status = '1' and r.status = '1' and u.sid = #{userId};
19.     </select>
20. </mapper>

复制代码

4.4.重写UserDetailsService方法

   重写 Spring Security 中的 UserDetailsService 接口的主要目的是提供自定义的用户认证逻辑。Spring Security 的 UserDetailsService 负责从数据源（通常是数据库）中加载用户信息，包罗用户名、密码和权限等，以便举行身份验证。
  通常情况下，我们需要重写 UserDetailsService 的 loadUserByUsername() 方法，该方法吸收用户名作为参数，并返回一个 UserDetails 对象，该对象包罗了与用户名对应的用户信息。在现实开辟中，我们可能需要自定义的用户信息存储方式，或者盼望在加载用户信息时举行一些特定的逻辑处理，比如自定义密码加密方式、从数据库或其他数据源加载用户信息等。

1. /**
2. * 自定义UserDetailsService 用于认证和授权
3. * 此处把用户的信息和权限交给spring security
4. * spring security会对用户的信息和权限信息进行管理
5. * @author hffan
6. * serDetailService接口主要定义了一个方法 l
7. * oadUserByUsername(String username)用于完成用户信息的查询，
8. * 其中username就是登录时的登录名称，登录认证时，需要自定义一个实现类实现UserDetailService接口，
9. * 完成数据库查询，该接口返回UserDetail。
10. */
11. @Component("customerUserDetailsService")
12. public class CustomerUserDetailsService implements UserDetailsService {
13.     @Resource
14.     private SysMyUserService userService;
15.     @Resource
16.     private SysMyPermissionService permissionService;
18.     @Override
19.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
20.         SysMyUser user = userService.getUserInfoByUserId(username);
21.         // 如果用户不存在
22.         if (user == null){
23.             throw new UsernameNotFoundException("用户名或者密码错误");
24.         }
25.         // 根据用户id查询用户权限
26.         List<SysMyPermission> permissionList = permissionService.getPermissionListByUserId(user.getSid());
27.         // 取出权限中配置code
28.         List<String> collect = permissionList.stream().filter(item -> item != null)
29.                                                        .map(item -> item.getPermissionCode())
30.                                                        .filter(item -> item != null)
31.                                                        .collect(Collectors.toList());
32.         // 转为数据
33.         String[] strings = collect.toArray(new String[collect.size()]);
34.         List<GrantedAuthority> authorityList = AuthorityUtils.createAuthorityList(strings);
35.         // 配置权限
36.         user.setAuthorities(authorityList);
37.         // 配置菜单
38.         user.setPermissionList(permissionList);
39.         // 授权
40.         return user;
41.     }
42. }

复制代码

4.5.自定义异常

   自定义异常，通过传入的异常 可以获取对应的信息返回给前端
  4.5.1.Token认证自定义异常

1. /**
2. * 自定义异常
3. * AuthenticationException 是spring security提供的异常
4. * 通过传入的异常 可以获取对应的信息返回给前端
5. * token异常
6. */
7. public class TokenException extends AuthenticationException {
8.     public TokenException(String msg) {
9.         super(msg);
10.     }
11. }

复制代码

4.5.2.用户认证自定义异常

1. /**
2. * 自定义异常
3. * 通过传入的异常 可以获取对应的信息返回给前端
4. * 用户认证异常
5. */
6. public class CustomerAuthenionException extends AuthenticationException {
7.     public CustomerAuthenionException(String msg) {
8.         super(msg);
9.     }
10. }

复制代码

4.6.编写自定义处理器

   通过实现SpringSecurity提供的一些接口，我们可以更好地管理身份验证和授权流程，提高用户体验和应用程序的安全性。
  4.6.1.匿名用户访问处理器

AuthenticationEntryPoint：

• 作用：AuthenticationEntryPoint 用于处理用户尝试访问受保护资源但未举行身份验证的情况。当用户尝试访问需要身份验证的资源但尚未举行身份验证时，AuthenticationEntryPoint 将被调用来触发身份验证流程。
  
• 详细讲解：当用户尝试访问安全受保护的资源但未举行身份验证时，AuthenticationEntryPoint 的 commence() 方法将被调用。在这个方法中，我们可以定制返回响应给用户，比方重定向到登录页面或返回401未授权错误等。
  

1. /**
2. * 匿名用户访问资源处理器
3. */
4. @Component("loginAuthenticationHandler")
5. public class LoginAuthenticationHandler implements AuthenticationEntryPoint {
6.     @Override
7.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
8.         response.setContentType("application/json;charset=UTF-8");
9.         ServletOutputStream out = response.getOutputStream();
10.         String res = JSONObject.toJSONString(ResultObject.createInstance(false,600,"匿名用户没有权限进行访问！"));
11.         out.write(res.getBytes("UTF-8"));
12.         out.flush();
13.         out.close();
14.     }
15. }

复制代码

4.6.2.认证用户无权限处理器

AccessDeniedHandler：

• 作用：AccessDeniedHandler 用于处理用户尝试访问受保护资源但权限不敷的情况。当用户固然举行了身份验证，但由于缺乏足够的权限而被拒绝访问资源时，AccessDeniedHandler 将被调用。
  
• 详细讲解：AccessDeniedHandler 的 handle() 方法在访问被拒绝时被调用。我们可以在这个方法中定义自定义的行为，比方返回自定义的错误页面、向用户发送通知或记载拒绝的访问尝试。
  

1. /**
2. * 认证用户访问无权限处理器
3. */
4. @Component("loginAccessDefineHandler")
5. public class LoginAccessDefineHandler implements AccessDeniedHandler {
8.     @Override
9.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
10.         response.setContentType("application/json;charset=UTF-8");
11.         ServletOutputStream out = response.getOutputStream();
12.         String res = JSONObject.toJSONString(ResultObject.createInstance(false,700,"您没有开通对应的权限，请联系管理员！"));
13.         out.write(res.getBytes("UTF-8"));
14.         out.flush();
15.         out.close();
16.     }
17. }

复制代码

4.6.3.账户信息异常处理器

AuthenticationFailureHandler：

• 作用：AuthenticationFailureHandler 用于处理身份验证失败的情况。当用户提供的凭据无效或身份验证过程出现错误时，AuthenticationFailureHandler 将被调用。
  
• 详细讲解：AuthenticationFailureHandler 的 onAuthenticationFailure() 方法在身份验证失败时被调用。我们可以在这个方法中执行自定义的行为，比方记载登录失败次数、向用户发送通知或返回自定义的错误页面。
  

1. @Component("loginFiledHandler")
2. public class LoginFiledHandler implements AuthenticationFailureHandler {
4.     @Override
5.     public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
6.         //1.设置响应编码
7.         response.setContentType("application/json;charset=UTF-8");
8.         ServletOutputStream out = response.getOutputStream();
9.         String str = null;
10.         int code = 500;
11.         if(exception instanceof AccountExpiredException){
12.             str = "账户过期，登录失败!";
13.         }else if(exception instanceof BadCredentialsException){
14.             str = "用户名或密码错误，登录失败!";
15.         }else if(exception instanceof CredentialsExpiredException){
16.             str = "密码过期，登录失败!";
17.         }else if(exception instanceof DisabledException){
18.             str = "账户被禁用，登录失败!";
19.         }else if(exception instanceof LockedException){
20.             str = "账户被锁，登录失败!";
21.         }else if(exception instanceof InternalAuthenticationServiceException){
22.             str = "账户不存在，登录失败!";
23.         }else if(exception instanceof CustomerAuthenionException){
24.             //token验证失败
25.             code = 600;
26.             str = exception.getMessage();
27.         } else{
28.             str = "登录失败!";
29.         }
30.         // 设置返回格式
31.         String res = JSONObject.toJSONString(ResultObject.createInstance(false,str));
32.         out.write(res.getBytes("UTF-8"));
33.         out.flush();
34.         out.close();
35.     }
36. }

复制代码

4.6.4.登录成功处理器

AuthenticationSuccessHandler：

• 作用：AuthenticationSuccessHandler 用于处理身份验证成功的情况。当用户成功举行身份验证并被授权访问资源时，AuthenticationSuccessHandler 将被调用。
  
• 详细讲解：AuthenticationSuccessHandler 的 onAuthenticationSuccess() 方法在身份验证成功时被调用。我们可以在这个方法中执行自定义的行为，比方记载登录成功的日志、向用户发送欢迎消息或重定向到特定页面。
  

1. /**
2. * 自定义认证成功处理器
3. */
4. @Component("loginSuccessHandler")
5. public class LoginSuccessHandler implements AuthenticationSuccessHandler {
7.     @Resource
8.     private RedisCache redisCache;
10.     @Override
11.     public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
12.         SysMyUser user = (SysMyUser)authentication.getPrincipal();
13.         // 登录成功处理
14.         //1.生成token
15.         String token = TokenUtil.genAccessToken(user.getUsername());
16.         long expireTime = TokenUtil.getExpirationTime(token);
17.         // 配置一下返回给前端的token信息
18.         LoginResultObject vo = new LoginResultObject();
19.         // 将实体类信息转为JSON
20.         // TODO 将token存入coookie中 后面加载页面 根据用户的id取查询对应的权限
21.         vo.setUserInfo(user);
22.         vo.setCode(200L);
23.         // TODO 将token存放到redis中 退出或者修改密码 清空token 获取的时候 也从redis中进行获取
24.         redisCache.setCacheObject(httpServletRequest.getRemoteAddr(),token,TokenUtil.ACCESS_EXPIRE, TimeUnit.MILLISECONDS);
25.         vo.setToken(token);
26.         vo.setExpireTime(expireTime);
28.         String res = JSONObject.toJSONString(vo);
29.         httpServletResponse.setContentType("application/json;charset=UTF-8");
30.         ServletOutputStream out = httpServletResponse.getOutputStream();
31.         out.write(res.getBytes("UTF-8"));
32.         out.flush();
33.         out.close();
34.     }
35. }

复制代码

4.7.自定义过滤器

   实现 Spring Security 中的 OncePerRequestFilter 接口，用于处理用户请求的过滤逻辑。
  

• 该过滤器用于对用户的请求举行拦截，验证用户的访问权限和身份信息。
  
• 如果请求的 URL 是某些特定的资源或者登录页面，则直接放行。
  
• 如果不是登录请求，则对请求中的 token 举行验证，以确保用户的身份信息有用。
  
• 如果验证通过，则将用户的身份信息设置到 Spring Security 的上下文中，从而完成用户的身份认证。
  

  

• @Component("checkTokenFilter")：将该类声明为 Spring 组件，并指定其名称为 “checkTokenFilter”。
  
• @EqualsAndHashCode(callSuper=false)：天生 equals() 和 hashCode() 方法，忽略父类 OncePerRequestFilter。
  
• @Data：Lombok 注解，主动天生 getter、setter、equals、hashCode 等方法。
  
• @Autowired 和 @Value：用于依赖注入和获取设置信息。
  
• 1. doFilterInternal

  复制代码
  方法：这是 OncePerRequestFilter 类的抽象方法，用于实现详细的请求过滤逻辑。
  
  
  
  • 起首判定请求的 URL 是否属于特定的资源，如果是则放行。
    
  • 判定是否是登录请求，如果是，则直接放行。
    
  • 如果不是登录请求，则验证请求中的 token，确保用户的身份信息有用。
    
  • 如果 token 验证失败，则调用 AuthenticationFailureHandler 处理身份验证失败的情况。
    
  • 如果 token 验证通过，则将用户的身份信息设置到 Spring Security 的上下文中。
    
  
  
• 1. validateToken

  复制代码
  方法：用于验证请求中的 token。
  
  
  
  • 起首从请求头部获取 token，如果没有则从请求参数中获取，如果仍旧没有则从 Redis 缓存中获取。
    
  • 解析 token，获取其中的用户名。
    
  • 根据用户名加载用户信息，使用自定义的 CustomerUserDetailsService。
    
  • 如果用户信息加载成功，则创建 UsernamePasswordAuthenticationToken，并将用户信息设置到 Spring Security 上下文中。
    
  
  
• 最后调用 filterChain.doFilter(httpServletRequest, httpServletResponse)，将请求传递给下一个过滤器处理。
  

1. @Data@Component("checkTokenFilter")@EqualsAndHashCode(callSuper=false)public class CheckTokenFilter extends OncePerRequestFilter {    @Value("${hrfan.login.url}")    private String loginUrl;    @Autowired    private LoginFiledHandler loginFailureHandler;    @Autowired    private CustomerUserDetailsService customerUserDetailsService;    @Resource    private RedisCache redisCache;    @Override    protected void doFilterInternal
2. (HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {        //获取请求的url(读取设置文件的url)        String url = httpServletRequest.getRequestURI();        if (StringUtils.contains(httpServletRequest.getServletPath(), "swagger")                || StringUtils.contains(httpServletRequest.getServletPath(), "webjars")                || StringUtils.contains(httpServletRequest.getServletPath(), "v3")                || StringUtils.contains(httpServletRequest.getServletPath(), "profile")                || StringUtils.contains(httpServletRequest.getServletPath(), "swagger-ui")                || StringUtils.contains(httpServletRequest.getServletPath(), "swagger-resources")                || StringUtils.contains(httpServletRequest.getServletPath(), "csrf")                || StringUtils.contains(httpServletRequest.getServletPath(), "favicon")                || StringUtils.contains(httpServletRequest.getServletPath(), "v2")                || StringUtils.contains(httpServletRequest.getServletPath(), "user")                || StringUtils.contains(httpServletRequest.getServletPath(), "getImageCode")) {            filterChain.doFilter(httpServletRequest, httpServletResponse);        }else if (StringUtils.equals(url,loginUrl)){            // 是登录请求放行            filterChain.doFilter(httpServletRequest, httpServletResponse);        }        else {            try {                //token验证（如果不是登录请求 验证toekn）                if(!url.equals(loginUrl)){                    validateToken
3. (httpServletRequest);                }            }catch (AuthenticationException e){                loginFailureHandler.onAuthenticationFailure(httpServletRequest,httpServletResponse,e);                return;            }            filterChain.doFilter(httpServletRequest,httpServletResponse);        }    }    //token验证    private void validateToken
4. (HttpServletRequest request){        //从请求的头部获取token        String token = request.getHeader("token");        //如果请求头部没有获取到token，则从请求参数中获取token        if(StringUtils.isEmpty(token)){            token = request.getParameter("token");        }        if (StringUtils.isEmpty(token)){            // 请求参数中也没有 那就从redis中举行获取根据ip所在取            token = redisCache.getCacheObject(request.getRemoteAddr());        }        if(StringUtils.isEmpty(token)){            throw new CustomerAuthenionException("token不存在！");        }        //解析token        String username = TokenUtil.getUserFromToken(token);        if(StringUtils.isEmpty(username)){            throw new CustomerAuthenionException("token解析失败!");        }        //获取用户信息        UserDetails user = customerUserDetailsService.loadUserByUsername(username);        if(user == null){            throw new CustomerAuthenionException("token验证失败!");        }        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user,null,user.getAuthorities());        authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));        //设置到spring security上下文        SecurityContextHolder.getContext().setAuthentication(authenticationToken);    }}

复制代码

4.8.设置登录返复书息

   用户返回用户登录 成功或者失败的信息，成功后需要包罗用户的相关信息 和token

1. /**
2. * 登录返回信息
3. */
4. @Data
5. public class LoginResultObject {
6.     private String token;
7.     //token过期时间
8.     private Long expireTime;
9.     private SysMyUser userInfo;
10.     private Long code;
11. }

复制代码

4.9.编写SpringSecurity设置

1. #### 注意
2.         因为新版本的SpringSecurity和旧版本的差距较大，所以这里保留了旧版本的写法
3.         我使用的SpringBoot 和 SpringSecurity 版本都是相对较新的 3.1.8版本 JDK版本是21

复制代码

1. import com.sys.my.config.security.details_service.CustomerUserDetailsService;
2. import com.sys.my.config.security.filter.CheckTokenFilter;
3. import com.sys.my.config.security.handler.LoginAccessDefineHandler;
4. import com.sys.my.config.security.handler.LoginAuthenticationHandler;
5. import com.sys.my.config.security.handler.LoginFiledHandler;
6. import com.sys.my.config.security.handler.LoginSuccessHandler;
7. import jakarta.annotation.Resource;
8. import org.springframework.context.annotation.Bean;
9. import org.springframework.context.annotation.Configuration;
10. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
11. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
12. import org.springframework.security.config.http.SessionCreationPolicy;
13. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
14. import org.springframework.security.crypto.password.PasswordEncoder;
15. import org.springframework.security.web.SecurityFilterChain;
16. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
17. import org.springframework.web.cors.CorsConfiguration;
18. import org.springframework.web.cors.CorsConfigurationSource;
19. import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
21. import java.util.Collections;
23. /**
24. * SpringSecurity配置类
25. */
26. @Configuration
27. @EnableWebSecurity  //启用Spring Security
28. public class SpringSecurityConfig {
31.     @Resource
32.     private CustomerUserDetailsService customerUserDetailsService;
36.     @Resource
37.     private LoginSuccessHandler loginSuccessHandler;
38.     @Resource
39.     private LoginFiledHandler loginFiledHandler;
40.     @Resource
41.     private LoginAuthenticationHandler loginAuthenticationHandler;
42.     @Resource
43.     private LoginAccessDefineHandler loginAccessDefineHandler;
45.     @Resource
46.     private CheckTokenFilter checkTokenFilter;
47.     /**
48.      * 密码处理
49.      * @return
50.      */
51.     @Bean
52.     public PasswordEncoder passwordEncoder(){
53.         return new BCryptPasswordEncoder();
54.     }
56.     /**
57.      * 新版的实现方法不再和旧版一样在配置类里面重写方法，而是构建了一个过滤链对象并通过@Bean注解注入到IOC容器中
58.      * 新版整体代码 （注意：新版AuthenticationManager认证管理器默认全局）
59.      * @param http http安全配置
60.      * @return SecurityFilterChain
61.      * @throws Exception 异常
62.      */
63.     @Bean
64.     public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
65.         http    // 使用自己自定义的过滤器 去过滤接口请求
66.                 .addFilterBefore(checkTokenFilter, UsernamePasswordAuthenticationFilter.class)
67.                 .formLogin((formLogin) ->
68.                         // 这里更改SpringSecurity的认证接口地址，这样就默认处理这个接口的登录请求了
69.                         formLogin.loginProcessingUrl("/api/v1/user/login")
70.                                 //　自定义的登录验证成功或失败后的去向
71.                                 .successHandler(loginSuccessHandler).failureHandler(loginFiledHandler)
72.                 )
73.                     // 禁用了 CSRF 保护。
74.                 .csrf((csrf) -> csrf.disable())
75.                     // 配置了会话管理策略为 STATELESS（无状态）。在无状态的会话管理策略下，应用程序不会创建或使用 HTTP 会话，每个请求都是独立的，服务器不会在请求之间保留任何状态信息。
76.                 .sessionManagement((sessionManagement) -> sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
77.                 .authorizeRequests((authorizeRequests) ->
78.                         // 这里过滤一些 不需要token的接口地址
79.                         authorizeRequests
80.                                 .requestMatchers("/api/v1/test/getTestInfo").permitAll()
81.                                 .requestMatchers(  "/v3/**","/profile/**","/swagger-ui.html",
82.                                         "/swagger-resources/**",
83.                                         "/v2/api-docs",
84.                                         "/v3/api-docs",
85.                                         "/webjars/**","/swagger-ui/**","/v2/**","/favicon.ico","/webjars/springfox-swagger-ui/**","/static/**", "/webjars/**", "/v2/api-docs", "/v2/feign-docs",
86.                                         "/swagger-resources/configuration/ui",
87.                                         "/test/user",
88.                                         "/swagger-resources", "/swagger-resources/configuration/security",
89.                                         "/swagger-ui.html", "/webjars/**").permitAll()
90.                                 .requestMatchers("/api/v1/user/login","/api/v1/user/getImageCode").permitAll()
91.                                 .anyRequest().authenticated()
92.                 )
93.                 .exceptionHandling((exceptionHandling) -> exceptionHandling
94.                         .authenticationEntryPoint(loginAuthenticationHandler) // 匿名处理
95.                         .accessDeniedHandler(loginAccessDefineHandler)  // 无权限处理
96.                 )
97.                 .cors((cors) -> cors.configurationSource(configurationSource()))
98.                 .headers((headers) -> headers.frameOptions((frameOptionsConfig -> frameOptionsConfig.disable())))
99.                 .headers((headers) -> headers.frameOptions((frameOptionsConfig -> frameOptionsConfig.sameOrigin())));
100.         // 构建过滤链并返回
101.         return http.build();
102.     }
105.     // 旧版本 需要继承  extends WebSecurityConfigurerAdapter
107.     // 新版的比较简单，直接定义好数据源，注入就可以了，无需手动到配置类中去将它提交给AuthenticationManager进行管理。
108.     // /**
109.     //  * 配置认证处理器
110.     //  * 自定义的UserDetailsService
111.     //  * @param auth
112.     //  * @throws Exception
113.     //  */
114.     // @Override
115.     // protected void configure(AuthenticationManagerBuilder auth) throws Exception {
116.     //     auth.userDetailsService(customerUserDetailsService);
117.     // }
119.     // /**
120.     //  * 配置权限资源
121.     //  * @param http
122.     //  * @throws Exception
123.     //  */
124.     // @Override
125.     // protected void configure(HttpSecurity http) throws Exception {
126.     //     // 每次请求前检查token
127.     //     http.addFilterBefore(checkTokenFilter, UsernamePasswordAuthenticationFilter.class);
128.     //     http.formLogin()
129.     //             .loginProcessingUrl("/api/v1/user/login")
130.     //             //　自定义的登录验证成功或失败后的去向
131.     //             .successHandler(loginSuccessHandler).failureHandler(loginFiledHandler)
132.     //             // 禁用csrf防御机制(跨域请求伪造)，这么做在测试和开发会比较方便。
133.     //             .and().csrf().disable()
134.     //             .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
135.     //             .and()
136.     //             .authorizeRequests()
137.     //             .antMatchers("/api/v1/test/getTestInfo").permitAll()
138.     //             // 放心swagger相关请求
139.     //             .antMatchers(  "/v3/**","/profile/**","/swagger-ui.html",
140.     //                     "/swagger-resources/**",
141.     //                     "/v2/api-docs",
142.     //                     "/v3/api-docs",
143.     //                     "/webjars/**","/swagger-ui/**","/v2/**","/favicon.ico","/webjars/springfox-swagger-ui/**","/static/**", "/webjars/**", "/v2/api-docs", "/v2/feign-docs",
144.     //                     "/swagger-resources/configuration/ui",
145.     //                     "/swagger-resources", "/swagger-resources/configuration/security",
146.     //                     "/swagger-ui.html", "/webjars/**").permitAll()
147.     //             .antMatchers("/api/v1/user/login","/api/v1/user/getImageCode").permitAll()
148.     //             .anyRequest().authenticated()
149.     //             .and()
150.     //             .exceptionHandling()
151.     //             // 匿名处理
152.     //             .authenticationEntryPoint(loginAuthenticationHandler)
153.     //             // 无权限处理
154.     //             .accessDeniedHandler(loginAccessDefineHandler)
155.     //             // 跨域配置
156.     //             .and()
157.     //             .cors()
158.     //             .configurationSource(configurationSource());
159.     //     // 设置iframe
160.     //     http.headers().frameOptions().sameOrigin();
161.     //     http.headers().frameOptions().disable();
162.     //
163.     // }
166.     /**
167.      * 跨域配置
168.      */
169.     CorsConfigurationSource configurationSource() {
170.         CorsConfiguration corsConfiguration = new CorsConfiguration();
171.         corsConfiguration.setAllowedHeaders(Collections.singletonList("*"));
172.         corsConfiguration.setAllowedMethods(Collections.singletonList("*"));
173.         corsConfiguration.setAllowedOrigins(Collections.singletonList("*"));
174.         corsConfiguration.setMaxAge(3600L);
176.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
177.         source.registerCorsConfiguration("/**", corsConfiguration);
178.         return source;
179.     }
180. }

复制代码

4.10.设置文件设置

1. hrfan:
2.   login:
3.     url: "/api/v1/user/login"

复制代码

5.测试

5.1.测试登录密码错误

5.2.测试正确密码

5.3.测试无token访问接口

   SpringSecurity为我们提供了基于注解的权限控制方案。
  在启动类上加上 @EnableGlobalMethodSecurity(prePostEnabled = true)

1.         @GetMapping("/jjwt")
2.         @PreAuthorize("hasAuthority('user_list')")
3.         public Map<String, String> jjwt(){
4.         // 这里的user_list 就是我们权限中permission_code
5.                 throw new RuntimeException("测试无token访问！");
6.         }

复制代码

5.4.测试不登陆访问

5.5.测试登录访问不受限制接口

5.6.测试放开的通用接口 比方/**

5.7.测试权限标识 和数据库不一致

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。