[Java] Spring IOC基于注解启动示例详析

• annotationconfigapplicationcontext
  
• annotationconfigwebapplicationcontext
  

annotationconfigapplicationcontext.png

<dependency>
 <groupid>org.springframework</groupid>
 <artifactid>spring-context</artifactid>
 <version>${spring.version}</version>
</dependency>

public static void main(string[] args) {
annotationconfigapplicationcontext applicationcontext = new annotationconfigapplicationcontext();
applicationcontext.register(beanconfig.class);
applicationcontext.refresh();
date date = applicationcontext.getbean("date",date.class);
system.out.println(date);
}

public annotationconfigapplicationcontext() {
   //负责注册class ，读取器
 this.reader = new annotatedbeandefinitionreader(this);
   //负责扫描指定类路径下的class，注册bean
 this.scanner = new classpathbeandefinitionscanner(this);
}

public annotatedbeandefinitionreader(beandefinitionregistry registry) {
 this(registry, getorcreateenvironment(registry));
}
 
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;
   //初始化conditionevaluator
 this.conditionevaluator = new conditionevaluator(registry, environment, null);
  
 /** 在給定的注册表中註冊所有相关的post processors
  * 判断容器是否已经存在给定注册表的bean，如果没有注册bean，并将bean放入容器中
  * 把所有的处理处理器列出来
  * configurationclasspostprocessor 內部管理的配置注解处理器
  * autowiredannotationbeanpostprocessor 内部管理@autowired 的处理器
  * requiredannotationbeanpostprocessor @required的处理器
  * commonannotationbeanpostprocessor jsr-250注解处理器 ，先判断是否支持jsr，如果支持注册
  * persistenceannotationbeanpostprocessor jpa管理 先使用类加载器查找是否存在，如果有这个包则注册
  * eventlistenermethodprocessor @eventlistener的处理器
  * defaulteventlistenerfactory 管理eventlistenerfactory处理器
  */
 annotationconfigutils.registerannotationconfigprocessors(this.registry);
}

public conditionevaluator(@nullable beandefinitionregistry registry,
  @nullable environment environment, @nullable resourceloader resourceloader) {
 
 this.context = new conditioncontextimpl(registry, environment, resourceloader); 
}
 //conditioncontextimpl 实现了conditioncontext接口，conditionevaluator静态内部类
 public conditioncontextimpl(@nullable beandefinitionregistry registry,
   @nullable environment environment, @nullable resourceloader resourceloader) {
 
  this.registry = registry;
  this.beanfactory = deducebeanfactory(registry);
  this.environment = (environment != null ? environment : deduceenvironment(registry));
  this.resourceloader = (resourceloader != null ? resourceloader : deduceresourceloader(registry));
  this.classloader = deduceclassloader(resourceloader, this.beanfactory);
 }

public classpathbeandefinitionscanner(beandefinitionregistry registry) {
 this(registry, true);
}
 
public classpathbeandefinitionscanner(beandefinitionregistry registry, boolean usedefaultfilters) {
 this(registry, usedefaultfilters, getorcreateenvironment(registry));
}
 
public classpathbeandefinitionscanner(beandefinitionregistry registry, boolean usedefaultfilters,
  environment environment) {
 this(registry, usedefaultfilters, environment,
   (registry instanceof resourceloader ? (resourceloader) registry : null));
}
 
public classpathbeandefinitionscanner(beandefinitionregistry registry, boolean usedefaultfilters,
  environment environment, @nullable resourceloader resourceloader) {
 assert.notnull(registry, "beandefinitionregistry must not be null");
 this.registry = registry;
 if (usedefaultfilters) {
  registerdefaultfilters();
 }
 setenvironment(environment);
 setresourceloader(resourceloader);
}
 
protected void registerdefaultfilters() {
 this.includefilters.add(new annotationtypefilter(component.class));
 classloader cl = classpathscanningcandidatecomponentprovider.class.getclassloader();
 try {
  this.includefilters.add(new annotationtypefilter(
  ((class<? extends annotation>) classutils.forname("javax.annotation.managedbean", cl)), false));
  logger.debug("jsr-250 'javax.annotation.managedbean' found and supported for component scanning");
 }
 catch (classnotfoundexception ex) {
 }
 try {
  this.includefilters.add(new annotationtypefilter(
  ((class<? extends annotation>) classutils.forname("javax.inject.named", cl)), false));
  logger.debug("jsr-330 'javax.inject.named' annotation found and supported for component scanning");
 }
 catch (classnotfoundexception ex) {
  // jsr-330 api not available - simply skip.
 }
}

public void register(class<?>... annotatedclasses) {
  assert.notempty(annotatedclasses, "at least one annotated class must be specified");
  this.reader.register(annotatedclasses); //调用 刚刚初始化读取器
 }
       |
============================annotatedbeandefinitionreader 读取器代码======================================================================================================
  public void register(class<?>... annotatedclasses) {
  for (class<?> annotatedclass : annotatedclasses) {
   registerbean(annotatedclass);
  }
  }
 
 public void registerbean(class<?> annotatedclass) {
  doregisterbean(annotatedclass, null, null, null);
 }
  
 /**
 *从给定的bean解析class给定的注解，执行相应的初始化，保存到spring容器中
 */
 <t> void doregisterbean(class<t> annotatedclass, @nullable supplier<t> instancesupplier, @nullable string name,
   @nullable class<? extends annotation>[] qualifiers, beandefinitioncustomizer... definitioncustomizers) {
 
  //根据class的annotated 得出元数据 annotationmetadata
  annotatedgenericbeandefinition abd = new annotatedgenericbeandefinition(annotatedclass);
  /**
  * 判断注册的class 是否包含@conditional注解，如果有获取全部value，放入list中
  * 排序后，遍历所有的conditiion的实现，使用反射获取对象，执行matches方法，
  * 如果发现有返回false，中断循环直接返回true，
  */
  if (this.conditionevaluator.shouldskip(abd.getmetadata())) { //如果 @conditional条件不满足，不进行注册
   return;
  }
 
  abd.setinstancesupplier(instancesupplier);
  //解析class是否有@scope,解析@scope注解返回scopemetadata对象，没有直接返回空
  scopemetadata scopemetadata = this.scopemetadataresolver.resolvescopemetadata(abd);
  abd.setscope(scopemetadata.getscopename());
  //判断注解上value是否有值，有就使用这个作为beanname，没有则取类名 
  string beanname = (name != null ? name : this.beannamegenerator.generatebeanname(abd, this.registry));
  //继续解析annotationmetadata的@lazy,@primary，@dependson，@role，@description的注解，放入结果放入对象的属性中
  annotationconfigutils.processcommondefinitionannotations(abd);
  //这个类只是beandefinition 包装类
  beandefinitionholder definitionholder = new beandefinitionholder(abd, beanname);
  //是否需要代理类，如果是则修改内部属性，重新生成beandefinition 对象
  definitionholder = annotationconfigutils.applyscopedproxymode(scopemetadata, definitionholder, this.registry);
  //调用defaultlistablebeanfactory.registerbeandefinition的方法，做一些安全性校验再，将definitionholder 放入register容器中
  beandefinitionreaderutils.registerbeandefinition(definitionholder, this.registry);
 }

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 {
  //对beandefinition 进行校验判断methodoverrides不能为空，必须拥有工厂方法
  ((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) {
  //这个方法是判断是否允许出现重名bean，并且是不同的定义bean，是否可以覆盖前者
   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 {
   //调用alreadycreated.isempty()，alreadycreated set对象，保存已经创建beanname
   //文档中表示created，跟这里注册应该不是同一个行为，这个要看到后面才知道什么意思
   if (hasbeancreationstarted()) {
  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 { 
  //spring beandefinition 容器，一个map转载
  this.beandefinitionmap.put(beanname, beandefinition);
  //保存beanname，主要用于记录每个bean注册顺序
  this.beandefinitionnames.add(beanname);
  //删除单例，注册成一个普通bean
  this.manualsingletonnames.remove(beanname);
   }
   this.frozenbeandefinitionnames = null;
  }
 
  if (oldbeandefinition != null || containssingleton(beanname)) { 
   //更新spring容器里beanname
   resetbeandefinition(beanname);
  }
 }

• rootbeandefinition     spring factory中的特定bean
  
• annotatedgenericbeandefinition      用户自定义bean