IOC(Inversion of Control)和DI(dependency injection)基本概念及原理

IOC介绍以及原理

1. 什么是IOC

1. 1. IOC (Inversion of Control,控制反转) ，是一种软件开发的设计原则(也是一种思想)，它指的是将控制权从应用程序代码移动到一个专门的框架中或容器中，由容器或框架管理和控制应用程序中对象之间的依赖关系（简单来说(将创建对象的控制权，反转到了容器上，通常我们实例化一个对象时，都是使用类的构造方法来new一个对象，这个过程是由我们自己来控制的，而控制反转就是把new对象这件事情交给spring容器去做)）
   2. 控制反转是将对象交给IoC容器去管理，而Spring是一个实现了IoC容器的框架，它可以帮助我们更方便地实现控制反转的管理机制
   3. 案例

//定义一个UserDao接口
public interface UserDao {//这是一个接口
    //这是接口里面的方法
    public void getUser();
}

//UserDao实现类
public Class userDaoImpl implements UserDao {//这是实现UserDao接口类
    @Override//这个注解表示重写的方法
    public void getUser() {
        System.out.println("获取用户数据");
    }
}


//UserService接口
public Interface UserService{//这是一个接口
    public void UserService();//这是UserService的方法
}

//Userservice实现类
public Class UserService implements UserService {//这是实现UserService接口类
   //创建UserDao对象
   private UserDao userDao = new UserDaoImpl();

   @Override
   public void getUser() {
       //调用该UserDao里面的方法
       userDao.getUser();
  }
}

//测试类
@Test//标注这个为测试方法
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}



//一般来说都是这样写的，那我在修改一下

//增加一个UserDao的实现类
public class MyUserDaoSqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

//我们要使用过这个实现类中的方法，我们就需要Service实现类修改对应的实现
public class UserServiceImpl implements UserService {
   //这里父类引用指向了子类,(使用了多态)//这里修改了
   private UserDao userDao = new MyUserDaoImpl();

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

//如果我们在添加一个UserDao的实现类呢
public class YouUserDaoImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("Oracle获取用户数据");
  }
}
那么我们要使用YouUserDao,
又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大，
是不是要频繁的去修改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();
   //使用MyUserDao实现
   service.setUserDao( new MyUserDaoSqlImpl() );
   service.getUser();
   //那我们现在又想用YouUserDao去实现呢
   service.setUserDao( new YouUserDaoImpl() );
   service.getUser();
}

//以前所有东西都是由程序去进行控制创建,而现在是由我们自行控制创建对象 ,
把主动权交给了调用者.程序不用去管怎么创建,
怎么实现了 . 它只负责提供一个接口 

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

1. DI ：依赖注入(dependent injection)

1. 1. 什么是DI注入

1. 1. 1. 他是spring框架核心的IOC的具体实现
      2. 我们在编写程序中，通过控制反转，将对象交给IOC容器去管理，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。
         简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
      3. DI相当与 UserDao userDao = new UserDaoImpl(); ，就是创建出来的对象