IOC容器:

在上篇文章Spring入门中对IOC进行了一个简单的介绍，但是要想真正的去理解IOC以及能更好的使用IOC，就要知道其理论。

1、IOC原型

IOC也就是控制反转，那么我们先按照之前的步骤（正向控制，对象通过new实现）来看：
我们之前在做数据和业务层一般分为以下几个步骤：

UserDao 接口
UserDaoImpl 实现类
UserService 接口
UserServiceImpl 实现类

UserDao 接口：

public interface UserDao {
    void getUser();//获取信息
}

UserDaoImpl 实现类：

public class UserDaoImpl implements UserDao {
    
    @Override
    public void getUser() {
        System.out.println("默认数据实现");
    }
}

UserService 接口：

public interface UserService {
    void getUser();
}

UserServiceImpl 实现类（核心：业务层调用Dao层）：

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

    @Override
    public void getUser() {
        userDao.getUser(); //这里去调用Dao层
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //用户实际调用的是业务层
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

这样没有问题可以输出 默认数据实现 字样
但是现在有新的需求，需要增加Mysql和Oracle两个UserDao实现类：

UserDaoMysqlImpl：

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("MySQL实现");
    }
}

UserDaoOracleImpl：

public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("oracle实现");
    }
}

如果需要使用这两个实现类，在测试类中去实现，我们需要每次都要修改业务层实现类：

UserServiceImpl：

public class UserServiceImpl implements UserService {
	//也就是需要用那个数据实例类就要在业务层更改
	//
    private UserDao userDao = new UserDaoImpl();
    private UserDao userDao = new UserDaoMysqlImpl();
	private UserDao userDao = new UserDaoOracleImpl();
    
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

但是这样存在一个很大的问题，如果之后有100个类，那么是否每次都需要在业务层更改？

显然是肯定不恰当的，不符合程序的设计原则，那么该如何改善？也就是当用户输入的参数变了后我们不能去修改原代码，我们可以这样修改：
加入Set方法

public class UserServiceImpl implements UserService {
    
    //不直接new，而是用下面的Set实现动态值的注入
    private UserDao userDao; 

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

这样我们只用在测试类（也就是客户端）根据传入值即可修改：

public class Test02 {
    public static void main(String[] args) {
       
        //用户实际调用的是业务层
        UserService userService = new UserServiceImpl();
        ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
        //（new 需要的类）
        /*
        *((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
        *((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
        */
        userService.getUser();
    }
}

这样就实现了不用去修改原代码，而是根据用户输入的参数去确定需要实现的类

两者有什么区别？

之前的程序是主动创建对象，控制权在程序员手里
使用Set注入后，程序没有主动性，而是变成了被动的接收对象（客户端传什么就创建什么）
也就是说如果在以后更新了很多实现类，只需要和用户说有了这个功能，用户即可通过给的接口去调用到实际业务层内的方法

这就是IOC的原型，也就是控制反转，把控制权交给了第三者（不是程序本身，也不是程序员）
在这里插入图片描述

2、在Spring中实现IOC

在这里插入图片描述
IOC是Spring的核心：

使用了多种方式实现IOC，其中有通过XML文件配置，也可以通过注解等
Spring容器在初始化的时候先读取配置文件，根据配置文件或元素创建于组织对象存取容器内，需要使用的时候再从IOC容器中取出需要的对象

通过Spring去实现IOC容器：

首先导入Spring：

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.20</version>
        </dependency>
        <!--spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.20</version>
        </dependency>
        <!-- spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.20</version>
        </dependency>
        <!-- spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.20</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

通过XML配置文件方法：

在resources内创建一个Spring的配置文件，名字可以随便取，例如：bean.XML
创建完打开可以看到这样的表头信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

在Spring中，对象都被bean代替，也就是说每一个bean都代表一个对象：

之前创建对象方式：类型变量名 = new 类型();
Spring中： bean = 对象

格式：

    <bean id="对象的变量名" class="需要new对象的全路径">
    	<!-- 如果这个对象有属性，可以用以下方式注入值，name=属性名，value=值 -->
        <property name="userDao" ref="UserDaoImpl"></property>
    </bean>

把上面的案例通过Spring的XML文件来配置实现：

    <bean id="UserDaoImpl" class="com.zte.dao.UserDaoImpl"/>
    <bean id="userDaoMysql" class="com.zte.dao.UserDaoMysqlImpl"/>
    <bean id="userDaoOracle" class="com.zte.dao.UserDaoOracleImpl"/>

    <bean id="userServiceImpl" class="com.zte.service.UserServiceImpl">
   		 <!--如果这个对象的参数是基本类型就用value接收，如果是引用类型用ref-->
        <property name="userDao" ref="UserDaoImpl"></property>
    </bean>

测试类写法：

public class Test01 {
    public static void main(String[] args) {

		//读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //去IOC容器中找bean，且id=userServiceImpl的对象
        UserServiceImpl userService = (UserServiceImpl) context.getBean("userServiceImpl");
        //使用它的方法
        userService.getUser();
    }
}

那这样如何控制？
我们只需在配置文件中的传入对象控制即可，例如：

    <bean id="userServiceImpl" class="com.zte.service.UserServiceImpl">
        <property name="userDao" ref="UserDaoImpl/"></property> 
        <!--
        <property name="userDao" ref="userDaoMysql/"></property> 
        <property name="userDao" ref="userDaoOracle/"></property> 
        -->
    </bean>