【闲聊杂谈】深入理解Spring Security设计原理

1、什么是Spring Security

顾名思义，Security的意思是安全，本质上就是一个很纯粹的权限管理框架，提供认证和授权两大核心功能。在目前主流的Spring生态中的项目，说到安全框架，基本上SpringSecurity是首选。当然，也可以使用Apache的Shiro框架，这两个基本上在国内安全性框架这一块几乎垄断。Java 领域老牌的权限管理框架当属 Shiro 了，Shiro 有着众多的优点，例如轻量、简单、易于集成等。当然 Shiro 也有不足，例如对 OAuth2 支持不够，在 Spring Boot 面前无法充分展示自己的优势等等，特别是随着现在 Spring Boot 和 Spring Cloud 的流行，Spring Security 正在走向舞台舞台中央。 Spring Security 是一个比 Shiro 优秀很多的权限管理框架，但是重量级、配置繁琐、门槛高这些问题一直困扰着 Spring Security 的开发者，也让很多初学者望而却步。直到 SpringBoot 横空出世，这些问题统统都得到缓解。在 SpringBoot 或者 Spring Cloud 中，如果想选择一个权限管理框架，几乎毫无疑问的选择 Spring Security，Shiro 在这个环境下已经不具备优势了。Spring Security是Spring采用 AOP思想，基于Servlet过滤器实现的安全框架。它提供了完善的认证机制和方法级的授权功能，是一款非常优秀的权限管理框架。

Spring Security开始于2003年年底，起因是Spring开发者邮件列表中的一个问题，有人提问是否考虑提供一个基于Spring的安全实现。 在当时Spring的社区相对较小，和今天的规模不可同日而语。其实Spring本身是从2003年初才作为一个sourceforge的项目出现的。 对这个问题的回应是，这的确是一个值得研究的领域，虽然限于时间问题阻碍了对它的继续研究。有鉴于此，一个简单的安全实现建立起来了，但没有发布。 几周之后，Spring社区的其他成员询问安全问题，代码就被提供给了他们。 随后又有人请求，在2004年一月左右，有20人在使用这些代码。 另外一些人加入到这些先行者中来，并建议在sourceforge上建立一个项目，项目在2004年3月正式建立起来。

2、Spring Security有多方便

新建一个SpringBoot项目，引入Spring Security依赖

启动项目。是的，你没有看错，引入依赖之后，一项配置不用配，一句代码不用写，直接启动项目即可，启动成功之后访问：http://localhost:8080，会直接跳转到：http://localhost:8080/login

这就说明Spring Security已经生效，自动为项目做了登录拦截，那这个账号和密码又是什么呢？Security默认的账号是user，对应的密码在项目启动的时候已经在控制台上打印出来了

使用默认的账号密码进行登录

登录成功，报错是因为登录成功之后没地方给它跳转，那也没法去写个登出按钮，只能直接访问：http://localhost:8080/logout 进行登出

登出成功后，跳回登录页面

通过上面一个小小的演示，已经通过Security实现最基本的登录登出功能。当然，这也是个简易的不能再简易的演示，实际开发中肯定会使用到自定的登录页面，用户的认证，权限的管理，授权的方式....后面有机会都会一一介绍。主要是这一篇我主要想梳理一下Security的设计原理，后面如果有空的话，就把Security的应用一并加入，顺便说一说Security如何实现JWT认证，以及分布式授权OAuth2.0的本质究竟是怎样。

3、Spring Security使用详解

Web项目环境搭建

引入相关的一些依赖，thymeleaf、MyBatis、MySQL、Druid等

配置文件该写的要写

spring:
  main:
    allow-circular-references: true

这是为了解决SpringBoot 2.6版本之后产生的循环依赖问题，依赖循环引用是不鼓励的，默认情况下是禁止的。不过作为最后的手段，可以通过设置对应的参数来自动打破循环。

主启动类不要忘记加上MyBatis的扫描注解

创建用户对象相关

创建User实体

package com.feenix.springsecurityboot.entity;

public class User {

    private Integer id;
    private String userName;
    private String password;
    private String salt;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", salt='" + salt + '\'' +
                '}';
    }
}

创建UserService接口

package com.feenix.springsecurityboot.service;

import org.springframework.security.core.userdetails.UserDetailsService;

public interface SysUserService extends UserDetailsService {
}

创建UserServiceImpl实现类

package com.feenix.springsecurityboot.service.impl;

import com.feenix.springsecurityboot.entity.SysUser;
import com.feenix.springsecurityboot.mapper.SysUserMapper;
import com.feenix.springsecurityboot.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class SysUserServiceImpl implements SysUserService {

    @Autowired
    private SysUserMapper userMapper;

    /**
     * 根据用户名查询用户信息
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        SysUser sysUser = userMapper.findByUsername(username);
        System.out.println("根据用户名[" + username + "]查询用户信息[" + sysUser.toString() + "]");

        if (null != sysUser) {
            List authorityList = new ArrayList<>();
            authorityList.add(new SimpleGrantedAuthority("ROLE_FEENIX"));

            UserDetails userDetails = new User(username,
                                               sysUser.getPassword(),
                                               true,
                                               true,
                                               true,
                                               true,
                                               authorityList) {
            };

            return userDetails;
        }

        return null;
    }

}

这里需要注意一下，authorityList.add(new SimpleGrantedAuthority("ROLE_FEENIX")); 就是给当前用户赋予了[FEENIX]这个角色。Security的对于角色名的要求是前面必须加上"ROLE_"前缀，且必须为大写。

创建UserMapper

package com.feenix.springsecurityboot.mapper;

import com.feenix.springsecurityboot.entity.SysUser;

public interface SysUserMapper {

    SysUser findByUsername(String username);

}

创建UserMapper.xml

    
        select
            id,
            username,
            password,
            salt
        from
            sys_user
        where
            username = #{username}
    

构建Security配置类

SpringBoot 2.7版本之前，对于Security的构建是通过继承WebSecurityConfigurerAdapter类，并重写其中的configure来配置自定义的过滤器链

package com.feenix.springsecurityboot.config;

import com.feenix.springsecurityboot.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;

import javax.sql.DataSource;

/**
 * 可以理解成是 SpringSecurity的配置文件
 * WebSecurityCofniguration中 @Bean注解 把 FilterChainProxy 注入到了容器中 而且名称为springSecurityFilterChain
 * 而 FilterChainProxy 对象是通过 WebSecurity 构建的
 */
@Configuration
@EnableWebSecurity
public class SpringSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    @Autowired
    private PersistentTokenRepository persistentTokenRepository;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(sysUserService)      // 数据库认证
            .passwordEncoder(bCryptPasswordEncoder); // 设置加密处理的方式
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        super.configure(web);
    }

    /**
     * HttpSecurity 相当于 SpringSecurity 配置文件中 http 标签
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/login.html", "/css/**", "/img/**").permitAll() // 可以匿名访问的资源(通通放过)
            .antMatchers("/**").hasAnyRole("FEENIX").anyRequest().authenticated() // 所有的请求都需要角色认证
            .and().formLogin().loginPage("/login.html").loginProcessingUrl("/login").defaultSuccessUrl("/home.html").permitAll() // 自定义登录界面、登录地址不拦截、登录成功后跳转界面
            .and().rememberMe().tokenRepository(persistentTokenRepository) // 开启[记住我]功能，并将记住我的相关信息持久化到数据库中
            .and().csrf().disable(); // 关闭CSRF
    }

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public PersistentTokenRepository persistentTokenRepository(DataSource dataSource){
        JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();
        tokenRepository.setDataSource(dataSource);
        return tokenRepository;
    }

}

值得注意的是，配置需要对应角色访问的用户：

.antMatchers("/**").hasAnyRole("FEENIX").anyRequest().authenticated()

这句代表，所有的访问资源(/**)得要有(FEENIX)这个角色才可以访问。上面在UserServiceImpl中对用户进行了授权，通过authorityList.add(new SimpleGrantedAuthority("ROLE_FEENIX"))给当前用户赋予了[FEENIX]这个角色，所以才可以通过拦截访问资源。

SpringBoot升级到 2.7 版本之后，因为WebSecurityConfigurerAdapter已经过期，应该使用新的写法：如果想要配置过滤器链，可以通过自定义 SecurityFilterChain Bean 来实现，如果想要配置WebSecurity，可以通过 WebSecurityCustomizer Bean 来实现。

访问：http://localhost:8080/login.html，输入账号密码，可以看到Security从自定义的SysUserService中走数据库查询用户查看是否具有相应的权限。

4、深入理解HttpSecurity设计

从上面的代码中可以看出，Security的核心过滤器链的配置便是继承WebSecurityConfigurerAdapter之后，重写其protected void configure(HttpSecurity http)方法。在这个方法中，通过HttpSecurity对象提供的各种方法设置拦截的各种权限。那么HttpSecurity这块是如何处理的呢，先看下HttpSecurity的类图结构

其实HttpSecurity的类图结构相对比较简单，继承了一个父类，实现了两个接口。

SecurityBuilder接口

先来看看SecurityBuilder接口，通过字面含义就可以知道这是一个创建对象的工具类

通过源码可以看到在SecurityBuilder中提供了一个build()方法。在接口名称处声明了一个泛型，而build()方法返回的正好是这个泛型的对象，其实就很好理解了：也就是SecurityBuilder会创建指定类型的对象。结合HttpSecurity中实现SecurityBuilder接口时指定的泛型，可以看出创建的具体对象是什么类型：SecurityBuilder会通过build方法创建一个DefaultSecurityFilterChain对象，也就是拦截请求的那个默认的过滤器链对象。

打开AbstractSecurityBuilder，进入到build()方法中的doBuild()方法

就会进入到AbstractConfiguredSecurityBuilder中的方法

进入到HttpSecurity中可以查看performBuild()方法的具体实现

在构造方法中绑定了对应的请求匹配器和过滤器集合：
private RequestMatcher requestMatcher = AnyRequestMatcher.INSTANCE;

对应的请求匹配器则是 AnyRequestMatcher 匹配所有的请求。当然现在比较关心默认的过滤器链中的过滤器是哪来的？

AbstractConfiguredSecurityBuilder抽象类

然后现在再来看看AbstractConfiguredSecurityBuilder这个抽象类，它其实是SecurityBuilder的实现，在这儿需要搞清楚它们之间的关系：

1、SecurityBuilder 声明了build方法；
2、AbstractSecurityBuilder 提供了获取对象的方法以及控制一个对象只能build一次；
3、AbstractConfiguredSecurityBuilder 除了提供对对象细粒度的控制外，还扩展了对configurer的操作；

首先 AbstractConfiguredSecurityBuilder 中定义了一个枚举类，将整个构建过程分为 5 种状态，也可 以理解为构建过程生命周期的五个阶段，通过这些状态来管理需要构建的对象的不同阶段：

    /**
	 * The build state for the application
	 *
	 * @author Rob Winch
	 * @since 3.2
	 */
	private enum BuildState {

		/**
		 * This is the state before the {@link Builder#build()} is invoked
		 */
		UNBUILT(0),

		/**
		 * The state from when {@link Builder#build()} is first invoked until all the
		 * {@link SecurityConfigurer#init(SecurityBuilder)} methods have been invoked.
		 */
		INITIALIZING(1),

		/**
		 * The state from after all {@link SecurityConfigurer#init(SecurityBuilder)} have
		 * been invoked until after all the
		 * {@link SecurityConfigurer#configure(SecurityBuilder)} methods have been
		 * invoked.
		 */
		CONFIGURING(2),

		/**
		 * From the point after all the
		 * {@link SecurityConfigurer#configure(SecurityBuilder)} have completed to just
		 * after {@link AbstractConfiguredSecurityBuilder#performBuild()}.
		 */
		BUILDING(3),

		/**
		 * After the object has been completely built.
		 */
		BUILT(4);

		private final int order;

		BuildState(int order) {
			this.order = order;
		}

		public boolean isInitializing() {
			return INITIALIZING.order == this.order;
		}

		/**
		 * Determines if the state is CONFIGURING or later
		 * @return
		 */
		public boolean isConfigured() {
			return this.order >= CONFIGURING.order;
		}

	}

然后来看看AbstractConfiguredSecurityBuilder中的add方法

	/**
	 * Adds {@link SecurityConfigurer} ensuring that it is allowed and invoking
	 * {@link SecurityConfigurer#init(SecurityBuilder)} immediately if necessary.
	 * @param configurer the {@link SecurityConfigurer} to add
	 */
	@SuppressWarnings("unchecked")
	private > void add(C configurer) {
		Assert.notNull(configurer, "configurer cannot be null");
		Class> clazz = (Class>) configurer
				.getClass();
		synchronized (this.configurers) {
			if (this.buildState.isConfigured()) {
				throw new IllegalStateException("Cannot apply " + configurer + " to already built object");
			}
			List> configs = null;
			if (this.allowConfigurersOfSameType) {
				configs = this.configurers.get(clazz);
			}
			configs = (configs != null) ? configs : new ArrayList<>(1);
			configs.add(configurer);
			this.configurers.put(clazz, configs);
			if (this.buildState.isInitializing()) {
				this.configurersAddedInInitializing.add(configurer);
			}
		}
	}

add 方法，这相当于是在收集所有的配置类。将所有的 xxxConfigure 收集起来存储到 configurers
中，将来再统一初始化并配置，configurers 本身是一个 LinkedHashMap ，key 是配置类的 class，value 是一个集合，集合里边放着 xxxConfigure 配置类。当需要对这些配置类进行集中配置的时候，会通过 getConfigurers 方法获取配置类，这个获取过程就是把 LinkedHashMap 中的 value 拿出来，放到一个集合中返回。

然后来看看AbstractConfiguredSecurityBuilder中的doBuild方法

	/**
	 * Executes the build using the {@link SecurityConfigurer}'s that have been applied
	 * using the following steps:
	 *
	 * 

	 * 
Invokes {@link #beforeInit()} for any subclass to hook into
	 * 
Invokes {@link SecurityConfigurer#init(SecurityBuilder)} for any
	 * {@link SecurityConfigurer} that was applied to this builder.
	 * 
Invokes {@link #beforeConfigure()} for any subclass to hook into
	 * 
Invokes {@link #performBuild()} which actually builds the Object
	 * 
	 */
	@Override
	protected final O doBuild() throws Exception {
		synchronized (this.configurers) {
			this.buildState = BuildState.INITIALIZING;
			beforeInit();
			init();
			this.buildState = BuildState.CONFIGURING;
			beforeConfigure();
			configure();
			this.buildState = BuildState.BUILDING;
			O result = performBuild();
			this.buildState = BuildState.BUILT;
			return result;
		}
	}

init方法：完成所有相关过滤器的初始化；
configure方法：完成HttpSecurity和对应的过滤器的绑定；

HttpSecurity实现类

HttpSecurity 做的事情，就是进行各种各样的 xxxConfigurer 配置。HttpSecurity 中有大量类似的方法，过滤器链中的过滤器就是这样一个一个配置的，每个配置方法的结尾都会来一句 getOrApply，这个是干嘛的？

	/**
	 * If the {@link SecurityConfigurer} has already been specified get the original,
	 * otherwise apply the new {@link SecurityConfigurerAdapter}.
	 * @param configurer the {@link SecurityConfigurer} to apply if one is not found for
	 * this {@link SecurityConfigurer} class.
	 * @return the current {@link SecurityConfigurer} for the configurer passed in
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private > C getOrApply(C configurer)
			throws Exception {
		C existingConfig = (C) getConfigurer(configurer.getClass());
		if (existingConfig != null) {
			return existingConfig;
		}
		return apply(configurer);
	}

getConfigurer 方法是在它的父类 AbstractConfiguredSecurityBuilder 中定义的，目的就是去查看当前 这个 xxxConfigurer 是否已经配置过了。如果当前 xxxConfigurer 已经配置过了，则直接返回，否则调用 apply 方法，这个 apply 方法最终会调 用到 AbstractConfiguredSecurityBuilder中的add 方法，将当前配置 configurer 收集起来 HttpSecurity 中还有一个 addFilter 方法

	@Override
	public HttpSecurity addFilter(Filter filter) {
		Integer order = this.filterOrders.getOrder(filter.getClass());
		if (order == null) {
			throw new IllegalArgumentException("The Filter class " + filter.getClass().getName()
					+ " does not have a registered order and cannot be added without a specified order. Consider using addFilterBefore or addFilterAfter instead.");
		}
		this.filters.add(new OrderedFilter(filter, order));
		return this;
	}

这个 addFilter 方法的作用，主要是在各个 xxxConfigurer 进行配置的时候，会调用到这个方法， （xxxConfigurer 就是用来配置过滤器的），把 Filter 都添加到 fitlers 变量中。

这就是 HttpSecurity 的一个大致工作流程。把握住了这个工作流程，剩下的就只是一些简单的重 复的 xxxConfigurer 配置了。

5、深入理解SecurityConfigurer设计

SecurityConfigurer 在 Spring Security 中是一个非常重要的角色。在前面的内容中曾经多次提到过，Spring Security 过滤器链中的每一个过滤器，都是通过 xxxConfigurer 来进行配置的，而这些 xxxConfigurer 实际上都是 SecurityConfigurer 的实现。

/**
 * Allows for configuring a {@link SecurityBuilder}. All {@link SecurityConfigurer} first
 * have their {@link #init(SecurityBuilder)} method invoked. After all
 * {@link #init(SecurityBuilder)} methods have been invoked, each
 * {@link #configure(SecurityBuilder)} method is invoked.
 *
 * @param  The object being built by the {@link SecurityBuilder} B
 * @param  The {@link SecurityBuilder} that builds objects of type O. This is also the
 * {@link SecurityBuilder} that is being configured.
 * @author Rob Winch
 * @see AbstractConfiguredSecurityBuilder
 */
public interface SecurityConfigurer> {

	/**
	 * Initialize the {@link SecurityBuilder}. Here only shared state should be created
	 * and modified, but not properties on the {@link SecurityBuilder} used for building
	 * the object. This ensures that the {@link #configure(SecurityBuilder)} method uses
	 * the correct shared objects when building. Configurers should be applied here.
	 * @param builder
	 * @throws Exception
	 */
	void init(B builder) throws Exception;

	/**
	 * Configure the {@link SecurityBuilder} by setting the necessary properties on the
	 * {@link SecurityBuilder}.
	 * @param builder
	 * @throws Exception
	 */
	void configure(B builder) throws Exception;

}

这个接口里的方法不多就两个：void init(B builder)和void configure(B builder)。在init方法和configure方法中的形参都是SecurityBuilder类型，而SecurityBuilder是用来构建过滤器链 的【DefaultSecurityFilterChainProxy】 SecurityConfigurer的实现当然很多。具体的Configurer实现可以先不关注，目前需要了解的SecurityConfigurer的核心实现有三个

SecurityConfigurerAdapter抽象类

SecurityConfigurerAdapter 实现了 SecurityConfigurer 接口，我们所使用的大部分的xxxConfigurer 也都是 SecurityConfigurerAdapter 的子类。SecurityConfigurerAdapter 在 SecurityConfigurer 的基础上，还扩展出来了几个非常好用的方法

CompositeObjectPostProcessor

	/**
	 * An {@link ObjectPostProcessor} that delegates work to numerous
	 * {@link ObjectPostProcessor} implementations.
	 *
	 * @author Rob Winch
	 */
	private static final class CompositeObjectPostProcessor implements ObjectPostProcessor