spring-boot 启动自动加载配置的原理相关

spring-boot 自动加载的原理

概述：

spring-boot项目中，我们只要创建一个启动类并且标注@SpringBootApplication注解，就可以完成自动化的配置，这其中的原理，主要就是@SpringBootApplication注解的作用，下面我们详细分析下这个注解。

一、SpringBootApplication注解

@SpringBootApplication注解主要包装了三个子注解如下：
@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan

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

其中@ComponentScan用来扫描包的作用，@SpringBootConfiguration是@Configuration的包装，@Configuration又是@Component的包装表示这个类是一个配置类。

@EnableAutoConfiguration注解是我们主要分析的对象。

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

此注解主要起作用的有2个，一个是@AutoConfigurationPackage，一个是@Import(重点分析)

我们知道@Import除了加载指定class的类，还可以指定ImportSelector实现的子类，这个接口方法selectImports，返回的列表即是这个@Import注解需要加载的类。

EnableAutoConfigurationImportSelector的具体实现。

public String[] selectImports(AnnotationMetadata metadata) {
			try {
				AnnotationAttributes attributes = getAttributes(metadata);
				List<String> configurations = getCandidateConfigurations(metadata,
						attributes); // 加载候选的配置类
				// ....略
				return configurations.toArray(new String[configurations.size()]);
			}
			catch (IOException ex) {
				throw new IllegalStateException(ex);
			}
		}

selectImports方法是调用getCandidateConfigurations方法加载候选类，而此方法实际是用SpringFactoriesLoader的loadFactoryNames方法来加载各种自动配置类。

		protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
			List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
					getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
			
			return configurations;
		}

SpringFactoriesLoader的loadFactoryNames方法传入了一个EnableAutoConfiguration的class全类名，然后主要是从META-INF/spring.factories路径下加载资源文件，遍历，然后找到符合这个全类名key的value值，进行解析处理。

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
			String factoryClassName = factoryClass.getName();
			try {
				Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
						ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); // 加载资源文件
				List<String> result = new ArrayList<String>();
				while (urls.hasMoreElements()) {
					URL url = urls.nextElement();
					Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url)); // 解析成prop
					String factoryClassNames = properties.getProperty(factoryClassName); // 得到factoryClass的属性
					result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
				}
				return result;
			}
			catch (IOException ex) {
			}
		}

下面我们从spring-boot-autoconfigure的jar包中META-INF下找到这个资源文件中的配置。

  org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
        org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
        org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
        org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\

二、部分默认配置类的配置解释

1、DataSourceAutoConfiguration的分析

1) 类上注解的配置

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })

这个注解一共包装了4个子注解,@Configuration是标注配置类，@ConditionalOnClass表示必须存在DataSource的类，@EnableConfigurationProperties是加载配置文件用途的。
@Import引入的2个类，都是采用直接指定类加载的方式，其中一个Registrar是用来生成一个BeanPostProcessor，实现当datasource的bean初始化后，必须加载DataSourceInitializer的用途。而DataSourcePoolMetadataProvidersConfiguration就是提供数据源提供者类的配置。比如DBCP、TOMCAT、等等数据源提供类。

2) 方法和子类配置

方法1）dataSourceInitializer配置主要是初始化一个公共的DataSourceInitializer的bean，这个bean的主要作用就是把配置类配置的url
、password等缺省赋值到已经创建的datasource中。

        @Bean
            @ConditionalOnMissingBean // 表示
            public DataSourceInitializer dataSourceInitializer() {
                return new DataSourceInitializer();
            }

内部类2）PooledDataSourceConfiguration这个内部类，主要是提供几种数据源的类，是采用@Import直接提供的方式。

        @Configuration
            @Conditional(PooledDataSourceCondition.class)
            @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
            @Import({ DataSourceConfiguration.Tomcat.class, DataSourceConfiguration.Hikari.class,
                    DataSourceConfiguration.Dbcp.class, DataSourceConfiguration.Dbcp2.class,
                    DataSourceConfiguration.Generic.class })
            protected static class PooledDataSourceConfiguration {
            }

这个内部类必须要存在dbcp2数据源的类，并且spring.datasource.type正确的指定，或者不提供(matchIfMissing = true)，如何创建一个数据源呢？其创建方法最终执行的是 DataSourceBuilder.create().....type().build()，

   @ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class) 
            @ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.commons.dbcp2.BasicDataSource", matchIfMissing = true)
            static class Dbcp2 extends DataSourceConfiguration {
        
                @Bean
                @ConfigurationProperties("spring.datasource.dbcp2")
                public org.apache.commons.dbcp2.BasicDataSource dataSource(
                        DataSourceProperties properties) {
                    return createDataSource(properties,
                            org.apache.commons.dbcp2.BasicDataSource.class);
                }
            }

最后列举一下我们自己创建的datasource，通过DataSourceBuilder创建，然后利用配置文件给定属性

       @ConfigurationProperties(prefix = "spring.datasource.xxx")
            @Bean(destroyMethod = "close", name = "xxx")
            public DataSource dataSource1() {
                return DataSourceBuilder.create().type(dataSourceType).build();
            }

三、Conditional系列注解的源码分析

我们在上面的配置类中各种ConditionalOnClass条件的使用，下面我们从一个ConditionalOnClass注解分析此类注解的原理。首先Conditional注解的value值是一个实现Condition的接口，这个接口的matches方法实现如果返回true，则加载此bean，而ConditionalOnClass的这个注解其实包装了Conditional，实现Condition接口的类是OnClassCondition

1、OnClassCondition
OnClassCondition继承了SpringBootCondition,SpringBootCondition实现matches的方法，而实际上matches调用的是子类的模板方法 getMatchOutcome。方法如下 (备注ConditionOutcome就是包装一个boolean类型的标记和信息的po类，match方法就是true,noMatch就是false)

  public ConditionOutcome getMatchOutcome(ConditionContext context,
            AnnotatedTypeMetadata metadata) {
            ConditionMessage matchMessage = ConditionMessage.empty();
            MultiValueMap<String, Object> onClasses = getAttributes(metadata,ConditionalOnClass.class); // 得到注解元素
            if (onClasses != null) {
                List<String> missing = getMatchingClasses(onClasses, MatchType.MISSING,context);  // 判断缺少的类
                if (!missing.isEmpty()) {
                    return ConditionOutcome
                            .noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
                                    .didNotFind("required class", "required classes")
                                    .items(Style.QUOTE, missing));
                }
            }
            //....
            return ConditionOutcome.match(matchMessage);
        }

private List<String> getMatchingClasses(MultiValueMap<String, Object> attributes,
				MatchType matchType, ConditionContext context) {
			List<String> matches = new LinkedList<String>();
			addAll(matches, attributes.get("value"));
			addAll(matches, attributes.get("name"));
			Iterator<String> iterator = matches.iterator();
			while (iterator.hasNext()) {
				if (!matchType.matches(iterator.next(), context)) {
					iterator.remove(); // matchType传入的枚举是不符合，这里！就是符合的移除，剩余的就是没有提供的。
				}
			}
			return matches;
		}

private enum MatchType {
			PRESENT { // 提供了class
				public boolean matches(String className, ConditionContext context) {
					return ClassUtils.isPresent(className, context.getClassLoader());
				}
			},
			MISSING {  // 没有提供calss
				public boolean matches(String className, ConditionContext context) {
					return !ClassUtils.isPresent(className, context.getClassLoader());
				}
			};
			public abstract boolean matches(String className, ConditionContext context);
		}

从上面的代码我们可以看到OnClassCondition的判断很简单，就是根据注解提供的value值的class类型，然后用class.forName 能够反射的就是为true，即是提供了这个类的，如果没有不提供的类，最终getMatchOutcome方法将返回匹配。

完毕！

spring-boot 启动自动加载配置的原理相关

猜你喜欢