浅谈对于IOC控制反转的基础实现

浅谈对于IOC控制反转的自我理解

1、自我理解

我们最开始用比较专一的方式，把类与类之间的联系绑定的过于精密；

举个文字描述的例子，下面会有相应的实例

在以前处理Dao层（数据）和Service层（逻辑）的时候，一般的情况是

1.先写一个interface 的 **Dao.java 的接口

2.在**DaoImpl.java 类中去实现这个接口的方法

3.为了实现具体代码的松耦合以及逻辑性、三层架构去写一个Service层的接口 Service.java 的接口接口中的方法也就是Dao.java 的接口中的方法

4.然后我们在**SviceImpl.java 实现类中去实现这个方法 也是调用Dao层之前实现的方法，通过一一绑定的方式（不过这里可以调其它的方法实现了一个业务的改变，不局限于一个Daoimpl类中的方法，可以是多个）：

xxDao 对象 = new xxDaoImpl(); 然后实现xxService接口的中的信息 在方法中调用 对象 中具体的方法

5.进行测试

在测试类中

xxService service = newxxServiceImpl();
service.getUser();

这样的方式是以前经常使用，在这里思考一个问题，那要是有多个XXdao的实现类改怎么办那，那就得修改代码指定的不同xxService去实现具体的业务，这种形式在实现方法很多的情况下太反人类吧。

大改造：也就是ioc容器最初的思想

在此基础上对以上的情况进行修改你会发现简单方便太多了：

我们在**ServiceImpl.java 调用xxDao 信息的时候不用一一绑定的方式，而是通过将其视为类中的属性 ，我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下

private xxDao xxDao;
// 利用set实现
public void setxxDao(xxrDao xxDao) {
this.xxDao = xxDao;
}

这种方式我们在测试的时候传一个具体的指向的对象类回来就能自己进行相应的绑定，不需要再手动一一捆绑

在测试类中的实现

UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() ); //这里就是对应的自动绑定自己信心
service.getUser(); //调用方法发现这就是我们需要的

通过以上案例的思路： 具体的案例在第二点

大家发现了区别没有 ? 可能很多人说没啥区别 . 但是, 他们已经发生了根本性的变化 , 很多地方都不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .（就类似现在的界面风格，使用者可以自行切换，而不是改变代码去切换）。

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

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。（类似于反射吧，最简单的new对象，直接用类名取，包名取等…）

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

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

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

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

2、IoC基础实例

直接上代码理解：

新建一个空白的maven项目

分析实现

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

1、先写一个UserDao接口

public interface UserDao {
   public void getUser();
}

2、再去写Dao的实现类

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

3、然后去写UserService的接口

public interface UserService {
   public void getUser();
}

4、最后写Service的实现类

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

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

5、测试一下

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

这是我们原来的方式 ,通过去new一个对象然后调用该对象再调用对象中具体的方法 .
那我们现在修改一下 .
把Userdao的实现类增加一个 .

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

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

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

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

在假设, 我们再增加一个Userdao的实现类 .

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

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

大家发现了区别没有 ? 可能很多人说没啥区别 . 他们已经发生了根本性的变化 , 很多地方都不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

（相当于现在用户可以在客户端自己改变界面的显示情况）

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