一、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