spring-ioc源码

一句话

AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(MainConfig.class);

IOC容器的初始化，通过这样一句话完成。加载入我们的配置类 MainConfig.class 这里我们采用的是注解配置类的方式。

一分三

进入到源码中，new AnnotationConfigApplicationContext()，究竟做了哪些事？

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//调用构造函数
		this();
		//注册我们的配置类
		register(annotatedClasses);
		//IOC容器刷新接口
		refresh();
	}

这里可以看到，调用AnnotationConfigApplicationContext的构造方法，里面有这样的三句话。关于这三句的大致完成的事注释已经写清。下面就分别进行细抠一下，具体完成的事情。

调用构造函数

这里提一下，AnnotationConfigApplicationContext是继承自GenericApplicationContext，会默认调用父类的构造函数

public GenericApplicationContext() {
		/**
		 * 调用父类的构造函数,为ApplicationContext spring上下文对象初始beanFactory
		 * 为啥是DefaultListableBeanFactory？我们去看BeanFactory接口的时候
		 * 发DefaultListableBeanFactory是最底层的实现，功能是最全的
		 */
		this.beanFactory = new DefaultListableBeanFactory();
	}

public AnnotationConfigApplicationContext() {
		/**
		 * 初始化注解模式下的bean定义扫描器
		 * 调用AnnotatedBeanDefinitionReader构造方法，传入的是this(AnnotationConfigApplicationContext)对象
		 */
		//注册内置BeanPostProcessor以及注册相关的BeanDefinition
		this.reader = new AnnotatedBeanDefinitionReader(this);
		/**
		 * 初始化我们的classPath类型的bean定义扫描器
		 */
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

首先是父类的构造函数，这里就实例化了一个BeanFactory。值得一提的是，整个spring框架中有很多个BeanFactory，他们根据各自继承体系的不同，在框架中担任不同的任务，当然后面提到的BeanDefinition也是这样，之后再对这些个玩意细抠一下。ok，来看一下这个BeanFactory的继承关系

这里先记住，调用父类构造器实例化了一个DefaultListableBeanFactory。

接着走，在Annotation的构造器中实例化了两个，一个是Bean定义的reader，一个是扫描器。后者是我们手动添加扫描的时候才会调用到，这里并不会。我们直接看第一个。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		//把ApplicationContext对象赋值给AnnotatedBeanDefinitionReader
		this.registry = registry;
		//用户处理条件表达式计算 @Conditionl
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		//注册一些配置的后置处理器
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

这里完成了三件：

• 首先是将BeanDefinitionRegistry赋值给此处的bean定义reader中，这个BeanDefinitionRegistry实际上就是刚刚的AnnotationConfigApplicationContext
• 然后实例化处理条件计算@Condition注解的类
• 最后，注册一些配置的后置处理器到beanDefinitionMap中共计6个

注册配置类

在AnnotationConfigApplicationContext的构造函数中，将我们的配置类作为参数调用register方法

直接跟到AnnotatedBeanDefinitionReader中

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
		//这里将配置类包装为一个BeanDefinition。
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    	    //通过获取元注解，判断是否含有Condition注解，有的话直接返回
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
		
		abd.setInstanceSupplier(instanceSupplier);
    		//保证缺省情况下，是单例模式
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
    	    //这里获取beanName，根据注解@componet系列的生成beanName，如果一个类上有两个@Component系注解，而且名字bean名字不同，这里就会报错
    	   //例如 @Service("car1")  @Component("car2")
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//处理bean定义中的5个通用注解：lazy、primary、DependsOn、Role、Description
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
                //这段if逻辑，针对的是Qualifier注解，
		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));
				}
			}
		}
                 //这段代码是spring5.0以后新加入的，Spring 5允许使用lambda 表达式来自定义注册一个 bean，具体操作我并不太清楚
		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}
		//这里将beanName同配置类的包装类bean定义一起，封装为一个Holder。相当于是一个bean定义的持有者。
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    	//这里通过注解工具类，获取到我们配置类上的@Scope注解内容。使用的是proxyMode属性设置的，默认为NO，也就是没有代理
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            //开始注册bean定义了
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

进入到注册bean定义的流程

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); //将配置类注册到beanDefinitionMap中

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

//defaultListableBeanFactory类中
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 oldBeanDefinition;
 
   oldBeanDefinition = this.beanDefinitionMap.get(beanName);
   if (oldBeanDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
               "': There is already [" + oldBeanDefinition + "] bound.");
      }
      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (this.logger.isWarnEnabled()) {
            this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  oldBeanDefinition + "] with [" + beanDefinition + "]");
         }
      }
      else if (!beanDefinition.equals(oldBeanDefinition)) {
         if (this.logger.isInfoEnabled()) {
            this.logger.info("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + oldBeanDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (this.logger.isDebugEnabled()) {
            this.logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + oldBeanDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            if (this.manualSingletonNames.contains(beanName)) {
               Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
               updatedSingletons.remove(beanName);
               this.manualSingletonNames = updatedSingletons;
            }
         }
      }
      else {
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
         this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }
 
   if (oldBeanDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

关键点在最后几行，86~88。将配置类放到了Map中，现在Map中有7个类。

本篇文章只是对大致的流程进行讲解，细节还是没有搞到位的，学习还是日益精进吧。