1、什么是IoC？

IoC = Inversion of Control【控制反转】

即就是说Spring就是一个“控制反转”的容器，还是不懂，没关系，继续往下看，通过传统程序和控制反转式程序对比一下，就明白了~

2、传统程序开发

假设我们现在需要制作一个“口红”的程序，实现思路如下：

制作一支口红（ lipstick），需要依赖于口红管（tube），而口红管则依赖于口红芯（core），口红芯依赖于口红颜料（pigment），最终代码实现如下：



/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick() {
        tube = new Tube();
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube() {
        core = new Core();

    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core() {
        pigment = new Pigment();
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color = "死亡芭比粉";
    public Pigment() {

    }
    public void init() {
        System.out.println("执行了pigment  init方法");
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Lipstick lipstick = new Lipstick();
        lipstick.init();
    }
}

打印结果：

从这里，看起来没有问题呀，但是，我们一起仔细想想看，随着市场用户量越来越大，个性化需求就会越来越多，这个时候，可能需要我们加工出不同颜色的口红，修改后，如下：



/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick(String color) {
        tube = new Tube(color);
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube(String color) {
        core = new Core(color);

    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core(String color) {
        pigment = new Pigment(color);
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color ;
    public Pigment(String color) {
        this.color = color;
    }
    public void init() {
        System.out.println("执行了pigment  init方法" +
                " 口红颜色："+color);
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Lipstick lipstick = new Lipstick("豆沙色");
        lipstick.init();
    }
}

从上述代码会发现，当我们增加一点点个性化设置，即更改最底层代码后，整个调用链上的代码都需要进行修改【耦合度太高，我们需要解耦】

3、控制反转式程序开发

控制翻转式程序开发，其实就是对传统式程序开发进行优化【解耦】

怎么理解呢，传统中，我们制作一支口红，需求者的需求发生改变时，口红的颜色不再是原来的颜色，我们就要去更改，而这里解耦，就是将口红颜色配制外包出去，这样一来，即使颜色发生改变了，我们只需要向代理厂下单即可，自身无需进行修改。

思路如下：

代码实现：


/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick(Tube tube) {

        this.tube = tube ;
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube(Core core) {
        this.core = core;
    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core(Pigment pigment) {
        this.pigment = pigment;
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color ;
    public Pigment(String color) {

        this.color = color;
    }
    public void init() {
        System.out.println("执行了pigment  init方法" +
                " 口红颜色："+color);
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Pigment pigment = new Pigment("丝绒红棕色");
        Core core = new Core(pigment);
        Tube tube = new Tube(core);
        Lipstick lipstick = new Lipstick(tube);
        lipstick.init();
    }
}

结果：

经过这样的调整后，无论底层类怎样变化，整个调用链是不需要做改变的，也就是完成了代码之间的解耦，实现了更加灵活、通用的程序设计啦~

二者对比：

我们对比后，会发现，传统的程序的类的创建，和正常流程是反的，也就是我们都已经要去使用了，才开始去创建，改进后的控制权发生反转，就不再是上级对象创建并控制下级对象了，而是把下级对象注入到当前对象中，下级的控制权不再是由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是IoC的实现思想