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

一、IOC分析

1. IOC是什么？

IOC：Inversion of Control控制反转，也称依赖倒置（反转）

问题：如何理解控制反转？

反转：依赖对象的获得被反转了。由自己创建，反转为从IOC容器中获取（和自动注入）

2. IOC容器带来什么好处？

　　1）代码更简洁，不需要去new需要使用的对象了。

　　2）面向接口编程，使用者与具体类解耦，易扩展、替换实现者。

　　3）可以方便进行AOP增强。进行AOP的前提是有IOC

3. IOC容器做什么工作？

　　IOC容器的工作：负责创建、管理类实例，向使用者提供实例。

4. IOC容器是否是工厂模式的实例？

　　是的。IOC容器负责来创建类实例对象，使用者需要实例就从IOC容器中get。也称IOC容器为bean工厂。

二、IOC设计实现

1. IOC容器的工作

创建、管理bean。它是一个工厂，负责对外提供bean实例。

问：bean是什么？

　　bean是组件，就是类对象！

1）IOC容器应该具备什么行为（对外接口）？

　　对外提供bean实例，getBean()方法

2） 这个getBean()方法是否需要参数？需要几个参数、什么类型的参数？

　　简单工厂模式中，当工厂能创建很多类产品时，如要创建某类产品，需要告诉工厂。

3）这个getBean()方法的返回值应是什么类型？

　　各种类型的bean，那就只能是Object了。

经过上面的问题Bean工厂的接口就可以定义出来了！！！

2. Bean工厂接口：

Bean工厂代码：

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;
}

Bean工厂怎么知道该如何创建bean？

如何告诉Bean工厂？

　　就是一个定义注册，我们可以给它定义一个bean定义注册接口

3. Bean定义注册接口

Bean定义注册接口代码：

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);
 
}

4. Bean定义

问题1：bean定义的用途是什么？

告诉Bean工厂该如何创建某类bean

问题2：获得类的实例的方式有哪些？

 new 构造方法

Person p = new Person();

工厂方法

静态的

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

成员方法

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

问题3：Bean工厂帮我们创建bean时，它需要获知哪些信息？

1）new 构造方法的方式创建bean时，Bean工厂需要知道要创建的类的类名

2）静态工厂方法的方式创建bean时，Bean工厂需要知道工厂类名、工厂方法名

3）成员工厂方法的方式创建bean时，Bean工厂需要知道工厂类名（工厂bean名）、工厂方法名

　　因为需要获取工厂类对象去调用工厂方法名创建bean，所以直接给工厂bean名先创建工厂bean对象

问题4：每次从Bean工厂获取bean实例时，是否都需要创建一个新的？

　　否，有的只需要单实例

问题5：Bean定义是给Bean工厂创建bean用的，那么Bean定义接口应向Bean工厂提供哪些方法？

new 构造方法的方式创建bean时，需要告诉bean工厂怎么获取类的名称——获取bean的类名：getBeanClass (): Class

静态工厂方法的方式创建bean时，需要告诉bean工厂怎么获取工厂方法名：getFactoryMethodName() : String

成员工厂方法的方式创建bean时，需要告诉bean工厂怎么获取工厂bean名：getFactoryBeanName() : String

是否是单例等方法：getScope() : Sting、isSingleton()、isPrototype()

问题6：类对象交给IOC容器来管理，类对象的生命周期中还可能有什么生命阶段事情要做吗？

比如创建对象后可能需要进行一些初始化

还有一些对象在销毁时可能要进行一些特定的销毁逻辑（如释放资源）

那就在Bean定义中提供让用户可指定初始化、销毁方法。

对Bean工厂就需提供getInitMethodName()、getDestroyMethodName()

5. Bean定义接口

bean定义接口BeanDefinition代码：

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;
    }
 
}

实现bean定义接口BeanDefinition实现一个通用的bean定义GenericBeanDefinition

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;
    }
 
}

我们继续看下面的图：

 说明：bean定义BeanDefinition通过bean定义注册接口BeanDefinitionRegistry注册到Bean工厂BeanFactory，Bean工厂BeanFactory负责创建bean

6. BeanFactory实现

实现一个最基础的默认bean工厂：DefaultBeanFactory

说明：

6.1 实现bean定义信息注册接口

问题1：bean定义信息如何存放？

　　Map

问题2：bean定义是否可以重名？重名怎么办？

　　重名抛异常

6.2 实现bean工厂

问题1：创建的bean用什么存放，方便下次获取？

　　Map，因为getBean是通过名字来取的，放在Map中更好

问题2：在getBean方法中要做哪些事？

　　创建bean实例，进行初始化

6.3 Bean工厂实现代码：

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);
                }
            }
        }
    }
}

 6.4 扩展DefaultBeanFactory

对于单例bean，我们可以提前实例化，这样做的好处是不用在需要的时候再取获取了，可以保证线程安全，提高性能

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);
                    }
                }
            }
        }
    }
}

6.5 测试IOC容器（bean工厂）创建bean实例

需要创建的bean实例ABean

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() 执行了");
    }
}

创建bean实例ABean的工厂ABeanFactory

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();
    }
}

测试IOC容器（bean工厂）创建bean实例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() 执行了

三、DI分析

DI（Dependency Injection）依赖注入分析

问题1：哪些地方会有依赖？

　　构造参数依赖

　　属性依赖

问题2：依赖注入的本质是什么？

　　赋值，给入构造参数值，给属性赋值

问题3：参数值、属性值可能是什么值？

　　直接值、bean依赖

举例：

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

name，age，cup都是直接值，boyfriend是bean依赖

问题4：直接值会有哪几种情况？

　　基本数据类型、String

　　数组、集合

　　Properties

　　Map

本质：参数值、属性值都是值。bean工厂在进行依赖注入时，就是给入值。

四、DI实现

1. 构造参数依赖

 1.1 构造参数依赖定义分析

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

问题1：我们要创建一个Girl是如何创建的？

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

直接把值传入构造函数即可

问题2：我们可不可以这样来定义构造参数依赖？

　　第一个参数值是："小青"

　　第二个参数值是：18

　　第三个参数值是：'D'

　　第四个参数值是：依赖一个Boy Bean

完全可以！

构造参数依赖设计

问题1：参数可以有多个，用什么存储？

　　集合：List

问题2：参数有顺序，如何体现顺序？

　　按参数顺序放入List

问题3：参数可以值直接值，也可以是bean依赖，如何表示？

　　因为可以有多种值，那就只能用Object

　　List<Object>  constructorArgumentValues

问题4：如果用Object来表示值，如何区分是Bean依赖？

　　为Bean依赖定义一种数据类型BeanReference，bean工厂在构造Bean实例时，遍历判断参数是否是BeanReference，如果是则替换为依赖的bean实例。

问题5：如果直接值是数组、集合等，它们的元素中有的是bean依赖，怎么处理？

　　元素值还是用BeanReference，同样bean工厂在使用时需遍历替换。

1.2 BeanReference

BeanReference就是用来说明bean依赖的：依赖哪个Bean

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;
    }
}

1.3 在BeanDefinition中增加获得构造参数值的方法

List<?> getConstructorArgumentValues();

在GenericBeanDefinition中增加对应的实现

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

构造参数依赖有了，下面就可以来实现构造参数依赖注入了！

1.4 BeanFactory中实现构造参数依赖注入

1.4.1 首先需要把bean定义中的构造参数引用转为真实的值，在DefaultBeanFactory中增加一个方法来干这事。

代码实现：

    //把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;
    }

问题：有参数了，如何断定是哪个构造方法、哪个工厂方法？需要考虑下面的情况

a）方法是可以重载的

b）形参定义时可能是接口或者父类，实参则是具体的子实现

c）可以通过反射获取提供的构造方法、方法，如下：

java.lang.Class

反射获取构造方法：

   //获取所有构造方法
   @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;
    }

判断逻辑：

a）先根据参数的类型进行精确匹配查找，如未找到，则进行第二步查找；

b）获得所有的构造方法遍历，通过参数数量过滤，再比对形参类型与实参类型

1.4.2 当我们判断出构造方法或者工厂方法后，对于原型Bean，下次获取是否就可以省去判断了？

也就是说，对于原型Bean，我们可以缓存下这个构造方法或工厂方法。如何实现？

在BeanDefinition中增加缓存的方法:

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

在GenericBeanDefinition中增加对应的实现：

    /* 下面的四个方法是供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;
    }

1.4.3 接下来可以写查找构造方法或查找工厂方法的代码了

1）在DefaultBeanFactory中增加查找构造方法的方法

    //查找构造方法的方法
    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);
        }
    }

2）修改DefaultBeanFactory中用构造方法创建实例的代码调用determineConstructor

    // 构造方法来构造对象
    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;
        }
    }

3）按照增加查找构造方法的方式修改静态工厂方法、工厂方法方式的参数依赖

增加查找工厂方法的方法

    //查找工厂方法的方法
    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);
        }
    }

修改DefaultBeanFactory中用工厂方法创建实例的代码调用determineFactoryMethod

    // 静态工厂方法
    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);
    }

1.4.4 测试

参数依赖注入测试

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

1.4.5 循环依赖如何处理

问题：构造对象时可以循环依赖吗/

构造实例对象时的循环依赖，会陷入僵死局面，是不允许构造实例时的循环依赖的。那么怎么发现循环依赖呢?

发现循环依赖的方法：加入一个正在构造的bean的记录，每个bean开始构造时加入该记录中，构造完成后从记录中移除。如果有依赖，先看依赖的bean是否在构造中，如是就构成了循环依赖，抛出异常

代码实现：

在DefaultBeanFactory增加如下代码：

        //记录正在构造的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();
    }
}

2. 属性依赖

问题1：属性依赖是什么？

　　某个属性依赖某个值，需要外部给入这个值

问题2：该如何来描述一个属性依赖？

　　属性名、值，定义一个来来表示这两个值

问题3：会有多个属性依赖，怎么存放？

　　List存放

问题4：属性值得情况和构造参数值得情况一样吗？

　　一样

2.1 定义属性依赖实体

属性依赖实体类类图如下：

属性依赖实体类代码：

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;
    }
 
}

2.2 在BeanDefinition接口中增加获得属性依赖定义的方法

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

2.3 在GenericBeanDefinition增加对应的实现

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

2.4 在DefaultBeanFactory中实现属性依赖

    //属性依赖实现
    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);
 
        }
    }

在doGetBean(String beanName)中增加对设置属性依赖的调用

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

注意：属性依赖是允许循环依赖的，因为是在实例创建好之后才设置属性依赖的值的！！！

2.5 属性依赖测试

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

完整代码获取地址：

Spring IOC分析和手写实现Spring IOC代码：https://github.com/leeSmall/FrameSourceCodeStudy/tree/master/spring-v1

Spring DI分析和手写实现Spring DI代码：https://github.com/leeSmall/FrameSourceCodeStudy/tree/master/spring-v2