跳到主要内容

01、Spring Security 实战 - 自动配置原理

1. 导入 SpringSecurity 依赖

<!--引入spring security依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. SpringBoot 的自动配置功能

使用Spring Boot时，我们只需引入对应的Starters，Spring Boot启动时便会自动加载相关依赖，配置相应的初始化参数，以最快捷、简单的形式对第三方软件进行集成，这便是Spring Boot的自动配置功能。

 

可以用一句话来描述整个过程：Spring Boot通过@EnableAutoConfiguration注解开启自动配置，加载spring.factories中注册的各种AutoConfiguration类，当某个AutoConfiguration类满足其注解@Conditional指定的生效条件（Starters提供的依赖、配置或Spring容器中是否存在某个Bean等）时，实例化该AutoConfiguration类中定义的Bean（组件等），并注入Spring容器，就可以完成依赖框架的自动配置。

  • @EnableAutoConfiguration：该注解由组合注解@SpringBootApplication引入，完成自动配置开启，扫描各个jar包下的spring.factories文件，并加载文件中注册的AutoConfiguration类等。
  • spring.factories：配置文件，位于jar包的META-INF目录下，按照指定格式注册了自动配置的AutoConfiguration类。spring.factories也可以包含其他类型待注册的类。该配置文件不仅存在于Spring Boot项目中，也可以存在于自定义的自动配置（或Starter）项目中。
  • AutoConfiguration类：自动配置类，代表了Spring Boot中一类以XXAutoConfiguration命名的自动配置类。其中定义了三方组件集成Spring所需初始化的Bean和条件。
  • @Conditional：条件注解及其衍生注解，在AutoConfiguration类上使用，当满足该条件注解时才会实例化AutoConfiguration类。
  • Starters：三方组件的依赖及配置，Spring Boot已经预置的组件。Spring Boot默认的Starters项目往往只包含了一个pom依赖的项目。如果是自定义的starter，该项目还需包含spring.factories文件、AutoConfiguration类和其他配置类。

1. 入口类和 @SpringBootApplication 注解

@EnableAutoConfiguration是开启自动配置的注解，在创建的Spring Boot项目中并不能直接看到此注解，它是由组合注解@SpringBootApplication引入的。

Spring Boot项目创建完成会默认生成一个*Application的入口类。通过该类的main方法即可启动Spring Boot项目。

@SpringBootApplication
public class SpringSecurity01Application {
   
     
    public static void main(String[] args) {
   
     
        SpringApplication.run(SpringSecurity01Application.class, args);
    }
}

在Spring Boot入口类（除单元测试外）中，唯一的一个注解就是@SpringBootApp-lication。它是Spring Boot项目的核心注解，用于开启自动配置，准确说是通过该注解内组合的@EnableAutoConfiguration开启了自动配置。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
   
      @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
   
     

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * 排除指定的自动配置类
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {
   
     };

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * 排除指定自动配置类名 
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {
   
     };

	/**
	 * Base packages to scan for annotated components. 
	 * 指定扫描的基础包，激活注解组件的初始化
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {
   
     };

	/**
	 * Type-safe alternative to {@linkscanBasePackages} for specifying the packages to
	 * scan for annotated components. The package of each class specified will be scanned.
	 * 指定扫描的类，用于初始化
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {
   
     };

	@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;
}

①@SpringBootConfiguration注解源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
   
     
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;
}

②@EnableAutoConfiguration注解源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
   
     

   /**
    * Environment property that can be used to override when auto-configuration is
    * enabled.
    */
   String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

   /**
    * Exclude specific auto-configuration classes such that they will never be applied.
    */
   Class<?>[] exclude() default {
   
     };

   /**
    * Exclude specific auto-configuration class names such that they will never be
    * applied.
    */
   String[] excludeName() default {
   
     };

}

注解中的成员属性：

  • exclude：根据类（Class）排除指定的自动配置，该成员属性覆盖了@SpringBootApplication中组合的@EnableAutoConfiguration中定义的exclude成员属性。
  • excludeName：根据类名排除指定的自动配置，覆盖了@EnableAutoConfiguration中的excludeName的成员属性。
  • scanBasePackages：指定扫描的基础package，用于激活@Component等注解类的初始化。
  • Spring Boot中大量使用了@AliasFor注解，该注解用于桥接到其他注解，该注解的属性中指定了所桥接的注解类。如果点进去查看，会发现@SpringBootApplication定义的属性在其他注解中已经定义过了。之所以使用@AliasFor注解并重新在@SpringBootApplication中定义，更多是为了减少用户使用多注解带来的麻烦。

@SpringBootApplication注解中组合了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。因此，在实践过程中也可以使用这3个注解来替代@SpringBootApplication。

 

2. 注解 @EnableAutoConfiguration功能

在未使用Spring Boot的情况下，Bean的生命周期由Spring来管理，然而Spring无法自动配置@Configuration注解的类。而Spring Boot的核心功能之一就是根据约定自动管理该注解标注的类。用来实现该功能的组件之一便是@EnableAutoConfiguration注解。

@EnableAutoConfiguration位于spring-boot-autoconfigure包内，当使用@SpringBootApplication注解时，@EnableAutoConfiguration注解会自动生效。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
   
     

   /**
    * Environment property that can be used to override when auto-configuration is
    * enabled.
    * 用来覆盖配置开启/关闭自动配置的功能
    */
   String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

   /**
    * Exclude specific auto-configuration classes such that they will never be applied.
    * 根据类排除指定的自动配置
    */
   Class<?>[] exclude() default {
   
     };

   /**
    * Exclude specific auto-configuration class names such that they will never be
    * applied.
    * 根据类名排除指定的自动配置
    */
   String[] excludeName() default {
   
     };
}

@EnableAutoConfiguration注解提供了一个常量和两个成员参数的定义：

  • ENABLED_OVERRIDE_PROPERTY：用来覆盖开启/关闭自动配置的功能；
  • exclude：根据类（Class）排除指定的自动配置；
  • excludeName：根据类名排除指定的自动配置；

@EnableAutoConfiguration会猜测你需要使用的Bean，但如果在实战中你并不需要它预置初始化的Bean，可通过该注解的exclude或excludeName参数进行有针对性的排除。比如，当不需要数据库的自动配置时：

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SpringSecurity01Application {
   
     
    public static void main(String[] args) {
   
     
        SpringApplication.run(SpringSecurity01Application.class, args);
    }
}

3. 条件注解 @Conditional

@Conditional注解是由Spring 4.0版本引入的新特性，可根据是否满足指定的条件来决定是否进行Bean的实例化及装配，比如，设定当类路径下包含某个jar包的时候才会对注解的类进行实例化操作。总之，就是根据一些特定条件来控制Bean实例化的行为，@Conditional注解代码如下：

@Target({
   
     ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
   
     

   Class<? extends Condition>[] value();
}

@Conditional注解唯一的元素属性是接口Condition的数组，只有在数组中指定的所有Condition的matches方法都返回true的情况下，被注解的类才会被加载。

@FunctionalInterface
public interface Condition {
   
     
   /**
    * Determine if the condition matches.
    */
   boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

matches方法的第一个参数为ConditionContext，可通过该接口提供的方法来获得Spring应用的上下文信息，ConditionContext接口定义如下：

public interface ConditionContext {
   
     

   /**
    * Return the {@link BeanDefinitionRegistry} that will hold the bean definition
    * should the condition match.
    * 
    */
   BeanDefinitionRegistry getRegistry();

   /**
    * Return the {@link ConfigurableListableBeanFactory} that will hold the bean
    * definition should the condition match, or {@code null} if the bean factory is
    * not available (or not downcastable to {@code ConfigurableListableBeanFactory}).
    */
   @Nullable
   ConfigurableListableBeanFactory getBeanFactory();

   /**
    * Return the {@link Environment} for which the current application is running.
    */
   Environment getEnvironment();

   /**
    * Return the {@link ResourceLoader} currently being used.
    */
   ResourceLoader getResourceLoader();

   /**
    * Return the {@link ClassLoader} that should be used to load additional classes
    * (only {@code null} if even the system ClassLoader isn't accessible).
    */
   @Nullable
   ClassLoader getClassLoader();
}

matches方法的第二个参数为AnnotatedTypeMetadata，该接口提供了访问特定类或方法的注解功能，并且不需要加载类，可以用来检查带有@Bean注解的方法上是否还有其他注解，AnnotatedTypeMetadata接口定义如下:

public interface AnnotatedTypeMetadata {
   
     

   MergedAnnotations getAnnotations();

   boolean isAnnotated(String annotationName);

   @Nullable
   Map<String, Object> getAnnotationAttributes(String annotationName);

   @Nullable
   Map<String, Object> getAnnotationAttributes(String annotationName,boolean classValuesAsString) ;
 
   @Nullable
   MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName);
 
   @Nullable
   MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName, boolean classValuesAsString);
}

该接口的isAnnotated方法能够提供判断带有@Bean注解的方法上是否还有其他注解的功能。其他方法提供不同形式的获取@Bean注解的方法上其他注解的属性信息。

在Spring Boot的autoconfigure项目中提供了各类基于@Conditional注解的衍生注解，它们适用不同的场景并提供了不同的功能:

  • @ConditionalOnBean：在容器中有指定Bean的条件下；
  • @ConditionalOnClass：在classpath类路径下有指定类的条件下；
  • @ConditionalOnCloudPlatform：当指定的云平台处于active状态时；
  • @ConditionalOnExpression：基于SpEL表达式的条件判断；
  • @ConditionalOnJava：基于JVM版本作为判断条件；
  • @ConditionalOnMissingBean：当容器里没有指定Bean的条件时；
  • @ConditionalOnMissingClass：当类路径下没有指定类的条件时；
  • @ConditionalOnProperty：在指定的属性有指定值的条件下；
  • @ConditionalOnResource：类路径是否有指定的值；
  • @ConditionalOnSingleCandidate：当指定的Bean在容器中只有一个或者有多个但是指定了首选的Bean时；
  • @ConditionalOnWebApplication：在项目是一个Web项目的条件下；

3. SpringSecurity的自动配置

1. SecurityAutoConfiguration

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SpringSecurity01Application {
   
     

    public static void main(String[] args) {
   
     
        SpringApplication.run(SpringSecurity01Application.class, args);
    }
}

Spring Boot通过@EnableAutoConfiguration注解开启自动配置，加载spring.factories中注册的各种AutoConfiguration类，当某个AutoConfiguration类满足其注解@Conditional指定的生效条件时，实例化该AutoConfiguration类中定义的Bean，并注入Spring容器，就可以完成依赖框架的自动配置。

首先，加载org.springframework.boot.autoconfigure包下META-INF/spring.factories中注册的key=org.springframework.boot.autoconfigure.EnableAutoConfiguration，value=SecurityAutoConfiguration的自动配置类：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
...
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
...

当完成注册之后，在加载的过程中会使用元数据的配置进行过滤，对应的配置内容在META-INF/spring-autoconfigure-metadata.properties文件中：

org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.ConditionalOnClass=org.springframework.security.authentication.DefaultAuthenticationEventPublisher

在过滤的过程中要判断自动配置类SecurityAutoConfiguration是否被@ConditionalOnClass注解，源代码如下:

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(DefaultAuthenticationEventPublisher.class)
@EnableConfigurationProperties(SecurityProperties.class)
@Import({
   
      SpringBootWebSecurityConfiguration.class, WebSecurityEnablerConfiguration.class,
      SecurityDataConfiguration.class, ErrorPageSecurityFilterConfiguration.class })
public class SecurityAutoConfiguration {
   
     

   @Bean
   @ConditionalOnMissingBean(AuthenticationEventPublisher.class)
   public DefaultAuthenticationEventPublisher authenticationEventPublisher(ApplicationEventPublisher publisher) {
   
     
      return new DefaultAuthenticationEventPublisher(publisher);
   }
}

可以看到，该配置类SecurityAutoConfiguration被@ConditionalOnClass注解，并且指定实例化的条件为类路径下必须有DefaultAuthenticationEventPublisher类存在，如果Spring容器当中没有对应的类，则该类不会被注入。再看一下该类的其他注解：

  • @Configuration：指定该类作为配置项来进行实例化操作；
  • @Import：导入@Configuration注解类，这里导入了SpringBootWebSecurityConfiguration.class，WebSecurityEnablerConfiguration.class，SecurityDataConfiguration.class，ErrorPageSecurityFilterConfiguration.class。
  • @ConditionalOnMissingBean：注释于方法上，与@Bean配合，当Spring容器中没有该Bean的实例化对象时才会进行实例化。即当Spring容器中没有AuthenticationEventPublisher实例时，才会实例化DefaultAuthenticationEventPublisher对象，注入Spring容器。如果有了，那么就会覆盖掉当前默认的。
  • @EnableConfigurationProperties：参数为SecurityProperties.class，开启属性注入，可以通过在application.yaml 文件中配置这个 SecurityProperties 类中的属性。
@ConfigurationProperties(prefix = "spring.security")
public class SecurityProperties {
     
       

   public static final int BASIC_AUTH_ORDER = Ordered.LOWEST_PRECEDENCE - 5;

   public static final int IGNORED_ORDER = Ordered.HIGHEST_PRECEDENCE;

   public static final int DEFAULT_FILTER_ORDER 
       = OrderedFilter.REQUEST_WRAPPER_FILTER_MAX_ORDER - 100;

   private final Filter filter = new Filter();
   private final User user = new User();

   public static class Filter {
     
       
       
      private int order = DEFAULT_FILTER_ORDER;
       
      private Set<DispatcherType> dispatcherTypes = new HashSet<>(
            Arrays.asList(DispatcherType.ASYNC, DispatcherType.ERROR, DispatcherType.REQUEST));
   }

   public static class User {
     
       
      /**
       * Default user name.
       */
      private String name = "user";

      /**
       * Password for the default user name.
       */
      private String password = UUID.randomUUID().toString();

      /**
       * Granted roles for the default user name.
       */
      private List<String> roles = new ArrayList<>();

      private boolean passwordGenerated = true;
   }
}

而在application.properties中，我们会进行如下对应配置，修改默认的用户名和密码：

spring.security.user.name=root
spring.security.user.password=root
spring.security.user.roles=admin,user

2. SpringBootWebSecurityConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnDefaultWebSecurity
@ConditionalOnWebApplication(type = Type.SERVLET)
class SpringBootWebSecurityConfiguration {
   
     

   @Bean
   @Order(SecurityProperties.BASIC_AUTH_ORDER)
   SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
   
     
      http.authorizeRequests()
           // 对所有的请求开启权限认证,认证之后才能访问
          .anyRequest().authenticated()
          .and()
           // 支持表单认证
          .formLogin()
          .and()
           // 支持basic认证
          .httpBasic();
      return http.build();
   }
}

@Configuration：说明该类SpringBootWebSecurityConfiguration会作为一个配置类的组件注入到Spring容器当中 ，并且不会生成对应的代理；

该类SpringBootWebSecurityConfiguration注入到Spring容器并实例化需要满足下面两个条件：

@ConditionalOnWebApplication(type = Type.SERVLET)：参数为Type.SERVLET，说明该类只有在基于servlet的Web应用中才会被实例化。SpringBoot 集成了tomcat，默认就是一个servelet项目，因此条件满足。

@ConditionalOnDefaultWebSecurity：组合了注解@Conditional(DefaultWebSecurityCondition.class)，该注解依赖于DefaultWebSecurityCondition类，

@Target({
   
      ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 条件注解，依赖于DefaultWebSecurityCondition类
@Conditional(DefaultWebSecurityCondition.class)
public @interface ConditionalOnDefaultWebSecurity {
   
     

}

如果@ConditionalOnDefaultWebSecurity 条件成立需要满足下面两个条件：

@ConditionalOnClass({ SecurityFilterChain.class, HttpSecurity.class }) ：当classpath类路劲下存在SecurityFilterChain.class, HttpSecurity.classs 时，条件成立；

@ConditionalOnMissingBean({ WebSecurityConfigurerAdapter.class, WebSecurityConfigurerAdapter.class })：当Spring容器中不存在WebSecurityConfigurerAdapter，WebSecurityConfigurerAdapter 实例时，条件成立；

class DefaultWebSecurityCondition extends AllNestedConditions {
   
     

   DefaultWebSecurityCondition() {
   
     
      super(ConfigurationPhase.REGISTER_BEAN);
   }

   // 在classpath类路径下有指定类存在的条件下
   // 在classpath类路径下存在 SecurityFilterChain，HttpSecurity 类时，条件满足
   @ConditionalOnClass({
   
      SecurityFilterChain.class, HttpSecurity.class })
   static class Classes {
   
     

   }

   // 当容器里没有指定Bean的条件时
   // Spring的容器中不存在 WebSecurityConfigurerAdapter，SecurityFilterChain 实例时，条件满足
   // 如果Spring容器中存在WebSecurityConfigurerAdapter, SecurityFilterChain，说明我们对WebSecurityConfigurerAdapter, SecurityFilterChain进行了自定义，那么该条件不满足，Spring容器将不会实例化 DefaultWebSecurityCondition
   @ConditionalOnMissingBean({
   
      WebSecurityConfigurerAdapter.class, SecurityFilterChain.class })
   static class Beans {
   
     

   }
}

当Spring容器中含有 WebSecurityConfigurerAdapter 类及其子类时
，那么这个默认的 DefaultWebSecurityCondition 将不会进行配置了，所以这也就是为什么我们对SpringSecurity进行扩展的时候，需要继承 WebSecurityConfigurerAdapter 类来达成自定义配置了。

3. 总结

经过上面的分析可以看出，默认情况下，条件都是满足的。SpringSecurity 默认生效的是配置：

@Configuration(proxyBeanMethods = false)
@ConditionalOnDefaultWebSecurity
@ConditionalOnWebApplication(type = Type.SERVLET)
class SpringBootWebSecurityConfiguration {
   
     

   @Bean
   @Order(SecurityProperties.BASIC_AUTH_ORDER)
   SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
   
     
      http.authorizeRequests()
           // 对所有的请求开启权限认证,认证之后才能访问
          .anyRequest().authenticated()
          .and()
           // 支持表单认证
          .formLogin()
          .and()
           // 支持basic认证
          .httpBasic();
      return http.build();
   }
}

WebSecurityConfigurerAdapter 这个类极其重要，Spring Security 核心配置都在这个类中，
如果想要扩展SpringSecurity的相关配置，可以在项目中自定义配置类继承WebSecurityConfigurerAdapter类或者实现SecurityFilterChain接口，这样操作都会覆盖掉上面的默认配置，SpringBoot 将所有的扩展配置都放在了WebSecurityConfigurerAdapter和SecurityFilterChain中。如果改配置可以扩展WebSecurityConfigurerAdapter，如果自定义过滤器可以扩展SecurityFilterChain。

如果要对 Spring Security 进行自定义配置，就要自定义这个类实例，通过覆盖类中方
法达到修改默认配置的目的：