目录
一、回顾一下
二、security使用
2.1 覆盖掉默认配置「自定义配置」
2.2 如何自定义认证
2.3 纯纯自定义
2.4 jwt
2.5 官网认证流程
2.6 RBAC模型
4.1. 创建表结构
2.7 如何实现权限流程
一、回顾一下
-
security干啥的?
认证和授权
-
使用方式
-
引入依赖, 基于spring boot的下的使用.
-
spring-boot-starter-security, 直接可以使用了.
-
-
观察一下
-
姿源分类
-
受保护的资源, 需要认证
-
公共方式, 不需要认证.
-
-
当我们把security引入到项目当中的时候,我们去访问一下受保护的资源,会弹出一个默认的一个登录界面.用户名称默认的是: user, 密码随机生成的.通过uuid生成的.如果认证成功,则直接跳转到要访问的接口.
-
-
基本原理
-
SecurityAutoConfiguration, spring security自动配置类.默认配置.如果我们啥也不干,则直接走默认配置.界面了,用户名称和密码都是默认生成的.
-
如果想要覆盖掉默认配置,则我们用两种方案.
-
继承一个类WebSecurityConfigurerAdapter, 重写方法.
-
将SecurityFilterChain放到容器当中.
/** * {@link Condition} for * {@link ConditionalOnDefaultWebSecurity @ConditionalOnDefaultWebSecurity}. * * @author Phillip Webb */ class DefaultWebSecurityCondition extends AllNestedConditions { DefaultWebSecurityCondition() { super(ConfigurationPhase.REGISTER_BEAN); } @ConditionalOnClass({ SecurityFilterChain.class, HttpSecurity.class }) static class Classes { } // 当IoC容器当中没有WebSecurityConfigurerAdapter.class, SecurityFilterChain.class 这两个类的对象 // 则默认生效,否则默认配置不生效. @ConditionalOnMissingBean({ WebSecurityConfigurerAdapter.class, SecurityFilterChain.class }) static class Beans { } } -
-
默认的配置类
SecurityProperties@ConfigurationProperties(prefix = "spring.security") public class SecurityProperties {} -
对认证资源进行配置
-
可以针对某一些资源,不进行认证, 默认是都进行认证的.
-
此时我们就覆盖掉默认配置.
-
-
二、security使用
2.1 覆盖掉默认配置「自定义配置」
public HttpSecurity authorizeRequests(
Customizer<ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry> authorizeRequestsCustomizer)
throws Exception {
ApplicationContext context = getContext();
authorizeRequestsCustomizer
.customize(getOrApply(new ExpressionUrlAuthorizationConfigurer<>(context)).getRegistry());
return HttpSecurity.this;
}认证成功之后的处理:
public final T successHandler(AuthenticationSuccessHandler successHandler) {
this.successHandler = successHandler;
return getSelf();
}package com.tingyi.configs;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
/**
* @author 听忆
*/
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
return http.authorizeRequests(authorize ->
authorize.mvcMatchers("/tom")
.permitAll()
.anyRequest()
.authenticated())
.formLogin()
// .successForwardUrl("/success") // 默认的话,跳转到你在认证之前的请求.
// .defaultSuccessUrl("/success", true) // true,表示强制跳转到指定的url
.successHandler(new AuthenticationSuccessHandler() { // security提供给我们的,认证成功之后的处理.我们可以在这里返回json给前端.
// 前后端分离项目使用的方式;
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
// 给前端返回一个json串.应用于前后端分离的项目.
Map<String, Object> map = new HashMap<>();
map.put("code", 0); // 状态码
map.put("msg", "认证成功");
map.put("authentication", authentication);
PrintWriter writer = response.getWriter();
String json = new ObjectMapper().writeValueAsString(map);
writer.print(json);
}
}).and()
.csrf(csrf -> csrf.disable())
.build();
}
}
认证流程:
浏览器输入了用户名称和密码 —> 服务器 –> security 进行认证, 怎么认证的?
UsernamePasswordAuthenticaionFilter
AbstractAuthenticationProcessingFilter
我们去认证的时候,服务器把密码存储到哪里地了.
UserDetailsService
UserDetailsManager, 用户信息管理.接口.封装了对用户所有操作.
InMemoryUserDetailsManager, 基于内存实现的.也就是说,将用户信息都存储在内存当中了.
2.2 如何自定义认证
DaoAuthenticationProvider
protected void additionalAuthenticationChecks(UserDetails userDetails,
UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
if (authentication.getCredentials() == null) {
this.logger.debug("Failed to authenticate since no credentials provided");
throw new BadCredentialsException(this.messages
.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
}
String presentedPassword = authentication.getCredentials().toString();
if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
this.logger.debug("Failed to authenticate since password does not match stored value");
throw new BadCredentialsException(this.messages
.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
}
}数据放到了内存当中,使用的是: InMemoryUserDetailsManager, 从内存读取数据,实际开发当中,数据源, 一般情况来自于数据库.也就是说, 我们存储用户名称和密码应该是存储在数据当中,咱们进行认证的时候,应该是从数据当中获取用户名称和密码.替换掉默认的: InMemoryUserDetailsManager.
通过查看,类关系图.发现有一个接口: UserDetailsService
package org.springframework.security.core.userdetails;
// 如果我们要自定义实现读取的数据源, 则必须实现这个接口,重写这个方法.
public interface UserDetailsService {
// 通过用户名称获取用户的详细信息.
// 返回值是一个UserDetails接口.实际上返回的应该是一个对象.
UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}
package org.springframework.security.core.userdetails;
import java.io.Serializable;
import java.util.Collection;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
/**
* Provides core user information.
*
* <p>
* Implementations are not used directly by Spring Security for security purposes. They
* simply store user information which is later encapsulated into {@link Authentication}
* objects. This allows non-security related user information (such as email addresses,
* telephone numbers etc) to be stored in a convenient location.
* <p>
* Concrete implementations must take particular care to ensure the non-null contract
* detailed for each method is enforced. See
* {@link org.springframework.security.core.userdetails.User} for a reference
* implementation (which you might like to extend or use in your code).
*
* @author Ben Alex
* @see UserDetailsService
* @see UserCache
* 用户详细信息
* 1. 用户名称
* 2. 用户密码
* 3. 用户的权限列表
* 1. 角色信息
* 2. 权限信息
*/
public interface UserDetails extends Serializable {
/**
* Returns the authorities granted to the user. Cannot return <code>null</code>.
* @return the authorities, sorted by natural key (never <code>null</code>)
* 权限列表
*/
Collection<? extends GrantedAuthority> getAuthorities();
/**
* Returns the password used to authenticate the user.
* @return the password
* 获取用户密码
*/
String getPassword();
/**
* Returns the username used to authenticate the user. Cannot return
* <code>null</code>.
* @return the username (never <code>null</code>)
* 用户名称
*/
String getUsername();
/**
* Indicates whether the user's account has expired. An expired account cannot be
* authenticated.
* @return <code>true</code> if the user's account is valid (ie non-expired),
* <code>false</code> if no longer valid (ie expired)
* 账号状态是否是过期的.
*/
boolean isAccountNonExpired();
/**
* Indicates whether the user is locked or unlocked. A locked user cannot be
* authenticated.
* @return <code>true</code> if the user is not locked, <code>false</code> otherwise
*/
boolean isAccountNonLocked();
/**
* Indicates whether the user's credentials (password) has expired. Expired
* credentials prevent authentication.
* @return <code>true</code> if the user's credentials are valid (ie non-expired),
* <code>false</code> if no longer valid (ie expired)
*/
boolean isCredentialsNonExpired();
/**
* Indicates whether the user is enabled or disabled. A disabled user cannot be
* authenticated.
* @return <code>true</code> if the user is enabled, <code>false</code> otherwise
*/
boolean isEnabled();
}
User, spring security提供的一个类,这个类实现了UserDetails接口.
// username,表示我们根据用户名称,从内存或者数据库查询出来的用户名称.
// password, 从内存或者数据库当中查询出来的密码
// authorities, 从内存或者数据库当中查询出来该用户名称对应的权限列表.
public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
this(username, password, true, true, true, true, authorities);
}
重要的接口和实现类:
UserDetailsService,
UserDetails loadUserByUsername(String username) throws UsernameNotFoundException; // 根据前端传递过来的用户名称,去数据当中查询出用户名称对应的详细信息,封装成UserDetails对象即可;
InMemoryUserDetailsManager,它是一个实现类,它表示从内存当中读取.
我们如果要换成从数据库当中读取用户信息,则必须实现UserDetailsService接口,重写方法.查询出来的数据,封里成UserDetatils对象.
UserDetails, 表示定义用户的各种各样的信息.
用户名称
用户密码
用户权限列表
实现类: User, 在UserDetailsService方法, loadUserByUsername返回它即可;
如果, controller当中的login,直接调用Service层,此时需要我们自己处理,整个验证过程.
现在我们如果在userDetailsService实现类当中,进行相关的业务处理,将验证过程直接交给了security. 不用我们操心了.
2.3 纯纯自定义
-
根据流程来说, 要将从内存获取数据方式改更从数据库进行查询.
自己定义一个UserDetailsService实现类,完成一个逻辑:
①. 根据用户名称去数据库查询出这个用户名称对应的数据.
②. 将查询出来的数据封装成UserDetails对象.
package com.tingyi.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.qf.entity.TbUser;
import com.qf.mapper.ITbUserMapper;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
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.Collections;
import java.util.List;
/**
* @author 听忆
* 自定义读取过程,之前是从在内存当中,根据用户名称获取用户详情,现在我们从数据库当中进行获取.
* mybatis plus 来读取一下.
*/
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
private final ITbUserMapper tbUserMapper;
public UserDetailsServiceImpl(ITbUserMapper tbUserMapper) {
this.tbUserMapper = tbUserMapper;
}
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 根据用户名称去数据库当中查找.
LambdaQueryWrapper<TbUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(TbUser::getUsername, username);
// 查询出结果,根据咱们自己就没有处理它.
TbUser user = tbUserMapper.selectOne(queryWrapper); // 通过这个对象,获取密码.还有权限列表.
// 最终我们得把获取到的数据封装成UserDetails对象.交给spring security处理去.
List<GrantedAuthority> grantedAuthorityList = Collections.emptyList(); // 权限列表.
// 封装UserDetails对象.
// User是UserDetails实现类.所以咱们可以直接返回这个实现类对象.
return new User(username, user.getPassword(), grantedAuthorityList);
}
}
-
手动完成认证
整个spring security一共15个过滤器. 其中有一个负责账号密码认证的过滤器:
UsernamePasswordAuthenticationFilter.
需要一个认证管理器:
AutenticationManager, 咱们是配置类,将它注入到IoC容器当中.
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
return authenticationConfiguration.getAuthenticationManager();
}直接调用认证方法:
@Override
public Result login(String username, String password) {
try {
// 1. 将用户名称和密码封装成UsernamePasswordAuthenticationToken.
UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
new UsernamePasswordAuthenticationToken(username, password);
// 2. 调用AuthenticationManager提供认证方法.
// Authentication authenticate(Authentication authentication) throws AuthenticationException;
Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);
// 3. 存储认证结果.
SecurityContextHolder.getContext().setAuthentication(authenticate);
return Result.success("认证成功", authenticate);
}catch (AuthenticationException e){
return Result.error("认证失败", e.getMessage());
}
}
-
更改配置文件
得去执行我们自己的认证页面.
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
return http.authorizeRequests(authorize ->
authorize.mvcMatchers("/tom", "/login")
.permitAll()
.anyRequest()
.authenticated())
// .formLogin() // 仅仅表示我使用表单验证, 但是配置用的都是默认的.
.formLogin(form -> form.loginPage("/login.html").permitAll()
.successHandler(new AuthenticationSuccessHandler() {
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
// 给前端返回一个json串.应用于前后端分离的项目.
response.setContentType("application/json;charset=utf-8");
Map<String, Object> map = new HashMap<>();
map.put("code", 0); // 状态码
map.put("msg", "认证成功");
map.put("authentication", authentication);
PrintWriter writer = response.getWriter();
String json = new ObjectMapper().writeValueAsString(map);
writer.print(json);
}
}).failureHandler(new AuthenticationFailureHandler() {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
// 给前端返回一个json串.应用于前后端分离的项目.
response.setContentType("application/json;charset=utf-8");
Map<String, Object> map = new HashMap<>();
map.put("code", -1); // 状态码
map.put("msg", "认证失败");
map.put("exception", exception);
PrintWriter writer = response.getWriter();
String json = new ObjectMapper().writeValueAsString(map);
writer.print(json);
}
}))
// .successForwardUrl("/success") // 默认的话,跳转到你在认证之前的请求.
// .defaultSuccessUrl("/success", true) // true,表示强制跳转到指定的url
.csrf(csrf -> csrf.disable())
.build();
}2.4 jwt
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.11.2</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>
<!--解决高版本JDK问题-->
<!--javax.xml.bind.DatatypeConverter错误-->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。
安全, 以json方式传输, 可以被验证和信任.本质还是一个字符串.定义规则,咱们可控的.
package com.tingyi.utils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;
import java.util.UUID;
/**
* jwt工具类.
*/
public class JwtUtil {
/**
* jwt过期时间
*/
public static final Long EXP_TTL = 60 * 60 * 1000L;
/**
* jwt使用的密钥
*/
public static final String JWT_KEY = "c3R1ZHkgaGFyZCBhbmQgbWFrZSBwcm9ncmVzcyBldmVyeSBkYXku";
/**
* 创建jwt字符串
* @param id id
* @param issuer 创建的作者
* @param subject 用户主体
* @param ttlMillis 过期时间, 毫秒值
* @return jwt字符串
*/
public static String createJWT(String id, String issuer, String subject, long ttlMillis) {
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(JWT_KEY);
Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
JwtBuilder builder = Jwts
.builder()
.setId(id)
.setIssuedAt(now)
.setSubject(subject)
.setIssuer(issuer)
.signWith(signingKey, signatureAlgorithm);
if (ttlMillis >= 0) {
long expMillis = nowMillis + ttlMillis;
Date exp = new Date(expMillis);
builder.setExpiration(exp);
}
return builder.compact();
}
/**
* 创建jwt字符串
* @param issuer 作者信息
* @param subject 用户主体信息
* @param ttlMillis 过期时间, 毫秒值
* @return jwt字符串
*/
public static String createJwt(String issuer, String subject, long ttlMillis){
return createJWT(uuid(), issuer, subject, ttlMillis);
}
/**
* 创建jwt字符串
* @param issuer 作者信息
* @param subject 用户主体信息
* @return jwt字符串
*/
public static String createJwt(String issuer, String subject){
return createJwt(issuer, subject, EXP_TTL);
}
/**
* 创建jwt字符串
* @param subject 用户主体
* @return jwt字符串
*/
public static String createJwt(String subject){
return createJwt("laoren", subject, EXP_TTL);
}
/**
* uuid
* @return String
*/
private static String uuid(){
return UUID.randomUUID().toString().replaceAll("-", "");
}
/**
* 解析jwt
* @param jwt jwt字符串
* @return Claims
*/
public static Claims parseJWT(String jwt) {
Claims claims = Jwts.parserBuilder()
.setSigningKey(DatatypeConverter.parseBase64Binary(JWT_KEY))
.build()
.parseClaimsJws(jwt).getBody();
return claims;
}
public static void main(String[] args) {
// 生成一个jwt串.
String jwt = createJWT("1024", "tom", "jack", EXP_TTL);
System.out.println(jwt);
// 解析jwt串.
Claims claims = parseJWT(jwt);
Object subject = claims.get("subject");
System.out.println(subject);
System.out.println(claims);
System.out.println(claims.getSubject());
System.out.println(claims.getIssuedAt());
System.out.println(claims.getExpiration());
}
}2.5 官网认证流程
Form Login :: Spring Security
2.6 RBAC模型
RBAC（Role-Based Access Control），基于角色的访问控制。通过用户关联角色，角色关联权限，来间接的为用户赋予权限。
4.1. 创建表结构
下面是标准的RBAC模型关系表:
用户表
-- 用户表
CREATE TABLE `sys_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
`name` varchar(50) NOT NULL COMMENT '用户名',
`nick_name` varchar(150) DEFAULT NULL COMMENT '昵称',
`password` varchar(100) DEFAULT NULL COMMENT '密码',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`),
UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=34 DEFAULT CHARSET=utf8 COMMENT='用户管理';角色表
-- 角色表
CREATE TABLE `sys_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
`name` varchar(100) DEFAULT NULL COMMENT '角色名称',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8 COMMENT='角色管理';用户角色表
-- 用户角色表
CREATE TABLE `sys_user_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
`user_id` bigint(20) DEFAULT NULL COMMENT '用户ID',
`role_id` bigint(20) DEFAULT NULL COMMENT '角色ID',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=88 DEFAULT CHARSET=utf8 COMMENT='用户角色';菜单表
-- 菜单表
CREATE TABLE `sys_menu` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
`name` varchar(50) DEFAULT NULL COMMENT '菜单名称',
`parent_id` bigint(20) DEFAULT NULL COMMENT '父菜单ID，一级菜单为0',
`url` varchar(200) DEFAULT NULL COMMENT '菜单URL,类型：1.普通页面（如用户管理， /sys/user） 2.嵌套完整外部页面，以http(s)开头的链接 3.嵌套服务器页面，使用iframe:前缀+目标URL(如SQL监控， iframe:/druid/login.html, iframe:前缀会替换成服务器地址)',
`perms` varchar(500) DEFAULT NULL COMMENT '授权(多个用逗号分隔，如：sys:user:add,sys:user:edit)',
`type` int(11) DEFAULT NULL COMMENT '类型 0：目录 1：菜单 2：按钮',
`icon` varchar(50) DEFAULT NULL COMMENT '菜单图标',
`order_num` int(11) DEFAULT NULL COMMENT '排序',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=57 DEFAULT CHARSET=utf8 COMMENT='菜单管理';角色菜单表
-- 角色菜单表
CREATE TABLE `sys_role_menu` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
`role_id` bigint(20) DEFAULT NULL COMMENT '角色ID',
`menu_id` bigint(20) DEFAULT NULL COMMENT '菜单ID',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=623 DEFAULT CHARSET=utf8 COMMENT='角色菜单';2.7 如何实现权限流程
按照: 认证的过程,其中实现了接口: UserDetailsService接口,之后,我们在重写的方法当中.
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
LambdaQueryWrapper<TbUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(TbUser::getUsername, username);
TbUser user = tbUserMapper.selectOne(queryWrapper); // 通过这个对象,获取密码.还有权限列表.
// 最终我们得把获取到的数据封装成UserDetails对象.交给spring security处理去.
// 这个集合当中,包含两个东西
// 角色列表, 应该通过用户id去数据库当中,通过多表查询给它查询出来. List<Role>
// 权限列表, 通过用户id, 去数据库当中,通过多表查询,权限查出来. List<Menu>
List<GrantedAuthority> grantedAuthorityList = Collections.emptyList(); // 权限列表.
// 上一步完成之后,将封装好的List<GrantedAuthority>交给spring security,它会在我们需要验证权限的时候,就会给你验证了.
// 如何知道我需要进行权限验证,当类上或者方法上标记相关注解了.则表示我需要验证了.
// 当前登录的用户,是否有某个角色.
// 当前登录的用户, 是否拥有这个权限.
return new User(username, user.getPassword(), grantedAuthorityList);
}@Secured注解, 是否拥有某个角色,某些角色.
@PreAuthorize, 是否拥有某些权限.
