概述
spring security 为所有的 configurer 提供了一个 抽象类 AbstractConfiguredSecurityBuilder，其类关系如下：
image-20210924144312842
AbstractConfiguredSecurityBuilder 通过关联 SecurityConfigurerAdapter、关联并组合 SecurityConfigurer、ObjectPostProcessor，并继承 AbstractSecurityBuilder 实现了 SecurityBuilder 接口
SecurityBuilder
/**
* 构造某个对象的接口定义
*
* @param <O> 要构造的对象的类型
* @author Rob Winch
* @since 3.2
*/
public interface SecurityBuilder<O> {
/**
* 调用此方法构造对象，返回该对象或者 null
* @return 如果实现类支持构造该对象，则返回构造后的对象 或 null
* @throws Exception 如果发生错误则抛出异常
*/
O build() throws Exception;
}
AbstractSecurityBuilder
/**
* SecurityBuilder 的基础实现类：职责为保证对象只被构建一次，并扩展一个获取构建后对象的方法
* time.
*
* @param <O> 要构造的对象的类型
* @author Rob Winch
*
*/
public abstract class AbstractSecurityBuilder<O> implements SecurityBuilder<O> {
private AtomicBoolean building = new AtomicBoolean();
private O object;
@Override
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");
}
/**
* 获取构建后的对象。如果还没有被构建，则抛出异常
* @return 构建后的对象
*/
public final O getObject() {
if (!this.building.get()) {
throw new IllegalStateException("This object has not been built");
}
return this.object;
}
/**
* 子类实现这个方法，执行构建过程
* @return 如果子类支持构造该对象，则返回构造后的对象 或 null
* @throws Exception 如果发生错误则抛出异常
*/
protected abstract O doBuild() throws Exception;
}
SecurityConfigurer
/**
* 允许配置 SecurityBuilder，所有实现类的 SecurityConfigurer 实例运行前须首先执行 init 方法。当所有实现类的 init
* 方法执行完成后，调用所有实现类的 configure 方法
*
* @param <O> 被 B（SecurityBuilder）构建出来的对象类型
* @param <B> 构造对象 O 的 SecurityBuilder 类型，这也是将要被配置的对象类型
* @author Rob Winch
* @see AbstractConfiguredSecurityBuilder
*/
public interface SecurityConfigurer<O, B extends SecurityBuilder<O>> {
/**
* 初始化 SecurityBuilder。这里应该只共享的创建后、修改后的状态数据，而不应该共享
* SecurityBuilder 构建过程中的对象属性。这样保证了 SecurityBuilder 的 configure
* 方法在构建时使用正确的共享对象。配置对象应该在此被应用。
*
* @param builder
* @throws Exception
*/
void init(B builder) throws Exception;
/**
* 配置 SecurityBuilder 必要的属性
* {@link SecurityBuilder}.
* @param builder
* @throws Exception
*/
void configure(B builder) throws Exception;
}
ObjectPostProcessor
/**
* 允许初始化对象。通常用来调用 Aware methods、InitializingBean#afterPropertiesSet()。并且保证
* DisposableBean#destroy() 被调用。
*
* @param <T> 此 ObjectPostProcessor 支持的对象类型
* @author Rob Winch
* @since 3.2
*/
public interface ObjectPostProcessor<T> {
/**
* 初始化对象，可能返回一个需要被使用的修改后的新对象
* @param 要初始化的对象
* @return 初始化后的对象
*/
<O extends T> O postProcess(O object);
SecurityConfigurerAdapter
/**
* SecurityConfigurer 的适配器类，它允许子类只实现他们感兴趣的方法。 同时它的 and() 方法也提供了一种获得对正在配置
* 的 SecurityBuilder 的引用的机制。
*
* @param <O> 被构建的对象
* @param <B> 构建 O 对象的构建器，同时也是此 SecurityConfigurerAdapter 对象正在配置的对象
* @author Rob Winch
* @author Wallace Wadge
*/
public abstract class SecurityConfigurerAdapter<O, B extends SecurityBuilder<O>> implements SecurityConfigurer<O, B> {
private B securityBuilder;
private CompositeObjectPostProcessor objectPostProcessor = new CompositeObjectPostProcessor();
@Override
public void init(B builder) throws Exception {
}
@Override
public void configure(B builder) throws Exception {
}
/**
* 使用完 SecurityConfigurer 之后获取 SecurityBuilder 引用。这在链式调用方法时非常有用。
*
* @return 返回 SecurityBuilder 来支持进一步的自定义配置
*/
public B and() {
return getBuilder();
}
/**
* 获取 SecurityBuilder 对象引用。不能为 null。
* @return SecurityBuilder 对象引用
* @throws IllegalStateException 如果 securityBuilder 是 null
*/
protected final B getBuilder() {
Assert.state(this.securityBuilder != null, "securityBuilder cannot be null");
return this.securityBuilder;
}
/**
* 执行对象的后置处理。默认是代理给 objectPostProcessor 对象
*
* @param object 被执行后置处理的对象
* @return 返回将要被使用的（修改后的）对象
*/
@SuppressWarnings("unchecked")
protected <T> T postProcess(T object) {
return (T) this.objectPostProcessor.postProcess(object);
}
/**
* 添加此对象（SecurityConfigurerAdapter）的一个后置处理器 ObjectPostProcessor 对象。
* 默认不做任何事情
*
* @param objectPostProcessor 将要被使用的后置处理器
*/
public void addObjectPostProcessor(ObjectPostProcessor<?> objectPostProcessor) {
this.objectPostProcessor.addObjectPostProcessor(objectPostProcessor);
}
/**
* 给对象装配将要使用的 SecurityBuilder。这个过程是在调用
* AbstractConfiguredSecurityBuilder#apply(SecurityConfigurerAdapter) 方法时自动执行。
*
* @param builder the {@link SecurityBuilder} to set
*/
public void setBuilder(B builder) {
this.securityBuilder = builder;
}
/**
* 一个代理多个 ObjectPostProcessor 实现对象的 ObjectPostProcessor 代理类
*
* @author Rob Winch
*/
private static final class CompositeObjectPostProcessor implements ObjectPostProcessor<Object> {
private List<ObjectPostProcessor<?>> postProcessors = new ArrayList<>();
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public Object postProcess(Object object) {
for (ObjectPostProcessor opp : this.postProcessors) {
Class<?> oppClass = opp.getClass();
Class<?> oppType = GenericTypeResolver.resolveTypeArgument(oppClass, ObjectPostProcessor.class);
if (oppType == null || oppType.isAssignableFrom(object.getClass())) {
object = opp.postProcess(object);
}
}
return object;
}
/**
* 添加一个 ObjectPostProcessor 的实现类对象
* @param objectPostProcessor 要被添加的 ObjectPostProcessor 对象
* @return 如果 ObjectPostProcessor 对象添加成功，则返回 true，否则返回 false
*/
private boolean addObjectPostProcessor(ObjectPostProcessor<?> objectPostProcessor) {
boolean result = this.postProcessors.add(objectPostProcessor);
this.postProcessors.sort(AnnotationAwareOrderComparator.INSTANCE);
return result;
}
}
}
AbstractConfiguredSecurityBuilder
/**
* <p>
* 允许通过使用 SecurityConfigurer 来配置 SecurityBuilder 来丰富其行为。
* </p>
*
* <p>
* 例如，SecurityBuilder 可以构建 DelegatingFilterProxy，但 SecurityConfigure 可以使用会话管理、基于表单的登录、
* 授权等所需的过滤器填充 SecurityBuilder
* </p>
*
* @param <O> 构建的目标对象
* @param <B> 构建目标对象的构建者
* @author Rob Winch
* @see WebSecurity
*/
public abstract class AbstractConfiguredSecurityBuilder<O, B extends SecurityBuilder<O>>
extends AbstractSecurityBuilder<O> {
private final Log logger = LogFactory.getLog(getClass());
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<>();
private final boolean allowConfigurersOfSameType;
private BuildState buildState = BuildState.UNBUILT;
private ObjectPostProcessor<Object> objectPostProcessor;
/***
* 使用提供的 ObjectPostProcessor 创建一个新的对象。 这个 ObjectPostProcessor 泛型必须是 Object，
* 这是因为可能许多种类型的对象都需要被后置处理。
*
* @param objectPostProcessor 要使用的 ObjectPostProcessor 后置处理器
*/
protected AbstractConfiguredSecurityBuilder(ObjectPostProcessor<Object> objectPostProcessor) {
this(objectPostProcessor, false);
}
/***
* 使用提供的 ObjectPostProcessor 创建一个新的对象。 这个 ObjectPostProcessor 泛型必须是 Object，
* 这是因为可能许多种类型的对象都需要被后置处理。
*
* @param objectPostProcessor 要使用的 ObjectPostProcessor 后置处理器
* @param allowConfigurersOfSameType 如果设置为 true，则在应用 SecurityConfigurer 时，不会覆盖其他对象
*/
protected AbstractConfiguredSecurityBuilder(ObjectPostProcessor<Object> objectPostProcessor,
boolean allowConfigurersOfSameType) {
Assert.notNull(objectPostProcessor, "objectPostProcessor cannot be null");
this.objectPostProcessor = objectPostProcessor;
this.allowConfigurersOfSameType = allowConfigurersOfSameType;
}
/**
* 类似于 build() 和 getObject 方法，但是会检查状态看是否需要先执行 build() 方法。
*
* @return 返回 build() 或 getObject() 的执行结果。如果在构建过程中发生错误，则返回 null。
*/
public O getOrBuild() {
if (!isUnbuilt()) {
return getObject();
}
try {
return build();
}
catch (Exception ex) {
this.logger.debug("Failed to perform build. Returning null", ex);
return null;
}
}
/**
* 在此 SecurityBuilder 对象应用 SecurityConfigurerAdapter，并且调用
* SecurityConfigurerAdapter#setBuilder(SecurityBuilder) 。
* @param configurer
* @return 返回配置后的 SecurityConfigurerAdapter 对象，可用于进一步的自定义配置
* @throws Exception
*/
@SuppressWarnings("unchecked")
public <C extends SecurityConfigurerAdapter<O, B>> C apply(C configurer) throws Exception {
configurer.addObjectPostProcessor(this.objectPostProcessor);
configurer.setBuilder((B) this);
add(configurer);
return configurer;
}
/**
* 在 SecurityBuilder 对象应用 SecurityConfigurer，覆盖完全相同类的任何 SecurityConfigure。
* 请注意，不考虑对象继承层次结构。
*
* @param configurer
* @return 返回装置后的 SecurityConfigurer 对象，可用于进一步的自定义配置
* @throws Exception
*/
public <C extends SecurityConfigurer<O, B>> C apply(C configurer) throws Exception {
add(configurer);
return configurer;
}
/**
* 设置一个在多个 SecurityConfigurer 对象间共享的对象。
* @param sharedType 被共享对象的 class 对象
* @param object 被共享的对象
*/
@SuppressWarnings("unchecked")
public <C> void setSharedObject(Class<C> sharedType, C object) {
this.sharedObjects.put(sharedType, object);
}
/**
* 获取被共享的对象。请注意：不考虑类继承层次
* @param sharedType 被共享对象的 class 对象
* @return 被共享的对象，如果没有找到则返回 null
*/
@SuppressWarnings("unchecked")
public <C> C getSharedObject(Class<C> sharedType) {
return (C) this.sharedObjects.get(sharedType);
}
/**
* 获取所有被共享的对象
* @return 所有被共享的对象
*/
public Map<Class<?>, Object> getSharedObjects() {
return Collections.unmodifiableMap(this.sharedObjects);
}
/**
* 添加一个 SecurityConfigurer（如果状态允许的话）并且有必要的话，调用 SecurityConfigurer#init(SecurityBuilder)
* 方法。
* @param configurer 要添加的 SecurityConfigurer
*/
@SuppressWarnings("unchecked")
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();
synchronized (this.configurers) {
if (this.buildState.isConfigured()) {
throw new IllegalStateException("Cannot apply " + configurer + " to already built object");
}
List<SecurityConfigurer<O, B>> 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);
}
}
}
/**
* 根据给定 Class 对象 获取所有的 SecurityConfigurer 对象集合，如果找不到则返回一个空集合
* 请注意：不考虑类继承层次结构。
* @param clazz 要寻找的 SecurityConfigurer 类型的的 class 对象
* @return 返回所有符合条件的 SecurityConfigurer 对象集合用来进一步的自定义配置
*/
@SuppressWarnings("unchecked")
public <C extends SecurityConfigurer<O, B>> List<C> getConfigurers(Class<C> clazz) {
List<C> configs = (List<C>) this.configurers.get(clazz);
if (configs == null) {
return new ArrayList<>();
}
return new ArrayList<>(configs);
}
/**
* 移除并返回所有指定 class 对象关联的 SecurityConfigurer 对象集合 如果没有找到，则返回空。
* 请注意：不考虑类继承层次结构。
*
* @param clazz 要寻找的 SecurityConfigurer 类型的的 class 对象
* @return 返回所有符合条件的 SecurityConfigurer 对象集合用来进一步的自定义配置
*/
@SuppressWarnings("unchecked")
public <C extends SecurityConfigurer<O, B>> List<C> removeConfigurers(Class<C> clazz) {
List<C> configs = (List<C>) this.configurers.remove(clazz);
if (configs == null) {
return new ArrayList<>();
}
return new ArrayList<>(configs);
}
/**
* 根据给定 Class 对象 获取 SecurityConfigurer 对象，如果找不到则返回 null
* 请注意：不考虑类继承层次结构。
*
* @param clazz
* @return 返回所有符合条件的 SecurityConfigurer 对象用来进一步的自定义配置
*/
@SuppressWarnings("unchecked")
public <C extends SecurityConfigurer<O, B>> C getConfigurer(Class<C> clazz) {
List<SecurityConfigurer<O, B>> configs = this.configurers.get(clazz);
if (configs == null) {
return null;
}
Assert.state(configs.size() == 1,
() -> "Only one configurer expected for type " + clazz + ", but got " + configs);
return (C) configs.get(0);
}
/**
* 移除并返回所有指定 class 对象关联的 SecurityConfigurer 对象，如果没有找到，则返回 null。
* 请注意：不考虑类继承层次结构。
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public <C extends SecurityConfigurer<O, B>> C removeConfigurer(Class<C> clazz) {
List<SecurityConfigurer<O, B>> configs = this.configurers.remove(clazz);
if (configs == null) {
return null;
}
Assert.state(configs.size() == 1,
() -> "Only one configurer expected for type " + clazz + ", but got " + configs);
return (C) configs.get(0);
}
/**
* 指定要使用的 ObjectPostProcessor。
* @param objectPostProcessor 要使用的 ObjectPostProcessor，不能为 null
* @return 返回 SecurityBuilder 来进行进一步的配置
*/
@SuppressWarnings("unchecked")
public B objectPostProcessor(ObjectPostProcessor<Object> objectPostProcessor) {
Assert.notNull(objectPostProcessor, "objectPostProcessor cannot be null");
this.objectPostProcessor = objectPostProcessor;
return (B) this;
}
/**
* 执行对象的后置处理。默认是代理给 ObjectPostProcessor 去处理。
*
* @param object 需要被后置处理的对象
* @return 将被使用的（可能被后置处理修改后的）对象
*/
protected <P> P postProcess(P object) {
return this.objectPostProcessor.postProcess(object);
}
/**
* 使用以下步骤应用 SecurityConfigurer 并执行构建：
*
* <ul>
* <li>调用预留给所有子类的 beforeInit() 钩子方法</li>
* <li>调用所有应用在此 builder 上的 SecurityConfigurer 的 SecurityConfigurer#init(SecurityBuilder) 方法</li>
* <li>调用预留给所有子类的 beforeConfigure() 钩子方法</li>
* <li>调用 performBuild() 方法执行实际的构建行为 </li>
* </ul>
*/
@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;
}
}
/**
* 在调用每个 SecurityConfigurer#init(SecurityBuilder) 方法之前调用此方法，
* 子类可以重写此方法以在不使用 SecurityConfigurer 的情况下挂钩到生命周期。
*/
protected void beforeInit() throws Exception {
}
/**
* 在调用每个 SecurityConfigurer#configure(SecurityBuilder) 方法之前调用此方法，
* 子类可以重写此方法以在不使用 SecurityConfigurer 的情况下挂钩到生命周期。
*/
protected void beforeConfigure() throws Exception {
}
/**
* 子类必须重写此方法，来执行真正的构建过程。
* @return 如果实现类支持，则返回构建后的对象或者 null
*/
protected abstract O performBuild() throws Exception;
@SuppressWarnings("unchecked")
private void init() throws Exception {
Collection<SecurityConfigurer<O, B>> configurers = getConfigurers();
for (SecurityConfigurer<O, B> configurer : configurers) {
configurer.init((B) this);
}
for (SecurityConfigurer<O, B> configurer : this.configurersAddedInInitializing) {
configurer.init((B) this);
}
}
@SuppressWarnings("unchecked")
private void configure() throws Exception {
Collection<SecurityConfigurer<O, B>> configurers = getConfigurers();
for (SecurityConfigurer<O, B> configurer : configurers) {
configurer.configure((B) this);
}
}
private Collection<SecurityConfigurer<O, B>> getConfigurers() {
List<SecurityConfigurer<O, B>> result = new ArrayList<>();
for (List<SecurityConfigurer<O, B>> configs : this.configurers.values()) {
result.addAll(configs);
}
return result;
}
/**
* 确定对象是否还没有被构建。
* @return 返回 true 则说明还没有被构建，否则已经被构建了。
*/
private boolean isUnbuilt() {
synchronized (this.configurers) {
return this.buildState == BuildState.UNBUILT;
}
}
/**
* 应用的构建状态
*
* @author Rob Winch
* @since 3.2
*/
private enum BuildState {
/**
* 在 SecurityBuilder#build() 未执行之前的状态
*/
UNBUILT(0),
/**
* 在 SecurityBuilder#build() 第一次执行之后并且所有的 SecurityConfigurer#init(SecurityBuilder)
* 方法被调用完成之前的状态。
*/
INITIALIZING(1),
/**
* 在所有的 SecurityConfigurer#init(SecurityBuilder) 被调用完成后，并且所有的
* SecurityConfigurer#configure(SecurityBuilder) 被调用完成之前的状态。
*/
CONFIGURING(2),
/**
*
* 在所有的 SecurityConfigurer#configure(SecurityBuilder) 被调用完成后，并且
* AbstractConfiguredSecurityBuilder#performBuild() 调用完成之前的状态。
*/
BUILDING(3),
/**
* 对象被构造完成之后的状态
*/
BUILT(4);
private final int order;
BuildState(int order) {
this.order = order;
}
public boolean isInitializing() {
return INITIALIZING.order == this.order;
}
/**
* 确定当前状态是否在 CONFIGURING 或者 之后的状态
* @return
*/
public boolean isConfigured() {
return this.order >= CONFIGURING.order;
}
}
}
