IOC理论推导

1、IOC基础

新建一个Maven项目

我们先用我们原来的方式写一段代码

1. UserDao接口

   public interface UserDao {
       void getUser();
   }
   

2. UserDaoImpl实现类

   public class UserDaoImpl implements UserDao {
       @Override
       public void getUser() {
           System.out.println("默认获取用户的数据");
       }
   }
   

3. UserService业务接口

   public interface UserService {
       void getUser();
   }
   

4. UserServiceImpl业务实现类

   public class UserServiceImpl implements UserService {
       private UserDao userDao = new UserDaoImpl();
       @Override
       public void getUser() {
           userDao.getUser();
       }
   }
   

5. 测试

   public class UserServiceImplTest {
       @Test
       public void getUser() {
           // 用户实际调用的是业务层，dao层他们不需要接触！
           UserService userService = new UserServiceImpl();
           userService.getUser();
       }
   }
   

这是我们原来的方式，那么现在我需要使用MySQL实现数据的查询

1. 新增一个UserDao的实现类UserDaoMysqlImpl

   public class UserDaoMysqlImpl implements UserDao {
       @Override
       public void getUser() {
           System.out.println("MySQL实现用户查询");
       }
   }
   

2. 如果想要调用这个实现类的方法，我们就需要去service实现类里面修改对应的实现

   public class UserServiceImpl implements UserService {
       private UserDao userDao = new UserDaoMysqlImpl();
       @Override
       public void getUser() {
           userDao.getUser();
       }
   }
   

再假如，我还需要添加Oracle数据库的数据查询

1. 再添加一个UserDao的实现类UserDaoOracleImpl

   public class UserDaoOracleImpl implements UserDao {
       @Override
       public void getUser() {
           System.out.println("Oracle实现数据查询");
       }
   }
   

这时候，我们又需要修改service实现类里面对应的实现。

假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对，每次变动 , 都需要修改大量代码，这种设计的耦合性太高了，牵一发而动全身。

那么我们需要怎么解决这个问题呢？

​ 我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set 进行注入！

1. 修改UserServiceImpl业务实现层

   public class UserServiceImpl implements UserService {
       private UserDao userDao;
       // 利用set进行动态实现值的注入！
       public void setUserDao(UserDao userDao) {
           this.userDao = userDao;
       }
       @Override
       public void getUser() {
           userDao.getUser();
       }
   }
   

2. 测试

   public class UserServiceImplTest {
       @Test
       public void getUser() {
           UserService userService = new UserServiceImpl();
           
           ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
           userService.getUser(); // 默认获取用户的数据
           
           ((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
           userService.getUser(); // MySQL实现用户查询
           
           ((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
           userService.getUser(); // Oracle实现数据查询
       }
   }
   

看起来代码没有发生什么大的改变，只是加入了一个set方法，但是他们已经发生了根本性的变化。

• 以前所有东西都是由程序进行控制创建。
• 而现在是由我们自行控制创建对象 , 把主动权交给了调用者。
• 程序不用去管怎么创建，怎么实现了。它只负责提供一个接口，符合开放封闭原则(扩展开放，对修改封闭)

​ 这种思想，从本质上解决了问题，我们程序员不再去管理对象的创建了，更多的去关注业务的实现，耦合性大大降低 ，这也就是IOC的原型 !

2、IOC的本质

控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。