目录
代码块1：根据配置类构造AnnotationConfigApplicationContext
代码块3：初始化父类GenericApplicationContext
代码块4：创建DefaultListableBeanFactory
代码块7：构造AnnotatedBeanDefinitionReader
代码块9：AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);注册registry中的注解后置处理器
代码块10：unwrapDefaultListableBeanFactory(registry)
代码块12： registry.registerBeanDefinition(beanName, definition);
代码块13：ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)
一、测试用例
public class User {
private String id;
private String userName;
public User() {
}
public User(String id, String userName) {
this.id = id;
this.userName = userName;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", userName='" + userName + '\'' +
'}';
}
}@Configuration
@ComponentScan
public class JavaConfig {
@Bean
public User user() {
return new User("001","test");
}
}public class Test {
public static void main(String[] args) {
System.out.println("hah");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class);
User user = (User) context.getBean("user");
System.out.println(user.toString());
}
}此测试用例参考spring5.3.x源码阅读环境搭建_smart_an的专栏-CSDN博客_spring源码搭建
二、源码解析
（一）构造上下文
代码块1：根据配置类构造AnnotationConfigApplicationContext
// 1. 使用从组件类中获取BeanDefinitions,并且自动刷新到上下文中
// conponentClassess 一般是被@Configuration注解标准的配置类
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
// 1. 构造器会先调用父类构造器，为beanFactory赋值
// 2. 调用this()方法，即默认构造器，设置默认的reader和默认的scanner
this();
register(componentClasses);
refresh();
}代码块2：this()
public AnnotationConfigApplicationContext() {
// 首先调用父类的无参构造器，初始化beanFactory
// 其次创建reader和scanner
// 获取/创建StandardEnvironment，创建评估其，注册1. 解析工厂，为工厂设置注解依赖比较器，和注解自动装配候选人解析器；
// 2. 注册@Configuration、autowired、jsr-250、jpa、event等后置处理器
this.reader = new AnnotatedBeanDefinitionReader(this);
// register:AnnotationConfigApplicationContext
// filter: AnnotationTypeFilter(Component)
// environment: StandardEnvironment
// resourceLoader: ApplicationConfigApplicationContext
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
// 从此类定义可以看出，继承自GenericApplicationContext
/**
* 独立的应用上下文，接收组件类，尤其是@Configuration、@Component、和符合JSR-330规范的javax.inject注解的组件类
* 继承GenericAllpicationContext,并实现AnnotationConfigRegistry接口
*
* GenericApplicationContext
*/
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {...代码块3：初始化父类GenericApplicationContext
GenericApplicationContext的主要作用是，初始化beanFactory,初始化resourceLoader，设置父ApplicationContext，设置BeanDefinition是否可以被重写，设置bean是否允许循环引用；实现ResourceLoader/ResourcePatternResolver接口，重写里边的getResource、getClassLoader、setClassLoader方法；实现AbstractApplicationContext的模板方法，包括refreshBeanFactroy，getBeanFactroy等；实现BeanDefinitionRegistry的方法，如registerBeanDefinition，removeBeanDefinition，getBeanDefinition，isBeanNameInUse，registerAlias，removeAlias，isAlias；实现注册单个Bean的方法，如registerBean。
// 默认构造器创建DefaultListableBeanFactory bean工厂
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
代码块4：创建DefaultListableBeanFactory
public DefaultListableBeanFactory() {
super();// 创建AbstractAutowireCapableBeanFactory
}
public AbstractAutowireCapableBeanFactory() {
// 调用父类构造器，AbstractBeanFactory
super();
// 在依赖检查和自动装配时忽略BeaanNameAware、BeanFactoryAware、BeanClassLoaderAware接口
ignoreDependencyInterface(BeanNameAware.class);
ignoreDependencyInterface(BeanFactoryAware.class);
ignoreDependencyInterface(BeanClassLoaderAware.class);
}
public AbstractBeanFactory() {
}代码块5：设置reader
public AnnotationConfigApplicationContext() {
// 首先调用父类的无参构造器，初始化beanFactory
// 其次创建reader和scanner
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
// 此处registry为AnnotationConfigApplicationContext
this(registry, getOrCreateEnvironment(registry));
}代码块6：getOrCreateEnvironment
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry instanceof EnvironmentCapable) {
return ((EnvironmentCapable) registry).getEnvironment();
}
return new StandardEnvironment();
}
// AbstractApplicationContext
public ConfigurableEnvironment getEnvironment() {
if (this.environment == null) {
this.environment = createEnvironment();
}
return this.environment;
}
protected ConfigurableEnvironment createEnvironment() {
return new StandardEnvironment();
}
public AbstractEnvironment() {
customizePropertySources(this.propertySources);
}
protected void customizePropertySources(MutablePropertySources propertySources) {
propertySources.addLast(
new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
propertySources.addLast(
new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}代码块7：构造AnnotatedBeanDefinitionReader
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}代码块8：构造ConditionEvaluator
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}代码块9：AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);注册registry中的注解后置处理器
// 注册registry中所有相关的注解后置处理器
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
// 注册registry中相关的 注解后置处理器
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 1. 解析工厂，为工厂设置注解依赖比较器，和注解自动装配候选人解析器
// 从registry中获取DefaultListableBeanFactroy
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
// 如果bean工厂不为空
if (beanFactory != null) {
// 如果bean工厂中的依赖比较器不是AnnotationAwareOrderComparator(注解适配排序比较器)
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
// 则将bean工厂中的依赖比较器设置为AnnotationAwareOrderComparator
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
// 如果bean工厂中的自动装配候选人解析器不是ContextAnnotationAutowireCandidateResolver(注解自动装配候选人解析器)
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
// 则将bean工厂中的自动装配候选人解析器设置为ContextAnnotationAutowireCandidateResolver
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
// 2. 注册@Configuration、autowired、jsr-250、jpa、event等后置处理器
// beanDefinitonHolder集合
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
// internalConfigurationAnnotationProcessor 内部配置注解后置处理器，用于处理@Configuration，
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
// registerPostProcessor(...)为：
// this.beanDefinitionMap.put(beanName, beanDefinition);
// this.beanDefinitionNames.add(beanName);
// 将def和beanName封装成RootBeanDefinition
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册internalAutowiredAnnotationProcessor
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册jsr-250的internalCommonAnnotationProcessor
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
// 在本类的静态块中
// jsr250Present = ClassUtils.isPresent("javax.annotation.Resource", classLoader);
// jpaPresent = ClassUtils.isPresent("javax.persistence.EntityManagerFactory", classLoader) &&
// ClassUtils.isPresent(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, classLoader);
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册internalPersistenceAnnotationProcessor
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册internalEventListenerProcessor
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 注册internalEventListenreFactory
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}代码块10：unwrapDefaultListableBeanFactory(registry)
// 从registry中获取DefaultListableBeanFactory
@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
// 如果registry是DefaultListableBeanFactroy，则知己返回
if (registry instanceof DefaultListableBeanFactory) {
return (DefaultListableBeanFactory) registry;
}
// 如果registry是GenericAppllicationContext，则从中获取DefaultListableBeanFactory
else if (registry instanceof GenericApplicationContext) {
return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
}
// 否则返回null
else {
return null;
}
}代码块11：registerPostProcessor
/**
* 注册后置处理器，registry，beanDefinition，beanname
* @param registry
* @param definition
* @param beanName
* @return
*/
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
//@Role，bean角色定义ROLE_APPLICATION(默认值)、ROLE_SUPPORT(辅助角色)、ROLE_INFRASTRUCTURE(后台角色，用户无感)
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}代码块12： registry.registerBeanDefinition(beanName, definition);
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// 调用beanFactory注册BeanDefinition
this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
}代码块13：ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
// AnnotationConfigApplicationContext、true、StandardEnvironment、AnnotationConfigApplicationContext
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;// AnnotationConfigApplicationContext
if (useDefaultFilters) {
registerDefaultFilters();// AnnotationTypeFilter(Component.class)
}
setEnvironment(environment);// StandardEnvironment
setResourceLoader(resourceLoader);// AnnotationConfigApplicationContext
}至此，new AnnotationConfigApplicationContext的this()方法完成，下一篇继续介绍register(componentClasses);
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
