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

目录

我自横刀向天笑,手写Spring IOC容器,快来Look Look!
相信很多朋友对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工厂接口

我自横刀向天笑,手写Spring IOC容器,快来Look Look!
主要用来创建和获取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定义的注册接口

我自横刀向天笑,手写Spring IOC容器,快来Look Look!
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定义接口

我自横刀向天笑,手写Spring IOC容器,快来Look Look!
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();
    }
}

执行后输出结果:

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

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

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

本文其他知识点链接:

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

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

上一篇:2021-2022学年英语周报七年级第56期答案及试题


下一篇:编程 可以做私活的网站 有兴趣的赶紧来look look