《深入浅出Spring》控制反转（IoC）与依赖注入（DI）

举例说明

• 引出spring

有2个类，A和B，如下：

public class A{
    public void sayHello(){}
}
public class B{
    public void sayHello();
}

上面2个类都有同样的sayHello方法。

现在我们调用B的sayHello方法完成一些事情，而B中的sayHello方法需要调用A中的sayHello方法才可以完成这个事情，所以B的代码变成了下面这样：

public class B{
    private A a; // @1
    public B(){
        this.a = new A(); //@2
    }
    public void sayHello(){
        this.a.sayHello(); //@3
    }
}

分析一下上面代码：

@1：B类中声明了一个A类型的属性a

@2：new了一个A对象，赋给了a属性

@3：B类中的sayHello方法中去调用a.sayHello()完成业务操作

先说一下什么是依赖关系？

当a对象完成某些操作需要调用b对象中的方法来实现时，说明a依赖于对象b，a和b是依赖关系。

上面代码中B的sayHello需要调用A的sayHello方法，说明了B依赖于A

上面代码存在一些问题问题

B类中a对象的创建被写死在B的构造方法中了，如果我们想在创建不同的B对象的时候，使用不同的a对象，此时是无能为力的；代码也不利于测试，由于B中a的创建被写死在构造方法中了，我们想测试一下B中不同a对象的效果，此时只能去修改B中的构造方法。

上面代码需要优化，B中a对象的创建不能写死，可以让外部传入进去，调整一下变成了下面这样

public class B {

    private A a;
    public B(A a){
        this.a = a;
    }
    public void sayHello(){
        this.a.sayHello(); 
    }
}

上面代码可以在创建B对象的时候，将外部创建好的a对象传入进去，此时a的控制权交给了使用者，创建B对象如下：

A a = new A();
B b = new B(a);
b.sayhello();
上面代码我们再扩展一下，如果B类中还需要依赖很多类似于A的对象，比如需要依赖于C、D、E、F或者更多对象，首先是需要调整B的构造方法，修改老的构造方法不是很好，可以在B中新增一些构造方法。

但是使用B的时候就变成了下面这样：

A a = new A();
C c = new C();
D d = new D();
E e = new E();
F f = new F();
…
B b = new B(a,c,d,e,f,…);
b.sayhello();

使用者创建B对象之前，需要先将B依赖的对象都给创建好，然后B依赖的这些对象传递给B对象，如果有很多地方都需要用到B类型的对象，都采用这种new的写法，代码量比较大，也不方便维护，如果B中新增了依赖，又需采用new的方式先创建好被依赖的对象，然后将被依赖的对象填充给B对象。

上面创建对象之前，需要先将被依赖对象通过new的方式创建好，然后将其传递给B，这些工作都是B的使用者自己去做的，所有对象的创建都是由使用者自己去控制的，弊端上面也说了，代码量也比较大，代码耦合度比较高（依赖有调整，改动也比较大），也不利于扩展。

那么有没有更好的方式来解决这些问题呢？

上面B对象以及B依赖的对象都是使用者自己主动去控制其创建的，能不能找一个第三方来把这个事情给做了，比如给第三方一个清单，清单中告诉第三方我需要用到B对象以及B需要依赖的对象，然后由这个第三方去负责创建和组装B对象，使用者需要使用B对象的时候，只需要向第三方发起一个查找，如果第三方那边有B对象，直接将其内部组装好的B对象返回就可以了，整个系统中所有需要用到的对象都可以列个清单，让第三方帮忙创造，用的时候只需要向第三方索取就可以了，当B中依赖的对象有新增或者删除的时候，只需要去调整一下清单就可以了，这个事情spring已经帮我们实现了。

spring容器

spring容器的概念，容器这个名字起的相当好，容器可以放很多东西，我们的程序启动的时候会创建spring容器，会给spring容器一个清单，清单中列出了需要创建的对象以及对象依赖关系，spring容器会创建和组装好清单中的对象，然后将这些对象存放在spring容器中，当程序中需要使用的时候，可以到容器中查找获取，然后直接使用。

IOC：控制反转

使用者之前使用B对象的时候都需要自己去创建和组装，而现在这些创建和组装都交给spring容器去给完成了，使用者只需要去spring容器中查找需要使用的对象就可以了；这个过程中B对象的创建和组装过程被反转了，之前是使用者自己主动去控制的，现在交给spring容器去创建和组装了，对象的构建过程被反转了，所以叫做控制反转；IOC是是面相对象编程中的一种设计原则，主要是为了降低系统代码的耦合度，让系统利于维护和扩展。

DI：依赖注入

依赖注入是spring容器中创建对象时给其设置依赖对象的方式，比如给spring一个清单，清单中列出了需要创建B对象以及其他的一些对象（可能包含了B类型中需要依赖对象），此时spring在创建B对象的时候，会看B对象需要依赖于哪些对象，然后去查找一下清单中有没有包含这些被依赖的对象，如果有就去将其创建好，然后将其传递给B对象；可能B需要依赖于很多对象，B创建之前完全不需要知道其他对象是否存在或者其他对象在哪里以及被他们是如何创建，而spring容器会将B依赖对象主动创建好并将其注入到B中去，比如spring容器创建B的时候，发现B需要依赖于A，那么spring容器在清单中找到A的定义并将其创建好之后，注入到B对象中。

总结

IOC控制反转，是一种设计理念，将对象创建和组装的主动控制权利交给了spring容器去做，控制的动作被反转了，降低了系统的耦合度，利于系统维护和扩展，主要就是指需要使用的对象的组装控制权被反转了，之前是自己要做的，现在交给spring容器做了。
DI依赖注入，表示spring容器中创建对象时给其设置依赖对象的方式，通过某些注入方式可以让系统更灵活，比如自动注入等可以让系统变的很灵活，这个后面的文章会细说。
spring容器：主要负责容器中对象的创建、组装、对象查找、对象生命周期的管理等等操作。

Spring容器基本使用及原理

IOC容器

IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由ioc容器进行管理，不需要我们再去手动通过new的方式去创建对象，由ioc容器直接帮我们组装好，当我们需要使用的时候直接从ioc容器中直接获取就可以了。

那么spring ioc容器是如何知道需要管理哪些对象呢？

需要我们给ioc容器提供一个配置清单，这个配置支持xml格式和java注解的方式，在配置文件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置文件，然后将这些对象给组装好以供外部访问者使用。

这里所说的IOC容器也叫spring容器。

Bean概念

由spring容器管理的对象统称为Bean对象。Bean就是普通的java对象，和我们自己new的对象其实是一样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

Spring容器使用步骤

引入spring相关的maven配置
创建bean配置文件，比如bean xml配置文件
在bean xml文件中定义好需要spring容器管理的bean对象
创建spring容器，并给容器指定需要装载的bean配置文件，当spring容器启动之后，会加载这些配置文件，然后创建好配置文件中定义好的bean对象，将这些对象放在容器中以供使用
通过容器提供的方法获取容器中的对象，然后使用

Spring容器对象

spring内部提供了很多表示spring容器的接口和对象，我们来看看比较常见的几个容器接口和具体的实现类。

BeanFactory接口

org.springframework.beans.factory.BeanFactory

spring容器中具有代表性的容器就是BeanFactory接口，这个是spring容器的顶层接口，提供了容器最基本的功能。

常用的几个方法

//按bean的id或者别名查找容器中的bean
Object getBean(String name) throws BeansException
//这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
//返回容器中指定类型的bean对象
<T> T getBean(Class<T> requiredType) throws BeansException;
//获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

ApplicationContext接口

org.springframework.context.ApplicationContext
这个接口继承了BeanFactory接口，所以内部包含了BeanFactory所有的功能，并且在其上进行了扩展，增加了很多企业级功能，比如AOP、国际化、事件支持等等。。

ClassPathXmlApplicationContext类

org.springframework.context.support.ClassPathXmlApplicationContext
这个类实现了ApplicationContext接口，注意一下这个类名称包含了ClassPath Xml，说明这个容器类可以从classpath中加载bean xml配置文件，然后创建xml中配置的bean对象，一会后面的案例就会用到这个类。

AnnotationConfigApplicationContext类

org.springframework.context.annotation.AnnotationConfigApplicationContext
这个类也实现了ApplicationContext接口，注意其类名包含了Annotation和config两个单词，上面我们有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。

注解的方式相对于xml方式更方便一些，也是我们比较推荐的方式，后面我们会大量使用这种方式，具体会详解。

使用xml文件的方式来学习spring

创建maven项目

<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>5.2.3.RELEASE</spring.version>
    </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>

目前我们使用spring最新的版本5.2.3.RELEASE，需要引入spring提供的3个构件

spring-core、spring-context、spring-beans

创建测试类Helloworld

package com.yuan11;

/**
 * @title: com.yuan11.Helloworld
 * @Author yuan11
 * @Date: 2022/5/31 23:53
 * @Version 1.0
 */
public class Helloworld {
    public void sayHello(){
        System.out.println("hellow world!!");
    }
}

在resource 目录下创建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-4.3.xsd">

    <!--
    定义一个bean
    id：bean的唯一标识，可以通过这个标识从容器中获取这个bean对象
    clss：这个bean的类型，完整类名称
    -->
    <bean id="helloWorld" class="com.yuan11.Helloworld"/>
</beans>

上面就是bean的定义文件，每个xml中可以定义多个bean元素，通过bean元素定义需要spring容器管理的对象，bean元素需指定id和class属性

id表示这个bean的标识，在容器中需要唯一，可以通过这个id从容器中获取这个对象；
class用来指定这个bean的完整类名
上面的配置文件中我们定义了一个helloWorld标识的HellWorld类型的bean对象。

创建测试类

package com.yuan11;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @title: ClientTest
 * @Author yuan11
 * @Date: 2022/6/1 0:03
 * @Version 1.0
 */
public class ClientTest {
    public static void main(String[] args) {
        //1.bean配置文件位置
        String beanXml = "classpath:beans.xml";
        //2.创建ClassPathXmlApplicationContext容器，给容器指定需要加载的bean配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);
        //3.从容器中获取需要的bean
        Helloworld helloWorld = context.getBean("helloWorld", Helloworld.class);
        //4.使用对象
        helloWorld.sayHello();
    }
}

上面main方法中有容器的详细使用步骤，需要先创建容器对象，创建容器的对象的时候需要指定bean xml文件的位置，容器启动之后会加载这些配文件，然后将这些对象构建好。

代码中通过容器提供的getBean方法从容器中获取了HellWorld对象，第一个参数就是xml中bean的id，第二个参数为bean对应的Class对象。

运行输出：
hellow world!!

源码查看：

我们用的是子类ClassPathXmlApplicationContext ，在beanFactory 父类 工厂类中属性 beanDefinitionMap 中添加了一条类定义信息

• 我们再添加一个类测试People

package com.yuan11;

/**
 * @title: People
 * @Author yuan11
 * @Date: 2022/6/1 0:18
 * @Version 1.0
 */
public class People {

    public void say(){
        System.out.println("i like spring!!");
    }
}

• 在bean.xml 文件中定义

 <bean id="people" class="com.yuan11.People"/>

• 重新启动调试
  
  此时我们看到beanFactory 属性beanDefinitionMap 中定义了两条数据。全部是bean.xml文件中声明的类。我们未对这两个类做任何的显示声明，beanFactory 已经帮我们声明完成，此时我们只要从map中取出我们需要的value 就能取到类的定义信息。

People people = context.getBean("people",People.class);
        people.say();

运行结果如下：
hellow world!!
i like spring!!

总结：

spring容器通过扫描bean.xml 文件帮助我们注入了定义的bean (class)，我们将bean的控制权交给了spring容器。