1. 权限管理
1. 授权核心概念
身份认证 ，就是判断一个用户是否为合法用户的处理过程。Spring Security 中支持多种不同方式的认证，但是无论开发者使用那种方式认证，都不会影响授权功能使用。因为Spring Security 很好做到了认证和授权解耦。
授权，即访问控制，控制谁能访问哪些资源。简单的理解授权就是根据系统提前设置好的规则，给用户分配可以访问某一个资源的权限，用户根据自己所具有权限，去执行相应操作。
认证成功之后会将当前登录用户信息保存到Authentication 对象中，Authentication 对象中有一个 getAuthorities() 方法，用来返回当前登录用户具备的权限信息，也就是当前用户具有权限信息。该方法的返回
值为Collection<? extends GrantedAuthority>，当需要进行权限判断时，就回根据集合返回权限信息调用相应方法进行判断。
当客户端发起请求时，身份认证过滤器会对用户进行身份认证，身份认证成功后，身份认证过滤器会将用户详情信息存储在安全上下文中，并将请求转发给授权过滤器，授权过滤器决定是否允许调用。
public interface Authentication extends Principal, Serializable {
// 由 AuthenticationManager 设置以指示已授予主体的权限。
Collection<? extends GrantedAuthority> getAuthorities();
// 返回身份认证过程中返回的密码或者任何秘钥
Object getCredentials();
// 存储有关身份验证请求的其他详细信息。 这些可能是 IP 地址、证书序列号等。
Object getDetails();
// 被认证的主体的身份。
// 被认证的主体的身份。 在使用用户名和密码的身份验证请求的情况下，这将是用户名。 调用者应填充身份验证请求的主体。
// AuthenticationManager 实现通常会返回一个包含更丰富信息的 Authentication 作为应用程序使用的主体。 许多身份验证提供程序将创建一个 UserDetails 对象作为主体。
Object getPrincipal();
// 如果身份认证程序结束则返回true，如果正在进行则返回false
boolean isAuthenticated();
void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}
public interface GrantedAuthority extends Serializable {
// 返回权限的名称
String getAuthority();
}
那么问题来了，针对于这个返回值 GrantedAuthority 应该如何理解呢? 是⻆色还是权限?
我们针对于授权可以是 基于⻆色权限管理 和 基于资源权限管理 ，从设计层面上来说，⻆色和权限是两个完全不同的东⻄：权限是一些具体操作，⻆色则是某些权限集合。如：READ_BOOK 和 ROLE_ADMIN 是完全不同的。因此至于返回值是什么取决于你的业务设计情况：
基于⻆色权限设计就是: 用户–》⻆色–》资源，返回就是用户的 ⻆色
基于资源权限设计就是: 用户–》权限–》资源，返回就是用户的 权限
基于⻆色和资源权限设计就是: 用户–》⻆色–》权限–》资源，返回统称为用户的权限
为什么可以统称为权限，因为从代码层面⻆色和权限没有太大不同都是权限，特别是在Spring Security 中，⻆色和权限处理方式基本上都是一样的。唯一区别SpringSecurity 在很多时候会自动给⻆色添加一个 ROLE_ 前缀，而权限则不会自动添加。
2. 权限管理策略
Spring Security 中提供的权限管理策略主要有两种类型:
基于过滤器(URL)的权限管理 (FilterSecurityInterceptor) ：基于过滤器的权限管理主要是用来拦截 HTTP 请求，拦截下来之后，根据 HTTP请求地址进行权限校验。
基于AOP (方法)的权限管理 (MethodSecurityInterceptor)：基于 AOP 权限管理主要是用来处理方法级别的权限问题。当需要调用某一个方法时，通过 AOP 将操作拦截下来，然后判断用户是否具备相关的权限。
2. 基于 URL 权限管理
@RestController
public class DemoController {
@GetMapping("/admin") //ADMIN
public String admin() {
return "admin ok";
}
@GetMapping("/user") //USER
public String user() {
return "user ok";
}
@GetMapping("/getInfo") //READ_INFO
public String getInfo() {
return "info ok";
}
}
/**
* 自定义 spring security 配置类
*/
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
//创建内存数据源
@Bean
public UserDetailsService userDetailsService() {
InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123").roles("ADMIN","USER").build());
inMemoryUserDetailsManager.createUser(User.withUsername("lisi").password("{noop}123").roles("USER").build());
inMemoryUserDetailsManager.createUser(User.withUsername("win7").password("{noop}123").authorities("READ_INFO").build());
return inMemoryUserDetailsManager;
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
//具有 admin 角色 通用: /admin /admin/ /admin.html
.mvcMatchers(HttpMethod.GET,"/admin").hasRole("ADMIN")
//具有 user 角色
.mvcMatchers("/user").hasRole("USER")
//READ_INFO 权限
.mvcMatchers("/getInfo").hasAuthority("READ_INFO")
.antMatchers(HttpMethod.GET,"/admin").hasRole("ADMIN")
.anyRequest().authenticated()
.and().formLogin()
.and().csrf().disable();
}
}
访问：http://localhost:8080/user，使用root/123登录后可访问，再访问http://localhost:8080/getInfo 则会报错403异常。
3. 基于 方法 权限管理
基于方法的权限管理主要是通过 A0P 来实现的，Spring Security 中通过MethodSecurityInterceptor 来提供相关的实现。不同在于FilterSecurityInterceptor 只是在请求之前进行前置处理，MethodSecurityInterceptor 除了前置处理之外还可以进行后置处理。前置处理就是在请求之前判断是否具备相应的权限，后置处理则是对方法的执行结果进行二次过滤。前置处理和后置处理分别对应了不同的实现类。
@EnableGlobalMethodSecurity 该注解是用来开启权限注解，用法如下：
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled=true,securedEnabled=true, jsr250Enabled=true)
public class SecurityConfig extends WebsecurityConfigurerAdapter{
}
perPostEnabled: 开启 Spring Security 提供的四个权限注解，@PostAuthorize、@PostFilter、@PreAuthorize 以及@PreFilter；
securedEnabled: 开启 Spring Security 提供的 @Secured 注解支持，该注解不支持权限表达式；
jsr250Enabled: 开启 JSR-250 提供的注解，主要是@DenyAll、@PermitAll、@RolesAll 同样这些注解也不支持权限表达式；
@PostAuthorize： 在目前标方法执行之后进行权限校验。
@PostFiter： 在目标方法执行之后对方法的返回结果进行过滤。
@PreAuthorize：在目标方法执行之前进行权限校验。
@PreFiter：在目前标方法执行之前对方法参数进行过滤。
@Secured：访问目标方法必须具各相应的⻆色。
@DenyAll：拒绝所有访问。
@PermitAll：允许所有访问。
@RolesAllowed：访问目标方法必须具备相应的⻆色。
@RestController
@RequestMapping("/hello")
public class AuthorizeMethodController {
// @PreAuthorize("hasRole('ADMIN') and authentication.name =='win7'")
@PreAuthorize("hasAuthority('READ_INFO')")
@GetMapping
public String hello() {
return "hello";
}
@PreAuthorize("authentication.name==#name")
@GetMapping("/name")
public String hello(String name) {
return "hello:" + name;
}
// filterTarget 必须是数组集合类型
@PreFilter(value = "filterObject.id%2!=0",filterTarget = "users")
@PostMapping("/users")
public void addUsers(@RequestBody List<User> users) {
System.out.println("users = " + users);
}
@PostAuthorize("returnObject.id==1")
@GetMapping("/userId")
public User getUserById(Integer id) {
return new User(id, "blr");
}
// 用来对方法返回值进行过滤
@PostFilter("filterObject.id%2==0")
@GetMapping("/lists")
public List<User> getAll() {
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i++) {
users.add(new User(i, "blr:" + i));
}
return users;
}
// 只能判断角色
@Secured({
"ROLE_USER"})
@GetMapping("/secured")
public User getUserByUsername() {
return new User(99, "secured");
}
// 具有其中一个即可
@Secured({
"ROLE_ADMIN","ROLE_USER"})
@GetMapping("/username")
public User getUserByUsername2(String username) {
return new User(99, username);
}
@PermitAll
@GetMapping("/permitAll")
public String permitAll() {
return "PermitAll";
}
@DenyAll
@GetMapping("/denyAll")
public String denyAll() {
return "DenyAll";
}
// 具有其中一个角色即可
@RolesAllowed({
"ROLE_ADMIN","ROLE_USER"})
@GetMapping("/rolesAllowed")
public String rolesAllowed() {
return "RolesAllowed";
}
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private Integer id;
private String name;
}
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled = true,jsr250Enabled = true)
public class WebSecurityConfigurer extends WebSecurityConfigurerAdapter {
//创建内存数据源
@Bean
public UserDetailsService userDetailsService() {
InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123").roles("ADMIN","USER").build());
inMemoryUserDetailsManager.createUser(User.withUsername("lisi").password("{noop}123").roles("USER").build());
inMemoryUserDetailsManager.createUser(User.withUsername("win7").password("{noop}123").authorities("READ_INFO").build());
return inMemoryUserDetailsManager;
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
//具有 admin 角色 通用: /admin /admin/ /admin.html
.mvcMatchers(HttpMethod.GET,"/admin").hasRole("ADMIN")
//具有 user 角色
.mvcMatchers("/user").hasRole("USER")
//READ_INFO 权限
.mvcMatchers("/getInfo").hasAuthority("READ_INFO")
.antMatchers(HttpMethod.GET,"/admin").hasRole("ADMIN")
.anyRequest().authenticated()
.and().formLogin()
.and().csrf().disable();
}
}
4. 授权流程
SpringSecurity存在一个称作 FilterSecurityInterceptor 的拦截器，该拦截器位于整个过滤器链的末端，核心功能是对权限控制过程进行拦截，即用来判断该请求能否访问HTTP端点。当对请求进行拦截后，下一步是获取请求的访问资源，以及访问这些资源所需要的权限信息，这一步称为权限配置。
ConfigAttribute 在 Spring Security 中，用户请求一个资源(通常是一个接口或者一个 Java 方法)需要的⻆色会被封装成一个 ConfigAttribute 对象，在ConfigAttribute 中只有一个 getAttribute方法，该方法返回一个 String 字符
串，就是⻆色的名称。一般来说，⻆色名称都带有一个 ROLE_ 前缀，投票器AccessDecisionVoter 所做的事情，其实就是比较用户所具各的⻆色和请求某个资源所需的 ConfigAtuibute 之间的关系。
AccesDecisionVoter 和 AccessDecisionManager 都有众多的实现类，在AccessDecisionManager 中会换个遍历 AccessDecisionVoter，进而决定是否允许用户访问，因而 AaccesDecisionVoter 和 AccessDecisionManager 两者的关系类似于 AuthenticationProvider 和 ProviderManager 的关系。
1. FilterSecurityInterceptor#invoke
// 实现了Servlet的Filter接口
public class FilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter {
private FilterInvocationSecurityMetadataSource securityMetadataSource;
public void setSecurityMetadataSource(FilterInvocationSecurityMetadataSource newSource) {
this.securityMetadataSource = newSource;
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
invoke(new FilterInvocation(request, response, chain));
}
public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
// ...
// 调用父类的beforeInvocation方法
InterceptorStatusToken token = super.beforeInvocation(filterInvocation);
// ...
super.afterInvocation(token, null);
}
}
2. AbstractSecurityInterceptor#beforeInvocation
public abstract class AbstractSecurityInterceptor
implements InitializingBean, ApplicationEventPublisherAware, MessageSourceAware {
public abstract SecurityMetadataSource obtainSecurityMetadataSource();
protected InterceptorStatusToken beforeInvocation(Object object) {
// ...
// 从SecurityMetadataSource中获取请求对应的ConfigAttribute集合（权限信息）
Collection<ConfigAttribute> attributes
= this.obtainSecurityMetadataSource().getAttributes(object);
// ...
// 是否需要认证，获取认证信息
Authentication authenticated = authenticateIfRequired();
// 执行授权
attemptAuthorization(object, attributes, authenticated);
// ...
}
}
步骤1：DefaultFil#terInvocationSecurityMetadataSource#getAttributes
public class DefaultFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
protected final Log logger = LogFactory.getLog(getClass());
private final Map<RequestMatcher, Collection<ConfigAttribute>> requestMap;
@Override
public Collection<ConfigAttribute> getAttributes(Object object) {
final HttpServletRequest request = ((FilterInvocation) object).getRequest();
int count = 0;
for (Map.Entry<RequestMatcher, Collection<ConfigAttribute>> entry : this.requestMap.entrySet()) {
if (entry.getKey().matches(request)) {
return entry.getValue();
}
else {
if (this.logger.isTraceEnabled()) {
this.logger.trace(LogMessage.format("Did not match request to %s - %s (%d/%d)", entry.getKey(),
entry.getValue(), ++count, this.requestMap.size()));
}
}
}
return null;
}
@Override
public boolean supports(Class<?> clazz) {
return FilterInvocation.class.isAssignableFrom(clazz);
}
}
步骤2：AbstractSecurityInterceptor#authenticateIfRequired
public abstract class AbstractSecurityInterceptor
implements InitializingBean, ApplicationEventPublisherAware, MessageSourceAware {
private Authentication authenticateIfRequired() {
Authentication authentication
= SecurityContextHolder.getContext().getAuthentication();
if (authentication.isAuthenticated() && !this.alwaysReauthenticate) {
if (this.logger.isTraceEnabled()) {
this.logger.trace(LogMessage.format("Did not re-authenticate %s before authorizing", authentication));
}
return authentication;
}
authentication = this.authenticationManager.authenticate(authentication);
// Don't authenticated.setAuthentication(true) because each provider does that
if (this.logger.isDebugEnabled()) {
this.logger.debug(LogMessage.format("Re-authenticated %s before authorizing", authentication));
}
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(authentication);
SecurityContextHolder.setContext(context);
return authentication;
}
}
根据上下文对象中的 Authentication 对象判断用户是否通过身份认证，如果尚未通过身份认证，则调用AuthenticationManager 进行认证，并把 Authentication 对象存储在上下文对象中。
步骤3：AbstractSecurityInterceptor#attemptAuthorization
public abstract class AbstractSecurityInterceptor
implements InitializingBean, ApplicationEventPublisherAware, MessageSourceAware {
private AccessDecisionManager accessDecisionManager;
private void attemptAuthorization(Object object, Collection<ConfigAttribute> attributes,Authentication authenticated) {
try {
this.accessDecisionManager.decide(authenticated, object, attributes);
}
// ...
}
}
public class AffirmativeBased extends AbstractAccessDecisionManager {
public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException {
int deny = 0;
for (AccessDecisionVoter voter : getDecisionVoters()) {
int result = voter.vote(authentication, object, configAttributes);
switch (result) {
case AccessDecisionVoter.ACCESS_GRANTED:
return;
case AccessDecisionVoter.ACCESS_DENIED:
deny++;
break;
default:
break;
}
}
if (deny > 0) {
throw new AccessDeniedException(
this.messages.getMessage("AbstractAccessDecisionManager.accessDenied", "Access is denied"));
}
// To get this far, every AccessDecisionVoter abstained
checkAllowIfAllAbstainDecisions();
}
}