一直很好奇代码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
的构造方法。进入发现构造方法中初始化了自己内部的beanFactory
为DefaultListableBeanFactory
:
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