我自横刀向天笑，手写Spring IOC容器，快来Look Look！

目录

• IOC分析
  • IOC是什么
  • IOC能够带来什么好处
  • IOC容器是做什么工作的
  • IOC容器是否是工厂模式的实例
• IOC设计实现
  • 设计IOC需要什么
  • 定义接口
    • 一：Bean工厂接口
    • 二：Bean定义的注册接口
    • 三：Bean定义接口
  • 实现接口
    • 一：Bean定义的实现GenericBeanDefinition
    • 二：Bean工厂的实现DefaultBeanFactory
  • 测试一下

相信很多朋友对Spring已经很熟悉了，面试中也经常会被问到Spring里面相关的知识，比如IOC、DI、AOP等，下面通过手写IOC的方式来对IOC里面相关的内容，进行熟悉和理解

---

IOC分析

IOC是什么

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

如何理解这个控制反转呢？

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

也就是说，你不要来找我了，我去找你，传统的方式呢，是我在对象内部来去控制另外的对象，有了IOC，IOC是一个专门的容器，来创建和管理这些对象

比如，我们平时找女朋友或者男朋友，就会想方设法的去打听他们的联系方式啊，爱好啊等等，这些东西啊都是需要我们自己去做的。IOC呢就好比婚介所啊，聊天交友群啊之类的，然后我们可以向他们提出我们的要求，身高体重，长相身材啊等等，这些介绍的中间人就会按照我们的要求去提供一个对象，然后我们和提供的这个对象谈恋爱就行了

IOC能够带来什么好处

通过上述的简单描述可以知道，IOC有下面这些好处：

1. 代码更加简洁，不需要自己去new使用的对象了，也做到了解耦
2. 面向接口编程，使用者和具体者之间解耦，容易扩展和替换实现者
3. 可以方便的进行AOP的增强

IOC容器是做什么工作的

IOC主要的工作就是创建、管理这些类的实例，然后可以向使用者提供这些实例

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

是的，IOC负责来创建类的实例对象，需要的话就从IOC容器中get，那么也可以称IOC容器为Bean工厂，生产的就是Bean实例

---

IOC设计实现

设计IOC需要什么

通过上面短短的信息，可以知道IOC容器既然是一个Bean工厂，那么是不是需要一个Bean工厂的接口，负责创建和获取这些bean呢？

又怎么知道用户提供的bean是什么样的呢？是不是还需要一个接口来去定义这些Bean？

Bean工厂和Bean的定义接口都有了，那么Bean工厂又怎么知道该如何创建Bean，是不是需要把Bean定义的信息告诉Bean工厂啊，那么可以定义一个注册接口，来作为Bean工厂和Bean定义之间沟通的桥梁

总结，设计IOC需要下面三个元素：

1. Bean工厂接口

2. Bean定义接口

3. Bean定义的注册接口

定义接口

一：Bean工厂接口

主要用来创建和获取Bean实例

/**
 * @ClassName BeanFactory
 * @Description: Bean工厂接口，负责创建和获取Bean
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public interface BeanFactory {

    /** 获取bean */
    Object getBean(String beanName) throws Exception;
}

二：Bean定义的注册接口

Bean定义的注册接口中需要哪些方法呢？

是不是需要能够注册和获取Bean定义的信息，那么注册的这些Bean定义信息还需要去区分它，那是不是给每个Bean定义，让它有一个唯一的名字就行了啊

/**
 * @ClassName BeanDefinitionRegistry
 * @Description: Bean定义的注册接口，作为Bean定义和Bean工厂之间的桥梁
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public interface BeanDefinitionRegistry {

    /** 注册Bean定义信息，beanName用来区分注册的Bean定义 */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
                        throws BeanDefinitionRegisterException;

    /** 获取Bean信息 */
    BeanDefinition getBeanDefinition(String beanName);

    /** 是否已经注册过了Bean定义 */
    boolean containsBeanDefinition(String beanName);
}

自定义的异常类：

/**
 * @ClassName BeanDefinitionRegisterException
 * @Description: 自定义异常类
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public class BeanDefinitionRegisterException extends Exception {

    public BeanDefinitionRegisterException(String message) {
        super(message);
    }

    public BeanDefinitionRegisterException(String message, Throwable cause) {
        super(message, cause);
    }
}

三：Bean定义接口

Bean定义它的用途是啥呢？就是告诉Bean工厂该如何去创建某个类的Bean

获取类的实例有下面几种方式：

1. new 构造方法

User user = new User()

2. 工厂方法：静态工厂

public class UserFactory {
   public static User getUser() {
      return new User();
   }
}

3. 工厂方法：成员方法

public class UserFactory {
   public User getUser() {
      return new User();
   }
}

Bean工厂帮助我们创建Bean的时候需要知道哪些信息呢？

5. 通过new构造方法的话，需要知道类名

6. 通过静态工厂方法，需要知道工厂类名、工厂方法名

7. 通过成员工厂方法，需要知道工厂bean名、工厂方法名

那么每次从Bean工厂获取bean的实例时，是不是都需要创建一个新的bean呢？肯定不是啊，有的只需要单例的就行

Bean定义信息是需要告诉Bean工厂如何创建Bean的，那么Bean定义需要向Bean工厂提供一些方法：

1. 获取Bean的类名：getBeanClass():Class
2. 获取工厂方法名：getFactoryMethodName():String
3. 获取工厂Bean名：getFactoryBeanName():String
4. 是不是单例，作用范围等：getScope():String、isSingleton()、isPrototype()

提供上述的几种方法是不是就足够了呢？类对象的生命周期还会有什么呢？

1. 创建对象后是不是还需要一些初始化：getInitMethodName():String
2. 比如有些对象在销毁时还需要进行一些特定的销毁逻辑（如释放资源）：getDestroyMethodName():String

那么提供上面的初始化方法和销毁方法，供用户使用，对Bean工厂呢，就是要获取这些初始化和销毁的方法

/**
 * @ClassName Beandefinition
 * @Description: Bean定义接口
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public interface BeanDefinition {

    /** 单例 */
    String SCOPE_SINGLETON = "singleton";

    /** 多例 */
    String SCOPE_PROTOTYPE = "prototype";

    /** 通过构造方法获取Bean */
    Class<?> getBeanClass();

    /** 设置beanClass */
    void setBeanClass(Class<?> beanClass);

    /** 通过静态工厂获取Bean */
    String getFactoryMethodName();

    /** 设置工厂方法名称 */
    void setFactoryMethodName(String factoryMethodName);

    /** 通过成员工厂获取Bean */
    String getFactoryBeanName();

    /** 设置工厂Bean名称 */
    void setFactoryBeanName(String factoryBeanName);

    /** 获取范围 */
    String getScope();

    /** 设置范围 */
    void setScope(String scope);

    /** 是不是单例的 */
    boolean isSingleton();

    /** 是不是多例的 */
    boolean isPrototype();

    /** 获取初始化方法 */
    String getInitMethodName();

    /** 设置初始化方法 */
    void setInitMethodName(String initMethodName);

    /** 获取销毁方法 */
    String getDestroyMethodName();

    /** 设置销毁方法 */
    void setDestroyMethodName(String destroyMethodName);

    /**
     * 验证方法：
     * 用来在注册Bean定义的时候验证是否可以注册
     */
    default boolean validate() {
        //没有定义BeanClass，或者没有指定工厂方法或工厂bean，则不合法，
        //这就是在玩我啊，啥都没有就像要个对象
        if (getBeanClass() == null) {
            if (StringUtils.isBlank(this.getFactoryMethodName())
                    || StringUtils.isBlank(this.getFactoryBeanName())) {
                return false;
            }
        }
        //定义了类，又定义了工厂bean，则不合法，不知道使用哪一个
        if (getBeanClass() != null && StringUtils.isNoneBlank(this.getFactoryBeanName())) {
            return false;
        }
        return true;
    };
}

实现接口

接口有了，接下来是不是要去实现它们了，要去做点有意思的事情了呢？

首先呢。来实现一个通用的Bean定义的GenericBeanDefinition类

一：Bean定义的实现GenericBeanDefinition

Bean定义的实现类，相对来说比较简单，主要做的事情就是获取和设置Bean定义信息

/**
 * @ClassName GenericBeanDefinition
 * @Description: Bean定义的实现类
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public class GenericBeanDefinition implements BeanDefinition {

    private Class<?> beanClass;

    private String factoryMethodName;

    private String factoryBeanName;

    private String initMethodName;

    private String destroyMethodName;

    private String scope = BeanDefinition.SCOPE_SINGLETON;

    @Override
    public Class<?> getBeanClass() {
        return beanClass;
    }

    @Override
    public void setBeanClass(Class<?> beanClass) {
        this.beanClass = beanClass;
    }

    @Override
    public String getFactoryMethodName() {
        return factoryMethodName;
    }

    @Override
    public void setFactoryMethodName(String factoryMethodName) {
        this.factoryMethodName = factoryMethodName;
    }

    @Override
    public String getFactoryBeanName() {
        return factoryBeanName;
    }

    @Override
    public void setFactoryBeanName(String factoryBeanName) {
        this.factoryBeanName = factoryBeanName;
    }

    @Override
    public String getScope() {
        return scope;
    }

    @Override
    public void setScope(String scope) {
        this.scope = scope;
    }

    @Override
    public boolean isSingleton() {
        return scope.equals(BeanDefinition.SCOPE_SINGLETON);
    }

    @Override
    public boolean isPrototype() {
        return scope.equals(BeanDefinition.SCOPE_PROTOTYPE);
    }

    @Override
    public String getInitMethodName() {
        return initMethodName;
    }

    @Override
    public void setInitMethodName(String initMethodName) {
        this.initMethodName = initMethodName;
    }

    @Override
    public String getDestroyMethodName() {
        return destroyMethodName;
    }

    @Override
    public void setDestroyMethodName(String destroyMethodName) {
        this.destroyMethodName = destroyMethodName;
    }

    @Override
    public String toString() {
        return "GenericBeanDefinition{" +
                "beanClass=" + beanClass +
                ", factoryMethodName='" + factoryMethodName + '\'' +
                ", factoryBeanName='" + factoryBeanName + '\'' +
                ", initMethodName='" + initMethodName + '\'' +
                ", destroyMethodName='" + destroyMethodName + '\'' +
                ", scope='" + scope + '\'' +
                '}';
    }
}

二：Bean工厂的实现DefaultBeanFactory

接下来需要实现Bean工厂，让它可以初步的工作起来

首先思考一下，创建的bean定义信息是不是需要存起来啊，那么定义一个Map来缓存Bean定义的信息

    /** Bean定义缓存 */
    private Map<String, BeanDefinition> beanDefinitionMap
                             = new ConcurrentHashMap<>();

创建好的Bean也需要存放起来，方便下一次获取

    /** Bean缓存 */
    private Map<String, Object> beanMap = new ConcurrentHashMap<>();

在getBean中需要做一些事情，创建Bean实例，然后可以初始化

   public class DefaultBeanFactory
         implements BeanFactory, BeanDefinitionRegistry {
        @Override
        public Object getBean(String beanName) throws Exception {
            return doGetBean(beanName);
        }
   }

接下来实现doGetBean方法：

通过上面的叙述，可以知道创建一个Bean实例有三种方法：通过构造方法、通过静态工厂、通过成员工厂方法，代码如下：

 private Object doGetBean(String beanName) throws Exception {

        //先去缓存里面判断一下，对应的beanName的对象是不是已经创建好了
        Object bean = beanMap.get(beanName);
        if (bean != null) {
            return bean;
        }

        BeanDefinition bd = beanDefinitionMap.get(beanName);
        Objects.requireNonNull(bd, "招不到【"+beanName+"】的Bean定义信息");
        Class<?> beanClass = bd.getBeanClass();
        if (beanClass != null) {
            //通过构造方法构建对象
            if (StringUtils.isBlank(bd.getFactoryMethodName())) {
                bean = createBeanByConstructor(bd);
            } else { //通过静态工厂构建对象
                bean = createBeanByStaticFactory(bd);
            }
        } else { //通过成员工厂构建对象
            bean = createBeanByFactoryBean(bd);
        }

        //开始bean的生命周期
        if (StringUtils.isNotBlank(bd.getInitMethodName())) {
            doInitMethod(bean, bd);
        }

        //对单例bean的处理
        if (bd.isSingleton()) {
            beanMap.put(beanName, bean);
        }

        return bean;
    }

代码逻辑：首先去beanMap里面拿Bean，如果已经存在了就直接返回了；然后根据beanName获取bean定义信息，后面加了一个根据beanName如果获取不到bean定义的非空判断；然后就是获取beanClass，如果说beanClass不等于空，工厂方法名字为空，那么可以知道这个是根据构造方法来创建Bean的；如果工厂方法非空，即是根据静态工厂创建Bean；如果beanClass是空的，那么可以断定是根据成员方法来创建Bean的

1. 通过构造方法创建Bean

首先肯定是要获取到类名，然后根据newInstance实例化Bean，最后返回就可以了

    /** 通过构造方法构建对象 */
    private Object createBeanByConstructor(BeanDefinition bd) throws Exception {
        //获取类名
        Class<?> type = bd.getBeanClass();
        //实例化bean
        Object bean = type.newInstance();
        return bean;
    }

2. 通过静态工厂创建Bean

静态工厂创建Bean，是根据类.方法名来创建的，首先也是获取到类名，然后就是获取工厂方法名，根据getMethod获取到方法，然后调用方法进行实例化

    /** 通过静态工厂构建对象 */
    private Object createBeanByStaticFactory(BeanDefinition bd) throws Exception {
        //获取工厂类名
        Class<?> type = bd.getBeanClass();
        //获取工厂方法名称
        String factoryMethodName = bd.getFactoryMethodName();
        Method method = type.getMethod(factoryMethodName, null);
        Object object = method.invoke(type, null);
        return object;
    }

3. 通过成员工厂创建Bean

成员工厂创建Bean，首先要获取到的就是工厂Bean，然后再获取工厂方法，最后根据getMethod获取到方法，然后调用方法进行实例化

    /** 通过成员工厂构建对象 */
    private Object createBeanByFactoryBean(BeanDefinition bd) throws Exception {
        //获取工厂bean名称
        String factoryBeanName = bd.getFactoryBeanName();
        //获取工厂bean
        Object factoryBean = getBean(factoryBeanName);
        //获取工厂方法
        String factoryMethodName = bd.getFactoryMethodName();
        Method method = factoryBean.getClass().getMethod(factoryMethodName, null);
        Object object = method.invoke(factoryBean, null);
        return object;
    }

下面是Bean注册接口的实现：

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException {
        Objects.requireNonNull(beanName, "注册bean需要指定beanName");
        Objects.requireNonNull(beanDefinition, "注册bean需要指定beanDefinition");

        if (!beanDefinition.validate()) {
            throw new BeanDefinitionRegisterException("名字为【"+beanName+"】的beanName不合法，" + beanDefinition);
        }
        if (containsBeanDefinition(beanName)) {
            throw new BeanDefinitionRegisterException("名字为【"+beanName+"】的beanName已经注册过了，" + beanName);
        }
        beanDefinitionMap.put(beanName, beanDefinition);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

代码逻辑：注册Bean定义信息，首先要有beanName，这个是用来区分Bean定义信息的，所以加了非空判断，bean定义信息也要判断是否为空，然后根据bean定义接口里面的验证方法，判断bean定义信息是不是合法的，然后再根据containsBeanDefinition方法判断一下是不是已经注册过了，最后把注册的Bean定义信息放到beanDefinitionMap里面就可以了

通过实现Closeable来实现销毁的逻辑：

    @Override
    public void close() throws IOException {
        // 针对单例Bean执行销毁方法
        for(Map.Entry<String, BeanDefinition> e : beanDefinitionMap.entrySet()) {
            //获取BeanName
            String beanName = e.getKey();
            //获取Bean定义
            BeanDefinition definition = e.getValue();

            //如果是单例Bean并且销毁方法非空，那么就执行销毁方法
            if(definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethodName())) {
                //得到Bean
                Object instance = beanMap.get(beanName);
                if(instance == null) {continue;}

                Method m = null;
                try {
                    m = instance.getClass().getMethod(definition.getDestroyMethodName(), null);
                    m.invoke(instance, null);
                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

整个代码实现：

/**
 * @ClassName DeafultBeanFactory
 * @Description: Bean工厂的实现类
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable {

    /** Bean定义缓存 */
    private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

    /** Bean缓存 */
    private Map<String, Object> beanMap = new ConcurrentHashMap<>();

    @Override
    public Object getBean(String beanName) throws Exception {
        return doGetBean(beanName);
    }

    private Object doGetBean(String beanName) throws Exception {

        //先去缓存里面判断一下，对应的beanName的对象是不是已经创建好了
        Object bean = beanMap.get(beanName);
        if (bean != null) {
            return bean;
        }

        BeanDefinition bd = beanDefinitionMap.get(beanName);
        Objects.requireNonNull(bd, "招不到【"+beanName+"】的Bean定义信息");
        Class<?> beanClass = bd.getBeanClass();
        if (beanClass != null) {
            //通过构造函数构建对象
            if (StringUtils.isBlank(bd.getFactoryMethodName())) {
                bean = createBeanByConstructor(bd);
            } else { //通过静态工厂构建对象
                bean = createBeanByStaticFactory(bd);
            }
        } else { //通过成员工厂构建对象
            bean = createBeanByFactoryBean(bd);
        }

        //开始bean的生命周期
        if (StringUtils.isNotBlank(bd.getInitMethodName())) {
            doInitMethod(bean, bd);
        }

        //对单例bean的处理
        if (bd.isSingleton()) {
            beanMap.put(beanName, bean);
        }

        return bean;
    }

    /** bean */
    private void doInitMethod(Object bean, BeanDefinition bd) throws Exception {
        Method method = bean.getClass().getMethod(bd.getInitMethodName(), null);
        method.invoke(bean, null);
    }

    /** 通过成员工厂构建对象 */
    private Object createBeanByFactoryBean(BeanDefinition bd) throws Exception {
        //获取工厂bean名称
        String factoryBeanName = bd.getFactoryBeanName();
        //获取工厂bean
        Object factoryBean = getBean(factoryBeanName);
        //获取工厂方法
        String factoryMethodName = bd.getFactoryMethodName();
        Method method = factoryBean.getClass().getMethod(factoryMethodName, null);
        Object object = method.invoke(factoryBean, null);
        return object;
    }

    /** 通过静态工厂构建对象 */
    private Object createBeanByStaticFactory(BeanDefinition bd) throws Exception {
        //获取工厂类名
        Class<?> type = bd.getBeanClass();
        //获取工厂方法名称
        String factoryMethodName = bd.getFactoryMethodName();
        Method method = type.getMethod(factoryMethodName, null);
        Object object = method.invoke(type, null);
        return object;
    }

    /** 通过构造函数构建对象 */
    private Object createBeanByConstructor(BeanDefinition bd) throws Exception {
        //获取类名
        Class<?> type = bd.getBeanClass();
        //实例化bean
        Object bean = type.newInstance();
        return bean;
    }

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException {
        Objects.requireNonNull(beanName, "注册bean需要指定beanName");
        Objects.requireNonNull(beanDefinition, "注册bean需要指定beanDefinition");

        if (!beanDefinition.validate()) {
            throw new BeanDefinitionRegisterException("名字为【"+beanName+"】的beanName不合法，" + beanDefinition);
        }
        if (containsBeanDefinition(beanName)) {
            throw new BeanDefinitionRegisterException("名字为【"+beanName+"】的beanName已经注册过了，" + beanName);
        }
        beanDefinitionMap.put(beanName, beanDefinition);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public void close() throws IOException {
        // 针对单例Bean执行销毁方法
        for(Map.Entry<String, BeanDefinition> e : beanDefinitionMap.entrySet()) {
            String beanName = e.getKey();
            BeanDefinition definition = e.getValue();

            if(definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethodName())) {
                Object instance = beanMap.get(beanName);
                if(instance == null) {continue;}

                Method m = null;
                try {
                    m = instance.getClass().getMethod(definition.getDestroyMethodName(), null);
                    m.invoke(instance, null);
                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

测试一下

首先定义一个接口：

public interface Boy {
    void sayLove();
}

Lad实现类：主要是验证通过new的方式

public class Lad implements Boy {

    @Override
    public void sayLove() {
        System.out.println("我爱你，亲爱的！"+ hashCode());
    }

    //初始化方法
    public void init() {
        System.out.println("老天赐予我一个对象吧！");
    }

   //销毁方法
    public void destroy() {
        System.out.println("自古多情空余恨，此恨绵绵无绝期！");
    }
}

BoyFactory类：验证静态工厂方法

public class BoyFactory {

    public static Boy getBean() {
        return new Lad();
    }
}

BoyFactoryBean实现类：验证成员工厂方法

public class BoyFactoryBean {

    public Boy buildBoy() {
        return new Boy() {
            @Override
            public void sayLove() {
                System.out.println("我爱你，大妹子！"+ hashCode());
            }
        };
    }
}

测试类：

/**
 * @ClassName Test
 * @Description: 测试类
 * @Author TR
 * @Date 2021/3/25
 * @Version V1.0
 */
public class TestDemo {

    static DefaultBeanFactory factory = new DefaultBeanFactory();

    /** 测试构造方法注册Bean */
    @Test
    public void testRegister() throws Exception {
        GenericBeanDefinition definition = new GenericBeanDefinition();
        //设置beanClass
        definition.setBeanClass(Lad.class);
        //设置为单例
        definition.setScope(BeanDefinition.SCOPE_SINGLETON);
        //设置初始化方法
        definition.setInitMethodName("init");
        //设置销毁方法
        definition.setDestroyMethodName("destroy");
        //注册bean定义
        factory.registerBeanDefinition("lad", definition);
    }

    /** 测试静态工厂注册Bean */
    @Test
    public void testRegisterStaticFactoryMethod() throws Exception {
        GenericBeanDefinition definition = new GenericBeanDefinition();
        //设置beanClass
        definition.setBeanClass(BoyFactory.class);
        //设置工厂方法名称
        definition.setFactoryMethodName("getBean");
        //注册bean定义
        factory.registerBeanDefinition("staticFactoryBoy", definition);
    }

    /** 测试成员方法注册Bean */
    @Test
    public void testRegisterFactoryMethod() throws Exception {
        GenericBeanDefinition definition = new GenericBeanDefinition();
        //首先要获取工厂Bean
        definition.setBeanClass(BoyFactoryBean.class);
        //工厂Bean的名称
        String fBeanName = "boyFactoryBean";
        //注册工厂Bean定义
        factory.registerBeanDefinition(fBeanName, definition);

        //然后设置工厂方法
        definition = new GenericBeanDefinition();
        //设置工厂Bean的名称
        definition.setFactoryBeanName(fBeanName);
        //设置工厂方法
        definition.setFactoryMethodName("buildBoy");
        //设置为多例
        definition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
        //注册bean定义
        factory.registerBeanDefinition("factoryBoy", definition);
    }

    @AfterClass
    public static void testGetBean() throws Exception {
        System.out.println("构造方法方式------------");
        for (int i = 0; i < 3; i++) {
            Boy boy = (Boy) factory.getBean("lad");
            boy.sayLove();
        }

        System.out.println("静态工厂方法方式------------");
        for (int i = 0; i < 3; i++) {
            Boy ab = (Boy) factory.getBean("staticFactoryBoy");
            ab.sayLove();
        }

        System.out.println("工厂方法方式------------");
        for (int i = 0; i < 3; i++) {
            Boy ab = (Boy) factory.getBean("factoryBoy");
            ab.sayLove();
        }
        factory.close();
    }
}

执行后输出结果：

可以看到构造方法获取的Bean它的hashCode是一样的，即是单例的；成员方法设置了多例，看到的是hashCode是不一样的

至此，手写IOC容器就结束了，希望通过本篇文章，能够让您对Spring的IOC有更深刻的理解，感谢阅读！

本文其他知识点链接：

女娲造人引发思考之Java设计模式：工厂模式

这个世界上只有一个你之Java设计模式：单例模式