框架源码系列二：手写Spring-IOC和Spring-DI（IOC分析、IOC设计实现、DI分析、DI实现）

package com.study.spring.beans;/**
*
* @Description: IOC容器(bean工厂)接口:负责创建bean实例
* @author leeSmall
* @date 2018年11月29日
*
*/
public interface BeanFactory {
/**
* 获取bean
*
* @param name bean的名字
*
* @return bean 实例
* @throws Exception
*/
Object getBean(String name) throws Exception;
}

package com.study.spring.beans;/**
*
* @Description: bean定义BeanDefinition定义好了就需要告诉IOC容器(bean工厂):
* 通过bean定义注册接口BeanDefinitionRegistry把bean定义BeanDefinition注册到IOC容器(bean工厂)BeanFactory
* @author leeSmall
* @date 2018年11月29日
*
*/
public interface BeanDefinitionRegistry { //注册bean定义
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegistException; //获取bean定义
BeanDefinition getBeanDefinition(String beanName); //判断是否包含bean定义
boolean containsBeanDefinition(String beanName);}

Person p = new Person();

public class PersonFactory {
public static Person getPerson() {
return new Person();
}
}

public class PersonFactory {
public Person getPerson() {
return new Person();
}
}

package com.study.spring.beans;import org.apache.commons.lang3.StringUtils;/**
*
* @Description: bean定义接口:要IOC容器(bean工厂)创建bean实例，就得告诉IOC容器(bean工厂)需要创建什么样的bean-BeanDefinition
* @author leeSmall
* @date 2018年11月29日
*
*/
public interface BeanDefinition { String SCOPE_SINGLETION = "singleton"; String SCOPE_PROTOTYPE = "prototype"; /**
* 类:new 构造方法的方式创建bean时，需要告诉bean工厂怎么获取类的名称
*/
Class<?> getBeanClass(); /**
* Scope
*/
String getScope(); /**
* 是否单例
*/
boolean isSingleton(); /**
* 是否原型
*/
boolean isPrototype(); /**
* 工厂bean名：成员工厂方法的方式创建bean时，需要告诉bean工厂怎么获取工厂bean名
*/
String getFactoryBeanName(); /**
* 工厂方法名:静态工厂方法的方式创建bean时，需要告诉bean工厂怎么获取工厂方法名
*/
String getFactoryMethodName(); /**
* 初始化方法
*/
String getInitMethodName(); /**
* 销毁方法
*/
String getDestroyMethodName(); /**
* 校验bean定义的合法性
*/
default boolean validate() {
// 没定义class,工厂bean或工厂方法没指定，则不合法。
if (this.getBeanClass() == null) {
if (StringUtils.isBlank(getFactoryBeanName()) || StringUtils.isBlank(getFactoryMethodName())) {
return false;
}
} // 定义了类，又定义工厂bean，不合法
if (this.getBeanClass() != null && StringUtils.isNotBlank(getFactoryBeanName())) {
return false;
} return true;
}}

package com.study.spring.beans;import org.apache.commons.lang3.StringUtils;/**
*
* @Description: bean定义有了就需要实现bean定义接口BeanDefinition实现一个通用的bean
* 定义GenericBeanDefinition,用来承载数据
* @author leeSmall
* @date 2018年11月29日
*
*/
public class GenericBeanDefinition implements BeanDefinition { //bean的名称
private Class<?> beanClass; //scope 默认单例
private String scope = BeanDefinition.SCOPE_SINGLETION; //工厂bean名
private String factoryBeanName; //工厂方法名
private String factoryMethodName; //初始化方法
private String initMethodName; //销毁方法
private String destroyMethodName; //设置bean的名称
public void setBeanClass(Class<?> beanClass) {
this.beanClass = beanClass;
} //设置scope
public void setScope(String scope) {
if (StringUtils.isNotBlank(scope)) {
this.scope = scope;
}
} //设置工厂bean名
public void setFactoryBeanName(String factoryBeanName) {
this.factoryBeanName = factoryBeanName;
} //设置工厂方法名
public void setFactoryMethodName(String factoryMethodName) {
this.factoryMethodName = factoryMethodName;
} //设置初始化方法
public void setInitMethodName(String initMethodName) {
this.initMethodName = initMethodName;
} //设置销毁方法
public void setDestroyMethodName(String destroyMethodName) {
this.destroyMethodName = destroyMethodName;
} @Override
public Class<?> getBeanClass() {
return this.beanClass;
} @Override
public String getScope() {
return this.scope;
} @Override
public boolean isSingleton() {
return BeanDefinition.SCOPE_SINGLETION.equals(this.scope);
} @Override
public boolean isPrototype() {
return BeanDefinition.SCOPE_PROTOTYPE.equals(this.scope);
} @Override
public String getFactoryBeanName() {
return this.factoryBeanName;
} @Override
public String getFactoryMethodName() {
return this.factoryMethodName;
} @Override
public String getInitMethodName() {
return this.initMethodName;
} @Override
public String getDestroyMethodName() {
return this.destroyMethodName;
} @Override
public String toString() {
return "GenericBeanDefinition [beanClass=" + beanClass + ", scope=" + scope + ", factoryBeanName="
+ factoryBeanName + ", factoryMethodName=" + factoryMethodName + ", initMethodName=" + initMethodName
+ ", destroyMethodName=" + destroyMethodName + "]";
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((beanClass == null) ? 0 : beanClass.hashCode());
result = prime * result + ((destroyMethodName == null) ? 0 : destroyMethodName.hashCode());
result = prime * result + ((factoryBeanName == null) ? 0 : factoryBeanName.hashCode());
result = prime * result + ((factoryMethodName == null) ? 0 : factoryMethodName.hashCode());
result = prime * result + ((initMethodName == null) ? 0 : initMethodName.hashCode());
result = prime * result + ((scope == null) ? 0 : scope.hashCode());
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
GenericBeanDefinition other = (GenericBeanDefinition) obj;
if (beanClass == null) {
if (other.beanClass != null)
return false;
} else if (!beanClass.equals(other.beanClass))
return false;
if (destroyMethodName == null) {
if (other.destroyMethodName != null)
return false;
} else if (!destroyMethodName.equals(other.destroyMethodName))
return false;
if (factoryBeanName == null) {
if (other.factoryBeanName != null)
return false;
} else if (!factoryBeanName.equals(other.factoryBeanName))
return false;
if (factoryMethodName == null) {
if (other.factoryMethodName != null)
return false;
} else if (!factoryMethodName.equals(other.factoryMethodName))
return false;
if (initMethodName == null) {
if (other.initMethodName != null)
return false;
} else if (!initMethodName.equals(other.initMethodName))
return false;
if (scope == null) {
if (other.scope != null)
return false;
} else if (!scope.equals(other.scope))
return false;
return true;
}}

package com.study.spring.beans;import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;/**
*
* @Description: bean定义BeanDefinition有了,bean定义注册BeanDefinitionRegistry也有了,
* 就可以实现一个默认的bean工厂DefaultBeanFactory来创建bean实例了,DefaultBeanFactory除了需要实现BeanFactory外,
* 还需要实现Bean定义注册接口BeanDefinitionRegistry,因为要把bean定义注册到bean工厂里面
* @author leeSmall
* @date 2018年11月29日
*
*/
public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable { private final Log logger = LogFactory.getLog(getClass()); //用Map来存放bean定义信息
private Map<String, BeanDefinition> beanDefintionMap = new ConcurrentHashMap<>(256); //用Map来存放创建的bean实例,注意这里只是存放单例bean,多实例每次都要创建新的,不需要存放
private Map<String, Object> beanMap = new ConcurrentHashMap<>(256); //注册bean定义
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionRegistException {
//判断给入的beanName和beanDefinition不能为空
Objects.requireNonNull(beanName, "注册bean需要给入beanName");
Objects.requireNonNull(beanDefinition, "注册bean需要给入beanDefinition"); // 校验给入的bean是否合法
if (!beanDefinition.validate()) {
throw new BeanDefinitionRegistException("名字为[" + beanName + "] 的bean定义不合法：" + beanDefinition);
} //如果已存在bean定义就抛异常
if (this.containsBeanDefinition(beanName)) {
throw new BeanDefinitionRegistException(
"名字为[" + beanName + "] 的bean定义已存在:" + this.getBeanDefinition(beanName));
} //把bean定义放到Map里面
this.beanDefintionMap.put(beanName, beanDefinition);
} //根据bean的名字从Map里面获取bean定义
@Override
public BeanDefinition getBeanDefinition(String beanName) {
return this.beanDefintionMap.get(beanName);
} //根据bean的名字判断Map里面是否包含bean定义
@Override
public boolean containsBeanDefinition(String beanName) { return this.beanDefintionMap.containsKey(beanName);
} //根据bean的名字获取bean实例,里面主要做的工作是创建bean实例和对bean实例进行初始化
@Override
public Object getBean(String name) throws Exception {
return this.doGetBean(name);
} //根据bean的名字获取bean实例,里面主要做的工作是创建bean实例和对bean实例进行初始化
protected Object doGetBean(String beanName) throws Exception {
//判断给入的bean名字不能为空
Objects.requireNonNull(beanName, "beanName不能为空"); //先从beanMap里面获取bean实例
Object instance = beanMap.get(beanName); //如果beanMap里面已存在bean实例就直接返回,不需要走后面的流程了
if (instance != null) {
return instance;
} //从beanDefintionMap里面获取bean定义信息
BeanDefinition bd = this.getBeanDefinition(beanName);
//bean定义信息不能为空
Objects.requireNonNull(bd, "beanDefinition不能为空"); //获取bean的类型
Class<?> type = bd.getBeanClass();
if (type != null) {
//如果bean的类型不为空,并且工厂方法名为空,说明是使用构造方法的方式来创建bean实例
if (StringUtils.isBlank(bd.getFactoryMethodName())) {
// 构造方法来构造对象
instance = this.createInstanceByConstructor(bd);
}
//如果bean的类型不为空,并且工厂方法名不为空,说明是使用静态工厂方法的方式来创建bean实例
else {
// 静态工厂方法
instance = this.createInstanceByStaticFactoryMethod(bd);
}
}
//如果bean的类型为空,说明是使用工厂bean的方式来创建bean实例
else {
// 工厂bean方式来构造对象
instance = this.createInstanceByFactoryBean(bd);
} // 执行初始化方法
this.doInit(bd, instance); //存放单例的bean到beanMap
if (bd.isSingleton()) {
beanMap.put(beanName, instance);
} return instance;
} // 构造方法来构造对象 反射
private Object createInstanceByConstructor(BeanDefinition bd)
throws InstantiationException, IllegalAccessException {
try {
//拿到bean的类型,然后调用newInstance通过反射来创建bean实例
return bd.getBeanClass().newInstance();
} catch (SecurityException e1) {
logger.error("创建bean的实例异常,beanDefinition：" + bd, e1);
throw e1;
}
} // 静态工厂方法 反射
private Object createInstanceByStaticFactoryMethod(BeanDefinition bd) throws Exception {
//拿到bean的类型
Class<?> type = bd.getBeanClass();
//通过静态工厂方法方法的名字getFactoryMethodName反射出bean的方法m创建bean实例
Method m = type.getMethod(bd.getFactoryMethodName(), null);
return m.invoke(type, null);
} // 工厂bean方式来构造对象 反射
private Object createInstanceByFactoryBean(BeanDefinition bd) throws Exception { //通过bean定义信息中工厂bean的名字获取工厂bean的实例
Object factoryBean = this.doGetBean(bd.getFactoryBeanName()); //通过bean定义信息中工厂方法的名字反射出工厂bean的方法m创建bean实例
Method m = factoryBean.getClass().getMethod(bd.getFactoryMethodName(), null);
return m.invoke(factoryBean, null);
} //执行初始化方法
private void doInit(BeanDefinition bd, Object instance) throws Exception {
// 获取bean定义中的初始化方法,如果存在初始化方法就通过反射去执行初始化方法
if (StringUtils.isNotBlank(bd.getInitMethodName())) {
Method m = instance.getClass().getMethod(bd.getInitMethodName(), null);
m.invoke(instance, null);
}
} //销毁
@Override
public void close() throws IOException {
// 执行单例实例的销毁方法
for (Entry<String, BeanDefinition> e : this.beanDefintionMap.entrySet()) {
String beanName = e.getKey();
BeanDefinition bd = e.getValue(); //获取bean定义中的销毁方法,如果存在销毁方法就通过反射去执行销毁方法
if (bd.isSingleton() && StringUtils.isNotBlank(bd.getDestroyMethodName())) {
Object instance = this.beanMap.get(beanName);
try {
Method m = instance.getClass().getMethod(bd.getDestroyMethodName(), null);
m.invoke(instance, null);
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e1) {
logger.error("执行bean[" + beanName + "] " + bd + " 的 销毁方法异常！", e1);
}
}
}
}
}

package com.study.spring.beans;import java.util.ArrayList;
import java.util.List;import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;/**
*
* @Description: 提前实例化单例bean
* @author leeSmall
* @date 2018年11月27日
*
*/
public class PreBuildBeanFactory extends DefaultBeanFactory { private final Log logger = LogFactory.getLog(getClass()); private List<String> beanNames = new ArrayList<>(); @Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionRegistException {
super.registerBeanDefinition(beanName, beanDefinition);
synchronized (beanNames) {
beanNames.add(beanName);
}
} public void preInstantiateSingletons() throws Exception {
synchronized (beanNames) {
for (String name : beanNames) {
BeanDefinition bd = this.getBeanDefinition(name);
if (bd.isSingleton()) {
this.doGetBean(name);
if (logger.isDebugEnabled()) {
logger.debug("preInstantiate: name=" + name + " " + bd);
}
}
}
}
}
}

package com.study.spring.samples;/**
*
* @Description: 需要创建的bean实例ABean
* @author leeSmall
* @date 2018年11月29日
*
*/
public class ABean { public void doSomthing() {
System.out.println(System.currentTimeMillis() + " " + this);
} public void init() {
System.out.println("ABean.init() 执行了");
} public void destroy() {
System.out.println("ABean.destroy() 执行了");
}
}

package com.study.spring.samples;/**
*
* @Description: 创建bean实例ABean的工厂ABeanFactory
* @author leeSmall
* @date 2018年11月29日
*
*/
public class ABeanFactory { //静态工厂方式
public static ABean getABean() {
return new ABean();
} //工厂bean的方式
public ABean getABean2() {
return new ABean();
}
}

package v1;import org.junit.AfterClass;
import org.junit.Test;import com.dn.spring.beans.BeanDefinition;
import com.dn.spring.beans.DefaultBeanFactory;
import com.dn.spring.beans.GenericBeanDefinition;
import com.dn.spring.samples.ABean;
import com.dn.spring.samples.ABeanFactory;/**
*
* @Description: 测试IOC容器（bean工厂）创建bean实例ABean
* @author leeSmall
* @date 2018年11月29日
*
*/
public class DefaultBeanFactoryTest { static DefaultBeanFactory bf = new DefaultBeanFactory(); //测试构造方法方式创建bean实例
@Test
public void testRegist() throws Exception { //创建bean定义
GenericBeanDefinition bd = new GenericBeanDefinition(); //设置bean的类名
bd.setBeanClass(ABean.class);
//设置是否单例
bd.setScope(BeanDefinition.SCOPE_SINGLETION);
// bd.setScope(BeanDefinition.SCOPE_PROTOTYPE); //设置bean的初始化方法
bd.setInitMethodName("init");
//设置bean的销毁方法
bd.setDestroyMethodName("destroy"); //把bean定义注册到bean工厂DefaultBeanFactory bf
bf.registerBeanDefinition("aBean", bd); } //静态工厂方法的方式创建bean实例
@Test
public void testRegistStaticFactoryMethod() throws Exception {
//创建bean定义
GenericBeanDefinition bd = new GenericBeanDefinition();
//设置工厂bean的名字
bd.setBeanClass(ABeanFactory.class);
//设置工厂方法名
bd.setFactoryMethodName("getABean");
//把bean定义注册到bean工厂DefaultBeanFactory bf
bf.registerBeanDefinition("staticAbean", bd);
} //工厂bean的方式创建bean实例
@Test
public void testRegistFactoryMethod() throws Exception {
//创建工厂bean定义
GenericBeanDefinition bd = new GenericBeanDefinition();
//设置工厂bean的名字
bd.setBeanClass(ABeanFactory.class);
String fbname = "factory";
//把工厂bean注册到bean工厂DefaultBeanFactory bf
bf.registerBeanDefinition(fbname, bd); //创建bean定义
bd = new GenericBeanDefinition();
//设置工厂bean的名字
bd.setFactoryBeanName(fbname);
//设置工厂bean的方法名
bd.setFactoryMethodName("getABean2");
//设置是否是单列
bd.setScope(BeanDefinition.SCOPE_PROTOTYPE); //把bean定义注册到bean工厂DefaultBeanFactory bf
bf.registerBeanDefinition("factoryAbean", bd);
} //获取bean实例并调用里面的方法
@AfterClass
public static void testGetBean() throws Exception {
System.out.println("构造方法方式------------");
for (int i = 0; i < 3; i++) {
ABean ab = (ABean) bf.getBean("aBean");
ab.doSomthing();
} System.out.println("静态工厂方法方式------------");
for (int i = 0; i < 3; i++) {
ABean ab = (ABean) bf.getBean("staticAbean");
ab.doSomthing();
} System.out.println("工厂方法方式------------");
for (int i = 0; i < 3; i++) {
ABean ab = (ABean) bf.getBean("factoryAbean");
ab.doSomthing();
} //销毁
bf.close();
}
}

构造方法方式------------
ABean.init() 执行了
1543478493599 com.dn.spring.samples.ABean@46fbb2c1
1543478493599 com.dn.spring.samples.ABean@46fbb2c1
1543478493599 com.dn.spring.samples.ABean@46fbb2c1
静态工厂方法方式------------
1543478493599 com.dn.spring.samples.ABean@5ef04b5
1543478493599 com.dn.spring.samples.ABean@5ef04b5
1543478493599 com.dn.spring.samples.ABean@5ef04b5
工厂方法方式------------
1543478493599 com.dn.spring.samples.ABean@5f4da5c3
1543478493600 com.dn.spring.samples.ABean@443b7951
1543478493600 com.dn.spring.samples.ABean@14514713
ABean.destroy() 执行了

public class Girl{
public Girl(String name,int age,char cup,Boy boyfriend){
} }

public class Girl{
public Girl(String name,int age,char cup,Boy boyfriend){
} }

Boy leeSmall = new Boy("leeSmall");
Girl girl = new Girl("小青"，18，'D',leeSmall);

package com.dn.spring.beans;
/**
* 用于依赖注入中描述bean依赖
*/
public class BeanReference {
private String beanName; public BeanReference(String beanName) {
super();
this.beanName = beanName;
} /**
* 获得引用的beanName
*/
public String getBeanName() {
return this.beanName;
}
}

List<?> getConstructorArgumentValues();

//构造参数存放属性
private List<?> constructorArgumentValues; //获得构造参数值
public List<?> getConstructorArgumentValues() {
return constructorArgumentValues;
} //设置构造参数值
public void setConstructorArgumentValues(List<?> constructorArgumentValues) {
this.constructorArgumentValues = constructorArgumentValues;
}

//把bean定义中的构造参数引用转为真实的值
private Object[] getConstructorArgumentValues(BeanDefinition bd) throws Exception { return this.getRealValues(bd.getConstructorArgumentValues()); } //把bean定义中的构造参数引用转为真实的值
private Object[] getRealValues(List<?> defs) throws Exception {
if (CollectionUtils.isEmpty(defs)) {
return null;
} Object[] values = new Object[defs.size()];
int i = 0;
Object v = null;
for (Object rv : defs) {
if (rv == null) {
v = null;
} else if (rv instanceof BeanReference) {
v = this.doGetBean(((BeanReference) rv).getBeanName());
} else if (rv instanceof Object[]) {
// TODO 处理集合中的bean引用
} else if (rv instanceof Collection) {
// TODO 处理集合中的bean引用
} else if (rv instanceof Properties) {
// TODO 处理properties中的bean引用
} else if (rv instanceof Map) {
// TODO 处理Map中的bean引用
} else {
v = rv;
} values[i++] = v;
} return values;
}

//获取所有构造方法
@CallerSensitive
public Constructor<?>[] getConstructors() throws SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
return copyConstructors(privateGetDeclaredConstructors(true));
}
//获取指定构造方法
@CallerSensitive
public Constructor<T> getConstructor(Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
return getConstructor0(parameterTypes, Member.PUBLIC);
}

//获取所有方法
@CallerSensitive
public Method[] getMethods() throws SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
return copyMethods(privateGetPublicMethods());
}
//获取指定方法
@CallerSensitive
public Method getMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
Method method = getMethod0(name, parameterTypes, true);
if (method == null) {
throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
}
return method;
}

/* 下面的四个方法是供beanFactory中使用的 */
//获取构造方法
public Constructor<?> getConstructor(); //缓存构造方法
public void setConstructor(Constructor<?> constructor); //获取工厂方法
public Method getFactoryMethod(); //缓存工厂方法
public void setFactoryMethod(Method factoryMethod);

/* 下面的四个方法是供beanFactory中使用的 */
//获取构造方法
public Constructor<?> getConstructor() {
return constructor;
} //缓存构造方法
public void setConstructor(Constructor<?> constructor) {
this.constructor = constructor;
} //获取工厂方法
public Method getFactoryMethod() {
return factoryMethod;
} //缓存工厂方法
public void setFactoryMethod(Method factoryMethod) {
this.factoryMethod = factoryMethod;
}

//查找构造方法的方法
private Constructor<?> determineConstructor(BeanDefinition bd, Object[] args) throws Exception { Constructor<?> ct = null; //如果参数为空,则返回无参的构造方法
if (args == null) {
return bd.getBeanClass().getConstructor(null);
} // 对于原型bean,从第二次开始获取bean实例时，可直接获得第一次缓存的构造方法。
ct = bd.getConstructor();
if (ct != null) {
return ct;
} // 先根据参数类型获取精确匹配的构造方法
Class<?>[] paramTypes = new Class[args.length];
int j = 0;
for (Object p : args) {
paramTypes[j++] = p.getClass();
}
try {
ct = bd.getBeanClass().getConstructor(paramTypes);
} catch (Exception e) {
// 这个异常不需要处理
} //如果根据参数类型进行精确批次查找没有找到构造方法,就获得所有的构造方法遍历，通过参数数量过滤，再比对形参类型与实参类型
if (ct == null) { // 没有精确参数类型匹配的，则遍历匹配所有的构造方法
// 判断逻辑：先判断参数数量，再依次比对形参类型与实参类型
outer: for (Constructor<?> ct0 : bd.getBeanClass().getConstructors()) {
Class<?>[] paramterTypes = ct0.getParameterTypes();
if (paramterTypes.length == args.length) {
for (int i = 0; i < paramterTypes.length; i++) {
//isAssignableFrom方法表示是否可以把args[i].getClass()赋值给paramterTypes[i]
if (!paramterTypes[i].isAssignableFrom(args[i].getClass())) {
continue outer;
}
} ct = ct0;
break outer;
}
}
} //如果找到构造方法了，并且是原型的就缓存起来
if (ct != null) {
// 对于原型bean,可以缓存找到的构造方法，方便下次构造实例对象。在BeanDefinfition中获取设置所用构造方法的方法。
// 同时在上面增加从beanDefinition中获取的逻辑。
if (bd.isPrototype()) {
bd.setConstructor(ct);
}
return ct;
} else {
throw new Exception("不存在对应的构造方法！" + bd);
}
}

// 构造方法来构造对象
private Object createInstanceByConstructor(BeanDefinition bd) throws Exception {
try {
//获取bean定义中的构造参数
Object[] args = this.getConstructorArgumentValues(bd);
//如果构造参数为空就使用无参构造函数
if (args == null) {
return bd.getBeanClass().newInstance();
}
//查找有参构造函数并返回
else {
// 决定构造方法
return this.determineConstructor(bd, args).newInstance(args);
}
} catch (SecurityException e1) {
logger.error("创建bean的实例异常,beanDefinition：" + bd, e1);
throw e1;
}
}

//查找工厂方法的方法
private Method determineFactoryMethod(BeanDefinition bd, Object[] args, Class<?> type) throws Exception {
if (type == null) {
type = bd.getBeanClass();
} //获取bean定义中国工厂方法的名字
String methodName = bd.getFactoryMethodName(); //如果参数为空就返回无参的方法
if (args == null) {
return type.getMethod(methodName, null);
} Method m = null;
// 对于原型bean,从第二次开始获取bean实例时，可直接获得第一次缓存的构造方法。
m = bd.getFactoryMethod();
if (m != null) {
return m;
} // 先根据参数类型获取精确匹配的方法
Class[] paramTypes = new Class[args.length];
int j = 0;
for (Object p : args) {
paramTypes[j++] = p.getClass();
}
try {
m = type.getMethod(methodName, paramTypes);
} catch (Exception e) {
// 这个异常不需要处理
} //如果根据参数类型进行精确批次查找没有找到工厂方法,就获得所有的构造方法遍历，通过参数数量过滤，再比对形参类型与实参类型
if (m == null) { // 没有精确参数类型匹配的，则遍历匹配所有的方法
// 判断逻辑：先判断参数数量，再依次比对形参类型与实参类型
outer: for (Method m0 : type.getMethods()) {
if (!m0.getName().equals(methodName)) {
continue;
}
Class<?>[] paramterTypes = m.getParameterTypes();
if (paramterTypes.length == args.length) {
for (int i = 0; i < paramterTypes.length; i++) {
//isAssignableFrom方法表示是否可以把args[i].getClass()赋值给paramterTypes[i]
if (!paramterTypes[i].isAssignableFrom(args[i].getClass())) {
continue outer;
}
} m = m0;
break outer;
}
}
} //如果找到构造方法了，并且是原型的就缓存起来
if (m != null) {
// 对于原型bean,可以缓存找到的方法，方便下次构造实例对象。在BeanDefinfition中获取设置所用方法的方法。
// 同时在上面增加从beanDefinition中获取的逻辑。
if (bd.isPrototype()) {
bd.setFactoryMethod(m);
}
return m;
} else {
throw new Exception("不存在对应的构造方法！" + bd);
}
}

// 静态工厂方法
private Object createInstanceByStaticFactoryMethod(BeanDefinition bd) throws Exception { Class<?> type = bd.getBeanClass();
Object[] realArgs = this.getRealValues(bd.getConstructorArgumentValues());
Method m = this.determineFactoryMethod(bd, realArgs, null);
return m.invoke(type, realArgs);
} // 工厂bean方式来构造对象
private Object createInstanceByFactoryBean(BeanDefinition bd) throws Exception { Object factoryBean = this.doGetBean(bd.getFactoryBeanName());
Object[] realArgs = this.getRealValues(bd.getConstructorArgumentValues());
Method m = this.determineFactoryMethod(bd, realArgs, factoryBean.getClass()); return m.invoke(factoryBean, realArgs);
}

package v2;import java.util.ArrayList;
import java.util.List;import org.junit.Test;import com.dn.spring.beans.BeanReference;
import com.dn.spring.beans.GenericBeanDefinition;
import com.dn.spring.beans.PreBuildBeanFactory;
import com.dn.spring.samples.ABean;
import com.dn.spring.samples.ABeanFactory;
import com.dn.spring.samples.CBean;
import com.dn.spring.samples.CCBean;/**
*
* @Description: 参数依赖注入测试
* @author leeSmall
* @date 2018年12月1日
*
*/
public class DItest {
static PreBuildBeanFactory bf = new PreBuildBeanFactory(); //构造函数参数依赖注入
@Test
public void testConstructorDI() throws Exception { GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(ABean.class);
List<Object> args = new ArrayList<>();
args.add("abean01");
args.add(new BeanReference("cbean"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("abean", bd); bd = new GenericBeanDefinition();
bd.setBeanClass(CBean.class);
args = new ArrayList<>();
args.add("cbean01");
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("cbean", bd); bf.preInstantiateSingletons(); ABean abean = (ABean) bf.getBean("abean"); abean.doSomthing();
} //静态工厂方法参数依赖注入
@Test
public void testStaticFactoryMethodDI() throws Exception { GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(ABeanFactory.class);
bd.setFactoryMethodName("getABean");
List<Object> args = new ArrayList<>();
args.add("abean02");
args.add(new BeanReference("cbean02"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("abean02", bd); bd = new GenericBeanDefinition();
bd.setBeanClass(CBean.class);
args = new ArrayList<>();
args.add("cbean02");
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("cbean02", bd); bf.preInstantiateSingletons(); ABean abean = (ABean) bf.getBean("abean02"); abean.doSomthing();
} //普通工厂方法的参数依赖注入
@Test
public void testFactoryMethodDI() throws Exception { GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setFactoryBeanName("abeanFactory");
bd.setFactoryMethodName("getABean2");
List<Object> args = new ArrayList<>();
args.add("abean03");
args.add(new BeanReference("cbean02"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("abean03", bd); bd = new GenericBeanDefinition();
bd.setBeanClass(ABeanFactory.class);
bf.registerBeanDefinition("abeanFactory", bd); bf.preInstantiateSingletons(); ABean abean = (ABean) bf.getBean("abean03"); abean.doSomthing();
}}

调用了含有CBean参数的构造方法
1543644406604 abean01 cb.name=cbean01调用了含有CBean参数的构造方法
1543644406607 abean02 cb.name=cbean02调用了含有CBean参数的构造方法
1543644406608 abean03 cb.name=cbean02

//记录正在构造的bean
private ThreadLocal<Set<String>> buildingBeans = new ThreadLocal<>(); // 记录正在创建的Bean
Set<String> ingBeans = this.buildingBeans.get();
if (ingBeans == null) {
ingBeans = new HashSet<>();
this.buildingBeans.set(ingBeans);
} // 检测循环依赖 因为如果已bean正在构造，这时发现有其他的bean依赖它，此时它又没有创建好久需要抛异常了
if (ingBeans.contains(beanName)) {
throw new Exception(beanName + " 循环依赖！" + ingBeans);
} // 记录正在创建的Bean
ingBeans.add(beanName);
.....................
......................
// 创建好实例后，移除创建中记录
ingBeans.remove(beanName);

package v2;import java.util.ArrayList;
import java.util.List;import org.junit.Test;import com.dn.spring.beans.BeanReference;
import com.dn.spring.beans.GenericBeanDefinition;
import com.dn.spring.beans.PreBuildBeanFactory;
import com.dn.spring.samples.DBean;
import com.dn.spring.samples.EBean;/**
*
* @Description: 循环依赖测试
* @author leeSmall
* @date 2018年12月1日
*
*/
public class CirculationDiTest { static PreBuildBeanFactory bf = new PreBuildBeanFactory(); //DBean依赖EBean,EBean又依赖DBean 抛异常
@Test
public void testCirculationDI() throws Exception {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(DBean.class);
List<Object> args = new ArrayList<>();
args.add(new BeanReference("ebean"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("dbean", bd); bd = new GenericBeanDefinition();
bd.setBeanClass(EBean.class);
args = new ArrayList<>();
args.add(new BeanReference("dbean"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("ebean", bd); bf.preInstantiateSingletons();
}
}

package com.study.spring.beans;/**
*
* @Description: 属性值依赖实体
* @author leeSmall
* @date 2018年12月1日
*
*/
public class PropertyValue { private String name; private Object value; public PropertyValue(String name, Object value) {
super();
this.name = name;
this.value = value;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Object getValue() {
return value;
} public void setValue(Object value) {
this.value = value;
}}

/**
* 获得属性依赖定义的方法
*
*/
List<PropertyValue> getPropertyValues();

//存放属性依赖
private List<PropertyValue> propertyValues; //获取属性依赖
public List<PropertyValue> getPropertyValues() {
return propertyValues;
} //设置属性依赖
public void setPropertyValues(List<PropertyValue> propertyValues) {
this.propertyValues = propertyValues;
}

//属性依赖实现
private void setPropertyDIValues(BeanDefinition bd, Object instance) throws Exception {
//bean定义中没有属性依赖就直接返回
if (CollectionUtils.isEmpty(bd.getPropertyValues())) {
return;
}
//如果bean定义中有属性依赖就设置值,设置方式和构造参数的设置一样
for (PropertyValue pv : bd.getPropertyValues()) {
//属性依赖没有给名字就直接跳过
if (StringUtils.isBlank(pv.getName())) {
continue;
}
//获取类对象
Class<?> clazz = instance.getClass();
//通过属性名获取类对象里面声明的字段
Field p = clazz.getDeclaredField(pv.getName()); //设置字段可访问
p.setAccessible(true); //把属性值转化为真正的值,和构造参数一样
Object rv = pv.getValue();
Object v = null;
if (rv == null) {
v = null;
} else if (rv instanceof BeanReference) {
v = this.doGetBean(((BeanReference) rv).getBeanName());
} else if (rv instanceof Object[]) {
// TODO 处理集合中的bean引用
} else if (rv instanceof Collection) {
// TODO 处理集合中的bean引用
} else if (rv instanceof Properties) {
// TODO 处理properties中的bean引用
} else if (rv instanceof Map) {
// TODO 处理Map中的bean引用
} else {
v = rv;
} //把真正的值v设置到属性p里面 即属性p依赖的值v
p.set(instance, v); }
}

// 给入属性依赖
this.setPropertyDIValues(bd, instance);

package v2;import java.util.ArrayList;
import java.util.List;import org.junit.Test;import com.dn.spring.beans.BeanReference;
import com.dn.spring.beans.GenericBeanDefinition;
import com.dn.spring.beans.PreBuildBeanFactory;
import com.dn.spring.beans.PropertyValue;
import com.dn.spring.samples.ABean;
import com.dn.spring.samples.CBean;
import com.dn.spring.samples.FBean;/**
*
* @Description: 属性依赖测试
* @author leeSmall
* @date 2018年12月1日
*
*/
public class PropertyDItest {
static PreBuildBeanFactory bf = new PreBuildBeanFactory(); @Test
public void testPropertyDI() throws Exception { //构造参数依赖
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(ABean.class);
List<Object> args = new ArrayList<>();
args.add("abean01");
args.add(new BeanReference("cbean"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("abean", bd); //构造参数依赖
bd = new GenericBeanDefinition();
bd.setBeanClass(CBean.class);
args = new ArrayList<>();
args.add("cbean01");
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("cbean", bd); //属性依赖
bd = new GenericBeanDefinition();
bd.setBeanClass(FBean.class);
List<PropertyValue> propertyValues = new ArrayList<>();
propertyValues.add(new PropertyValue("name", "FFBean01"));
propertyValues.add(new PropertyValue("age", 18));
propertyValues.add(new PropertyValue("aBean", new BeanReference("abean")));
bd.setPropertyValues(propertyValues);
bf.registerBeanDefinition("fbean", bd); bf.preInstantiateSingletons(); FBean fbean = (FBean) bf.getBean("fbean");
System.out.println("设置的属性依赖值: " + fbean.getName() + " " + fbean.getAge());
fbean.getaBean().doSomthing();
}}

调用了含有CBean参数的构造方法
设置的属性依赖值: FFBean01 18
1543649718902 abean01 cb.name=cbean01