参考b站up主：传送门

前沿 ：

回顾上章：最顶层就是一个过滤器
SpringSecurity流程：FilterChainProxy->根据请求决定一个 SecurityFilterChain (挨个调用其matches方法 匹配请求能否处理)-> 执行SecurityFilterChain中的一系列过滤器

FilterChainProxy相关的东西。
SecurityFilterChain接口用于配置一个FilterChainProxy

//Used to configure a FilterChainProxy.
public interface SecurityFilterChain {

	boolean matches(HttpServletRequest request);
	List<Filter> getFilters();

}

SecurityConfigurer、AbstractConfiguredSecurityBuilder
AbstractConfiguredSecurityBuilder上章提到过，间接实现了SecurityBuilder。

SecurityConfigurer

SecurityConfigurer用来去配置一个SecurityBuilder

/**
Allows for configuring a SecurityBuilder. All SecurityConfigurer first have their init(SecurityBuilder) method invoked. After all init(SecurityBuilder) methods have been invoked, each configure(SecurityBuilder) method is invoked.
*/
//所有的SecurityConfigurer都首先调用它的init(SecurityBuilder) 方法
public interface SecurityConfigurer<O, B extends SecurityBuilder<O>>{
// 初始化方法 初始化一个SecurityBuilder
void init(B builder) throws Exception;
// 配置方法
void configure(B builder) throws Exception;
}

1、SecurityConfigurer是去配置一个SecurityBuilder。
2、SecurityBuilder是构建对象的
最后：它的子类是相当的多

AbstractConfiguredSecurityBuilder

是SecurityBuilder的间接实现
1、共享对象设置
2、控制初始化（初始化前、中、后 配置 前、中、后）

AbstractSecurityBuilder

它做的事就是只允许build一次

public abstract class AbstractSecurityBuilder<O> implements SecurityBuilder<O>{
       private AtomicBoolean building = new AtomicBoolean();
       
       public final O build() throws Exception {
		if (this.building.compareAndSet(false, true)) {
			this.object = doBuild();
			return this.object;
		}
		throw new AlreadyBuiltException("This object has already been built");
	}
}

聊回AbstractConfiguredSecurityBuilder

（因为它在构建安全对象都会参与的类）
我们知道SecurityBuilder是为了构建对象的这个对象可能是SecurityFilterChain安全的过滤器链也有可能是AuthenticationManager（认证的管理器）后面说。

属性

//AbstractConfiguredSecurityBuilder需要被一堆的SecurityConfigurer去配置，所以需要维护一个configurers
private final LinkedHashMap<Class<? extends SecurityConfigurer<O, B>>, List<SecurityConfigurer<O, B>>> configurers = new LinkedHashMap<>();
//
private final List<SecurityConfigurer<O, B>> configurersAddedInInitializing = new ArrayList<>();

// 共享对象
private final Map<Class<?>, Object> sharedObjects = new HashMap<>();
//同一个configure是否允许出现两个
private final boolean allowConfigurersOfSameType;
//后置处理
private ObjectPostProcessor<Object> objectPostProcessor;

使用最频繁的方法

使用spring-security时我们经常使用.X.X.X 都会调用这个方法
添加一个SecurityConfigurer进来

private <C extends SecurityConfigurer<O, B>> void add(C configurer) {
		Assert.notNull(configurer, "configurer cannot be null");

		Class<? extends SecurityConfigurer<O, B>> clazz = (Class<? extends SecurityConfigurer<O, B>>) configurer
				.getClass();
				// 同步 只允许一个线程工作。configurers 一个LinkedHashMap
		synchronized (configurers) {
		//BuildState是一个枚举类 状态：未构建、初始化、配置、构建中、构建完成
			if (buildState.isConfigured()) {//是否已经配置
			//已经构建过了 不需要再应用
				throw new IllegalStateException("Cannot apply " + configurer
						+ " to already built object");
			}
			List<SecurityConfigurer<O, B>> configs = allowConfigurersOfSameType ? this.configurers
					.get(clazz) : null;
			if (configs == null) {
				configs = new ArrayList<>(1);
			}
			// 添加
			configs.add(configurer);
			this.configurers.put(clazz, configs);
			// 是否正在初始化
			if (buildState.isInitializing()) {
			//
				this.configurersAddedInInitializing.add(configurer);
			}
		}
	}