本文共 20404 字，大约阅读时间需要 68 分钟。
相信很多朋友对Spring已经很熟悉了，面试中也经常会被问到Spring里面相关的知识，比如IOC、DI、AOP等，下面通过手写IOC的方式来对IOC里面相关的内容，进行熟悉和理解
IOC分析
IOC是什么
Inversion of Control 控制反转，也称依赖倒置（反转）
如何理解这个控制反转呢？
反转：依赖对象的获得被反转了，由自己创建，反转为从IOC容器中获取（和自动注入）；
也就是说，你不要来找我了，我去找你，传统的方式呢，是我在对象内部来去控制另外的对象，有了IOC，IOC是一个专门的容器，来创建和管理这些对象
比如，我们平时找女朋友或者男朋友，就会想方设法的去打听他们的联系方式啊，爱好啊等等，这些东西啊都是需要我们自己去做的。IOC呢就好比婚介所啊，聊天交友群啊之类的，然后我们可以向他们提出我们的要求，身高体重，长相身材啊等等，这些介绍的中间人就会按照我们的要求去提供一个对象，然后我们和提供的这个对象谈恋爱就行了
IOC能够带来什么好处
通过上述的简单描述可以知道，IOC有下面这些好处：
- 代码更加简洁，不需要自己去new使用的对象了，也做到了解耦
- 面向接口编程，使用者和具体者之间解耦，容易扩展和替换实现者
- 可以方便的进行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工厂提供一些方法：
- 获取Bean的类名：getBeanClass():Class
- 获取工厂方法名：getFactoryMethodName():String
- 获取工厂Bean名：getFactoryBeanName():String
- 是不是单例，作用范围等：getScope():String、isSingleton()、isPrototype()
提供上述的几种方法是不是就足够了呢？类对象的生命周期还会有什么呢？
- 创建对象后是不是还需要一些初始化：getInitMethodName():String
- 比如有些对象在销毁时还需要进行一些特定的销毁逻辑（如释放资源）：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 beanDefinitionMap = new ConcurrentHashMap<>();
创建好的Bean也需要存放起来，方便下一次获取
/** Bean缓存 */ private Map 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 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 beanDefinitionMap = new ConcurrentHashMap<>(); /** Bean缓存 */ private Map 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 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有更深刻的理解，感谢阅读！
本文其他知识点链接：
转载地址：http://lliuz.baihongyu.com/