Spring学习第3篇：Spring容器的基本使用

绝地灬酷狼 2024-04-01 13:32 69阅读 0赞

> 大家家好，我是一名网络怪咖，北漂五年。相信大家和我一样，都有一个大厂梦，作为一名资深Java选手，深知Spring重要性，现在普遍都使用SpringBoot来开发，面试的时候SpringBoot原理也是经常会问到，SpringBoot是为了简化Spring开发，但是底层仍然是Spring。如果不了解Spring源码，那就更别提SpringBoot源码了，接下来我准备用两个月时间，从基础到源码彻彻底底的学习一遍Spring。  
>   
> 学习框架一定要踏踏实实一步一个脚印的学，很多人都比较喜欢急功近利，选择跳着学，包括我有时候也是，最终会发现你不但节约不了时间，反而会更耗时，而且学着学着很容易放弃。

#### 目录 ####

*   *  一、概念知识
     *  二、入门练习
     *  三、BeanFactory接口
     *  四、BeanFactory 和 ApplicationContext 区别
     *  五、bean 标签和管理对象细节
     *   *  5.1.bean 标签
         *  5.2.alias元素
         *  5.3.bean 的作用范围和生命周期
         *  5.4.实例化 Bean 的四种方式
     *  六、import元素

### 一、概念知识 ###

**IOC容器也叫spring容器**

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

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

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

**Bean概念**

> Bean :在计算机英语中，有可重用组件的含义，由spring容器管理的对象统称为`Bean对象`。其实只是一个称呼而已，`Bean对象`就是普通的java对象，和我们自己new的对象其实是一样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

**Spring容器使用步骤**

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

### 二、入门练习 ###

往后要练习的模块有很多，这里我们直接使用maven父子工程。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70][]

> 只需要引入spring-context的依赖就可以了

（1）父工程的pom.xml

<?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>com.gzl.cn</groupId>
        <artifactId>spring-demo</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
        	<module>spring-ioc-xml</module>
        </modules>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            
            <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
            
            <maven.compiler.source>8</maven.compiler.source>
            
            <maven.compiler.target>8</maven.compiler.target>
            <spring.version>5.3.23</spring.version>
        </properties>
    
        
        <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>org.springframework</groupId>
                   <artifactId>spring-context</artifactId>
                   <version>${spring.version}</version>
               </dependency>
           </dependencies>
        </dependencyManagement>
    </project>

（2）子工程pom.xml

（3）添加TestController 和 TestService

public class TestController {
        
    
    	public TestController() {
        
            System.out.println("TestController初始化了");
        }
    
        public void method1(){
        
            System.out.println("method1");
        }
    
        public void method2(){
        
            System.out.println("method2");
        }
    }

public class TestService {
        
    
    	public TestService() {
        
            System.out.println("TestService初始化了");
        }
     
        public void method1() {
        
            // 业务省略...
        }
    
        public void method2() {
        
            // 业务省略...
        }
    }

（4）添加bean.xml

上面这一大堆url是命名空间，也就是提供了bean标签，spring需要根据这个来进行解析bean标签，如果没有他的话启动会报错

<?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="testService" class="com.gzl.cn.service.TestService"/>
        <bean id="testController" class="com.gzl.cn.controller.TestController"/>
    </beans>

（5）添加测试类

public class Client {
        
        public static void main(String[] args) {
        
            // 默认就是从项目根路径寻找bean.xml, classpath:bean.xml 和 bean.xml 是一样的效果
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
            TestController testController = (TestController)classPathXmlApplicationContext.getBean("testController");
            TestService testService = (TestService)classPathXmlApplicationContext.getBean("testService");
            System.out.println(testController);
            System.out.println(testService);
            testController.method1();
        }
    }

运行结果：

> 通过运行结果不难发现，spring是通过我们提供的xml知道需要创建哪些对象，并通过无参构造器进行创建。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 1][]

这里还有一个细节问题，当ClassPathXmlApplicationContext初始化过后，xml当中声明的对象就已经全部都初始化了。也就是对象是随着容器的初始化进行初始化的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 2][]

### 三、BeanFactory接口 ###

通过上面示例不能发现classPathXmlApplicationContext就是spring容器的核心，classPathXmlApplicationContext是BeanFactory下面的一个类，spring内部提供了很多表示spring容器的接口和对象，我们上面入门demo使用的是xml配置，所以这里用到了classPathXmlApplicationContext，我们来看看比较常见的几个容器接口和具体的实现类。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 3][]

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

源码当中是有注释的：[https://github.com/spring-projects/spring-framework/blob/main/spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java][https_github.com_spring-projects_spring-framework_blob_main_spring-beans_src_main_java_org_springframework_beans_factory_BeanFactory.java]

public interface BeanFactory {
        
    
    	// 按bean的id查找容器中的bean
        Object getBean(String var1) throws BeansException;
    	// 这个是一个泛型方法，按照bean的id查找指定类型的bean，返回指定类型的bean对象
        <T> T getBean(String var1, Class<T> var2) throws BeansException;
    	// 返回容器中指定id的bean对象，允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数(如果有的话)
        Object getBean(String var1, Object... var2) throws BeansException;
    	// 根据class类型来寻找bean
        <T> T getBean(Class<T> var1) throws BeansException;
    	// 根据class类型来寻找bean，允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数(如果有的话)
        <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
    	// 返回指定bean的提供程序，允许延迟按需检索实例，包括可用性和惟一性选项。这个方法比较特别，以后会专门来讲
        <T> ObjectProvider<T> getBeanProvider(Class<T> var1);
        <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
    	// 根据名称判断bean是否存在
        boolean containsBean(String var1);
    	// 是否为单实例Bean
        boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
    	// 是否为原型（多实例）
        boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
    	// 检查给定名称的调用是否会返回一个可赋值给指定目标类型的对象。
        boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
        boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
    	// 根据bean的id查找返回的对象类型。
        @Nullable
        Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
        @Nullable
        Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;
    	// 根据实例的名字获取实例的别名
        String[] getAliases(String var1);
    }

### 四、BeanFactory 和 ApplicationContext 区别 ###

这个问题在面试的时候经常会问

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 4][]

> `BeanFactory`有一个子接口`ApplicationContext`，也被称为`Spring`上下文，`spring Ioc`容器的实现，从根源上是`beanfactory`，它继承了BeanFactory的基本功能， 同时也继承了容器的高级功能，如：MessageSource（国际化资源接口）、ResourceLoader（资源加载接口）、ApplicationEventPublisher（应用事件发布接口）等。轮层级来说，真正可以作为一个可以独立使用的ioc容器还是`DefaultListableBeanFactory`，因此可以这么说，`DefaultListableBeanFactory` 是整个spring ioc的始祖。

ApplicationContext：是IOC容器另一个重要接口，

*  BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
 *  ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
 *  BeanFactory：什么时候使用什么时候创建对象。

因为`ApplicationContext`和`BeanFactory`两个都是接口我们没法从功能上区分，所以我们可以通过`classPathXmlApplicationContext` 和`XmlBeanFactory`来进行比较，`classPathXmlApplicationContext` 属于`ApplicationContext`，而 `XmlBeanFactory`属于`BeanFactory`系列的，`XmlBeanFactory`继承自`DefaultListableBeanFactory`，重写了一些功能，使自己更强大。

public class Client {
        
        public static void main(String[] args) {
        
            XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("bean.xml"));
        }
    }

运行结果：并没有访问无参构造器初始化，当通过XmlBeanFactory 第一次访问getBean方法的时候才会触发初始化！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 5][] ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 6][]

接下来再来看classPathXmlApplicationContext：

运行结果：不管使用没使用都会触发初始化！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 7][]

**这里我们简单做个总结：**

*  关系：BeanFactory和ApplicationContext都是接口，BeanFactory是最顶级的接口，ApplicationContext是BeanFactory的子接口。
 *  BeanFactory中定义了各种bean的方法，比如根据id或者类型来获取bean，以及判断bean是否存在等方法。ApplicationContext继承了他的所有方法，并且还继承了很多接口，如：MessageSource（国际化资源接口）、ResourceLoader（资源加载接口）、ApplicationEventPublisher（应用事件发布接口）等。
 *  初始化：接口就是定义方法，压根没功能，一般说起来功能的差距也就是上面我们所测试的`classPathXmlApplicationContext` 和`XmlBeanFactory`的区别，XmlBeanFactory就是对应的BeanFactory，BeanFactory是懒加载方式，只在第一次使用的时候初始化。而`classPathXmlApplicationContext` 是初始化容器的时候加载所有对象。

**ApplicationContext 接口的实现类**

*  ClassPathXmlApplicationContext：它是从类的根路径下加载xml配置文件 推荐使用这种
 *  FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
 *  AnnotationConfigApplicationContext：注意其类名包含了Annotation和config两个单词，上面我们有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。

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

### 五、bean 标签和管理对象细节 ###

#### 5.1.bean 标签 ####

**作用：**

*  用于配置对象让 spring 来创建的。
 *  默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

**格式：**

**属性：**

*  `id：`给对象在容器中提供一个唯一标识。
 *  `name：` 每个bean都有一个名称，叫做bean名称，bean名称在一个spring容器中必须唯一，否则会报错，通过bean名称可以从spring容器获取对应的bean对象。但是这个bean名称是可以存在多个的。
 *  `class：`指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
 *  `scope：`指定对象的作用范围。
    
     *  singleton :默认值，单例的
     *  prototype :多例的
     *  request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中
     *  session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中
     *  global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session
 *  `init-method：`指定类中的初始化方法名称，也就是创建对象的时候执行。
 *  `destroy-method：`指定类中销毁方法名称，卸载对象的时候执行。
 *  `factory-bean：`工厂bean名称，使用后面会讲到
 *  `factory-method：`工厂方法，使用后面会讲到

![在这里插入图片描述][ded550a0fc084d8ea02f8fea0531d4cf.png]

**bean别名**

> 相当于人的外号一样，一个人可能有很多外号，当别人喊这个人的名称或者外号的时候，都可以找到这个人。那么bean也一样，也可以给bean起几个外号，这个外号在spring中叫做bean的别名，spring容器允许使用者通过名称或者别名获取对应的bean对象。

**名称和别名可以通过bean元素中的id和name来定义，具体定义规则如下：：**

*  当id存在的时候，不管name有没有，取id为bean的名称
 *  当id不存在，此时需要看name，name的值可以通过`,;或者空格`分割，最后会按照分隔符得到一个String数组，数组的第一个元素作为bean的名称，其他的作为bean的别名
 *  当id和name都存在的时候，id为bean名称，name用来定义多个别名
 *  当id和name都不指定的时候，bean名称自动生成，生成的规则是`全类名#序号` 序号是从0开始，多个别名的话依次往下排。
    
     *  ![在这里插入图片描述][368484481ec847f88254b5dfd6f0a7e0.png]

**`一个实例 bean 可以没有别名，但是一定存在bean名称！`**

获取当前名称的bean所有别名：`String[] aliases = context.getAliases(beanName);`  
获取容器所有名称：`String[] beanDefinitionNames = classPathXmlApplicationContext.getBeanDefinitionNames();`

**通过下面示例来加深一下别名和名称：**

public class Client {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
            String[] beanDefinitionNames = classPathXmlApplicationContext.getBeanDefinitionNames();
            for (String name : beanDefinitionNames) {
        
                System.out.println("获取bean名称为:" + name + "的别名");
                String[] testServices = classPathXmlApplicationContext.getAliases(name);
                System.out.println(Arrays.asList(testServices));
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 8][]

#### 5.2.alias元素 ####

alias元素也可以用来给某个bean定义别名，语法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 9][]

> 在beanFactory中维护着一个名为aliasMap的Map<String,String>集合，存储别名和beanName之间的映射关系

#### 5.3.bean 的作用范围和生命周期 ####

单例对象：scope=“singleton”  
一个应用只有一个对象的实例。  
生命周期：  
对象出生：当应用加载，创建容器时，对象就被创建了。  
对象活着：只要容器在，对象一直活着。  
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope=“prototype”  
每次访问对象时，都会重新创建对象实例。  
生命周期：  
对象出生：当使用对象时，创建新的对象实例。  
对象活着：只要对象在使用中，就一直活着。  
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

#### 5.4.实例化 Bean 的四种方式 ####

**第一种方式：使用默认无参构造函数**

<bean id="testService" class="com.gzl.cn.service.TestService"/>

**第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象**

> 静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其静态方法配置给Spring即可

public class TestController {
        
    	/**
    	* 模拟一个静态工厂，创建业务层实现类
    	*/
        public static TestService testService() {
        
            return new TestService();
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            // 1.使用 ApplicationContext 接口，就是在获取 spring 容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
            // 2.根据 bean 的 id 获取对象
            TestService testService = (TestService)classPathXmlApplicationContext.getBean("testService");
            testService.method1();
        }
    }

**第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象**

> 实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean

public class TestController {
        
        /**
         * 模拟一个实例工厂，创建业务层实现类
         * 此工厂创建对象，必须现有工厂实例对象，再调用方法
         */
        public TestService testService() {
        
            return new TestService();
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            // 这个参数就是传xml所在的位置，默认就是从项目根路径寻找bean.xml, classpath:bean.xml 和 bean.xml 是一样的效果
            // 1.使用 ApplicationContext 接口，就是在获取 spring 容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
            // 2.根据 bean 的 id 获取对象
            TestController testController = (TestController) classPathXmlApplicationContext.getBean("testController");
            TestService testService = (TestService) classPathXmlApplicationContext.getBean("testService");
            System.out.println(testController);
            System.out.println(testService);
            System.out.println(testController.testService());
        }
    }

这里有一个细节，就是从容器当中取出来的工厂类，再次执行工厂方法拿到的对象 和 存到容器当中的对象不是一个！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 10][]

**第四种方式：通过FactoryBean来创建bean对象**

> BeanFactory是spring容器的顶层接口，而这里要说的是FactoryBean，也是一个接口，这两个接口很容易搞混淆，FactoryBean可以让spring容器通过这个接口的实现来创建我们需要的bean对象。

上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范，FactoryBean接口定义如下：

public interface FactoryBean<T> {
        
    	String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”;
    	
    	T getObject() throws Exception; //获得实例对象方法
    	
    	Class<?> getObjectType(); //获得实例对象类型方法
    	
    	// 是否是单例
    	default boolean isSingleton() {
        
    		return true;
    	}
    }

**案例：**

public class TestController {
        
    
        public TestController() {
        
            System.out.println("TestController初始化了");
        }
    
    }

public class TestControllerFctoryBean implements FactoryBean<TestController> {
        
    
        /**
         * 实际上相当于将这个方法的返回值加入到容器当中
         *
         * @return
         */
        @Override
        public TestController getObject() {
        
            return new TestController();
        }
    
        @Override
        public Class<?> getObjectType() {
        
        	// 需要创建的对象的类型
            return TestController.class;
        }
    	
    	/**
         * true代表的是单例对象，如果是false的话每次从容器获取的对象就不是同一个了
         *
         * @return
         */
        @Override
        public boolean isSingleton() {
        
            return true;
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
    
            for (String beanName : classPathXmlApplicationContext.getBeanDefinitionNames()) {
        
                System.out.println(beanName + ":" + classPathXmlApplicationContext.getBean(beanName));
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 11][]

> 当首次用到TestController时，才调用getObject() ，此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池中，并且后期每次使用到TestController都从该缓存池中返回的是同一个testController实例。

### 六、import元素 ###

当我们的系统比较大的时候，会分成很多模块，每个模块会对应一个bean xml文件，我们可以在一个总的bean xml中对其他bean xml进行汇总，相当于把多个bean xml的内容合并到一个里面了，可以通过import元素引入其他bean配置文件。

语法：`<import resource="其他配置文件的位置" />`

用法如下：

bean.xml

bean1.xml

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/141e1e899be944d2b9346c69e9aafe4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1412b39a95f747a788ef942f26fd5b6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e19cbc83374646f995887509d26a9114.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/284d587410fb411094a9be138e0545c5.png
[https_github.com_spring-projects_spring-framework_blob_main_spring-beans_src_main_java_org_springframework_beans_factory_BeanFactory.java]: https://github.com/spring-projects/spring-framework/blob/main/spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1389fe2867fb46aa85cb8fce7f4e80ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/ebc8487ec32b417489a1b0d6d527db49.png?x-ossprocess=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/eab3918d8b1f47f0a830e3ef4b5e8d23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6f90fd57f7804f5985a6a0449bb1e16b.png
[ded550a0fc084d8ea02f8fea0531d4cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c36999adf497400491b72040d54d8cec.png
[368484481ec847f88254b5dfd6f0a7e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bf324700042f47fc88e41deae165f6e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/48354adcd9cd4e2781c1469393270305.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bcfcf77ff32c41b180e7727c5734851e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/00614fa0766d450780a4fd9c0a76da6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/eec07f961f204b5eb54592e1dbf26e8e.png