Spring控制反转的理解-IOC的理解

我们通过举一个小小的例子来说明什么是控制反转IOC？

初级阶段，我们写代码是这样的：

1. 新建一个UserDao和它的实现类

public interface UserDao {
    void save();
}
           

public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("UserDao.save");
    }
}
           

1. 新建UserService接口，和它的实现类，调用UserDao，实现相应的业务

public interface UserService {
    void addUser();
}
           

public class UserServiceImpl implements UserService {
    //代码初级阶段，我们都是直接new一个UserDao实现类，然后调用它
    private UserDao userDao = new UserDaoImpl();

    public void addUser() {
        System.out.println("UserServiceImpl.addUser");
        userDao.save();
    }
}
           

初级阶段我们这样写代码会有一个严重的弊端！！！

• Service层和Dao层的耦合性太高
• 如果我们在增加其他的UserDao实现类，比如采用MySQL存储的MysqlUserDaoImpl，或者采用Oracle存储的UserDao实现类，就需要更改代码，这样做显然不切实际，我们总不能换一个UserDao实现类，就改一次代码
• 什么叫耦合性？就是，我们在UserServiceImpl中直接new了一个具体的UserDao实现类，这时Service层和这个具体的UserDao关联了，如果这个UserDao被废用，整个代码就不能继续运行，需要重新更改代码；

下面我们增加一个MySqlUserDaoImpl：

public class MySqlUserDaoImpl implements UserDao {
    public void save() {
        System.out.println("MySqlUserDaoImpl.save：采用mysql实现数据库存储");
    }
}
           

• 这样我们就要更改我们的Service层代码，new一个新的实现类

public class UserServiceImpl implements UserService {
    private UserDao userDao = new MySqlUserDaoImpl();

    public void addUser() {
        System.out.println("UserServiceImpl.addUser");
        userDao.save();
    }
}

           

注意：重点！！

• 这时，我们将创建userDao的权利交给了程序，在运行的时候，由程序来创建userDao，而不受我们程序员的控制（就是我们想创建哪个UserDao，就创建哪个）

下面我们给UserService向外提供一个接口，实现程序员控制UserDao的创建：

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    //我们通过增加一个set方法，用户可以传递一个userDao进来，然后赋值给UserDao
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser() {
        System.out.println("UserServiceImpl.addUser");
        userDao.save();
    }
}
           

像这种通过set方法给UserDao赋值的过程就叫依赖注入DI

测试

@Test
public void test1() {
    UserService userService = new UserServiceImpl();
    userService.setUserDao(new MySqlUserDaoImpl());
    userService.addUser();
}
           

或许你还会感觉，这样还是由程序来创建具体的UserDao，确实上面的代码，还是受到程序控制

这样我们给它加一个switch判断，就更明显了

@Test
public void test1() {
    UserService userService = new UserServiceImpl();
    int i = 1;
    switch (i){
        case 0:
            userService.setUserDao(new UserDaoImpl());
            break;
        case 1:
            userService.setUserDao(new MySqlUserDaoImpl());
            break;
    }
    userService.addUser();
}
           

这时我们就可以通过键盘输入，来控制对象的创建

这样的话，我们就可以实现由程序员（用户）来创建具体的UserDao实现类

• 这样的，将创建对象的权利交给用户，而不是程序的过程就叫控制反转（IOC）；
• 控制反转的关键在于，我们在代码中不直接实例化具体的对象，而是在运行期间交由用户动态产生；向外提供接口，供外部传递参数；也可以通过动态代理的方法实现

而控制反转的核心就是依赖注入，什么是依赖？

• 上面我们创建UserService的时候，需要调用UserDao的功能，这时UserService就依赖了UserDao
• 而Spring之所以能够实现控制反转，就是因为实现了依赖注入
• 依赖注入：即我们上面说的，在UserService里不直接实现一个具体的UserDao，而是通过set方法将UserDao这个依赖动态的注入到UserSvice中

以上就是我对控制反转IOC的理解