Spring源码剖析-基于注解的IOC启动流程(四)

秒速五厘米 2022-10-17 11:27 196阅读 0赞

# 前言 #

前面章节我们已经分析了XML配置的IOC的启动流程，这章节来分析一下基于注解配置的IOC启动流程，有了前面的铺垫，这章分析起来将会比较简单。

# Spring的注解编程 #

相信比较老的程序员是体验过使用Spring的xml配置来开发项目，大量繁杂复杂的配置增加了开发的繁琐性。Spring在 2.0 以后就引入了注解编程来代替复杂成XML配置-即JavaConfig，Spring框架内部也是大量使用注解代替XML配置，对于新的程序员可能都是直接使用SpringBoot开发项目,SpringBoot本身就是基于Spring封装推荐使用全注解编程的快速开发框架。比如：在SpringBoot中，以前的XML配置已经变成了注解了@Configuration 的配置类 ，下面我们来入门一个简单的基于注解的IOC

第一步:创建一个类

public class MyBean { 
    }

第二步：定义一个基于注解的配置

//定义一个基于注解的Spring配置类，相当于是Spring的xml配置
    @Configuration
    public class AppConfig { 
    
        //向容器中注册一个Bean
        @Bean
        public MyBean myBean(){ 
            return new MyBean();
        }
    }

第三步：使用 AnnotationConfigApplicationContext容器工厂加载位置

public class MyBeanTest { 
    
        @Test
        public void testMyBean(){ 
            //通过容器工厂：AnnotationConfigApplicationContext 加载配置
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
            //通过容器工厂获取MyBean
            MyBean myBean = applicationContext.getBean(MyBean.class);
            //打印myBean
            System.out.println(myBean);
        }
    }

# 容器工厂：AnnotationConfigApplicationContext #

AnnotationConfigApplicationContext是一个基于注解的IOC容器工厂，以注解了@Configuration的配置类作为输入。它继承了 GenericApplicationContext 容器工厂，和AnnotationConfigRegistry 注解配置注册器，源码如下：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry { 
    
    	//基于注解方式的Bean的注册器，提供了注册Bean的方法
    	private final AnnotatedBeanDefinitionReader reader;
    	
    	//bean 定义扫描器，它检测类路径上的 bean ，使用给定的注册器注册相应的 bean 定义。
    	//通过可配置的类型过滤器检测候选类。 默认过滤器包括使用 Spring 的@Component 、 @Repository 、 @Service或@Controller型注释的@Component 。
    	private final ClassPathBeanDefinitionScanner scanner;
    
    
    	/** * Create a new AnnotationConfigApplicationContext that needs to be populated * through {@link #register} calls and then manually {@linkplain #refresh refreshed}. */
    	//创建Bean的注册器 和 Bean的扫描器
    	public AnnotationConfigApplicationContext() { 
    		this.reader = new AnnotatedBeanDefinitionReader(this);
    		this.scanner = new ClassPathBeanDefinitionScanner(this);
    	}
    	//根据class注册一个类
    	@Override
    	public void register(Class<?>... componentClasses) { 
    		Assert.notEmpty(componentClasses, "At least one component class must be specified");
    		this.reader.register(componentClasses);
    	}
    
    	//扫描一个包，注册多个类
    	@Override
    	public void scan(String... basePackages) { 
    		Assert.notEmpty(basePackages, "At least one base package must be specified");
    		this.scanner.scan(basePackages);
    	}

下面是继承体系：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0OTQxNDg_size_16_color_FFFFFF_t_70]

## AnnotatedBeanDefinitionReader ##

`AnnotatedBeanDefinitionReader` 是基于注解方式的Bean的注册器，它负责把传入类的class封装成BeanDefinition ,并解析类的注解：@Scope,@Lazy,@Primary等等，然后使用`BeanDefinitionRegistry` 注册Bean。

public class AnnotatedBeanDefinitionReader { 
    	//Bean的注册器
    	private final BeanDefinitionRegistry registry;
    	//Bean的名字生成器
    	private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
    	//Scope元注解解析器
    	private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    	//根据多个class注册Bean
    	public void register(Class<?>... componentClasses) { 
    		for (Class<?> componentClass : componentClasses) { 
    			registerBean(componentClass);
    		}
    	}
    	//根据class注册一个 Bean
    	public void registerBean(Class<?> beanClass) { 
    		doRegisterBean(beanClass, null, null, null);
    	}
    	...省略...

## ClassPathBeanDefinitionScanner ##

Bean的扫描器，根据给定的包路径扫描注解了：`@Component,@Service,@Controller,@Repository`的类，使用`BeanDefinitionRegistry` 注册Bean到Spring容器中。

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider { 
    
    	private final BeanDefinitionRegistry registry;
    	...省略...
    	//扫描一个包
    	public int scan(String... basePackages){ 
    		...省略...
    	}
    	//注册一个Bean
    	protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) { 
    		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    	}

# 启动流程：AnnotationConfigApplicationContext #

在前面的章节已经介绍过IOC容器工厂的继承体系了，这里不多赘述,下面我们直接从AnnotationConfigApplicationContext的构造器分析IOC的流程。下面是源码

/** 根据给定的配置类，创建新的AnnotationConfigApplicationContext容器工厂 * Create a new AnnotationConfigApplicationContext, deriving bean definitions * from the given annotated classes and automatically refreshing the context. * @param annotatedClasses one or more annotated classes, * e.g. {@link Configuration @Configuration} classes */
    	 //annotatedClasses 是贴了@Configuration的Spring的配置类，
    	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { 
    		//创建 AnnotatedBeanDefinitionReader注册器 和 ClassPathBeanDefinitionScanner扫描器
    		this();
    		//执行注册，传入配置类
    		register(annotatedClasses);
    		//刷新容器
    		refresh();
    	}

从该构造方法参数可以看得出，这里是可以传入多个配置类的，方法中做了三件事情

*  调用构造器创建AnnotatedBeanDefinitionReader Bean注册器 和 ClassPathBeanDefinitionScanner Bean扫描器
 *  调用register方法执行注册
 *  调用refresh方法刷新容器

\[注意\] 配置类本身也是一个Bean，register方法的目的是对当前传入的配置类进行注册。

跟一下 `AnnotationConfigApplicationContext#register` 方法，源码如下：

@Override
    public void register(Class<?>... componentClasses) { 
    	Assert.notEmpty(componentClasses, "At least one component class must be specified");
    	//调用AnnotatedBeandefinitionReader 注册器注册Bean
    	this.reader.register(componentClasses);
    }

## Bean的注册AnnotatedBeanDefinitionReader ##

代码来到 `AnnotatedBeanDefinitionReader#register` 方法，源码如下

public class AnnotatedBeanDefinitionReader { 
    	//BeanDefinition 的注册器
    	private final BeanDefinitionRegistry registry;
    	//名字生成器
    	private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
    	//scope 解析器
    	private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    
    	...省略...
    	//注册多个类
    	public void register(Class<?>... componentClasses) { 
    		for (Class<?> componentClass : componentClasses) { 
    			registerBean(componentClass);
    		}
    	}

register方法中通过for的方式把多个配置类交给registerBean方法去注册，代码来到 `.AnnotatedBeanDefinitionReader#registerBean(java.lang.Class<?>)`

public void registerBean(Class<?> beanClass) { 
    		doRegisterBean(beanClass, null, null, null);
    	}
    
    	//从给定的 bean 类注册一个 bean，从类声明的注释中获取其元数据
    	<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
    			@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { 
    		//创建带注释的通用 Bean 定义
    		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    		//判断配置类上是否有 Conditional 条件注解，判断是否要跳过该Bean的注册
    		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { 
    			return;
    		}
    
    		abd.setInstanceSupplier(instanceSupplier);
    		//通过 ScopeMetadataResolver 解析 当前Bean的@Scope注解，封装成 ScopeMetadata
    		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    		// scope属性，默认是 singleton 单利
    		abd.setScope(scopeMetadata.getScopeName());
    		//生成Bean的名字，如果从注解中没有获取到name,就生成唯一的默认 bean 名称。
    		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    		//处理注解 Bean 定义中的通用注解 ,比如读取：lazy， @Primary，@DependsOn ， Description等注解属性，然后设置到BeanDefinition对象
    		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    		//检查是否有而外的限定符注解
    		if (qualifiers != null) { 
    			for (Class<? extends Annotation> qualifier : qualifiers) { 
    				//如果有@Primary注解，这标记该Bean是自动注入时的首选Bean
    				if (Primary.class == qualifier) { 
    					abd.setPrimary(true);
    				}
    				//如果配置了@Lazy这设置为懒加载
    				else if (Lazy.class == qualifier) { 
    					abd.setLazyInit(true);
    				}
    				else { 
    					//如果没有@Primary和Lazy配置，则指定自动注入时使用名称自动注入
    					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
    				}
    			}
    		}
    		for (BeanDefinitionCustomizer customizer : definitionCustomizers) { 
    			customizer.customize(abd);
    		}
    		//封装一个BeanDefinitionHolder，以beanName作为名字
    		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    		//Scope作用域，创建相应的代理对象
    		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    		//注册BeanDefinition
    		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    	}

该方法中做了如下事情

*  给当前Bean创建一个 AnnotatedGenericBeanDefinition
 *  通过 ScopeMetadataResolver 元注解解析器解析 当前Bean的@Scope注解，封装成 ScopeMetadata，然后把scope设置给BeanDefinition
 *  为Bean设置name,如果没有指定name就生成一个全局唯一的name
 *  处理Bean的通用注解如：lazy， @Primary，@DependsOn ， Description等注解属性
 *  创建Scope的代理对象
 *  调用 BeanDefinitionReaderUtils\#registerBeanDefinition 注册Beandefinition

至于`BeanDefinitionReaderUtils#registerBeanDefinition` 在前面一章我们就看过了，其实现方式是通过`BeanDefinitionRegistry`把BeanDefinition注册到 `DefaultListableBeanFactory` 容器工厂管理Bean的Map中(`beanDefinitionMap = new ConcurrentHashMap(256)`)

到这里，配置类的Bean的注册就完了，那有些同学会问，在配置类AppConfig中注册的 MyBean 是在什么起作用的呢？它是在refresh()方法中调用 `finishBeanFactoryInitialization(beanFactory)` 执行的。该方法中会把单利的Bean预先实例化，这里我不展开说。

# 总结 #

这篇文章比较简单，讲了一下基于注解的 `AnnotationConfigApplicationContext(annotatedClasses)` 容器工厂启动过程，这里做个总结

1.  通过构造器创建 AnnotatedBeanDefinitionReader Bean注册器 和 ClassPathBeanDefinitionScanner Bean扫描器
2.  然后将传入的配置类封装成 AnnotatedGenericBeanDefinition ，并解析该类的注解，如：@Lazy,@Scope，@Primary等属性都设置给BeanDefinition
3.  调用BeanDefinitionReaderUtils\#registerBeanDefinition把BeanDefinition注册到DefaultListableBeanFactory中一个管理Bean的Map中

文章结束，下一章我们将继续讨论AnnotationConfigApplicationContext的另外一种启动方式：基于包路径的扫描方式。 如果喜欢的请给个好评吧,你的肯定是我最大的动力 ！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0OTQxNDg_size_16_color_FFFFFF_t_70]: /images/20221014/04de809fb3cd4ce89943fd1dd82c4fee.png