spring初识 IOC（Inversion of Control）:控制反转

为什么要引入IOC

创建一个普通的java项目，完成下述功能

UserDao.java

package com.mashibing.dao;
​
public interface UserDao {
    public void getUser();
}

UserDaoImpl.java

package com.mashibing.dao.impl;
​
import com.mashibing.dao.UserDao;
​
public class UserDaoImpl  implements UserDao {
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

UserService.java

package com.mashibing.service;
​
public interface UserService {
    public void getUser();
}
​

UserServiceImpl.java

package com.mashibing.service.impl;
​
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.service.UserService;
​
public class UserServiceImpl implements UserService {
​
    private UserDao userDao = new UserDaoImpl();
​
    @Override
    public void getUser() {
        userDao.getUser();
    }
}
​

SpringDemoTest.java

package com.mashibing.test;
​
import com.mashibing.service.UserService;
import com.mashibing.service.impl.UserServiceImpl;
​
public class SpringDemoTest {
    public static void main(String[] args) {
       UserService service = new UserServiceImpl();
       service.getUser();
    }
}
​

在之前的代码编写过程中，我们都是这么完成我们的功能的，但是如果增加一个UserDao的实现类呢？

UserDaoMysqlImpl.java

package com.mashibing.dao.impl;
​
import com.mashibing.dao.UserDao;
​
public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("mysql");
    }
}

如果我们想要使用mysql的话，那么就必须要修改UserServiceImpl.java的代码：

package com.mashibing.service.impl;
​
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.service.UserService;
​
public class UserServiceImpl implements UserService {
​
    private UserDao userDao = new UserDaoImpl();
​
    @Override
    public void getUser() {
        userDao.getUser();
    }
}
​

但是如果我们再增加一个oracle的类呢？

UserDaoOracleImpl.java

package com.mashibing.dao.impl;
​
import com.mashibing.dao.UserDao;
​
public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("oracle");
    }
}

此时UserService还是要继续修改，很显然这样的方式已经不适用于我们的需求了，那么怎么解决呢，可以使用如下的方式

UserServiceImpl.java

package com.mashibing.service.impl;
​
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.service.UserService;
​
public class UserServiceImpl implements UserService {
    private UserDao userDao;
​
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    @Override
    public void getUser() {
        userDao.getUser();
    }
}
​

测试类SpringDemoTest.java

package com.mashibing.test;
​
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.dao.impl.UserDaoOracleImpl;
import com.mashibing.service.UserService;
import com.mashibing.service.impl.UserServiceImpl;
​
public class SpringDemoTest {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();
​
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();
    }
}

其实从刚刚的代码中，大家应该能体会解耦的重要性了，下面我们就开始学习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），bean本身通过直接构造类来控制依赖关系的实例化或位置，或提供诸如服务定位器模式之类的机制。

如果这个过程比较难理解的话，那么可以想象自己找女朋友和婚介公司找女朋友的过程。如果这个过程能够想明白的话，那么我们现在回答上面的问题：

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

DI与IOC

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

本文地址：https://blog.csdn.net/qq_35565025/article/details/110271564