IOC

控制反转IOC

①控制反转，把对象创建和对象之间的调用过程，交给Spring进行
②使用IOC目的：为了耦合度降低

IOC理论案例

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

1. 先写一个UserDao接口

package com.itheima.dao;
public interface UserDao {
    public void save();
}

2. 再去写Dao的实现类

package com.itheima.dao.impl;
import com.itheima.dao.UserDao;
public class UserDaoImpl implements UserDao {
    public void save() {
      System.out.println("获取用户数据");
    }
}

3. 然后去写UserService的接口

public interface UserService {
    public void getUser();
}

4. 最后写Service的实现类

package com.itheima.service.impl;
import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.service.UserService;
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();
    }

这里打印出来UserDao的实现，如果增加一个
我们在service层调用dao层就需要再次去创建StudentImpl对象，去修改程序的service实现类的实现。如下：

public class UserServiceImpl implements UserService {

       UserDao userDao = new StudentImpl();
//    UserDao userDao = new UserDaoImpl();
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

这里，程序是主动创建对象（new UserServiceImpl()），控制权在程序员手上。

IOC的思想（注入）

我们可以使用方法把实现类的对象注入到service实现类里。可以使用set进行注入，让程序实现类的时候不在用程序员去创建对象，修改代码，只需要把这个对象注入即可，从原来的手动修改对象到被动的接收对象, 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口，即IOC的思想。
这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型

1. 修改的实现类

package com.itheima.service.impl;
import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;


import com.itheima.service.UserService;
public class UserServiceImpl implements UserService {

     UserDao userDao = new UserDaoImpl();
//    UserDao userDao = new StudentImpl();
    // 利用set实现
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

2. 修改测试类测试

    @Test
    public void  test01(){
        UserServiceImpl service = new UserServiceImpl();
        service.setUserDao( new UserDaoImpl() );
        service.getUser();

        service.setUserDao( new StudentImpl() );
        service.getUser();
    }

IOC底层

什么是 IOC

1. 控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
2. 使用 IOC 目的：为了耦合度降低

IOC 底层原理

• XML解析

• 工厂模式

• 反射

• 原始方式
  目的：想在UserService类中调用UserDao方法
  原始方式提供程序员创建对象来进行调用该对象的方法，耦合度（service与dao关联过于依赖，牵一发动全身）太高了
  

• 工厂模式
  工厂模式的出现就是为了解耦
  

• IOC模式
  目的：耦合度降低到最低
  这个在不改类路径的情况下，随意修改类名称，都可以提供IOC进行反射、xml解析创建对象，即时修改路径只需要在xml修改对应的包路径即可，耦合度大大降低。
  

总结

1. 原先我们创建在写实现类的时候都要在程序中创建一个对象，现在我们不需要在程序中去创建对象，而是把程序创建对象的主动权交给在测试类中的调用者，程序员不在主动的去管理对象的创建与控制，而是把对象创建、管理交给spring完成，我们只需要在测试类中调用spring提供的接口就行。
2. 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

接下来是Spring进行操作，Spring到底帮我们干了什么呢？