一、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
     
       beanDefintionMap = new ConcurrentHashMap<>(256);    //用Map来存放创建的bean实例,注意这里只是存放单例bean,多实例每次都要创建新的,不需要存放    private Map
      
        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
       
         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
     
       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@46fbb2c11543478493599 com.dn.spring.samples.ABean@46fbb2c11543478493599 com.dn.spring.samples.ABean@46fbb2c1静态工厂方法方式------------1543478493599 com.dn.spring.samples.ABean@5ef04b51543478493599 com.dn.spring.samples.ABean@5ef04b51543478493599 com.dn.spring.samples.ABean@5ef04b5工厂方法方式------------1543478493599 com.dn.spring.samples.ABean@5f4da5c31543478493600 com.dn.spring.samples.ABean@443b79511543478493600 com.dn.spring.samples.ABean@14514713ABean.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
     
       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

输出结果：

调用了含有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
     
      
       > buildingBeans = new ThreadLocal<>();        // 记录正在创建的Bean        Set
       
         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

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

 2.3 在GenericBeanDefinition增加对应的实现

//存放属性依赖    private List
     
       propertyValues;    //获取属性依赖    public List
      
        getPropertyValues() {        return propertyValues;    }    //设置属性依赖    public void setPropertyValues(List
       
         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

输出结果：

调用了含有CBean参数的构造方法设置的属性依赖值: FFBean01 181543649718902 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