SpringSecurity
2023/01/10 -
官方文档 - https://docs.spring.io/spring-security/reference/index.html
Spring Security 是一个提供身份验证 、授权 和针对常见攻击的保护 的框架。凭借对保护命令 式应用程序和反应式 应用程序的一流支持，它是保护基于 Spring 的应用程序的事实标准。
有关功能的完整列表，请参阅参考资料的功能 部分。
SpringSecurity 简介 **SpringSecurity **是 Spring 家族中的一个安全管理框架。提供了更丰富 的功能，社区资源更多。一般来说，中大型的项目都是使用 SpringSecurity 来做安全框架。
一般的 Web 应用都需要进行 认证 和 授权
认证： 验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权： 经过认证后判断当前用户是否有权限进行某个操作
而认证和授权也是 SpringSecurity 作为安全框架的核心功能
SpringBoot AutoConfiguration Spring Boot automatically:
Enables Spring Security’s default configuration, which creates a servlet Filter as a bean named springSecurityFilterChain. This bean is responsible for all the security (protecting the application URLs, validating submitted username and passwords, redirecting to the login form, and so on) within your application.
Creates a UserDetailsServicebean with a username of user and a randomly generated password that is logged to the console.
Registers the Filter with a bean named springSecurityFilterChain with the Servlet container for every request.
Spring Boot is not configuring much, but it does a lot. A summary of the features follows:
Require an authenticated user for any interaction with the application
Generate a default login form for you
Let the user with a username of user and a password that is logged to the console to authenticate with form-based authentication (in the preceding example, the password is 8e557245-73e2-4286-969a-ff57fe326336)
Protects the password storage with BCrypt
Lets the user log out
CSRF attack preventionSession Fixation protectionSecurity Header integration
Integrate with the following Servlet API methods:
SpringSecurity 快速入门 添加依赖 通过
[maven]: https://mvnrepository.com/ “maven”
添加相关依赖
也可 使用 Spring Initializer 勾选 SpringSecurity 的 starter
demo 启动 springboot 的application 的启动类
发送请求
springsecurity 拦截请求 验证是否是本系统的用户
引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登陆页面，默认用户名是user,密码会输出在控制台。
必须登陆之后才能对接口进行访问。
SpringSecurity 使用 认证 登陆校验流程 原理初探 想要知道如何实现自己登陆流程逻辑就必须要先知道 demo 中的 SpringSecurity 的流程
SpringSecurity 的完整流程 SpringSecurity 的 原理其实是一个过滤器链 ，内部包含了 提供各种功能的 过滤器。如下图所示（demo）
上图只展示了 核心的过滤器，非核心的并没有展示
UsernamePasswordAuthenticationFilter
ExceptionTranslationFilterAccessDeniedException 和 AuthenticationException
FilterSecurityInterceptor
可以通过 Debug 查看当前系统中 SpringSecurity 过滤器链中有哪些过滤器以及他们的顺序
认证流程详解
概念速查:
Authentication接口
**AuthenticationManager接口**：定义了认证Authentication的方法
**UserDetailsService接口**：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
**UserDetails接口**：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。
解决问题 思路分析 登陆
自定义登陆接口
调用 ProviderManager 的方法进行认证，如果认证通过，生成 JWT
把 用户信息 存入 Redis 中
自定义 UserDetailService
校验
定义 JWT 认证过滤器
获取 token
解析 token 获取其中的 userId
从 Redis 中获取用户信息
存入 SecurityContextHolder
准备工作 添加依赖 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-data-redis</artifactId > </dependency > <dependency > <groupId > com.alibaba</groupId > <artifactId > fastjson</artifactId > <version > 1.2.33</version > </dependency > <dependency > <groupId > io.jsonwebtoken</groupId > <artifactId > jjwt</artifactId > <version > 0.9.0</version > </dependency >
② 添加Redis相关配置
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.serializer.SerializerFeature;import com.fasterxml.jackson.databind.JavaType;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.type.TypeFactory;import org.springframework.data.redis.serializer.RedisSerializer;import org.springframework.data.redis.serializer.SerializationException;import com.alibaba.fastjson.parser.ParserConfig;import org.springframework.util.Assert;import java.nio.charset.Charset;public class FastJsonRedisSerializer <T> implements RedisSerializer <T>{ public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8" ); private Class<T> clazz; static { ParserConfig.getGlobalInstance().setAutoTypeSupport(true ); } public FastJsonRedisSerializer (Class<T> clazz) { super (); this .clazz = clazz; } @Override public byte [] serialize(T t) throws SerializationException { if (t == null ) { return new byte [0 ]; } return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET); } @Override public T deserialize (byte [] bytes) throws SerializationException { if (bytes == null || bytes.length <= 0 ) { return null ; } String str = new String (bytes, DEFAULT_CHARSET); return JSON.parseObject(str, clazz); } protected JavaType getJavaType (Class<?> clazz) { return TypeFactory.defaultInstance().constructType(clazz); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.StringRedisSerializer;@Configuration public class RedisConfig { @Bean @SuppressWarnings(value = { "unchecked", "rawtypes" }) public RedisTemplate<Object, Object> redisTemplate (RedisConnectionFactory connectionFactory) { RedisTemplate<Object, Object> template = new RedisTemplate <>(); template.setConnectionFactory(connectionFactory); FastJsonRedisSerializer serializer = new FastJsonRedisSerializer (Object.class); template.setKeySerializer(new StringRedisSerializer ()); template.setValueSerializer(serializer); template.setHashKeySerializer(new StringRedisSerializer ()); template.setHashValueSerializer(serializer); template.afterPropertiesSet(); return template; } }
③ 响应类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 import com.fasterxml.jackson.annotation.JsonInclude;@JsonInclude(JsonInclude.Include.NON_NULL) public class ResponseResult <T> { private Integer code; private String msg; private T data; public ResponseResult (Integer code, String msg) { this .code = code; this .msg = msg; } public ResponseResult (Integer code, T data) { this .code = code; this .data = data; } public Integer getCode () { return code; } public void setCode (Integer code) { this .code = code; } public String getMsg () { return msg; } public void setMsg (String msg) { this .msg = msg; } public T getData () { return data; } public void setData (T data) { this .data = data; } public ResponseResult (Integer code, String msg, T data) { this .code = code; this .msg = msg; this .data = data; } }
④工具类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 import io.jsonwebtoken.Claims;import io.jsonwebtoken.JwtBuilder;import io.jsonwebtoken.Jwts;import io.jsonwebtoken.SignatureAlgorithm;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;import java.util.Date;import java.util.UUID;public class JwtUtil { public static final Long JWT_TTL = 60 * 60 *1000L ; public static final String JWT_KEY = "sangeng" ; public static String getUUID () { String token = UUID.randomUUID().toString().replaceAll("-" , "" ); return token; } public static String createJWT (String subject) { JwtBuilder builder = getJwtBuilder(subject, null , getUUID()); return builder.compact(); } public static String createJWT (String subject, Long ttlMillis) { JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID()); return builder.compact(); } private static JwtBuilder getJwtBuilder (String subject, Long ttlMillis, String uuid) { SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; SecretKey secretKey = generalKey(); long nowMillis = System.currentTimeMillis(); Date now = new Date (nowMillis); if (ttlMillis==null ){ ttlMillis=JwtUtil.JWT_TTL; } long expMillis = nowMillis + ttlMillis; Date expDate = new Date (expMillis); return Jwts.builder() .setId(uuid) .setSubject(subject) .setIssuer("sg" ) .setIssuedAt(now) .signWith(signatureAlgorithm, secretKey) .setExpiration(expDate); } public static String createJWT (String id, String subject, Long ttlMillis) { JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id); return builder.compact(); } public static void main (String[] args) throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg" ; Claims claims = parseJWT(token); System.out.println(claims); } public static SecretKey generalKey () { byte [] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY); SecretKey key = new SecretKeySpec (encodedKey, 0 , encodedKey.length, "AES" ); return key; } public static Claims parseJWT (String jwt) throws Exception { SecretKey secretKey = generalKey(); return Jwts.parser() .setSigningKey(secretKey) .parseClaimsJws(jwt) .getBody(); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 import java.util.*;import java.util.concurrent.TimeUnit;@SuppressWarnings(value = { "unchecked", "rawtypes" }) @Component public class RedisCache { @Autowired public RedisTemplate redisTemplate; public <T> void setCacheObject (final String key, final T value) { redisTemplate.opsForValue().set(key, value); } public <T> void setCacheObject (final String key, final T value, final Integer timeout, final TimeUnit timeUnit) { redisTemplate.opsForValue().set(key, value, timeout, timeUnit); } public boolean expire (final String key, final long timeout) { return expire(key, timeout, TimeUnit.SECONDS); } public boolean expire (final String key, final long timeout, final TimeUnit unit) { return redisTemplate.expire(key, timeout, unit); } public <T> T getCacheObject (final String key) { ValueOperations<String, T> operation = redisTemplate.opsForValue(); return operation.get(key); } public boolean deleteObject (final String key) { return redisTemplate.delete(key); } public long deleteObject (final Collection collection) { return redisTemplate.delete(collection); } public <T> long setCacheList (final String key, final List<T> dataList) { Long count = redisTemplate.opsForList().rightPushAll(key, dataList); return count == null ? 0 : count; } public <T> List<T> getCacheList (final String key) { return redisTemplate.opsForList().range(key, 0 , -1 ); } public <T> BoundSetOperations<String, T> setCacheSet (final String key, final Set<T> dataSet) { BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key); Iterator<T> it = dataSet.iterator(); while (it.hasNext()) { setOperation.add(it.next()); } return setOperation; } public <T> Set<T> getCacheSet (final String key) { return redisTemplate.opsForSet().members(key); } public <T> void setCacheMap (final String key, final Map<String, T> dataMap) { if (dataMap != null ) { redisTemplate.opsForHash().putAll(key, dataMap); } } public <T> Map<String, T> getCacheMap (final String key) { return redisTemplate.opsForHash().entries(key); } public <T> void setCacheMapValue (final String key, final String hKey, final T value) { redisTemplate.opsForHash().put(key, hKey, value); } public <T> T getCacheMapValue (final String key, final String hKey) { HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash(); return opsForHash.get(key, hKey); } public void delCacheMapValue (final String key, final String hkey) { HashOperations hashOperations = redisTemplate.opsForHash(); hashOperations.delete(key, hkey); } public <T> List<T> getMultiCacheMapValue (final String key, final Collection<Object> hKeys) { return redisTemplate.opsForHash().multiGet(key, hKeys); } public Collection<String> keys (final String pattern) { return redisTemplate.keys(pattern); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 import javax.servlet.http.HttpServletResponse;import java.io.IOException;public class WebUtils { public static String renderString (HttpServletResponse response, String string) { try { response.setStatus(200 ); response.setContentType("application/json" ); response.setCharacterEncoding("utf-8" ); response.getWriter().print(string); } catch (IOException e) { e.printStackTrace(); } return null ; } }
⑤实体类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 import java.io.Serializable;import java.util.Date;@Data @AllArgsConstructor @NoArgsConstructor public class User implements Serializable { private static final long serialVersionUID = -40356785423868312L ; private Long id; private String userName; private String nickName; private String password; private String status; private String email; private String phonenumber; private String sex; private String avatar; private String userType; private Long createBy; private Date createTime; private Long updateBy; private Date updateTime; private Integer delFlag; }
实现 数据库校验用户 我们可以自定义一个 UserDetailService ,让 SpringSecurity 使用我们自己的UserDetailService。我们自己的 UserDetailService 可以从数据库中查询用户名和密码
登录接口 接下来我们需要自定义 登录接口，然后让 SpringSecurity 对这个接口进行放行，让用户访问这个接口的时候不用登录也可以访问
在接口中，我们通过 AuthenticationManager 的 authenticate 方法来进行用户认证，所以需要在 SecurityConfig中配置 AuthenticationManage 注入容器
认证成功的话，要生成一个 jwt，放入响应中返回。并且为了让用户下回请求时能通过 jwt 识别出具体是哪个用户，我们需要把 用户信息 存入 redis，可以将 userid 作为 key
1 2 3 4 5 6 7 8 9 10 11 @RestController public class LoginController { @Autowired private LoginServcie loginServcie; @PostMapping("/user/login") public ResponseResult login (@RequestBody User user) { return loginServcie.login(user); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .anyRequest().authenticated(); } @Bean @Override public AuthenticationManager authenticationManagerBean () throws Exception { return super .authenticationManagerBean(); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 @Service public class LoginServiceImpl implements LoginServcie { @Autowired private AuthenticationManager authenticationManager; @Autowired private RedisCache redisCache; @Override public ResponseResult login (User user) { UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken (user.getUserName(),user.getPassword()); Authentication authenticate = authenticationManager.authenticate(authenticationToken); if (Objects.isNull(authenticate)){ throw new RuntimeException ("用户名或密码错误" ); } LoginUser loginUser = (LoginUser) authenticate.getPrincipal(); String userId = loginUser.getUser().getId().toString(); String jwt = JwtUtil.createJWT(userId); redisCache.setCacheObject("login:" +userId,loginUser); HashMap<String,String> map = new HashMap <>(); map.put("token" ,jwt); return new ResponseResult (200 ,"登陆成功" ,map); } }
UsernamePasswordAuthenticationToken 是由Spring Security提供的一个类，表示带有用户名和密码的身份验证请求。使用提供的用户名和密码从 user 对象创建了 authenticationToken。
authenticationManager 是实现了 AuthenticationManager 接口的一个实例，负责进行用户身份验证。调用 authenticationManager 的 authenticate 方法，并将 authenticationToken 作为参数传入。
authenticate 方法执行身份验证过程，包括根据存储的凭据验证用户名和密码，并执行任何其他的身份验证检查。如果身份验证成功，将返回一个 Authentication 对象，表示已经通过身份验证的用户。
authenticate 是从 authenticate 方法返回的 Authentication 对象，表示已认证的用户。在 authenticate 对象上调用 getPrincipal 方法，以检索表示已认证用户的主体对象。
LoginUser 类是您定义的自定义类，用于表示用户详细信息。检索到的主体对象被强制转换为 LoginUser 类型，以访问用户的信息。
认证过滤器 我们需要自己定义一个 过滤器，这个过滤器会去获取请求头中的 token，对 token 进行解析，取出其中的 userid
使用 userid 去 redis 中获取对应的 LoginUser 对象
然后 封装 Authentication 对象 到 SecurityContextHolder
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 @Component public class JwtAuthenticationTokenFilter extends OncePerRequestFilter { @Autowired private RedisCache redisCache; @Override protected void doFilterInternal (HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String token = request.getHeader("token" ); if (!StringUtils.hasText(token)) { filterChain.doFilter(request, response); return ; } String userid; try { Claims claims = JwtUtil.parseJWT(token); userid = claims.getSubject(); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException ("token非法" ); } String redisKey = "login:" + userid; LoginUser loginUser = redisCache.getCacheObject(redisKey); if (Objects.isNull(loginUser)){ throw new RuntimeException ("用户未登录" ); } UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken (loginUser,null ,null ); SecurityContextHolder.getContext().setAuthentication(authenticationToken); filterChain.doFilter(request, response); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Autowired JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter; @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .anyRequest().authenticated(); http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); } @Bean @Override public AuthenticationManager authenticationManagerBean () throws Exception { return super .authenticationManagerBean(); } }
退出登录 我们只需要定义一个退出接口，然后获取 SecurityContextHolder 中的 Authentication ,解析获得 userid，然后从 redis 中删除对应的数据即可
1 2 3 4 5 6 7 8 @Override public ResponseResult logout () { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); LoginUser loginUser = (LoginUser) authentication.getPrincipal(); Long userid = loginUser.getUser().getId(); redisCache.deleteObject("login:" +userid); return new ResponseResult (200 ,"退出成功" ); }
授权 权限系统的作用 例如一个学校图书馆的管理系统，如果是普通学生登录就能看到借书还书相关的功能，不可能让他看到并且去使用添加书籍信息，删除书籍信息等功能。但是如果是一个图书馆管理员的账号登录了，应该就能看到并使用添加书籍信息，删除书籍信息等功能。
总结起来就是不同的用户可以使用不同的功能 。这就是权限系统要去实现的效果。
我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。
所以我们还需要在后台进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作。
权限系统的作用是对用户在系统中可操作的功能和可查看的数据范围进行控制。它是后台系统中常见的模块，用于管理不同用户对资源的访问权限 ，以避免因权限控制缺失或操作不当而引发的风险问题。权限系统通过设定不同的用户角色，并将权限分配给各个角色，来实现不同用户可以使用不同功能的效果。它主要包括认证和授权两种功能。认证是验证用户身份的过程，而授权则是根据认证用户的权限来授予或拒绝对特定资源的访问。权限系统的作用是确保不同用户可以使用不同功能和访问不同数据。需要注意的是，仅依赖前端来确定用户权限并选择显示哪些菜单和按钮是不够的。
授权基本流程 在 SpringSecurity 中 ，会使用默认的 FilterSecurityInteceptor 来进行权限校验。FilterSecurityInteceptor 中 会从 SecurityContextHolder 中获取其中的 authentication ，然后获取其中的 权限信息。当前用户是否拥有 访问当前资源的所需的权限
所以 我们在项目只需要把当前登录用户的权限信息也存入 authentication
然后设置我们资源所需要的权限即可
授权实现 限制访问资源所需权限 SpringSecurity 为我们提供了基于注解的 权限解决方案，这也是我们项目中主要采用的方式。我们可以通过使用注解去访问对应的资源所需的权限
但是使用之前，需要 开启相关的配置
1 2 3 @Configuration @EnableGlobalMethodSecurity(prePostEnabled = true) public class SecurityConfig extends WebSecurityConfigurerAdapter {
然后才可以使用 注解 @PreAuthorize
1 2 3 4 5 @GetMapping @PreAuthorize("hasAuthority('test')") public String test () { return "test" ; }
封装权限信息 前面在写 UserDetailServiceImpl 说过，在查询出 用户后还需要获取对应的权限信息，封装到 UserDetails 中 返回
我们先直接把 权限信息 写死封装到 UserDetails 的实现类中 进行测试
我们之前定义了 Usertails 的 实现类 LoginUser ，想要让其能封装权限信息，就要对其进行更改
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 package com.sangeng.domain;import com.alibaba.fastjson.annotation.JSONField;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.authority.SimpleGrantedAuthority;import org.springframework.security.core.userdetails.UserDetails;import java.util.Collection;import java.util.List;import java.util.stream.Collectors;@Data @NoArgsConstructor public class LoginUser implements UserDetails { private User user; private List<String> permissions; public LoginUser (User user,List<String> permissions) { this .user = user; this .permissions = permissions; } @JSONField(serialize = false) private List<GrantedAuthority> authorities; @Override public Collection<? extends GrantedAuthority > getAuthorities() { if (authorities!=null ){ return authorities; } authorities = permissions.stream(). map(SimpleGrantedAuthority::new ) .collect(Collectors.toList()); return authorities; } @Override public String getPassword () { return user.getPassword(); } @Override public String getUsername () { return user.getUserName(); } @Override public boolean isAccountNonExpired () { return true ; } @Override public boolean isAccountNonLocked () { return true ; } @Override public boolean isCredentialsNonExpired () { return true ; } @Override public boolean isEnabled () { return true ; } }
LoginUser修改完后我们就可以在UserDetailsServiceImpl中去把权限信息封装到LoginUser中了。我们写死权限进行测试，后面我们再从数据库中查询权限信息。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 package com.sangeng.service.impl;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;import com.sangeng.domain.LoginUser;import com.sangeng.domain.User;import com.sangeng.mapper.UserMapper;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.core.userdetails.UserDetailsService;import org.springframework.security.core.userdetails.UsernameNotFoundException;import org.springframework.stereotype.Service;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Objects;@Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserMapper userMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper <>(); wrapper.eq(User::getUserName,username); User user = userMapper.selectOne(wrapper); if (Objects.isNull(user)){ throw new RuntimeException ("用户名或密码错误" ); } List<String> list = new ArrayList <>(Arrays.asList("test" )); return new LoginUser (user,list); } }
从数据库查询权限信息 RBAC 权限模型 RBAC 权限模型（Role-Based Access Control) 即： 基于角色的 权限控制。这是目前最常被 开发者使用也是相对易用、通用的权限模型
准备工作 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 CREATE DATABASE `clearance_operation` ;USE `clearance_operation`; DROP TABLE IF EXISTS `sys_menu`;CREATE TABLE `sys_menu` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT, `menu_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '菜单名' , `path` varchar (200 ) DEFAULT NULL COMMENT '路由地址' , `component` varchar (255 ) DEFAULT NULL COMMENT '组件路径' , `visible` char (1 ) DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）' , `status` char (1 ) DEFAULT '0' COMMENT '菜单状态（0正常 1停用）' , `perms` varchar (100 ) DEFAULT NULL COMMENT '权限标识' , `icon` varchar (100 ) DEFAULT '#' COMMENT '菜单图标' , `create_by` bigint (20 ) DEFAULT NULL , `create_time` datetime DEFAULT NULL , `update_by` bigint (20 ) DEFAULT NULL , `update_time` datetime DEFAULT NULL , `del_flag` int (11 ) DEFAULT '0' COMMENT '是否删除（0未删除 1已删除）' , `remark` varchar (500 ) DEFAULT NULL COMMENT '备注' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 2 DEFAULT CHARSET= utf8mb4 COMMENT= '菜单表' ; DROP TABLE IF EXISTS `sys_role`;CREATE TABLE `sys_role` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT, `name` varchar (128 ) DEFAULT NULL , `role_key` varchar (100 ) DEFAULT NULL COMMENT '角色权限字符串' , `status` char (1 ) DEFAULT '0' COMMENT '角色状态（0正常 1停用）' , `del_flag` int (1 ) DEFAULT '0' COMMENT 'del_flag' , `create_by` bigint (200 ) DEFAULT NULL , `create_time` datetime DEFAULT NULL , `update_by` bigint (200 ) DEFAULT NULL , `update_time` datetime DEFAULT NULL , `remark` varchar (500 ) DEFAULT NULL COMMENT '备注' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 3 DEFAULT CHARSET= utf8mb4 COMMENT= '角色表' ; DROP TABLE IF EXISTS `sys_role_menu`;CREATE TABLE `sys_role_menu` ( `role_id` bigint (200 ) NOT NULL AUTO_INCREMENT COMMENT '角色ID' , `menu_id` bigint (200 ) NOT NULL DEFAULT '0' COMMENT '菜单id' , PRIMARY KEY (`role_id`,`menu_id`) ) ENGINE= InnoDB AUTO_INCREMENT= 2 DEFAULT CHARSET= utf8mb4; DROP TABLE IF EXISTS `sys_user`;CREATE TABLE `sys_user` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT COMMENT '主键' , `user_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '用户名' , `nick_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '昵称' , `password` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '密码' , `status` char (1 ) DEFAULT '0' COMMENT '账号状态（0正常 1停用）' , `email` varchar (64 ) DEFAULT NULL COMMENT '邮箱' , `phonenumber` varchar (32 ) DEFAULT NULL COMMENT '手机号' , `sex` char (1 ) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）' , `avatar` varchar (128 ) DEFAULT NULL COMMENT '头像' , `user_type` char (1 ) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）' , `create_by` bigint (20 ) DEFAULT NULL COMMENT '创建人的用户id' , `create_time` datetime DEFAULT NULL COMMENT '创建时间' , `update_by` bigint (20 ) DEFAULT NULL COMMENT '更新人' , `update_time` datetime DEFAULT NULL COMMENT '更新时间' , `del_flag` int (11 ) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 3 DEFAULT CHARSET= utf8mb4 COMMENT= '用户表' ; DROP TABLE IF EXISTS `sys_user_role`;CREATE TABLE `sys_user_role` ( `user_id` bigint (200 ) NOT NULL AUTO_INCREMENT COMMENT '用户id' , `role_id` bigint (200 ) NOT NULL DEFAULT '0' COMMENT '角色id' , PRIMARY KEY (`user_id`,`role_id`) ) ENGINE= InnoDB DEFAULT CHARSET= utf8mb4;
1 2 3 4 5 6 7 8 9 10 11 SELECT DISTINCT m.`perms` FROM sys_user_role ur LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id` LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id` LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id` WHERE user_id = 2 AND r.`status` = 0 AND m.`status` = 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 package com.sangeng.domain;import com.baomidou.mybatisplus.annotation.TableId;import com.baomidou.mybatisplus.annotation.TableName;import com.fasterxml.jackson.annotation.JsonInclude;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import java.io.Serializable;import java.util.Date;@TableName(value="sys_menu") @Data @AllArgsConstructor @NoArgsConstructor @JsonInclude(JsonInclude.Include.NON_NULL) public class Menu implements Serializable { private static final long serialVersionUID = -54979041104113736L ; @TableId private Long id; private String menuName; private String path; private String component; private String visible; private String status; private String perms; private String icon; private Long createBy; private Date createTime; private Long updateBy; private Date updateTime; private Integer delFlag; private String remark; }
代码实现 我们只需要根据用户id去查询到其所对应的权限信息即可。
所以我们可以先定义个mapper，其中提供一个方法可以根据userid查询权限信息。
1 2 3 4 5 6 7 8 9 10 11 import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.cccs7.domain.Menu;import java.util.List;public interface MenuMapper extends BaseMapper <Menu> { List<String> selectPermsByUserId (Long id) ; }
尤其是自定义方法，所以需要创建对应的mapper文件，定义对应的sql语句
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace ="com.sangeng.mapper.MenuMapper" > <select id ="selectPermsByUserId" resultType ="java.lang.String" > SELECT DISTINCT m.`perms` FROM sys_user_role ur LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id` LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id` LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id` WHERE user_id = #{userid} AND r.`status` = 0 AND m.`status` = 0 </select > </mapper >
在application.yml中配置mapperXML文件的位置
1 2 3 4 5 6 7 8 9 10 11 12 spring: datasource: url: jdbc:mysql://localhost:3306/cccs7_security?characterEncoding=utf-8&serverTimezone=UTC username: root password: xxxxx driver-class-name: com.mysql.cj.jdbc.Driver redis: host: localhost port: 6379 mybatis-plus: mapper-locations: classpath*:/mapper/**/*.xml
然后我们可以在UserDetailsServiceImpl中去调用该mapper的方法查询权限信息封装到LoginUser对象中即可。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 @Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserMapper userMapper; @Autowired private MenuMapper menuMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper <>(); wrapper.eq(User::getUserName,username); User user = userMapper.selectOne(wrapper); if (Objects.isNull(user)){ throw new RuntimeException ("用户名或密码错误" ); } List<String> permissionKeyList = menuMapper.selectPermsByUserId(user.getId()); return new LoginUser (user,permissionKeyList); } }
自定义失败处理 我们希望在 认证失败 或者 授权失败的时候 也能和我们的接口一样 返回相同的结构的 JSON，这样可以让 前端能对响应进行统一的 处理。要实现 这个功能我们需要知道 SpringSecurity 的异常处理机制。
Spring Security的异常处理机制主要包括认证异常处理和权限异常处理在Spring Security的过滤器链中，有一个专门用来处理异常的过滤器，即ExceptionTranslationFilter1 。当出现认证异常或授权异常时，Spring Security会捕获并进行相应的处理。以下是Spring Security异常处理的一般流程：
认证异常处理：当用户认证失败时，会抛出相应的认证异常，例如BadCredentialsException（密码错误）、DisabledException（账号被禁用）等。Spring Security会捕获这些异常并根据配置的认证异常处理器进行处理。
权限异常处理：当用户在访问受限资源时，如果没有足够的权限，会抛出相应的权限异常，例如AccessDeniedException。Spring Security会捕获这些异常并根据配置的权限异常处理器进行处理。
在 SpringSecurity 中 ，如果我们在 认证或者 授权的过程中 出现了异常 会被 ExceptionTranslationFilter 中去判断是 认证失败 还是 授权失败 出现额度异常。
如果是 认证过程出现的异常 ，会被封装成 AuthenticationException 然后调用 AuthenticationEntryPoint 对象的方法去进行 异常处理
如果 是 授权过程中出现的异常 会被封装为 AccessDeniedException 然后调用 AccessDeniedHandler 对象的方法进行 异常处理
所以，如果我们需要实现自定义异常处理，我们只需要自定义 AccessDeniedHandler 和 AuthenticationEntryPoint 然后配置给 SecurityConfig 即可
自定义 AccessDeniedHanler、AuthenticationAEntryPoint 1 2 3 4 5 6 7 8 9 10 11 @Component public class AccessDeniedHandlerImpl implements AccessDeniedHandler { @Override public void handle (HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException { ResponseResult result = new ResponseResult (HttpStatus.FORBIDDEN.value(), "权限不足" ); String json = JSON.toJSONString(result); WebUtils.renderString(response,json); } }
1 2 3 4 5 6 7 8 9 @Component public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint { @Override public void commence (HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { ResponseResult result = new ResponseResult (HttpStatus.UNAUTHORIZED.value(), "认证失败请重新登录" ); String json = JSON.toJSONString(result); WebUtils.renderString(response,json); } }
配置 securityconfig 1 2 3 4 5 @Autowired private AuthenticationEntryPoint authenticationEntryPoint;@Autowired private AccessDeniedHandler accessDeniedHandler;
1 2 http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint). accessDeniedHandler(accessDeniedHandler);
