自学内容网 自学内容网
自学内容网 > 正文

【Spring Framework】使用XML配置文件定义Bean及其依赖注入方式

🕗 发布于 2024-07-26 11:10 spring  xml  java  

在 Spring Framework 中，使用 XML 配置文件来定义 Bean、配置依赖关系以及管理应用程序的行为是一个经典且有效的方法。尽管在现代开发中注解和 Java 配置（基于 Java 的配置类）正变得越来越流行，XML 配置依然在某些场景下具有其优势，特别是在需要将配置与代码分离的情况下。本文将详细讲解 Spring XML 配置文件的使用方式，并通过示例代码进行演示。

目录

  1. Spring XML 配置文件简介
  2. 基本结构和命名空间
  3. Bean 定义和实例化
  4. 依赖注入的方式
  5. 自动装配（Autowiring）
  6. Bean 的作用域
  7. 生命周期回调
  8. 集合类型的注入
  9. 外部化配置与属性占位符
  10. 使用 Profiles 管理环境
  11. 总结

1. Spring XML 配置文件简介

Spring XML 配置文件主要用于描述应用程序的组件、组件间的关系以及配置组件的属性。在早期的 Spring 开发中，XML 配置文件是定义 Spring 应用程序上下文的主要方式。在 Spring 框架中，一个 XML 配置文件通常包括以下内容：

  • Bean 定义：声明应用程序中使用的 Java 对象。
  • 依赖注入：配置 Bean 之间的依赖关系。
  • 作用域设置：定义 Bean 的生命周期和范围。
  • 生命周期回调：定义 Bean 初始化和销毁时的回调方法。
  • 属性配置：加载外部属性文件并配置 Bean 属性。

2. 基本结构和命名空间

一个典型的 Spring XML 配置文件结构如下：

<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 和其他配置 -->
    
</beans>
  • <beans>：这是 Spring 的根元素，用于包含所有 Bean 的定义和其他配置。
  • xmlns 和 xsi:schemaLocation：定义了 XML 的命名空间和模式文件的位置，确保 XML 配置文件的合法性和正确性。

3. Bean 定义和实例化

在 Spring 中，每个 Java 对象都可以定义为一个 Bean。通过 <bean> 标签，我们可以指定类名、ID 以及构造函数参数。

3.1 无参构造函数实例化

下面的示例展示了如何通过无参构造函数来实例化一个简单的 Bean：

<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">

    <!-- 定义一个名为 userService 的 Bean -->
    <bean id="userService" class="com.example.UserService"/>

</beans>

UserService.java：

package com.example;

public class UserService {
    public UserService() {
        System.out.println("UserService 被实例化了");
    }
}

在上面的例子中，Spring 会通过默认的无参构造函数实例化 UserService 类。

3.2 有参构造函数实例化

如果需要通过构造函数传递参数进行实例化，可以使用 <constructor-arg> 标签：

<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">

    <!-- 定义一个名为 userService 的 Bean，并传递构造函数参数 -->
    <bean id="userService" class="com.example.UserService">
        <constructor-arg value="John Doe"/>
        <constructor-arg value="john.doe@example.com"/>
    </bean>

</beans>

UserService.java：

package com.example;

public class UserService {
    private String name;
    private String email;

    public UserService(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public void displayUserInfo() {
        System.out.println("Name: " + name + ", Email: " + email);
    }
}

在这个示例中，Spring 会调用 UserService 的有参构造函数，并传入指定的参数。

4. 依赖注入的方式

Spring 支持两种主要的依赖注入方式：构造函数注入和属性注入（setter 注入）。通过这两种方式，Spring 可以轻松地管理对象间的依赖关系。

4.1 构造函数注入

构造函数注入在实例化对象时将依赖传递给构造函数：

<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">

    <!-- 定义 UserRepository -->
    <bean id="userRepository" class="com.example.UserRepository"/>

    <!-- 定义 UserService，并通过构造函数注入 UserRepository -->
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userRepository"/>
    </bean>

</beans>

UserService.java：

package com.example;

public class UserService {
    private final UserRepository userRepository;

    // 通过构造函数注入依赖
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performAction() {
        userRepository.save();
    }
}

UserRepository.java：

package com.example;

public class UserRepository {
    public void save() {
        System.out.println("User saved!");
    }
}

在此示例中，UserRepository 被注入到 UserService 中，UserService 在其构造函数中接收 UserRepository 的实例。

4.2 属性注入（setter 注入）

属性注入通过 setter 方法来注入依赖：

<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">

    <!-- 定义 UserRepository -->
    <bean id="userRepository" class="com.example.UserRepository"/>

    <!-- 定义 UserService，并通过属性注入 UserRepository -->
    <bean id="userService" class="com.example.UserService">
        <property name="userRepository" ref="userRepository"/>
    </bean>

</beans>

UserService.java：

package com.example;

public class UserService {
    private UserRepository userRepository;

    // 通过 setter 方法注入依赖
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performAction() {
        userRepository.save();
    }
}

在上述例子中，Spring 会通过 setUserRepository 方法将 UserRepository 注入到 UserService 中。

5. 自动装配（Autowiring）

自动装配（Autowiring）是一种通过 Spring 自动满足 Bean 依赖的方式。Spring 提供了多种自动装配模式，以减少显式配置的工作量：

  • no：默认值，不自动装配。
  • byName：通过 Bean 的名称自动装配。
  • byType：通过 Bean 的类型自动装配。
  • constructor：通过构造函数自动装配。
  • autodetect：Spring 自动决定是使用 constructor 还是 byType。
5.1 byName 自动装配

按名称自动装配会根据属性名称来匹配和注入 Bean：

<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">

    <!-- 定义 UserRepository -->
    <bean id="userRepository" class="com.example.UserRepository"/>

    <!-- 定义 UserService，按名称自动装配 -->
    <bean id="userService" class="com.example.UserService" autowire="byName"/>
    
</beans>

UserService.java：

package com.example;

public class UserService {
    private UserRepository userRepository;

    // setter 方法用于 byName 自动装配
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performAction() {
        userRepository.save();
    }
}

在 byName 模式下，Spring 会查找与 setUserRepository 方法名称匹配的 Bean，并自动注入。

5.2 byType 自动装配

按类型自动装配会根据属性的类型来匹配和注入 Bean：

<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">

    <!-- 定义 UserRepository -->
    <bean id="userRepository" class="com.example.UserRepository"/>

    <!-- 定义 UserService，按类型自动装配 -->
    <bean id="userService" class="com.example.UserService" autowire="byType"/>
    
</beans>

UserService.java：

package com.example;

public class UserService {
    private UserRepository userRepository;

    // setter 方法用于 byType 自动装配
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performAction() {
        userRepository.save();
    }
}

在 byType 模式下，Spring 会查找与属性类型匹配的 Bean，并自动注入。

6. Bean 的作用域

在 Spring 中，Bean 可以有不同的作用域，决定了 Bean 的生命周期和可见性。Spring 支持以下作用域：

  • singleton（默认）: 每个 Spring 容器中只有一个共享实例。
  • prototype: 每次请求都会创建一个新的实例。
  • request: 每个 HTTP 请求创建一个实例（仅适用于 Web 应用程序）。
  • session: 每个 HTTP 会话创建一个实例（仅适用于 Web 应用程序）。
  • globalSession: 每个全局 HTTP 会话创建一个实例（仅适用于 Web 应用程序）。
6.1 Singleton 作用域
<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">

    <!-- 定义一个 Singleton 作用域的 Bean -->
    <bean id="singletonBean" class="com.example.SingletonBean" scope="singleton"/>

</beans>

在 Singleton 作用域下，Spring 会创建一个共享实例，所有对该 Bean 的引用都指向同一个对象。

6.2 Prototype 作用域
<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">

    <!-- 定义一个 Prototype 作用域的 Bean -->
    <bean id="prototypeBean" class="com.example.PrototypeBean" scope="prototype"/>

</beans>

在 Prototype 作用域下，每次请求该 Bean 时，Spring 都会创建一个新的实例。

7. 生命周期回调

Spring 提供了多种方式来管理 Bean 的生命周期，包括初始化和销毁回调方法。

7.1 init-method 和 destroy-method

通过 XML 配置文件，可以指定 Bean 的初始化和销毁方法：

<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，指定初始化和销毁方法 -->
    <bean id="lifecycleBean" class="com.example.LifecycleBean" 
          init-method="init" destroy-method="destroy"/>
    
</beans>

LifecycleBean.java：

package com.example;

public class LifecycleBean {
    public void init() {
        System.out.println("Bean 初始化");
    }

    public void destroy() {
        System.out.println("Bean 销毁");
    }
}
7.2 实现 InitializingBean 和 DisposableBean 接口

除了通过 XML 配置，还可以通过实现 InitializingBean 和 DisposableBean 接口来管理 Bean 的生命周期：

package com.example;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class LifecycleBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean 初始化");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Bean 销毁");
    }
}

8. 集合类型的注入

Spring 支持对集合类型（List、Set、Map、Properties）的注入，这使得管理复杂的数据结构变得简单。

8.1 List 注入
<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">

    <!-- 定义 ItemService 并注入 List -->
    <bean id="itemService" class="com.example.ItemService">
        <property name="items">
            <list>
                <value>Item1</value>
                <value>Item2</value>
                <value>Item3</value>
            </list>
        </property>
    </bean>
    
</beans>

ItemService.java：

package com.example;

import java.util.List;

public class ItemService {
    private List<String> items;

    public void setItems(List<String> items) {
        this.items = items;
    }

    public void displayItems() {
        for (String item : items) {
            System.out.println(item);
        }
    }
}
8.2 Map 注入
<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">

    <!-- 定义 DictionaryService 并注入 Map -->
    <bean id="dictionaryService" class="com.example.DictionaryService">
        <property name="dictionary">
            <map>
                <entry key="key1" value="value1"/>
                <entry key="key2" value="value2"/>
                <entry key="key3" value="value3"/>
            </map>
        </property>
    </bean>
    
</beans>

DictionaryService.java：

package com.example;

import java.util.Map;

public class DictionaryService {
    private Map<String, String> dictionary;

    public void setDictionary(Map<String, String> dictionary) {
        this.dictionary = dictionary;
    }

    public void displayDictionary() {
        for (Map.Entry<String, String> entry : dictionary.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}
8.3 Properties 注入
<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">

    <!-- 定义 AppConfig 并注入 Properties -->
    <bean id="appConfig" class="com.example.AppConfig">
        <property name="properties">
            <props>
                <prop key="url">http://example.com</prop>
                <prop key="username">admin</prop>
                <prop key="password">secret</prop>
            </props>
        </property>
    </bean>
    
</beans>

AppConfig.java：

package com.example;

import java.util.Properties;

public class AppConfig {
    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void displayConfig() {
        System.out.println("URL: " + properties.getProperty("url"));
        System.out.println("Username: " + properties.getProperty("username"));
        System.out.println("Password: " + properties.getProperty("password"));
    }
}

9. 外部化配置与属性占位符

Spring

提供了将配置外部化的功能，可以从属性文件中加载属性，并通过占位符的方式在 XML 配置中使用这些属性。这种方法对于环境配置、数据库连接信息等场景非常有用。

9.1 使用 PropertyPlaceholderConfigurer
<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 class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:application.properties"/>
    </bean>

    <!-- 定义数据库连接的 Bean，使用属性占位符 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>
    
</beans>

application.properties：

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mydb
db.username=root
db.password=password
9.2 使用 context:property-placeholder

通过 context:property-placeholder 标签简化属性配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 声明属性占位符 -->
    <context:property-placeholder location="classpath:application.properties"/>

    <!-- 定义数据库连接的 Bean -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>
    
</beans>

10. 使用 Profiles 管理环境

Spring Profiles 是一种功能，允许你根据运行时的环境来激活或切换不同的配置。它在开发、测试、生产环境中非常有用，可以轻松切换配置。

10.1 配置 Profiles

定义两个不同的数据库配置文件，分别用于开发和生产环境：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 声明属性占位符 -->
    <context:property-placeholder location="classpath:application.properties"/>

    <!-- 开发环境的配置 -->
    <beans profile="dev">
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName" value="${db.dev.driver}"/>
            <property name="url" value="${db.dev.url}"/>
            <property name="username" value="${db.dev.username}"/>
            <property name="password" value="${db.dev.password}"/>
        </bean>
    </beans>

    <!-- 生产环境的配置 -->
    <beans profile="prod">
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName" value="${db.prod.driver}"/>
            <property name="url" value="${db.prod.url}"/>
            <property name="username" value="${db.prod.username}"/>
            <property name="password" value="${db.prod.password}"/>
        </bean>
    </beans>
    
</beans>

application.properties：

db.dev.driver=com.mysql.jdbc.Driver
db.dev.url=jdbc:mysql://localhost:3306/devdb
db.dev.username=devuser
db.dev.password=devpassword

db.prod.driver=com.mysql.jdbc.Driver
db.prod.url=jdbc:mysql://localhost:3306/proddb
db.prod.username=produser
db.prod.password=prodpassword
10.2 激活 Profile

可以通过设置 spring.profiles.active 环境变量来激活相应的 Profile：

java -Dspring.profiles.active=dev -jar myapp.jar

在上述命令中，-Dspring.profiles.active=dev 将激活开发环境配置。

11. 总结

Spring Framework 的 XML 配置文件提供了强大且灵活的功能来管理 Java 应用程序的组件和依赖关系。通过 XML 配置文件，开发者可以：

  • 定义 Bean 及其依赖关系
  • 配置不同的作用域和生命周期回调
  • 注入集合类型和外部化配置
  • 使用 Profiles 来管理不同环境下的配置

虽然现代开发中注解和 Java 配置类变得越来越流行，但 XML 配置依然在特定场景中提供了不可替代的便利性，特别是在需要与非开发人员共享配置或遵循传统企业规范的情况下。

通过本篇文章的讲解和示例代码，希望能够帮助你深入理解 Spring Framework XML 配置文件的使用方式，以及如何通过这种方式有效地管理和构建应用程序。


原文地址：https://blog.csdn.net/u013675821/article/details/140693758

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • 配置cobbler服务提供centos7安装源

    由RedHat公司基于python语言开发，作用：快速批量部署Linux系统。

    阅读更多2024-09-17
  • 【MySQL学习】基础指令全解：构建你的数据库技能

    本文详细介绍了SQL操作指令的各种基础和高级操作，帮助读者掌握SQL数据库技巧。

    阅读更多2024-09-17
  • OpenGL笔记二十一之几何类设计

    — 2024-09-16 下午。

    阅读更多2024-09-17
  • UiBot教程：实现复杂流程图的高效方法

    我们需要在两个流程块之间传递“字符串格式的系统时间”，所以最简单的方法就是在流程图中定义一个变量。举个例子，我们可以创建一个名为x的流程图变量，这样在流程图所包含的所有流程块中都可以直接使用这个变量。

    阅读更多2024-09-17
  • 12 数组——27. 移除元素 ★

    给你一个数组nums和一个值val，你需要原地移除所有数值等于val的元素，并返回移除后数组的新长度。

    阅读更多2024-09-17
  • 工资重回“3000块”时代

    3000元是一个心理价位，但实际上对于许多家庭来说，可能在县城生活，除了基本的生活开销，很难剩下更多的钱。也就是说，如果你的工作收入在这个“五千块定律”所设定的范围内，并且在三年内没有超过平均水平的涨

    阅读更多2024-09-17
  • 谷歌向安卓用户推出Gemini Live聊天机器人

    即使你的手机处于锁定状态，屏幕处于关闭状态，你也可以开始与助手交谈，而且还可以通过谷歌(Google)的新款Pixel Buds Pro 2无线耳机进行访问，这样你就可以在手机放在包里的时候免提通话。

    阅读更多2024-09-17
  • Linux进阶命令-sed&split

    sed（Stream Editor）是一个流编辑器，用于在文本流中进行文本替换和转换操作。它通常用于命令行环境下，可以接受标准输入（stdin）、文件内容或管道输入，并对文本进行修改或处理。

    阅读更多2024-09-17
  • RTMP直播播放器的几种选择

    在选择RTMP直播播放器时，需要根据具体的应用场景、平台兼容性、功能需求以及用户体验等因素进行综合考虑。同时，也可以参考其他用户的评价和专业评测来选择最适合的播放器。

    阅读更多2024-09-17
  • Linux套接字

    套接字是实现网络通信的核心组件，它提供了灵活且强大的接口，使得开发者能够轻松地在网络环境中构建复杂的应用程序。无论是TCP还是UDP协议，都可以通过适当的套接字类型来满足不同的通信需求.

    阅读更多2024-09-17
自学内容网
Copyright © 2015-2024