所有文章
https://www.cnblogs.com/lay2017/p/11478237.html
prepareContext方法核心逻辑
上一篇文章中,我们通过createApplicationContext方法创建了一个ApplicationContext的实例对象。本文将阅读一下在ApplicationContext在refresh之前的prepareContext中做了哪些事情。
我们跟进prepareContext方法
private void prepareContext( ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner ) { // 设置Environment context.setEnvironment(environment); // 后置处理 postProcessApplicationContext(context); // 调用ApplicationContextInitializer接口的实现 applyInitializers(context); // 发布ApplicationContext准备事件 listeners.contextPrepared(context); ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); // 注册args参数为单例bean beanFactory.registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { // 注册banner为单例bean beanFactory.registerSingleton("springBootBanner", printedBanner); } if (beanFactory instanceof DefaultListableBeanFactory) { // 设置beanFactory中是否允许重复bean覆盖 ((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } // 加载main方法所在类 Set<Object> sources = getAllSources(); // 注册main方法所在类到beanFactory load(context, sources.toArray(new Object[0])); // 发布Context加载事件 listeners.contextLoaded(context); }
我们看到prepareContext方法主要逻辑包含了三块内容
1)基本的初始化,如设置Environment,调用ApplicationContextInitializer接口的实现类
2)注册现有的对象为单例bean,如args、banner
3)加载main方法所在的主类
load方法加载主类
很显然,加载main方法的主类是我们关注的重点。我们先看看getAllSources方法返回
public Set<Object> getAllSources() { Set<Object> allSources = new LinkedHashSet<>(); // 添加主类 if (!CollectionUtils.isEmpty(this.primarySources)) { allSources.addAll(this.primarySources); } // 添加附加资源类 if (!CollectionUtils.isEmpty(this.sources)) { allSources.addAll(this.sources); } return Collections.unmodifiableSet(allSources); }
primarySources是在SpringApplication初始化的时候设置的,而sources默认是没有的。所在getAllSoures方法将返回main方法所在的主类。
下面,我们跟进load方法,阅读一下加载main所在主类的逻辑
protected void load(ApplicationContext context, Object[] sources) { // 获取BeanDefinition加载器 BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources); if (this.beanNameGenerator != null) { loader.setBeanNameGenerator(this.beanNameGenerator); } if (this.resourceLoader != null) { loader.setResourceLoader(this.resourceLoader); } if (this.environment != null) { loader.setEnvironment(this.environment); } // 加载资源 loader.load(); }
load方法中,先是获得了BeanDefinitionLoader,然后去加载资源。这里要注意!为什么是BeanDefinitionLoader呢?
首先,我们得知道Spring的bean资源来自各种地方,如xml、annotation等,那么这些bean在配置的时候也就是对bean进行定义,而这些定义映射到内存中的对象就是BeanDefinition的对象,Spring后续会根据BeanDefinition再获取具体的bean。
简单来说就是:配置 --> BeanDefinition --> Bean 这样一个逻辑
所以,后续我们会看到BeanDefinitionLoader会将主类加载成BeanDefinition,然后注册到ApplicationContext当中。
先跟进getBeanDefinitionRegistry方法,看看BeanDefinition会被注册到哪里去
private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) { // 返回当前ApplicationContext if (context instanceof BeanDefinitionRegistry) { return (BeanDefinitionRegistry) context; } if (context instanceof AbstractApplicationContext) { return (BeanDefinitionRegistry) ((AbstractApplicationContext) context).getBeanFactory(); } throw new IllegalStateException("Could not locate BeanDefinitionRegistry"); }
我们注意,springboot的AnnotationConfigServletWebServerApplicationContext这个ApplicationContext的实现类,随着继承链路向上走是继承自GenericApplicationContext的,而GenericApplicationContext实现了BeanDefinitionRegistry。
所以,getBeanDefinitionRegistry将最终返回强转过的ApplicationContext。也就是说BeanDefinition将被注册到ApplicationContext里面。
回到load方法中,我们再跟进createBeanDefinitionLoader方法
protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) { return new BeanDefinitionLoader(registry, sources); }
再跟进构造方法
BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) { this.sources = sources; // 注解方式的读取器 this.annotatedReader = new AnnotatedBeanDefinitionReader(registry); // xml方式的读取器 this.xmlReader = new XmlBeanDefinitionReader(registry); // 类路径下的扫描器 this.scanner = new ClassPathBeanDefinitionScanner(registry); // 扫描排除当前main方法的主类 this.scanner.addExcludeFilter(new ClassExcludeFilter(sources)); }
我们看到加载器支持注解、xml两种方式。类路径下的扫描器排除了当前的主类
回到load方法
protected void load(ApplicationContext context, Object[] sources) { // 获取BeanDefinition加载器 BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources); if (this.beanNameGenerator != null) { loader.setBeanNameGenerator(this.beanNameGenerator); } if (this.resourceLoader != null) { loader.setResourceLoader(this.resourceLoader); } if (this.environment != null) { loader.setEnvironment(this.environment); } // 加载资源 loader.load(); }
此时,我们已经获取了BeanDefinitionLoader,下面调用该loader的load方法开始加载
跟进第二个load方法
public int load() { int count = 0; for (Object source : this.sources) { count += load(source); } return count; }
再跟进第三个load方法
private int load(Object source) { if (source instanceof Class<?>) { return load((Class<?>) source); } if (source instanceof Resource) { return load((Resource) source); } if (source instanceof Package) { return load((Package) source); } if (source instanceof CharSequence) { return load((CharSequence) source); } throw new IllegalArgumentException("Invalid source type " + source.getClass()); }
由于我们的主类是一个class,所以进入第一个if分支的load方法
继续跟进
private int load(Class<?> source) { // 省略 if (isComponent(source)) { this.annotatedReader.register(source); return 1; } return 0; }
该方法先通过isComponent方法判断了主类是不是被@Component注解,如果是,那么调用注解方式的阅读器,注册该资源。
跟进isComponent方法,看看怎么判断的
private boolean isComponent(Class<?> type) { // 找到是否匹配@Component注解 if (AnnotationUtils.findAnnotation(type, Component.class) != null) { return true; } // 省略 }
其实就是找这个类是否有@Component注解,但请注意我们通常都使用@SpringBootApplication这个注解,并没有直接注解@Component。而@SpringBootApplication是一个组合注解,其中就组合了@Component
而AnnotationUtils.findAnnotation方法将会递归遍历注解,最终找到@Component。
isComponent判断为true以后,我们再跟进annotationReader.register(source)阅读一下读取主类的过程
public void register(Class<?>... annotatedClasses) { for (Class<?> annotatedClass : annotatedClasses) { registerBean(annotatedClass); } }
继续跟进registerBean方法
public void registerBean(Class<?> annotatedClass) { doRegisterBean(annotatedClass, null, null, null); }
再跟进doRegisterBean方法,该方法比较长,我们省略掉一些次要的部分
<T> void doRegisterBean( Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers ) { // 先包装成BeanDefinition AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); // 解析scope元数据 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); abd.setScope(scopeMetadata.getScopeName()); // 生成bean的名 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 解析一些常见的注解元数据 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 注册BeanDefinition到ApplicationContext BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }
可以看到,doRegisterBean方法的主要逻辑就是包装并解析出一个BeanDefinition,然后调用registerBeanDefinition方法把BeanDefinition给注册到ApplicationContext中。
注册相关的本文就不再继续展开了,后续的文章会跟进这些内容。
总结
总的来说,prepareContext方法主要就是为了加载并注册主类的BeanDefinition到ApplicationContext。这里注意!我们一直都在说注册到ApplicationContext,但熟悉spring的都会知道无论是Bean还是BeanDefinition都是注册到BeanFactory中的。但我们一直没有严格区分它,后续的文章我们将会把ApplicationContext和BeanFactory进行区分。