Spring的容器之IoC（一）

Spring的容器之IoC（一）

IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。

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

1.1、IoC容器

1.1.1、控制反转（IoC）

• 控制反转是一种思想。
• 控制反转是为了降低程序耦合度，提高程序扩展力。
• 控制反转，反转的是什么？
• • 将对象的创建权利交出去，交给第三方容器负责。
  • 将对象和对象之间关系的维护权交出去，交给第三方容器负责。
• 控制反转这种思想如何实现呢？
• • DI（Dependency Injection）：依赖注入

1.1.2、依赖注入

DI（Dependency Injection）：依赖注入，依赖注入实现了控制反转的思想。

依赖注入：

• 指Spring创建对象的过程中，将对象依赖属性通过配置进行注入
• 依赖指的是对象和对象之间的关联关系。
• 注入指的是一种数据传递行为，通过注入行为来让对象和对象产生关系。

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

• 第一种：set注入
• 第二种：构造注入

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

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

1.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.2、基于XML管理Bean

1.2.1、搭建子模块spring6-ioc-xml

①搭建模块

搭建方式如：spring6_03，此处用的是Spring6，JDK17

②添加依赖

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.3</version>
    </dependency>
​
    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
​
    <!--log4j2的依赖-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.19.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j2-impl</artifactId>
        <version>2.19.0</version>
    </dependency>
</dependencies>

③引入配置文件

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

<!-- 这是Spring的配置文件 文件名可以随便命名，必须是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标签表示一个Java类并且如果使用了配置文件，配置文件里的类会被加载到容器里面-->
    <bean id="UserDAOBean" class="com.qiuye.spring6_03.dao.UserDAO"></bean>

    <bean id="UserMysqkDAOBean" class="com.qiuye.spring6_03.dao.UserMysqlDAO"></bean>

    <bean id="UserServiceBean" class="com.qiuye.spring6_03.service.UserService">
        <property name="userDAO" ref="UserDAOBean"></property>
        <property name="userMysqlDAO" ref="UserMysqkDAOBean"></property>
    </bean>

</beans>

bean标签表示一个Java类，如果使用了配置文件，该配置文件里的类会被加载到容器里面。bean标签里的id表示该类的唯一标识，不可重复；bean标签里面的class表示该类的全量类名；bean标签下的property表示该类的属性。

④引入java类

引入spring-first模块java及test目录下实体类
这里是将userDao和userMysqlDao注入到UserService里，它们都有一个add方法。

public class UserService {
    private UserDAO userDAO;
    private UserMysqlDAO userMysqlDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void setUserMysqlDAO(UserMysqlDAO userMysqlDAO) {
        this.userMysqlDAO = userMysqlDAO;
    }

    public void add(){
        userDAO.add();
        userMysqlDAO.add();
    }
}
​

public class HelloWorldTest {
​
    private Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);
​
    @Test
    public void test(){
        
    }
}

1.2.2、获取bean

①方式一：根据id获取

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

@Test
public void testHelloWorld1(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    UserDAO bean = ac.getBean("UserDAOBean");
    bean.add();
}

使用ClassPathXmlApplicationContext获取ApplicationContext的话，配置文件必须放在根目录下

②方式二：根据类型获取

@Test
public void testHelloWorld1(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    UserDAO bean = ac.getBean(UserDAO.class);
    bean.add();
}

③方式三：根据id和类型

@Test
public void testHelloWorld2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    UserDAO bean = ac.getBean("UserDAOBean", UserDAO.class);
    bean.add();
}

④注意的地方

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

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

<bean id="helloworldOne" class="com.atguigu.spring6.bean.HelloWorld"></bean>
<bean id="helloworldTwo" class="com.atguigu.spring6.bean.HelloWorld"></bean>

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

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.atguigu.spring6.bean.HelloWorld' available: expected single matching bean but found 2: helloworldOne,helloworldTwo

⑤扩展

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

这是可以的，但前提是实现该接口的bean唯一

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

此时是不行，因为bean不唯一

结论

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

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