SpringBoot自动装配原理解析

@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 {

	@AliasFor(annotation = EnableAutoConfiguration.class) 
	Class<?>[] exclude() default {}; 
	@AliasFor(annotation = EnableAutoConfiguration.class) 
	String[] excludeName() default {};

//根据包路径扫描 
	@AliasFor(annotation = ComponentScan.class, attribute = 
"basePackages") 
	String[] scanBasePackages() default {};

//直接根据 class 类扫描 
	@AliasFor(annotation = ComponentScan.class, attribute = 
"basePackageClasses") 
	Class<?>[] scanBasePackageClasses() default {}; 
}

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Inherited 
@AutoConfigurationPackage 
@Import(AutoConfigurationImportSelector.class) 
public @interface EnableAutoConfiguration { 
	String ENABLED_OVERRIDE_PROPERTY = 
"spring.boot.enableautoconfiguration"; 
//按类型排序不需要自动装配的类 
	Class<?>[] exclude() default {}; 
//按名称排除不需要自动装配的类 
	String[] excludeName() default {}; 
}

public class AutoConfigurationImportSelector implements  
DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, 
BeanFactoryAware, EnvironmentAware, Ordered { 
... 
public String[] selectImports(AnnotationMetadata annotationMetadata) { 
	if (!this.isEnabled(annotationMetadata)) { 
	return NO_IMPORTS; 
} else { 
//1. 加载 META-INF/spring-autoconfigure-metadata.properties文件 
	AutoConfigurationMetadata autoConfigurationMetadata = 
AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);

//2. 获取注解的属性及其值（PS：注解指的是@EnableAutoConfiguration 注解） 
	AnnotationAttributes attributes = 
this.getAttributes(annotationMetadata);

//3. 在classpath下所有的 META-INF/spring.factories 文件中查找 
org.springframework.boot.autoconfigure.EnableAutoConfiguration 的值， 
并将其封装到一个 List 中返回 
	List<String> configurations =

this.getCandidateConfigurations(annotationMetadata, attributes); 
//4. 对上一步返回的 List 中的元素去重、排序 
	configurations = this.removeDuplicates(configurations);

//5.依据第 2 步中获取的属性值排除一些特定的类 
	Set<String> exclusions = 
this.getExclusions(annotationMetadata, attributes);

//6. 对上一步中所得到的 List 进行过滤，过滤的依据是条件匹配。这里用到的过滤器是org.springframework.boot.autoconfigure.condition.OnClassCondition最终返回的是一个 ConditionOutcome[]数组。
//（PS：很多类都是依赖于其它的类的，当有某个类时才会装配，所以这次过滤的就是根据是否有某个class进而决定是否装配的。这些类所依赖的类都写在META-INF/spring-autoconfigure-metadata.properties 文件里）

	this.checkExcludedClasses(configurations, exclusions); 
	configurations.removeAll(exclusions); 
	configurations = this.filter(configurations,autoConfigurationMetadata);
	this.fireAutoConfigurationImportEvents(configurations,exclusions); 
	return StringUtils.toStringArray(configurations); 
	} 
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { 
	List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderF actoryClass(), this.getBeanClassLoader());

	Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging,  make sure that file is correct."); 
	return configurations; 
	} 
	
... 
}

public abstract class SpringFactoriesLoader { 
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"; 
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { 
	MultiValueMap<String, String> result = cache.get(classLoader); 
	if (result != null) 
	return result; 
	try { 
		Enumeration<URL> urls = (classLoader != null ?

classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : 
ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); 
	result = new LinkedMultiValueMap<>(); 
	while (urls.hasMoreElements()) { 
		URL url = urls.nextElement(); 
		UrlResource resource = new UrlResource(url);Properties properties = 
		PropertiesLoaderUtils.loadProperties(resource); 
		for (Map.Entry<?, ?> entry : properties.entrySet()) { 
			List<String> factoryClassNames = Arrays.asList( 
		
		StringUtils.commaDelimitedListToStringArray((String) entry.getValue())); 
			result.addAll((String) entry.getKey(), factoryClassNames); 
		} 
	} 
		cache.put(classLoader, result); 
		return result; 
}

catch (IOException ex) { 
	throw new IllegalArgumentException("Unable to load  
	factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex); 
	} 
}

...

@Configuration 
@ConditionalOnClass(RedisOperations.class) 
@EnableConfigurationProperties(RedisProperties.class) 
@Import({ LettuceConnectionConfiguration.class, 
JedisConnectionConfiguration.class }) 
public class RedisAutoConfiguration { 
...}

<dependency> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-data-redis</artifactId> 
</dependency>

@ConfigurationProperties(prefix = "spring.redis") 
	public class RedisProperties { 
	private int database = 0; 
	private String url; 
	private String host = "localhost"; 
	private String password; 
	private int port = 6379; 
...

@Configuration 
@ConditionalOnClass(RedisOperations.class) 
@EnableConfigurationProperties(RedisProperties.class)@Import({ LettuceConnectionConfiguration.class, 
JedisConnectionConfiguration.class }) 
public class RedisAutoConfiguration {

	@Bean 
//用户没定义就使用默认的 
	@ConditionalOnMissingBean(name = "redisTemplate") 
	public RedisTemplate<Object, Object> redisTemplate( 
		RedisConnectionFactory redisConnectionFactory) throws  
UnknownHostException { 
	  RedisTemplate<Object, Object> template = new RedisTemplate<>(); 
	  template.setConnectionFactory(redisConnectionFactory); 
	  return template; 
    }

    @Bean 
	@ConditionalOnMissingBean(StringRedisTemplate.class) 
	public StringRedisTemplate stringRedisTemplate( 
		RedisConnectionFactory redisConnectionFactory) throws  
UnknownHostException { 
      StringRedisTemplate template = new StringRedisTemplate(); 
	  template.setConnectionFactory(redisConnectionFactory); 
      return template; 
	} 
}