Spring源码深入阅读AnnotationConfigApplicationContext

2022-06-13 08:59:52

一直很好奇代码AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SimpleBeanConfig.class);运行的时候,spring容器做了什么事情,为了搞清楚,我要看一看Spring源码剖析一下。

一、首先写一个测试方法如下:

AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(StudentConfig.class);
        Student simpleBean=(Student) context.getBean("student");
        System.out.println(simpleBean.toString());

通过debug发现,spring的容器创建以及类的实例化都是在第一行代码中实现的,因此进去AnnotationConfigApplicationContext 看一下,发现构造方法中有三行代码如下:

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses){
        this();
        this.register(annotatedClasses);
        this.refresh();}

二、Spring容器管理bean

首先调用this()就是本类的构造方法,由于AnnotationConfigApplicationContext继承了GenericApplicationContext因此首先会执行GenericApplicationContext的构造方法。进入发现构造方法中初始化了自己内部的beanFactoryDefaultListableBeanFactory

public GenericApplicationContext(){
        this.customClassLoader=false;
        this.refreshed= new AtomicBoolean();
        this.beanFactory= new DefaultListableBeanFactory();}

1.this()方法

接下来再看AnnotationConfigApplicationContext中自己的构造方法
this()调用的是本地的无参构造方法,里边有两行代码

public AnnotationConfigApplicationContext(){
        this.reader= new AnnotatedBeanDefinitionReader(this);
        this.scanner= new ClassPathBeanDefinitionScanner(this);}

进入AnnotatedBeanDefinitionReader
1.1AnnotatedBeanDefinitionReader

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry){
        this(registry, getOrCreateEnvironment(registry));}

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment){
        this.beanNameGenerator= new AnnotationBeanNameGenerator();
        this.scopeMetadataResolver= new AnnotationScopeMetadataResolver();
        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,(ResourceLoader)null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);}

在最后一行中将处理注解的基础设施类放到DefaultListableBeanFactory,内容如下:
1.2AnnotationConfigUtils#registerAnnotationConfigProcessors

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, Object source){
        DefaultListableBeanFactory beanFactory= unwrapDefaultListableBeanFactory(registry);if(beanFactory!= null){if(!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)){
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);}if(!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)){
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());}}

        Set<BeanDefinitionHolder> beanDefs= new LinkedHashSet(4);
        RootBeanDefinition def;if(!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")){
            def= new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));}if(!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")){
            def= new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));}if(!registry.containsBeanDefinition("org.springframework.context.annotation.internalRequiredAnnotationProcessor")){
            def= new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.annotation.internalRequiredAnnotationProcessor"));}if(jsr250Present&&!registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")){
            def= new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.annotation.internalCommonAnnotationProcessor"));}if(jpaPresent&&!registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")){
            def= new RootBeanDefinition();

            try{
                def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));} catch(ClassNotFoundException var6){
                throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);}

            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));}if(!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")){
            def= new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.event.internalEventListenerProcessor"));}if(!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")){
            def= new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def,"org.springframework.context.event.internalEventListenerFactory"));}return beanDefs;}

1.3AnnotationConfigUtils#registerPostProcessor

private static BeanDefinitionHolder registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName){
        definition.setRole(2);
        registry.registerBeanDefinition(beanName, definition);return new BeanDefinitionHolder(definition, beanName);}

其中registerPostProcessor(),就是注册动作,继续深入registerBeanDefinition

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException{
        this.beanFactory.registerBeanDefinition(beanName, beanDefinition);}

只有一行代码,继续入:
1.4DefaultListableBeanFactory#registerBeanDefinition

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException{

	Assert.hasText(beanName,"Bean name must not be empty");
	Assert.notNull(beanDefinition,"BeanDefinition must not be null");if(beanDefinition instanceof AbstractBeanDefinition){
		try{((AbstractBeanDefinition) beanDefinition).validate();} catch(BeanDefinitionValidationException ex){
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);}}
	//注册BeanDefinition,就是将BeanDefinition放入一个map中,key是beanName
	//注册之前,先查下是否被注册过
	BeanDefinition existingDefinition= this.beanDefinitionMap.get(beanName);
	//如果已经存在,那么就检查是否允许覆盖,不允许直接跑异常,允许的话就记录一些日志,然后覆盖if(existingDefinition!= null){
		//默认允许覆盖if(!isAllowBeanDefinitionOverriding()){
			//如果bean已经被注册了,并且不允许覆盖,那么抛出异常
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Cannot register bean definition [" + beanDefinition +"] for bean '" + beanName +"': There is already [" + existingDefinition +"] bound.");}elseif(existingDefinition.getRole()< beanDefinition.getRole()){
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTUREif(logger.isWarnEnabled()){
				logger.warn("Overriding user-defined bean definition for bean '" + beanName +"' with a framework-generated bean definition: replacing [" +
						existingDefinition +"] with [" + beanDefinition +"]");}}elseif(!beanDefinition.equals(existingDefinition)){if(logger.isInfoEnabled()){
				logger.info("Overriding bean definition for bean '" + beanName +"' with a different definition: replacing [" + existingDefinition +"] with [" + beanDefinition +"]");}}else{if(logger.isDebugEnabled()){
				logger.debug("Overriding bean definition for bean '" + beanName +"' with an equivalent definition: replacing [" + existingDefinition +"] with [" + beanDefinition +"]");}}
		this.beanDefinitionMap.put(beanName, beanDefinition);}else{
		//检查bean的创建过程是否已经开始了
		//通过判断一个set集合是否为空,因为创建过的bean都会放到那个set中保存下if(hasBeanCreationStarted()){
			// Cannot modify startup-time collection elements anymore(for stable iteration)
			synchronized(this.beanDefinitionMap){
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//下面4行是更新beanDefinitionNames的list
				List<String> updatedDefinitions= new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames= updatedDefinitions;
				//manualSingletonNames人工注册的单例集合,也要更新if(this.manualSingletonNames.contains(beanName)){
					Set<String> updatedSingletons= new LinkedHashSet<>(this.manualSingletonNames);
					updatedSingletons.remove(beanName);
					this.manualSingletonNames= updatedSingletons;}}}else{
			// Stillin startup registration phase:仍然在启动注册阶段
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			this.manualSingletonNames.remove(beanName);}
		this.frozenBeanDefinitionNames= null;}if(existingDefinition!= null|| containsSingleton(beanName)){
		resetBeanDefinition(beanName);}}

beanDefinitionMap:将注册的bean往map中存放,是个ConcurrentHashMap;
放到map之前,先查看map中是否已经存在了,如果已经存在,再判断是否允许覆盖;
如果 map中不存在,那么就put进去。

2.this.register(annotatedClasses);

接下来是AnnotationConfigApplicationContext中的第二个方法this.register,看参数以及方法名就知道是往容器中注册

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses){
        this();
        this.register(annotatedClasses);
        this.refresh();}

2.1进入到this.register(annotatedClasses);

public void register(Class<?>... annotatedClasses){
        Assert.notEmpty(annotatedClasses,"At least one annotated class must be specified");
        this.reader.register(annotatedClasses);}

调用的是AnnotationConfigApplicationContext的注册方法
2.2进入this.reader.register(annotatedClasses);

public void register(Class<?>... annotatedClasses){
        Class[] var2= annotatedClasses;
        int var3= annotatedClasses.length;

        for(int var4= 0; var4< var3; ++var4){
            Class<?> annotatedClass= var2[var4];
            this.registerBean(annotatedClass);}}

其实参数是一个数组,进行遍历调用registerBean
2.3单行直接入,跳到registerBean

public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers){
        //得到bean的描述信息,比如bean的注解,作用范围,是否懒加载,注入方式等
	AnnotatedGenericBeanDefinition abd= new AnnotatedGenericBeanDefinition(annotatedClass);
	//被条件注解@Conditional注释的bean跳过注册if(this.conditionEvaluator.shouldSkip(abd.getMetadata())){return;}

	abd.setInstanceSupplier(instanceSupplier);
	//解析bean的Scope,比如是否单例singleton还是其他
	ScopeMetadata scopeMetadata= this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	//生成bean name,默认就是类名小写
	String beanName=(name!= null ? name: this.beanNameGenerator.generateBeanName(abd, this.registry));
	//通过判断注解内容,设置一些公共属性,比如是否懒加载,优先级等
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);if(qualifiers!= null){for(Class<? extends Annotation> qualifier: qualifiers){if(Primary.class== qualifier){
				abd.setPrimary(true);}elseif(Lazy.class== qualifier){
				abd.setLazyInit(true);}else{
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));}}}for(BeanDefinitionCustomizer customizer: definitionCustomizers){
		customizer.customize(abd);}

	BeanDefinitionHolder definitionHolder= new BeanDefinitionHolder(abd, beanName);
	definitionHolder= AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

就是获取封装以及注册

3.this.refresh();

方法名为刷新,即为刷新容器。

public void refresh() throws BeansException, IllegalStateException{
        synchronized(this.startupShutdownMonitor){
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory= this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try{
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();} catch(BeansException var9){if(this.logger.isWarnEnabled()){
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);}

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;} finally{
                this.resetCommonCaches();}}}

3.1this.prepareRefresh();做一些刷新前的准备,记录时间什么的

protected void prepareRefresh(){
        this.startupDate= System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);if(this.logger.isInfoEnabled()){
            this.logger.info("Refreshing " + this);}

        this.initPropertySources();
        this.getEnvironment().validateRequiredProperties();
        this.earlyApplicationEvents= new LinkedHashSet();}

3.2ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory(){
        this.refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory= this.getBeanFactory();if(this.logger.isDebugEnabled()){
            this.logger.debug("Bean factory for " + this.getDisplayName() +": " + beanFactory);}return beanFactory;}

拿到工厂类
3.3AbstractBeanFactory#addBeanPostProcessor

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor){
        Assert.notNull(beanPostProcessor,"BeanPostProcessor must not be null");
        this.beanPostProcessors.remove(beanPostProcessor);
        this.beanPostProcessors.add(beanPostProcessor);if(beanPostProcessor instanceof InstantiationAwareBeanPostProcessor){
            this.hasInstantiationAwareBeanPostProcessors=true;}if(beanPostProcessor instanceof DestructionAwareBeanPostProcessor){
            this.hasDestructionAwareBeanPostProcessors=true;}}

addBeanPostProcessor()方法定义在AbstractBeanFactory抽象类中,Spring添加自己定义的后置处理器
通过this.beanPostProcessors.add(beanPostProcessor);将spring后置处理器全部添加到BeanPostProcessor泛型的一个list当中
private final List beanPostProcessors = new ArrayList();
3.4BeanPostProcessor接口:

public interface BeanPostProcessor{
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;

    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;}

定义了一个前置处理器和一个后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor, PriorityOrdered{
	/**
	 * 这里拿到bean之后可以根据此bean创建一个代理类对象
	 * AOP正是通过BeanPostProcessor和IOC容器建立起了联系
	 * @param bean the new bean instance
	 * @param beanName the name of the bean
	 * @return
	 * @throws BeansException
	 */
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException{if(beanName.equals("student")){
			System.out.println("MyBeanPostProcessor的前置处理器执行");}return bean;}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException{if(beanName.equals("student")){
			System.out.println("MyBeanPostProcessor的后置处理器执行");}return bean;}

	@Override
	public int getOrder(){return 101;}}

后置处理器的优先级通过继承接口:PriorityOrdered重写getOrder()方法来设置,数字越小优先级越高,所以bean后置处理器在AbstractBeanFactory抽象类中放在一个list的集合中,是一个列表,在创建bean的时候依次执行。
3.4postProcessBeanFactory能够更改工厂bean的一些行为,可自行扩展

3.5invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor能够在bean实例化之前进行一定的操作,通过”order”控制执行次序(要实现Ordered接口)。
优先处理BeanDefinitionRegistryPostProcessor其次是BeanFactoryPostProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());if(beanFactory.getTempClassLoader()== null&& beanFactory.containsBean("loadTimeWeaver")){
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}

3.6registerBeanPostProcessors(beanFactory)

public static void registerBeanPostProcessors(
	ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext){

	//从beanFactory查询之前注册的BeanPostProcessor类型的bean名字
	String[] postProcessorNames= beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	//实例化一个BeanPostProcessorChecker,用于记录日志信息,比如当一个bean没有被任何后置处理器处理时
	//BeanPostProcessorChecker是一个内部类,实现了BeanPostProcessor接口
	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligiblefor getting processed by all BeanPostProcessors.
	int beanProcessorTargetCount= beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,Ordered, and the rest.
	//这里也分为PriorityOrdered,Ordered, and 其他 3中情况分开处理;所以先遍历一遍,把类型分开;
	//遍历时候,顺便把PriorityOrdered实例化了
	List<BeanPostProcessor> priorityOrderedPostProcessors= new ArrayList<>();
	//是否框架内部使用的PostProcessor
	List<BeanPostProcessor> internalPostProcessors= new ArrayList<>();
	List<String> orderedPostProcessorNames= new ArrayList<>();
	List<String> nonOrderedPostProcessorNames= new ArrayList<>();for(String ppName: postProcessorNames){if(beanFactory.isTypeMatch(ppName, PriorityOrdered.class)){
			BeanPostProcessor pp= beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);if(pp instanceof MergedBeanDefinitionPostProcessor){
				internalPostProcessors.add(pp);}}elseif(beanFactory.isTypeMatch(ppName, Ordered.class)){
			orderedPostProcessorNames.add(ppName);}else{
			nonOrderedPostProcessorNames.add(ppName);}}

	// First, register the BeanPostProcessors that implement PriorityOrdered.
	//首先注册实现了PriorityOrdered接口的,注册就是把实例化的ostProcessors放到容器的list结合中
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// Next, register the BeanPostProcessors that implement Ordered.
	//然后注册Ordered实现了Ordered接口的
	List<BeanPostProcessor> orderedPostProcessors= new ArrayList<>();for(String ppName: orderedPostPro
  • 作者:旭旭1998
  • 原文链接:https://blog.csdn.net/qq_39898191/article/details/108681252
    更新时间:2022-06-13 08:59:52