Spring快速入门（二）---IOC容器

IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。

Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。

我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。

IoC 容器是 Spring 框架中最重要的核心组件之一，它贯穿了 Spring 从诞生到成长的整个过程。

1、IoC容器

1.1、控制反转（IoC）

        在传统的程序设计中，对象之间的依赖关系通常由对象自身控制，即一个对象直接创建new和管理其依赖的对象。而在控制反转中，对象的创建和管理被反转，由外部容器来负责创建和管理对象，而被依赖的对象则通过接口、构造函数、属性注入等方式传递给被依赖的对象，从而实现了解耦。

        控制反转指的是将控制权交给外部容器，由容器来决定和管理组件之间的依赖关系和执行流程。

• 控制反转是一种思想。

• 控制反转是为了降低程序耦合度，提高程序扩展力。

• 控制反转，反转的是什么？

• • 将对象的创建权利交出去，交给第三方容器负责。

    • 将对象和对象之间关系的维护权交出去，交给第三方容器负责。

• 控制反转这种思想如何实现呢？

• • DI（Dependency Injection）：依赖注入

原理：

1.2、依赖注入（DI）

依赖注入（Dependency Injection，简称DI）是面向对象编程中的一种设计模式，依赖注入实现了控制反转的思想。。在DI模式中，组件之间的依赖关系由外部容器（通常是一个框架或者一个容器）来负责管理和注入，而不是由组件自己去创建或者查找依赖对象。例如，将对象B注入（赋值）给对象A的成员变量。

依赖注入则是控制反转的一种具体实现方式，用于管理和注入组件的依赖对象。

依赖注入：

• 指Spring创建对象的过程中，将对象依赖属性通过配置进行注入

依赖注入常见的实现方式包括两种：

• 第一种：set注入

• 第二种：构造注入

所以结论是：IOC 就是一种控制反转的思想， 而 DI 是对IoC的一种具体实现。

Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。

1.3、IoC容器在Spring的实现

Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式：

①BeanFactory

这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

②ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

类型名	简介
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

1.4、Ioc和DI关系

1. 定义：

   • 依赖注入（DI）：依赖注入是一种设计模式，用于解决组件之间的依赖关系管理问题。在DI模式中，依赖关系由外部容器负责管理和注入，而不是由组件自己创建或查找依赖对象。

   • 控制反转（IoC）：控制反转是一种编程范式，其核心思想是将控制权从组件内部转移到外部容器，由容器来决定和管理组件之间的依赖关系和执行流程。

2. 关注点：

   • 依赖注入（DI）：DI关注的是组件之间的依赖关系管理，它解决了组件之间依赖关系的创建和维护问题。

   • 控制反转（IoC）：IoC关注的是控制权的转移，它通过将控制权交给外部容器来实现组件的解耦和松耦合设计。

3. 实现方式：

   • 依赖注入（DI）：DI通过将依赖对象注入到组件中来实现，常见的实现方式包括构造函数注入、属性注入和接口注入等。

   • 控制反转（IoC）：IoC通过将控制权交给外部容器来实现，常见的实现方式包括依赖查找和依赖注入等。

4. 关系：

   • 依赖注入（DI）是控制反转（IoC）的一种具体实现方式，是实现IoC的手段之一。

   • 控制反转（IoC）是一种更广泛的编程范式，它包含了依赖注入在内的多种实现方式，如依赖查找、服务定位等。

总的来说，依赖注入是实现控制反转的一种具体方式，它解决了组件之间的依赖关系管理问题，而控制反转则是一种更广义的编程思想，强调将控制权从组件内部转移到外部容器，实现组件之间的解耦和松耦合设计。

2、基于XML管理Bean

2.1、搭建子模块spring1

①搭建模块

如上

②引入配置文件

引入spring-first模块配置文件：applicationContext.xml、log4j2.xml

③添加依赖

④引入java类User

在java路径下，创建一个com.example.IOCxml的文件夹

package com.example.IOCxml;
​
public class User {
    private String name;
    private Integer age;
​
    private void run(){
        System.out.printf("run...");
    }
}

​

⑤编写配置文件

<bean id="user" class="com.example.IOCxml.User"></bean>

2.2、获取bean

①方式一：根据id获取

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据id获取对象
        User user=(User)context.getBean("user");
        System.out.println("根据id获取bean"+user);
//根据id获取beancom.example.IOCxml.User@e25b2fe
​

②方式二：根据类型获取

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user2=context.getBean(User.class);
        System.out.println("根据类型获取bean"+user);
//根据类型获取beancom.example.IOCxml.User@e25b2fe

③方式三：根据id和类型

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user3=context.getBean("user",User.class);
        System.out.println("根据id和类型获取bean"+user);
//根据id和类型获取beancom.example.IOCxml.User@e25b2fe

④注意的地方

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个

当IOC容器中一共配置了两个：

<bean id="user" class="com.example.IOCxml.User"></bean>
<bean id="user1" class="com.example.IOCxml.User"></bean>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.atguigu.spring6.bean.HelloWorld’ available: expected single matching bean but found 2: user,user1

----当Spring框架在处理依赖注入时，它会根据类型匹配原则来查找合适的Bean进行注入。如果有多个同类型的Bean存在，Spring会期望有一个明确的选择来决定使用哪一个。然而，如果没有给出明确的指定，比如通过@Primary或@Qualifier注解，Spring就无法做出这个决定，因此会抛出NoUniqueBeanDefinitionException异常。

⑤扩展知识

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是bean唯一

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为bean不唯一

package com.example.IOCxml.Bean;
​
public interface UserDao {
    public void run();
}
//UserDao.java

package com.example.IOCxml.Bean;
​
public class UserDaoImpl implements UserDao {
​
    public void run() {
        System.out.println("run...");
    }
​
}
//UserDaoImpl.java

<!--一个接口，实现类获取对象-->
    <bean id="user" class="com.example.IOCxml.Bean.UserDaoImpl"></bean>
public class TestUserImpl {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContextImpl.xml");
        //根据类型获取对象
        UserDao userdao =context.getBean(UserDao.class);
        userdao.run();
    }
}

结论

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

java中，instanceof运算符用于判断前面的对象是否是后面的类，或其子类、实现类的实例。如果是返回true，否则返回false。也就是说：用instanceof关键字做判断时， instanceof 操作符的左右操作必须有继承或实现关系

2.3、依赖注入之setter注入

1.创建类，定义属性，生成属性set方法

2.在spring配置文件配置

①创建学生类Book

package com.example.IOCxml;
​
public class Book {
    private String Bname;
    private String Author;
​
    public String getBname() {
        return Bname;
    }
​
    public void setBname(String bname) {
        Bname = bname;
    }
​
    public String getAuthor() {
        return Author;
    }
​
    public void setAuthor(String author) {
        Author = author;
    }
​
    @Override
    public String toString() {
        return "Book{" +
                "Bname='" + Bname + '\'' +
                ", Author='" + Author + '\'' +
                '}';
    }
}
​

②配置bean时为属性赋值

applicationset.xml

   <bean id="book" class="com.example.IOCxml.Book">
        <property name="author" value="东野圭吾"></property>
        <property name="bname" value="白夜行"></property>
    </bean>

③测试

public class TestBook {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationset.xml");
        Book book=(Book)context.getBean("book");
​
        System.out.println(book);
    }
}
//Book{Bname='白夜行', Author='东野圭吾'}

2.4、依赖注入之构造器注入

1.创建类，定义属性，生成有参数构造方法

2.进行配置

①在Book类中添加有参构造

    public Book(String Bname,String Author){
        this.Author=Author;
        this.Bname=Bname;
    }

②配置bean时为属性赋值

application.xml

   <bean id="book" class="com.example.IOCxml.Book">
        <constructor-arg name="Author" value="东野圭吾"></constructor-arg>
        <constructor-arg name="Bname" value="白夜行"></constructor-arg>
    </bean>

③测试

public class TestBook {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("application.xml");
        Book book=(Book)context.getBean("book");
​
        System.out.println(book);
    }
}
//有参。。。
//Book{Bname='白夜行', Author='东野圭吾'}

注意：

constructor-arg标签还有两个属性可以进一步描述构造器参数：

• index属性：指定参数所在位置的索引（从0开始）

• name属性：指定参数名

2.5、特殊值处理

①字面量赋值

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>

②null值

<property name="name">
    <null />
</property>

③xml实体

<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替，特殊符号使用转义 -->
<property name="expression" value="a &lt; b"/>

④CDATA节

<property name="expression">
    <!-- 解决方案二：使用CDATA节 -->
    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
    <!-- 所以CDATA节中写什么符号都随意 -->
    <value><![CDATA[a < b]]></value>
</property>

2.6、为对象类型属性赋值

前期准备：

创建一个部门类：

package com.example.IOCxml.job;
//部门
public class Dept {
    private String bname;
​
    public String getBname() {
        return bname;
    }
​
    public void setBname(String bname) {
        this.bname = bname;
    }
​
    public void run(){
        System.out.println("dept......"+bname);
    }
}

创建一个员工类：

package com.example.IOCxml.job;
//员工
public class Emp {
    private Dept dept;
​
    private String ename;
    private String age;
​
    public Dept getDept() {
        return dept;
    }
​
    public void setDept(Dept dept) {
        this.dept = dept;
    }
​
    public String getEname() {
        return ename;
    }
​
    public void setEname(String ename) {
        this.ename = ename;
    }
​
    public String getAge() {
        return age;
    }
​
    public void setAge(String age) {
        this.age = age;
    }
​
    public void work(){
        System.out.println("emp work....");
        dept.run();
    }
}

方法一：应用外部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">
​
    <bean id="dept" class="com.example.IOCxml.job.Dept">
        <property name="bname" value="销售"></property>
    </bean>
​
    <bean id="emp" class="com.example.IOCxml.job.Emp">
        <!--普通属性注入-->
        <property name="ename" value="张"></property>
        <property name="age" value="25"></property>
        <!--注入对象类型属性-->
        <property name="dept" ref="dept"></property>
    </bean>
​
​
</beans>

编写测试类：

public class TestJob {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationBean.xml");
​
        Emp emp=(Emp) context.getBean("emp");
        emp.work();
    }
}

首先两个bean标签--创建dept对象和emp对象，进行注入普通类型属性，在emp的bean标签里面，通过relf将前面的bean创建的dept对象注入。

方式二：内部bean

编写xml文件

    <bean id="emp" class="com.example.IOCxml.job.Emp">
        <!--普通属性注入-->
        <property name="ename" value="张"></property>
        <property name="age" value="25"></property>
        <!--注入对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.example.IOCxml.job.Dept">
                <property name="bname" value="销售"></property>
            </bean>
        </property>
    </bean>

​

编写测试类

public class TestJob {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationBean.xml");
​
        Emp emp=(Emp) context.getBean("emp");
        emp.work();
    }
}

有一种dept的bean标签包含到emp的bean标签的感觉。

方式三：级联属性赋值

编写xml文件

    <bean id="dept" class="com.example.IOCxml.job.Dept">
        <property name="bname" value="销售"></property>
    </bean>
    
    <bean id="emp" class="com.example.IOCxml.job.Emp">
        <!--普通属性注入-->
        <property name="ename" value="张"></property>
        <property name="age" value="25"></property>
        <!--注入对象类型属性-->
        <property name="dept" ref="dept"></property>
        <property name="dept.bname" value="财务部"></property>
    </bean>
​

编写测试类：

public class TestJob {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationBean.xml");
​
        Emp emp=(Emp) context.getBean("emp");
        emp.work();
    }
}

先进行外部引入dept，再次进行property标签，value将值进行更新，name需要设置成对象的对应属性。

2.7、为数组类型属性赋值

​

    <bean id="dept" class="com.example.IOCxml.job.Dept">
        <property name="bname" value="销售"></property>
    </bean>
    
    <bean id="emp" class="com.example.IOCxml.job.Emp">
        <!--普通属性注入-->
        <property name="ename" value="张"></property>
        <property name="age" value="25"></property>
        <!--注入对象类型属性-->
        <property name="dept" ref="dept"></property>
        <!--数组类型属性-->
        <property name="hobby">
            <array>
                <value>吃饭</value>
                <value>睡觉</value>
            </array>
        </property>
    </bean>

2.8、为集合类型属性赋值

①为List集合类型属性赋值

在dept类中，创建一个emp的list集合以及对应的get和set方法

    private List<Emp> emp;
​
    public List<Emp> getEmp() {
        return emp;
    }
​
    public void setEmp(List<Emp> empList) {
        this.emp = empList;
    }
        public void run(){
        System.out.println("dept......"+bname);
        <!--对集合进行遍历-->
        for(Emp emp:emp){
            System.out.println(emp);
        }
    }

编写xml文件

​
    <bean id="emp01" class="com.example.IOCxml.job.Emp">
        <property name="ename" value="汪"></property>
        <property name="age" value="20"></property>
    </bean>
    <bean id="emp02" class="com.example.IOCxml.job.Emp">
        <property name="ename" value="陈"></property>
        <property name="age" value="25"></property>
    </bean>
    <bean id="dept" class="com.example.IOCxml.job.Dept">
        <property name="bname" value="财务"></property>
        <property name="emp">
            <list>
                <ref bean="emp01"></ref>
                <ref bean="emp02"></ref>
            </list>
        </property>
    </bean>

​

通过list标签中的ref将emp01和emp02数据引入到集合中。其中第二个property标签的名字为集合的名称。

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建需要的类：

//teacher
package com.example.IOCxml.Student;
​
public class Teacher {
    private String tid;
    private String tname;
​
    public String getTid() {
        return tid;
    }
​
    public void setTid(String tid) {
        this.tid = tid;
    }
​
    public String getTname() {
        return tname;
    }
​
    public void setTname(String tname) {
        this.tname = tname;
    }
​
}

​

//student
​
package com.example.IOCxml.Student;
​
import java.util.Map;
​
public class Student {
    private String sid;
    private String sname;
    private Map<String,Teacher> teachermap;
​
    @Override
    public String toString() {
        return "Student{" +
                "sid='" + sid + '\'' +
                ", sname='" + sname + '\'' +
                ", teachermap=" + teachermap +
                '}';
    }
​
    public String getSid() {
        return sid;
    }
​
    public void setSid(String sid) {
        this.sid = sid;
    }
​
    public String getSname() {
        return sname;
    }
​
    public void setSname(String sname) {
        this.sname = sname;
    }
​
    public Map<String, Teacher> getTeachermap() {
        return teachermap;
    }
​
    public void setTeachermap(Map<String, Teacher> teachermap) {
        this.teachermap = teachermap;
    }
}
​

编写xml文件

​

    <!--创建两个对象，分别为teacher和student-->
    <!--注入普通类型属性-->
    <!--在学生bean中注入map集合类型属性-->
    <bean id="teacher" class="com.example.IOCxml.Student.Teacher">
        <property name="tid" value="200"></property>
        <property name="tname" value="陈"></property>
    </bean>
    <bean id="student" class="com.example.IOCxml.Student.Student">
        <property name="sid" value="100"></property>
        <property name="sname" value="王"></property>
        <property name="teachermap">
            <map>
                <entry>
                    //键，值
                    <key><value>1</value></key>
                    <ref bean="teacher"></ref>
                </entry>
            </map>
        </property>
    </bean>