学习Spring，手撸控制反转

前言：

image.png

往往在各路博客中浏览Spring相关的内容。总是能看到高度总结的内容

Spring的核心就是 AOP(面向切面) 和 IOC (控制反转)

就像我们经常能看到的一句话

编程的核心就是，数据结构和算法

哎。这些话当然是大佬经过多年摸索总结出来的经验，看着俏皮。但是我们这种小白怎么又能明白里面的内涵呢？

今天就通过自己手撸一个控制反转来，来学习到底什么是IOC

什么是控制反转？

引用开涛老师的ioc的几个问题。总结的非常的精辟

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

先来个正转的例子

可能看了开涛老师的总结，还是有点似懂非懂，既然反转没明白，我么就先看看正转
我们现在假设有一个人叫王五，他拥有回家这个动作。但是他回家比较远，那么他需要一辆车。
所以在回家的方法实现的时候，他在方法中new了一台宝马，然后开着宝马回家了

public class WangWu {
    //回家
    public void goHome(){
        //实例化一辆宝马车
        BMW bmw=new BMW();
        //宝马启动
        bmw.start();
        //左转
        bmw.left();
        //熄火
        bmw.stop();
    }
}

我们观察到，wangwu这里对象要实现回家的方法，就依赖宝马这个对象。这时，对象内部主动的去实例化依赖的对象。这种控制依赖对象的方式就是正转

约定IOC

Spring框架在易用性上面也得到了开发者的认可。可是框架是怎么做到去掉复杂的配置的呢？那就是约定！
按照框架和开发者约定好的规矩，就能帮开发者去除很多配置的步骤。那我们现在要手撸ioc，我们也需要约定下ioc的规矩
我们立下3个规矩

既然是控制反转，那么我们的bean就不能由对象内部去创建，而是构造函数传入
1. 依赖对象都以构造函数的方式传入
还有就是所有的对象都有IOC去管理，也就是对象的全生命周期都交给IOC
2. 所有bean的生命周期交给IOC管理
第三就很明显了。刚刚的正转也看到了。被依赖对象是后于依赖对象实例化的。我们现在是反转，那么被依赖对象需要先被创建
3. 被依赖的bean需要优先创建

故事背景

我们需要两个人,张三，李四
他们都是有车一族。他们都开车回家。
他们一个有辆奥迪，一个有辆宝马。
宝马和奥迪都有启动，左转，右转，停止四个功能

创建故事背景中的角色

人类抽象接口。很简单每个人都具有回家的方法

/**
 * 人类接口，抽象方法 回家
 */
public interface Human {
   void  goHome();
}

汽车抽象接口。每个汽车都有的功能

/**
 * 汽车抽象接口
 */
public interface Car {
    void start();
    void left();
    void right();
    void stop();
}

有车一族抽象类，有车一族代表部分人类，他们有个特别的属性。那就是车，这个车按照我们我们约定的方式，通过构造函数传入

/**
 * 有车一族，继承人类
 */
public abstract class HumenWithCar implements Human {
    protected  Car car;

    public HumenWithCar(Car car) {
        this.car = car;
    }

    /**
     * 由于每个人回家的路线是不同的，有车一族这个类不能给具体的实现。交由具体的某个人来实现回家方法
     */
    public abstract void goHome();
}

奥迪车（宝马车）代码类似，我就不放了。继承Car接口，实现接口中定义的内容

public class Audi implements Car {
    public void start() {
        System.out.println("Audi start");
    }

    public void left() {
        System.out.println("Audi left");
    }

    public void right() {
        System.out.println("Audi right");
    }

    public void stop() {
        System.out.println("Audi stop");
    }
}

张三（李四）代码类似，我就不放了。由于父类构造函数中需要传递一辆车，那么张三的构造对象也需要接收一个Car对象交个父类。并且通过Car对象实现张三的回家方法

public class ZhangSan extends HumenWithCar {
    public ZhangSan(Car car) {
        super(car);
    }

    public void goHome() {
        car.start();
        car.left();
        car.right();
        car.stop();
    }
}

构建IOC控制器

IOC控制器，由3个部分组成:

控制器的私有属性，用来存放各种bean的容器，Map类型。

  //创建一个储存bean的容器 使用线程安全的Map（String 就是每个bean的ID，代表一个对象的键值）
    private Map beans = new ConcurrentHashMap();

获取bean的方法，只需传入bean的Id就返回容器中的bean

 public Object getBean(String beanId) {
        //传入键值，到容器中取对应的bean
        Object bean=beans.get(beanId);
        if (bean==null) {
            throw new RuntimeException("所需对象在容器中没有找到");
        }
        return bean;
    }

设置bean，将需要生成的类，beanId,依赖对象所需的参数传入

 /**
     * 将所需要的bean放入容器
     * @param clazz 所需要的对象的类
     * @param beanId 创建bean对象在容器中的id
     * @param relyBeanIds 依赖对象在容器的beanId（有可能有多个，就传多个）
     */
    public void setBean(Class clazz, String beanId, String... relyBeanIds) {
        //首先我们所有的bean都通过构造方法去创建，构造方法就需要所需的参数
        //参数其实就是这个类所依赖的类的对象。那我们先去取所依赖的对象。然后传进去就好了
        //考虑到有多个依赖就会有多个构造方法
        Object[] paramValues = new Object[relyBeanIds.length];
        for (int i = 0; i < paramValues.length; i++) {
            //这里
            paramValues[i] = getBean(relyBeanIds[i]);
        }
        Object bean = null;
        //实例化我们要创建的bean。通过构造方法
        for (Constructor constructor : clazz.getConstructors()) {
            //catch异常，但不处理的原因是，如果构造方法没有构造出一个bean的话。走到异常里面。则 bean对象任然是一个null。我们留在最后判断
            try {
                bean = constructor.newInstance(paramValues);
            } catch (InstantiationException ignored) {
            } catch (IllegalAccessException ignored) {
            } catch (InvocationTargetException ignored) {
            }
        }
        //如果循环了一轮之后，容器还是没有值
        if (bean == null) {
            throw new RuntimeException("传入依赖对象时出错");
        }
        //将实例化好的对象放到容器中
        beans.put(beanId,bean);
    }

使用IOC

一切就绪就需要使用下我们的代码了
项目呢，事先引入了junit 用于做单元测试
首先搞个单测类

image.png

类里面使用一个私有属性，用来存放IOC控制器的实例
private IocController iocController=new IocController();

通过注解声明一个前置方法，用来初始化容器，将所需要的bean都注册进去

    @Before
    public void before(){
        //把bean依次注册到容器中
        //bean的id我就占时使用的类的名字，这个其实是不规范的，应该是一个不会重复的字符串
        iocController.setBean(BMW.class,BMW.class.getName());
        iocController.setBean(Audi.class,Audi.class.getName());
        //因为张三这个对象依赖Audi这个对象，所以第三个参数需要传入Audi对象的beanId,来控制依赖
        iocController.setBean(ZhangSan.class,ZhangSan.class.getName(),Audi.class.getName());
        //李四同理
        iocController.setBean(LiSi.class,LiSi.class.getName(),BMW.class.getName());
    }

将需要的bean都注册好了，我们就可以快乐使用它了

    @Test
    public void test(){
        //在容器中取出张三对象
        Human zhangsan= (Human) iocController.getBean(ZhangSan.class.getName());
        //调用回家方法
        zhangsan.goHome();
    }

执行结果

执行回家方法的结果

尾巴

本次内容只能算是学习总结。内容比较简单，好在是一些思想性的东西。能为读者带来一些帮助那是更好，如果文中有解释错误的地方，希望大佬能够指出。感谢
完整代码：以下链接
gihub地址