简单介绍：

在之前的入门程序中，我们简单的介绍了关于Spring框架中的控制反转的概念，这次我们就来详细的介绍和体验一下Spring中的控制反转的理论和实操。

使用方法：

控制反转（IoC）是面向对象编程中的一个设计原则，用于降低代码之间的耦合度。

在传统的面向对象编程中，获取对象的方式使用关键字”new“主动创建一个对象，也就是说，应用程序掌握着对象的控制权。在使用Spring框架之后，对象的实例不再由调用者创建，而是由Spring的IoC容器来创建，IoC容器会负责控制程序之前的关系，而不是由调用者的成都代码直接控制。

IoC设计原则是借助于IoC容器实现具有依赖关系对象之间的解耦，各个对象封装之后，通过IoC容器来关联这些对象类。这样对象类与对象类之间就通过IoC容器进行联系，而对象类与对象类之间没有什么直接联系。

引用程序引入IoC容器之后，在客户端类中将不再创建对象类，而是直接从IoC容器中获取所需的对象类中。

这句话就是IoC的和核心思想，说白了，就是将我们之前通过new关键字创建对象的过程，替换成使用IoC容器中的getBean()方法来获取我们所需要的对象。

代码实现：

我们再复习一下之前我们的Spring的入门程序中的操作步骤：

1.首先在pom文件中引入Spring的Maven坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency><!--Spring IOC-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.21.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2.创建Java对象类

package com.spring;

public class user {
    private int id;
    private String name;

    public void show(){
        System.out.println("你好"+name);
    }

    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public user(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public user() {
    }
}

3.编辑Bena管理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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.spring.user">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
    </bean>

</beans>

4.编写测试类进行测试

import com.spring.user;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("userBeanContext.xml");
        user u = (user) context.getBean("user");
        System.out.println(u.toString());
    }
}

这些是创建一个入门程序的大致步骤，然后接下来，如果上一个案例中我们成功的运行出结果，那么现在我们可以继续使用这个案例文件，我们来看一下运行结果：

就是输出user类的信息这个简单的案例。我们要体会的有两个部分，首先就是我们的创建对象部分，我们并没有出现 user u = new user()的语句，也就是说我们没有出现new user()的过程，而是通过IoC的容器中获取到了user对象，其中，ClassPathXmlApplicationContext()就是我们所说的Ioc容器，getBean()方法就是我们所有的由IoC容器来获取对象类，也就是用getBean()方法去代替我们的new关键字。

IoC的另一个作用：我们并不关心类的依赖关系，我们只需要知道我们应该获取那个对象即可

关于Bean的依赖关系属于是管理和维护Bean的方面，而IoC在Bean的管理方面的理念是，对于我们来说，我们并不需要关心Bean是如何来的，以及类的依赖关系，而是侧重于我们只需要知道我们需要获取的对象即可。那么我们也会以代码的形式来将理论融入到实践中

我们现在添加一个新的类，起名叫做student：

package com.spring;

public class student {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "com.spring.student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public student() {
    }
}

我们让user类去依赖这个类，所谓的依赖关系，就是user类中有一个属性是student类。

当我们创建user类的时候，我们会需要先创建student类，这就是类的依赖关系。在之前的传统的开发中，遇到一个类需要依赖另一个类的时候，我们需要先创建另一个类，之后才能创建需要的类，但是在Spring框架中，IoC会帮我们完成这种依赖关系，具体的配置文件如下：

第一个红色框是我们被依赖的类，也就是student类，而在user类中，我们创建一个新的属性，它的类型就是student，然后我们使用一个特殊的属性ref，这个属性的全称叫做reference（引用），这个属性是用来给引用数据类型赋值的，这个属性的值指向我们创建被依赖的类的<bean>标签的id的值，对应到我们的案例中也就是创建student的<bean>标签的id的值，之后我们继续在测试类中执行我们之前的代码即可

运行结果：

可以看到，我们只是得到了user类，但是我们输出的时候依然得到了student类的数据，也就是说它其实隐藏了一个创建student并且赋值给user类的过程并没有让我们看见，或者说并不需要我们去关心，这就是IoC帮我们自动维护了类之间的依赖关系，我们只需要明确我们需要那个对象并从IoC容器中获取即可。