Spring学习②__IOC分析

IOC

​想要搞明白IOC，那么需要搞清楚如下几个问题：

1. 谁控制谁
2. 控制什么
3. 什么是反转
4. 哪些方面被反转

基本概念

IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern.
IOC与大家熟知的依赖注入同理，. 这是一个通过依赖注入对象的过程 也就是说，它们所使用的对象，是通过构造函数参数，工厂方法的参数或这是从工厂方法的构造函数或返回值的对象实例设置的属性，然后容器在创建bean时注入这些需要的依赖。 这个过程相对普通创建对象的过程是反向的（因此称之为IoC）。

控制反转IOC

在传统的创建对象过程中，对象通常会在需要的地方直接创建它所依赖的其他对象，或通过某种手段（如服务定位器模式）来获取它们。这种方式下，对象本身对其依赖关系的实例化和管理有直接的控制权，因此耦合度较高，不利于代码的复用和维护。

而在IoC（控制反转）中，这个过程被反转了。对象的依赖关系不再由对象本身来创建和管理，而是交由外部容器（如Spring容器）来负责。容器负责实例化对象，注入依赖关系，并将构建好的对象提供给需要的地方。这样，对象本身就不再关心依赖关系的实例化和管理，从而实现了控制反转。

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

1. 谁控制谁：在之前的编码过程中，都是需要什么对象自己去创建什么对象，有程序员自己来控制对象，而有了IOC容器之后，就会变成由IOC容器来控制对象
2. 控制什么：在实现过程中所需要的对象及需要依赖的对象
3. 什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖的对象，这是正转的，而有了IOC之后，依赖的对象直接由IOC容器创建后注入到对象中，由主动创建变成了被动接受，这是反转
4. 哪些方面被反转：依赖的对象

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()），控制权在程序员手上。

控制反转DL

我们可以使用方法把实现类的对象注入到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）。

DI与IOC

很多人把IOC和DI说成一个东西，笼统来说的话是没有问题的，但是本质上还是有所区别的,希望大家能够严谨一点，IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式

• IOC（Inversion of Control，控制反转）是一种设计原则，它将对象的创建、配置和管理从代码中解耦，交给一个外部容器（如Spring容器）来完成。这样，对象之间的依赖关系可以在容器中进行配置，而不是在代码中显式创建。这使得代码更加模块化，更容易测试和维护。
• 依赖注入（DI，Dependency Injection）是实现IOC的一种方法。通过将依赖关系（如服务、数据源等）作为参数传递给对象（通常是通过构造函数、属性或方法），从而将依赖关系的创建和管理从对象内部移至外部容器。这样，对象不需要直接创建或查找它们所依赖的资源，而是依赖于容器来提供这些资源。这使得对象更加松耦合，更容易测试和重用。

总结一下，IOC是一种设计原则，它将对象的创建、配置和管理交给外部容器，使代码更加模块化和易于维护。而依赖注入是实现IOC的一种方法，它通过将依赖关系作为参数传递给对象，从而将依赖关系的创建和管理从对象内部移至外部容器。这使得对象更加松耦合，更容易测试和重用。

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