[Java] Spring bean的实例化和IOC依赖注入详解

public void preinstantiatesingletons() throws beansexception {
   //beandefinitionnames就是上一节初始化完成后的所有beandefinition的beanname
   list<string> beannames = new arraylist<string>(this.beandefinitionnames);
   for (string beanname : beannames) {
   rootbeandefinition bd = getmergedlocalbeandefinition(beanname);
   if (!bd.isabstract() && bd.issingleton() && !bd.islazyinit()) {
     //getbean是主力中的主力，负责实例化bean和ioc依赖注入
     getbean(beanname);
   }
   }
 }

protected object docreatebean(final string beanname, final rootbeandefinition mbd, final object[] args) {
  // instantiate the bean.
  beanwrapper instancewrapper = null;
  if (mbd.issingleton()) {
  instancewrapper = this.factorybeaninstancecache.remove(beanname);
  }
  if (instancewrapper == null) {
  //createbeaninstance就是实例化bean的过程，无非就是一些判断加反射，最后调用ctor.newinstance(args);
  instancewrapper = createbeaninstance(beanname, mbd, args);
  }
}

• autowiredannotationbeanpostprocessor
  
• commonannotationbeanpostprocessor
  
• requiredannotationbeanpostprocessor
  

reflectionutils.dowithlocalfields(targetclass, new reflectionutils.fieldcallback() 
reflectionutils.dowithlocalmethods(targetclass, new reflectionutils.methodcallback()

public static void main(string[] args) throws classnotfoundexception {
  class<?> clazz = class.forname("com.viewscenes.netsupervisor.entity.user");
  field[] fields = clazz.getfields();
  method[] methods = clazz.getmethods();
 
  for (int i = 0; i < fields.length; i++) {
  field field = fields[i];
  if (field.isannotationpresent(autowired.class)) {
    //转换成autowiredfieldelement对象，加入容器
  }
  }
  for (int i = 0; i < methods.length; i++) {
  method method = methods[i];
  if (method.isannotationpresent(autowired.class)) {
    //转换成autowiredmethodelement对象，加入容器
  }
  }
  return new injectionmetadata(clazz, elements);
}

public injectionmetadata(class<?> targetclass, collection<injectedelement> elements) {
  //targetclass是bean的class对象
  this.targetclass = targetclass; 
  //injectedelements是一个injectedelement对象的集合
  this.injectedelements = elements;
}
//member是成员本身，字段或者方法
//pd是jdk中的内省机制对象，后面的注入属性值要用到
protected injectedelement(member member, propertydescriptor pd) {
  this.member = member;
  this.isfield = (member instanceof field);
  this.pd = pd;
}

reflectionutils.dowithlocalfields(targetclass, new reflectionutils.fieldcallback() {
  @override
  public void dowith(field field) throws illegalargumentexception, illegalaccessexception {
  annotationattributes ann = findautowiredannotation(field);
  if (ann != null) {
    if (modifier.isstatic(field.getmodifiers())) {
    if (logger.iswarnenabled()) {
      logger.warn("autowired annotation is not supported on static fields: " + field);
    }
    return;
    }
    boolean required = determinerequiredstatus(ann);
    currelements.add(new autowiredfieldelement(field, required));
  }
  }
});
 
reflectionutils.dowithlocalmethods(targetclass, new reflectionutils.methodcallback() {
  @override
  public void dowith(method method) throws illegalargumentexception, illegalaccessexception {
  method bridgedmethod = bridgemethodresolver.findbridgedmethod(method);
  if (!bridgemethodresolver.isvisibilitybridgemethodpair(method, bridgedmethod)) {
    return;
  }
  annotationattributes ann = findautowiredannotation(bridgedmethod);
  if (ann != null && method.equals(classutils.getmostspecificmethod(method, clazz))) {
    if (modifier.isstatic(method.getmodifiers())) {
    if (logger.iswarnenabled()) {
      logger.warn("autowired annotation is not supported on static methods: " + method);
    }
    return;
    }
    if (method.getparametertypes().length == 0) {
    if (logger.iswarnenabled()) {
      logger.warn("autowired annotation should be used on methods with parameters: " + method);
    }
    }
    boolean required = determinerequiredstatus(ann);
    propertydescriptor pd = beanutils.findpropertyformethod(bridgedmethod, clazz);
    currelements.add(new autowiredmethodelement(method, required, pd));
  }
  }
});

public class user { 
  @autowired
  role role;
}

protected void inject(object bean, string beanname, propertyvalues pvs) throws throwable {
  //以user类中的@autowired role role为例，这里的field就是
  //public com.viewscenes.netsupervisor.entity.role com.viewscenes.netsupervisor.entity.user.role
  field field = (field) this.member;
  object value;
  dependencydescriptor desc = new dependencydescriptor(field, this.required);
  desc.setcontainingclass(bean.getclass());
  set<string> autowiredbeannames = new linkedhashset<string>(1);
  typeconverter typeconverter = beanfactory.gettypeconverter();
  try {
  //这里的beanname因为bean，所以会重新进入populatebean方法，先完成role对象的注入
  //value == com.viewscenes.netsupervisor.entity.role@7228c85c
  value = beanfactory.resolvedependency(desc, beanname, autowiredbeannames, typeconverter);
  }
  catch (beansexception ex) {
  throw new unsatisfieddependencyexception(null, beanname, new injectionpoint(field), ex);
  }
  if (value != null) {
  //设置可访问，直接赋值
  reflectionutils.makeaccessible(field);
  field.set(bean, value);
  }
}

public class user {
  @autowired
  public void setrole(role role) {}
}

reflectionutils.makeaccessible(method);
method.invoke(bean, arguments);

<bean id="user" class="com.viewscenes.netsupervisor.entity.user">
  <property name="id" value="1001"></property>
  <property name="name" value="网机动车"></property>
  <property name="age" value="24"></property>
  <property name="role" ref="role"></property>
</bean>
<bean id="role" class="com.viewscenes.netsupervisor.entity.role">
  <property name="id" value="1002"></property>
  <property name="name" value="中心管理员"></property>
</bean>

mutablepropertyvalues:
 //propertyvaluelist就是有几个property 节点
 list<propertyvalue> propertyvaluelist:
  propertyvalue:
   name   //对应配置文件中的name  ==id
   value   //对应配置文件中的value ==1001 
  propertyvalue:
   name   //对应配置文件中的name  ==name
   value   //对应配置文件中的value ==网机动车

public void setvalue(final object object, object valuetoapply) throws exception {
  //pd 是内省对象propertydescriptor
  final method writemethod = this.pd.getwritemethod());
  writemethod.setaccessible(true);
  final object value = valuetoapply;
  //以id为例 writemethod == public void com.viewscenes.netsupervisor.entity.user.setid(java.lang.string)
  writemethod.invoke(getwrappedinstance(), value);
}

//在实例化和ioc依赖注入完成后调用
  private void invokeawaremethods(final string beanname, final object bean) {
  if (bean instanceof aware) {
  //让我们的bean可以拿到自身在容器中的beanname
  if (bean instanceof beannameaware) {
    ((beannameaware) bean).setbeanname(beanname);
  }
  //可以拿到classloader对象
  if (bean instanceof beanclassloaderaware) {
    ((beanclassloaderaware) bean).setbeanclassloader(getbeanclassloader());
  }
  //可以拿到beanfactory对象
  if (bean instanceof beanfactoryaware) {
    ((beanfactoryaware) bean).setbeanfactory(abstractautowirecapablebeanfactory.this);
  }
  if (bean instanceof environmentaware) {
    ((environmentaware) bean).setenvironment(this.applicationcontext.getenvironment());
  }
  if (bean instanceof embeddedvalueresolveraware) {
    ((embeddedvalueresolveraware) bean).setembeddedvalueresolver(this.embeddedvalueresolver);
  }
  if (bean instanceof resourceloaderaware) {
    ((resourceloaderaware) bean).setresourceloader(this.applicationcontext);
  }
  if (bean instanceof applicationeventpublisheraware) {
    ((applicationeventpublisheraware) bean).setapplicationeventpublisher(this.applicationcontext);
  }
  if (bean instanceof messagesourceaware) {
    ((messagesourceaware) bean).setmessagesource(this.applicationcontext);
  }
  if (bean instanceof applicationcontextaware) {
    ((applicationcontextaware) bean).setapplicationcontext(this.applicationcontext);
  }
  ......未完
  }
}

public class awaretest1 implements beannameaware,beanclassloaderaware,beanfactoryaware{
  public void setbeanname(string name) {
  system.out.println("beannameaware:" + name);
  }
  public void setbeanfactory(beanfactory beanfactory) throws beansexception {
  system.out.println("beanfactoryaware:" + beanfactory); 
  }
  public void setbeanclassloader(classloader classloader) {
  system.out.println("beanclassloaderaware:" + classloader); 
  }
}

//输出结果
beannameaware:awaretest1
beanclassloaderaware:webappclassloader
  context: /springmvc_dubbo_producer
  delegate: false
  repositories:
  /web-inf/classes/
----------> parent classloader:
java.net.urlclassloader@2626b418
beanfactoryaware:org.springframework.beans.factory.support.defaultlistablebeanfactory@5b4686b4: defining beans ...未完

if (method.getparametertypes().length != 0) {
  throw new illegalstateexception("lifecycle method annotation requires a no-arg method: " + method);
}
public void invoke(object target) throws throwable {
  reflectionutils.makeaccessible(this.method);
  this.method.invoke(target, (object[]) null);
}
 
5.2.2 afterpropertiesset
这个要实现initializingbean接口。这个也不能有参数，因为它接口方法就没有定义参数。
  boolean isinitializingbean = (bean instanceof initializingbean);
  if (isinitializingbean && (mbd == null || !mbd.isexternallymanagedinitmethod("afterpropertiesset"))) {
  if (logger.isdebugenabled()) {
    logger.debug("invoking afterpropertiesset() on bean with name '" + beanname + "'");
  }
  ((initializingbean) bean).afterpropertiesset();
  }

reflectionutils.makeaccessible(initmethod);
initmethod.invoke(bean);