IOC控制反转理解

1. IOC基础

IOC：全称Inversion Of Control，中文翻译是控制反转的意思。初学Spring绕不过去的一个弯，需要好好理解IOC的思想。网上看了很多博客，也看了很多网课，但是还是云里云雾。终于看到一个容易理解的例子，写下自己对IOC的理解。

2. IOC推导与理解

首先编写一个基本的项目，结构如下：

1. 有一个Meizi（妹子）接口，里面有一个方法describe。

2. 编写四个类（四种类型的妹子）：Yujie（御姐）、Luoli（萝莉）、Xuemei（学妹）、NvWang（女王）类实现Meizi接口，重写describe方法。

3. 一个Nan（男生）接口，里面有一个方法getMeizi。

4. 编写两个类：yihao（一号男生）、erhao（二号男生）实现Nan接口，重写getMeizi方法。

为了简单方便将所有的类实现都放在一个代码块中，这里利用男生找对象的方式进行理解IOC的含义。

2.1、最基本的实现方式

interface Meizi {
    public void describe();
}


class Yujie implements Meizi{
    @Override
    public void describe() {
        System.out.println("御姐~");
    }
}


//这里只列出一种女生类型的具体实现，其他的类似


interface Nan {
    public void getMeizi();
}

class yihao implements Nan{

    @Override
    public void getMeizi() {
        Meizi meizi = new Yujie();
        meizi.describe();
    }
}

class erhao implements Nan{

    @Override
    public void getMeizi() {
        Meizi meizi = new Yujie();
        meizi.describe();
    }
}

现在整个实现是上图所示，getMeizi方法内部依赖四种类型的妹子。

1. 很容易看到这种设计方式违背了OOP的设计原则，至少违背了迪米特法则。我们不应该将一个陌生类（接口）作为局部变量！

2. 没有改动的余地，现在男生都想找一个御姐对象，如果需求变更男生想找一个女王呢？是不是需要更改所有男生的代码？

2.2、采用组合的方式实现

假设男生最开始都有一个御姐类型的女朋友

interface Meizi {
    public void describe();
}


class Yujie implements Meizi{
    @Override
    public void describe() {
        System.out.println("御姐~");
    }
}


//这里只列出一种女生类型的具体实现，其他的类似


interface Nan {
    public void getMeizi();
}


class yihao implements Nan{
    private Meizi meizi = new Yujie();
    
    @Override
    public void getMeizi() {
        meizi.describe();
    }
}
class erhao implements Nan{
    private Meizi meizi = new Yujie();
    
    @Override
    public void getMeizi() {
        meizi.describe();
    }
}
public class Main {
    public static void main(String[] args) {
        yihao man1 = new yihao();			
        man1.getMeizi();

        erhao man2 = new erhao();
        man2.getMeizi();
    }
}

采用组合关系之后如上图，现在真正的问题来了：

1. 组合关系：什么是组合关系？谁也离不开谁、二者之间是一个整体；比如：脑袋和身体这种关系；叫组合关系。

2. 男一号、男二号能保证自己以后一定会跟御姐妹子走到最后吗？或者说二者之间一定不会分手吗？组合关系限定死了男一号、男二号更换对象的权利，他们没有权利在更换对象了！当然御姐妹子也没有权利更换男朋友了！

3. 如果想跟换对象是需要重新去修改源代码，重新new一个对象。

4. 这个代码设计也不好，男生、女生都丧失了更换对象的权利。耦合度太高了，硬生生的将两个人绑在了一起。

2.3、采用聚合方式（松耦合）

组合方式限定死了男生的对象、没有办法更换。现在将组合方式改为聚合，不在内部直接new一个确定的对象（主动创建）。而是通过set方法给男生一个女朋友（被动接受）。

interface Meizi {
    public void describe();
}


class Yujie implements Meizi{
    @Override
    public void describe() {
        System.out.println("御姐~");
    }
}


//这里只列出一种女生类型的具体实现，其他的类似


interface Nan {
    public void getMeizi();
}


class yihao implements Nan{
    private Meizi meizi;

    public void setMeizi(Meizi meizi) {
        this.meizi = meizi;
    }

    @Override
    public void getMeizi() {
        meizi.describe();
    }
}
class erhao implements Nan{
    private Meizi meizi;

    public void setMeizi(Meizi meizi) {
        this.meizi = meizi;
    }

    @Override
    public void getMeizi() {
        meizi.describe();
    }
}

public class Main {
    public static void main(String[] args) {
        yihao man1 = new yihao();
        man1.setMeizi(new Yujie());
        man1.getMeizi();

        erhao man2 = new erhao();
        man2.setMeizi(new Luoli());
        man2.getMeizi();
    }
}

通过set注入方式就可以实现解耦。

1. 假定IOC是一个婚介所，现在男女生都婚介所登记资料，男生告诉IOC需要什么样的对象，IOC就给男生一个。

2. 由男生主动搭讪妹子寻找对象（new），演变成了被动的由婚介所介绍对象（set注入）！

3. 到此IOC就是大概一个这样的概念：控制反转，反转的是创建对象的方式，由主动化为被动的一个过程。

3. IOC总结

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring的IOC容器来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象 .