我自横刀向天笑，手写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工厂接口

主要用来创建和获取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;@Overridepublic Class<?> getBeanClass() {return beanClass;}@Overridepublic void setBeanClass(Class<?> beanClass) {this.beanClass = beanClass;}@Overridepublic String getFactoryMethodName() {return factoryMethodName;}@Overridepublic void setFactoryMethodName(String factoryMethodName) {this.factoryMethodName = factoryMethodName;}@Overridepublic String getFactoryBeanName() {return factoryBeanName;}@Overridepublic void setFactoryBeanName(String factoryBeanName) {this.factoryBeanName = factoryBeanName;}@Overridepublic String getScope() {return scope;}@Overridepublic void setScope(String scope) {this.scope = scope;}@Overridepublic boolean isSingleton() {return scope.equals(BeanDefinition.SCOPE_SINGLETON);}@Overridepublic boolean isPrototype() {return scope.equals(BeanDefinition.SCOPE_PROTOTYPE);}@Overridepublic String getInitMethodName() {return initMethodName;}@Overridepublic void setInitMethodName(String initMethodName) {this.initMethodName = initMethodName;}@Overridepublic String getDestroyMethodName() {return destroyMethodName;}@Overridepublic void setDestroyMethodName(String destroyMethodName) {this.destroyMethodName = destroyMethodName;}@Overridepublic 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 DefaultBeanFactoryimplements BeanFactory, BeanDefinitionRegistry {@Overridepublic 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();//实例化beanObject 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();//获取工厂beanObject factoryBean = getBean(factoryBeanName);//获取工厂方法String factoryMethodName = bd.getFactoryMethodName();Method method = factoryBean.getClass().getMethod(factoryMethodName, null);Object object = method.invoke(factoryBean, null);return object;}

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

    @Overridepublic 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);}@Overridepublic BeanDefinition getBeanDefinition(String beanName) {return beanDefinitionMap.get(beanName);}@Overridepublic boolean containsBeanDefinition(String beanName) {return beanDefinitionMap.containsKey(beanName);}

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

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

    @Overridepublic void close() throws IOException {// 针对单例Bean执行销毁方法for(Map.Entry<String, BeanDefinition> e : beanDefinitionMap.entrySet()) {//获取BeanNameString beanName = e.getKey();//获取Bean定义BeanDefinition definition = e.getValue();//如果是单例Bean并且销毁方法非空，那么就执行销毁方法if(definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethodName())) {//得到BeanObject 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<>();@Overridepublic 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();//获取工厂beanObject 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();//实例化beanObject bean = type.newInstance();return bean;}@Overridepublic 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);}@Overridepublic BeanDefinition getBeanDefinition(String beanName) {return beanDefinitionMap.get(beanName);}@Overridepublic boolean containsBeanDefinition(String beanName) {return beanDefinitionMap.containsKey(beanName);}@Overridepublic 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 {@Overridepublic 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() {@Overridepublic 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 */@Testpublic void testRegister() throws Exception {GenericBeanDefinition definition = new GenericBeanDefinition();//设置beanClassdefinition.setBeanClass(Lad.class);//设置为单例definition.setScope(BeanDefinition.SCOPE_SINGLETON);//设置初始化方法definition.setInitMethodName("init");//设置销毁方法definition.setDestroyMethodName("destroy");//注册bean定义factory.registerBeanDefinition("lad", definition);}/** 测试静态工厂注册Bean */@Testpublic void testRegisterStaticFactoryMethod() throws Exception {GenericBeanDefinition definition = new GenericBeanDefinition();//设置beanClassdefinition.setBeanClass(BoyFactory.class);//设置工厂方法名称definition.setFactoryMethodName("getBean");//注册bean定义factory.registerBeanDefinition("staticFactoryBoy", definition);}/** 测试成员方法注册Bean */@Testpublic void testRegisterFactoryMethod() throws Exception {GenericBeanDefinition definition = new GenericBeanDefinition();//首先要获取工厂Beandefinition.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);}@AfterClasspublic 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设计模式：单例模式