springboot做为一个基于spring开发的框架,天然也继承了spring的容器属性。容器中的bean天然成为了springboot各类功能的基础。本节就来分析一下springboot如何将各类bean加载进容器中。web
开始分析以前首先咱们先概览一下springboot框架究竟加载了多少bean。在main函数中添加以下代码,运行。spring
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(Application.class, args);
Arrays.stream(context.getBeanDefinitionNames()).forEach(System.out::println);
}
复制代码
不出意外的话,控制台会打印出上百个bean的名字。虽然咱们仅仅只写了两个类而已!那么这些类的加载有何规则呢?相比于spring的xml配置文件,springboot的自动化配置又是如何实现的?这些都将在本节揭晓。springboot
public ConfigurableApplicationContext run(String... args) {
...
//建立ApplicationContext
context = createApplicationContext();
...
//作一些初始化配置
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
refreshContext(context);
afterRefresh(context, applicationArguments);
...
}
复制代码
首先咱们进入SpringApplication的run方法中,在run方法中咱们看到和ApplicationContext有关的代码一共有4行,第一行建立了ApplicationContext,第二行作了一些初始化配置,第三行调用了refresh方法,读过spring源码的话应该知道这个方法包含了ApplicationContext初始化最重要也最大部分的逻辑,因此这行待会会重点分析,最后一行是一个空方法,留着子类覆写。bash
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
break;
...
}
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
复制代码
首先进入create方法,在SpringApplication初始化的时候,咱们已经知道了这是一个网络服务,因此这边建立的类是DEFAULT_SERVLET_WEB_CONTEXT_CLASS类,(org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext) 在这边直接调用了无参构造函数。先进入构造函数看一下作了那些事情。网络
public AnnotationConfigServletWebServerApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
复制代码
初始化了reader和scanner组件,reader是用来注册bean的,scanner是用来扫描bean的。这两个组件初始化的逻辑都不复杂,读者能够自行理解。可是重点关注一个地方。在reader的构造函数中:app
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
...
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
...
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
...
}
复制代码
一个ConfigurationClassPostProcessor的bean被注入到了容器中,这个地方留意一下,后面这个bean很重要。框架
建立完成了以后,咱们看一下prepareContext方法ide
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
...
load(context, sources.toArray(new Object[0]));
...
}
复制代码
prepareContext方法中,调用了一些监听器,和初始化接口,可是最重要的是load这个方法。load这个方法,将咱们main方法的这个类传入了容器中。这个类上面有一个很是重要的注解SpringBootApplication。函数
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(Application.class, args);
Arrays.stream(context.getBeanDefinitionNames()).forEach(System.out::println);
}
}
复制代码
下面就进入到了最重要的refresh方法,若是读过《spring源码深度解析》这本书的话,这个地方的逻辑应该感到很亲切,没读过的话强烈建议读一下,无论spring怎么发展,基础仍是那些的。post
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
...
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
...
}
复制代码
因此refresh方法中的逻辑我也很少介绍了,直接进入主题。invokeBeanFactoryPostProcessors方法。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
...
}
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
...
}
复制代码
在invokeBeanFactoryPostProcessors方法中,从容器中获取了BeanDefinitionRegistryPostProcessor类型的类,而后执行了这些类的postProcessBeanDefinitionRegistry方法。还记得上面我让大家重点关注的ConfigurationClassPostProcessor么,他就是实现了BeanDefinitionRegistryPostProcessor,因此这个地方会调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法。那么咱们进入方法瞧瞧。
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
...
processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
...
//判断@Configuration注解
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
...
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//解析带有@Configuration注解的类
parser.parse(candidates);
...
}
复制代码
processConfigBeanDefinitions方法主要有两个逻辑,首先判断类上是否带有@Configuration注解,而后解析该类。其实在这儿,主要解析的就是@SpringBootApplication注解。由于点开@SpringBootApplication注解的源码
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
@Configuration
public @interface SpringBootConfiguration {
}
复制代码
@SpringBootApplication注解上面有@SpringBootConfiguration注解,然后者又包含了@Configuration注解,因此这个地方,解析的就是带有@SpringBootApplication注解的类。进入parse方法。
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
...
this.deferredImportSelectorHandler.process();
}
复制代码
主要有两个逻辑,咱们一个一个来分析。首先再次进入parse方法
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
...
SourceClass sourceClass = asSourceClass(configClass);
do {
//进入这个方法
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
复制代码
在doProcessConfigurationClass中,咱们看到了熟悉的Component,PropertySources,ComponentScan,ImportResource,以及Import注解,上述几个注解的功能你们应该都很熟悉了,我就很少介绍了,这些注解在这儿就完成了他们的使命,通过这个方法后,咱们本身写的类就会所有进入springboot容器中了。
下面开始分析this.deferredImportSelectorHandler.process();
public void process() {
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
...
}
复制代码
进入方法后发现若是deferredImportSelectors为空的话,就什么都作不了。可是调用debug后发现这个地方是有值的,那么他是何时被放进来的呢。咱们回头看刚刚的doProcessConfigurationClass方法。
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
...
// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), true);
...
}
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
...
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(
configClass, (DeferredImportSelector) selector);
...
}
}
public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
...
this.deferredImportSelectors.add(holder);
}
}
复制代码
在processImports发现了添加的痕迹。可是添加有个前提条件是要import导入的类selector instanceof DeferredImportSelector,这个条件是怎么实现的呢?答案就在@SpringBootApplication注解中。
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
public class AutoConfigurationImportSelector
implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
BeanFactoryAware, EnvironmentAware, Ordered {
复制代码
因此到这儿咱们就知道了deferredImportSelectors里面有一个元素,就是这边的AutoConfigurationImportSelector。
因此到这儿,咱们就能够接着分析process方法了
public void process() {
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
//注册
deferredImports.forEach(handler::register);
//解析
handler.processGroupImports();
}
}
finally {
this.deferredImportSelectors = new ArrayList<>();
}
}
复制代码
一个注册方法,一个解析方法,注册方法逻辑比较简单,咱们直接进入解析方法。
public void processGroupImports() {
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
//这个地方看一下getImports方法
grouping.getImports().forEach(entry -> {
...
//这个方法标记一下,processImport待会回来
processImports(configurationClass, asSourceClass(configurationClass),
asSourceClasses(entry.getImportClassName()), false);
...
}
}
public Iterable<Group.Entry> getImports() {
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
//重点看process方法
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector());
}
return this.group.selectImports();
}
public void process(AnnotationMetadata annotationMetadata,
DeferredImportSelector deferredImportSelector) {
...
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(getAutoConfigurationMetadata(),
annotationMetadata);
...
}
protected AutoConfigurationEntry getAutoConfigurationEntry(
AutoConfigurationMetadata autoConfigurationMetadata,
AnnotationMetadata annotationMetadata) {
...
List<String> configurations = getCandidateConfigurations(annotationMetadata,
attributes);
...
}
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
...
return configurations;
}
复制代码
SpringFactoriesLoader.loadFactoryNames这个方法熟悉么,一直在用,因此话很少说,先看看getSpringFactoriesLoaderFactoryClass返回了一个什么类。返回的是EnableAutoConfiguration.class; 因此进入配置文件查看。
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
...
...
...
复制代码
你应该会看到这么长长的一串配置,这里就是springboot自动化配置的中心了。我就以aop来展现一下springboot是如何简化spring的配置的。
首先通过咱们刚刚的一串逻辑org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,这个类会被加载进容器中,那么这个类,和aop又有啥关系呢。
@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
AnnotatedElement.class })
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
public static class JdkDynamicAutoProxyConfiguration {
}
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
public static class CglibAutoProxyConfiguration {
}
}
复制代码
查看该类的源码,发现该类加载时有两个判断条件,容器中须要有EnableAspectJAutoProxy.class, Aspect.class, Advice.class,AnnotatedElement.class这几个注解,或者有spring.aop相关的配置。(关于Conditional条件的机制后面再详细解读,这个地方大概了解一下便可)
若是咱们在启动时的类上添加了EnableAspectJAutoProxy注解的话,该注解会加载AspectJAutoProxyRegistrar类,这个类又会向容器注入AnnotationAwareAspectJAutoProxyCreator类,然后者正是aop的核心类。只要这个类进入容器,容器就带有了aop功能(aop如何实现的看我推荐的那本书,书上很详细)。
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
复制代码
那么若是我没有显示的添加EnableAspectJAutoProxy注解会怎样呢?若是没有显示添加的话,只要知足其余条件,AopAutoConfiguration类依然会被加载进容器,而他进入容器后,里面获得两个静态类也会被扫描进容器,而这两个类都是带有EnableAspectJAutoProxy注解的,因此aop功能依然能够实现。
因此当咱们得到了自动化配置的这些支持后,就该回到刚刚标记的processImport方法了。
public void processGroupImports() {
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
grouping.getImports().forEach(entry -> {
ConfigurationClass configurationClass = this.configurationClasses.get(
entry.getMetadata());
try {
//刚刚标记的方法
processImports(configurationClass, asSourceClass(configurationClass),
asSourceClasses(entry.getImportClassName()), false);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configurationClass.getMetadata().getClassName() + "]", ex);
}
});
}
}
复制代码
这个方法会把咱们得到的自动化配置相关支持所有导入容器,这样在通过spring那一套加载逻辑以后,咱们的springboot项目就能够得到各类咱们配置的功能了。