Spring5源码-AnnotationConfigApplicationContext分析

947531076

已于 2024-11-01 11:15:06 修改

阅读量757

点赞数 14

文章标签： spring java 后端

于 2024-10-30 09:50:17 首次发布

本文链接：https://blog.youkuaiyun.com/u011958119/article/details/142971629

版权

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);里面都做了什么

AnnotationConfigApplicationContext分析

分析AnnotationConfigApplicationContext类的构造函数，
1、创建beanFactory（因为该类继承自GenericApplicationContext），以及AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner对象。
2、将传入的普通类（这里是AppConfig）转化为BeanDefinition对象后，注册到Spring容器中
3、刷新

	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}
	
	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
	}

	public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

AnnotatedBeanDefinitionReader分析

AnnotatedBeanDefinitionReader用于将普通的类转化为BeanDefinition对象后，注册到Spring容器中（其实就是加到beanDefinitionMap中）。在创建AnnotatedBeanDefinitionReader对象时会注册五个Spring内部使用的后置处理器。
在这里插入图片描述

internalConfigurationAnnotationProcessor对应的类是ConfigurationClassPostProcessor，用来对 @Component @ComponentScan @Configuration @Service @Controller @PropertySource @Import @ImportResource @Bean 进行注解扫描
internalAutowiredAnnotationProcessor 对应的类是AutowiredAnnotationBeanPostProcessor，扫描@Autowired 注解,@Value注解，进行属性填充
internalCommonAnnotationProcessor 对应的类是CommonAnnotationBeanPostProcessor，扫描@Resource注解,@PreDestory,@PostConstruct注解，进行属性填充
PersistenceAnnotationBeanPostProcessor：支持JPA中相关注解的支持；
EventListenerMethodProcessor和DefaultEventListenerFactory：这两个类主要完成对@EventListener等事件注解支持；

	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);
	}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {
	//获取beanFactory 
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
        	设置实现Order接口的排序器
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
        	//置@AutoWired的候选的解析器
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        //注册internalConfigurationAnnotationProcessor
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        //注册internalAutowiredAnnotationProcessor
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        //注册internalCommonAnnotationProcessor
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 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);
        //注册internalPersistenceAnnotationProcessor
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
         //注册internalEventListenerProcessor
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        //注册internalEventListenerFactory
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

ClassPathBeanDefinitionScanner分析

完成对指定包路径下的Bean进行扫描，把含有特定注解的Bean生成BeanDefinition注册到IoC容器中。

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
		this(registry, true);
	}
	
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
		this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
	}
	//构造函数中默认会注册@Component过滤器
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		if (useDefaultFilters) {
			//注册默认的过滤器，当扫描的时候带有@Component注解的类就能满足
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}
	
	public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		//遍历包
		for (String basePackage : basePackages) {
			//查找符合Filter条件的类（默认情况下是带有@Component注解的类），并转化为BeanDefinition
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

注册BeanDefinition

通过调用AnnotatedBeanDefinitionReader的register方法来实现注册功能

	public void register(Class<?>... componentClasses) {
		Assert.notEmpty(componentClasses, "At least one component class must be specified");
		StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register")
				.tag("classes", () -> Arrays.toString(componentClasses));
		this.reader.register(componentClasses);
		registerComponentClass.end();
	}

	//AnnotatedBeanDefinitionReader#register()
	public void register(Class<?>... componentClasses) {
		for (Class<?> componentClass : componentClasses) {
			registerBean(componentClass);
		}
	}

	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {
		//创建BeanDefinition
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(supplier);
		//解析scope
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//解析类上的注解（Lazy、Primary、DependsOn、Role、Description）并存入BeanDefinition
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}
		//BeanDefinitionHolder用于持有Bean的定义、名称和别名
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		//解析代理方式（接口还是类）
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//注册BeanDefinition（this.beanDefinitionMap.put(beanName, beanDefinition);）
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

BeanDefinition接口

BeanDefinition，描述了如何创建一个Bean实例，包括Bean的类、作用域、属性、依赖关系以及生命周期回调等信息。

AnnotatedBeanDefinition
- ScannedGenericBeanDefinition：继承GenericBeanDefinition，有@Component注解的类
- AnnotatedGenericBeanDefinition：继承GenericBeanDefinition，@Configuration注解的类
- ConfigurationClassBeanDefinition：继承RootBeanDefinition，且是私有的
AbstractBeanDefinition
- RootBeanDefinition：最常用的实现类,用于表示一个独立的、不依赖于其他Bean定义的Bean
- ChildBeanDefinition：用于表示从父Bean继承属性的Bean，本身不包含完整的Bean定义信息，而是引用一个父Bean（通常是RootBeanDefinition），并从父Bean那里继承属性，这允许开发者在多个Bean之间共享配置，减少重复
- GenericBeanDefinition 可以作为RootBeanDefinition或ChildBeanDefinition的轻量级替代方案，旨在通过动态属性设置来支持灵活的Bean定义，它通常用于编程式地创建和配置Bean定义

BeanDefinition的常用属性

beanClass：bean对象的实际class类

scope：模式，Scope提供两种选择，即单例和原型

lazyInit:是否懒加载，一般情况下，Spring会在容器启动时，将需要的Bean先实例化好以备用。但是，当配置为懒加载时，相应的Bean会在需要用到时才实例化，即将实例化过程延后了。

dependsOn：设置依赖的bean对象，被依赖的bean对象总是会比当前bean对象先创建

autowireCandidate：设置是否可以自动注入。只对@Autowired注解有效，配置文件中可以通过property显示注入

primary：配置bean为主要候选bean。当通过接口注入时，如一个接口有多个实现，Spring会优先选择主要Bean定义注入。

factoryBeanName：一般情况下，Spring会通过反射的形式生成Bean，但是，也可以通过工厂模式来生成。该属性用于指定工厂模式下工厂Bean的名称。

factoryMethodName：设置创建bean的工厂中，创建bean的具体方法

initMethodName：设置创建bean时，默认初始化的方法

destroyMethodName：设置销毁bean时调用的方法名称，注意需要调用context的close()方法才会调用

factoryMethodName:表示这个 Bean 是通过工厂方法创建，此时，"class"属性失效。

parentName：bean定义对象的父类定义对象名称

总结

1、Spring底层采用BeanDefinition来存储Bean的元数据信息，为后期创建Bean提供Bean的相关信息。

2、AnnotationConfigApplicationContext用于将普通的类转化为BeanDefinition对象并注册到Spring容器中，自身不提供任何功能，都是借助于AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner来实现的。该对象创建时，步骤如下：

创建Bean工厂（也就是DefaultListableBeanFactory对象）
创建AnnotatedBeanDefinitionReader对象，创建时还会注册5个后置处理器供Spring内部使用。
创建ClassPathBeanDefinitionScanner对象，用于扫描并解析类，和AnnotatedBeanDefinitionReader功能差不多，区别是Reader是给几个类就注册几个，而Scanner是给一个包，扫描包下的所有类。

参考文档：
https://blog.youkuaiyun.com/m0_67505824/article/details/123497460
https://zhuanlan.zhihu.com/p/687068784