IOC (控制反转)

控制反转: 面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

为什么要是用控制反转IOC？

首先出场景：

• IocDao.java

public interface IocDao {

    public void TestIoc();
}
1
2
3
4

• IocDaoImpl.java

public class IocDaoImpl implements IocDao{
    @Override
    public void TestIoc() {
        System.out.println("这里是在IocDaoImpl 重写了IocDao 的TestIoc这个方法");
    }
}
1
2
3
4
5
6

• IocDaoImpl2.java

public class IocDaoImpl2 implements IocDao{
    @Override
    public void TestIoc() {
        System.out.println("这里是在IocDaoImpl2 重写了IocDao 的TestIoc这个方法");
    }
}
1
2
3
4
5
6

• IocService.java

public interface IocService {
    public void TestIoc();
}
1
2
3

• IocServiceImpl.java

public class IocServiceImpl implements IocService{
    private IocDao iocDao;
    @Override
    public void TestIoc() {
        iocDao=new IocDaoImpl();
        iocDao.TestIoc();
    }
}
1
2
3
4
5
6
7
8

测试类：

• Test.java

public class Test {
    public static void main(String[] args) {
        IocService iocService = new IocServiceImpl();
        iocService.TestIoc();
    }
}

1
2
3
4
5
6
7

此时我们是调用了 IocDao 接口的实现类IocDaoImpl里面的方法，假设现在增加了一个IocDao的实现类IocDaoImpl2，如果想实现IocDaoImpl 里面的方法，就需要去修改 IocServiceImpl 的实现类对应的实现：

public class IocServiceImpl implements IocService{
    private IocDao iocDao;
    @Override
    public void TestIoc() {
        iocDao=new IocDaoImpl2();
        iocDao.TestIoc();
    }
}
1
2
3
4
5
6
7
8

注意： 这里解释一下，为什么不是在IocServiceImpl 中新增一个实现方法来达到目的，其一我们是想用这个例子来引入我们为什么要使用IOC，其二是因为我们要保持在低耦合性，如果我们新增了一个实现方法来达到目的，那么我们的测试方法是不是也要修改？这显然不不现实

---

可以看到每当我们新增一个IocDao的实现类，像实现其新增实现类的方法，都需要去修改 IocServiceImpl 里的实现，这很显然与我们所推崇的 高内聚、低耦合相违背；

我们可以稍微修改一下我们的 IocServiceImpl 中的实现方法：

public class IocServiceImpl implements IocService{
    private IocDao iocDao;

    public IocDao getIocDao() {
        return iocDao;
    }

    public void setIocDao(IocDao iocDao) {
        this.iocDao = iocDao;
    }

    @Override
    public void TestIoc() {
        iocDao.TestIoc();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

再看我们的测试类：

public class Test {
    public static void main(String[] args) {
        IocServiceImpl iocService = new IocServiceImpl();
        iocService.setIocDao(new IocDaoImpl());
        iocService.TestIoc();

        iocService.setIocDao(new IocDaoImpl2());
        iocService.TestIoc();
    }
}
1
2
3
4
5
6
7
8
9
10

可以看到我们只对IocServiceImpl 做了一个简单的改变，然后，无论IocDao 增加多少个IocDaoImpl 的实现类，我们只需要在实际使用的时候（这里用Test类做对比），选择我们所需要使用实现类的方法即可;即我们不需要再对IocServiceImpl 作出相应的改变了，大大的降低了代码的耦合性。