Spring 依赖注入实战指南：XML、注解、Java 配置全面对比-EW帮帮网

Spring 依赖注入实战指南：XML、注解、Java 配置全面对比

本博客涵盖了 Spring 依赖注入（DI）的基本概念、三种实现方式（构造器注入、Setter 注入、字段注入）以及三种配置方式（XML 配置、基于注解配置、基于 Java 配置），每种方式都附有具体的代码示例和各自的优缺点说明。

一、依赖注入（DI）的基本概念

依赖注入（Dependency Injection，DI） 是 Spring 实现控制反转（IoC）的主要手段。其核心思想是：

控制反转（IoC）
将对象的创建和生命周期管理权交给 Spring 容器，而不是由应用程序代码通过 new 操作来直接创建对象。
依赖注入（DI）
由容器将所依赖的对象自动注入到目标 Bean 中，从而降低各组件之间的耦合性，提高代码的可测试性与可维护性。

在 DI 中，“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”都由容器根据配置决定，而开发者只需关注业务逻辑。

二、依赖注入的实现方式

Spring 中常见的依赖注入实现方式主要有以下三种：

1. 构造器注入

实现原理

通过在目标类中定义带依赖参数的构造函数，Spring 在创建 Bean 时自动调用该构造函数，并传入所需的依赖对象。

示例代码

// 定义依赖接口
package com.example.di;
public interface Engine {
    void start();
}

// Engine 的实现类（燃油引擎）
package com.example.di;
import org.springframework.stereotype.Component;

@Component
public class CombustionEngine implements Engine {
    @Override
    public void start() {
        System.out.println("燃油引擎启动...");
    }
}

// 目标 Bean：Car，通过构造器注入 Engine
package com.example.di;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private final Engine engine; // 可声明为 final

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

// 配置类及主程序入口
package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example.di")
public class AppConfig {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

优缺点

优势：
- 必需依赖：确保对象在创建时即获得所有必需依赖，保证 Bean 的完整性。
- 不可变性：依赖字段可声明为 final，增强对象的安全性和稳定性。
- 依赖关系清晰：构造函数参数明确展示了类所依赖的所有对象。
弊端：
- 参数臃肿：当依赖项较多时，构造函数的参数列表可能显得过长，影响可读性。
- 灵活性较低：对于可选依赖，不够灵活，可能需要提供多个重载构造器来应对不同场景。

2. Setter 注入

实现原理

在目标类中提供相应的 setter 方法，Spring 在对象实例化后调用这些方法来注入依赖。

示例代码

// Engine 接口及实现（例如电动引擎）
package com.example.di;
public interface Engine {
    void start();
}

package com.example.di;
import org.springframework.stereotype.Component;

@Component
public class ElectricEngine implements Engine {
    @Override
    public void start() {
        System.out.println("电动引擎启动...");
    }
}

// 目标 Bean：Car，通过 setter 方法注入 Engine
package com.example.di;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private Engine engine;

    @Autowired
    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

// 配置类及主程序入口（同构造器注入示例）
package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example.di")
public class AppConfig {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

优缺点

优势：
- 灵活性：允许在对象创建后再注入依赖，适用于可选依赖和需要动态修改依赖的场景。
- 默认值设置：可以通过 setter 方法设定默认值，降低因未注入导致的问题。
- 依赖接口明确：依赖关系在公共接口中明确暴露，有助于理解和维护。
弊端：
- 初始化时不完全：对象在所有 setter 方法调用前可能处于不完整状态。
- 不可使用 final：无法将依赖字段声明为 final，降低了对象的不可变性和安全性。

3. 字段注入

实现原理

直接在目标类的成员变量上使用注解（如 @Autowired、@Resource 或 @Inject），由 Spring 通过反射自动注入依赖。

示例代码

// Engine 接口及实现（继续使用燃油引擎示例）
package com.example.di;
public interface Engine {
    void start();
}

package com.example.di;
import org.springframework.stereotype.Component;

@Component
public class CombustionEngine implements Engine {
    @Override
    public void start() {
        System.out.println("燃油引擎启动...");
    }
}

// 目标 Bean：Car，使用字段注入
package com.example.di;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    @Autowired
    private Engine engine; // 直接在字段上注解

    public void start() {
        engine.start();
    }
}

// 配置类及主程序入口（与前面示例相同）
package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example.di")
public class AppConfig {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

优缺点

优势：
- 代码简洁：不需要编写构造函数或 setter 方法，直接在字段上使用注解即可。
- 开发效率高：对于简单场景，可以快速完成依赖注入。
弊端：
- 隐藏依赖关系：依赖关系未在构造函数或公共接口中明确体现，降低了代码的可读性。
- 无法使用 final：注入字段不能声明为 final，可能导致意外修改。
- 测试不便：在单元测试中手动实例化对象时，难以直接注入依赖，可能需要借助反射等方式。
- 依赖容器环境：在非 Spring 容器下直接 new 对象时，依赖注入不会生效，容易引发 NullPointerException。

三、依赖注入的配置方式

Spring 提供了多种配置依赖注入的方式，常见的有以下三种：

1. XML 配置方式

示例

XML 配置文件（beans.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">

    <!-- 定义 Engine Bean，通过构造器注入 -->
    <bean id="engine" class="com.example.di.CombustionEngine" />

    <!-- 定义 Car Bean，使用构造器注入 engine -->
    <bean id="car" class="com.example.di.Car">
        <constructor-arg ref="engine"/>
    </bean>
</beans>

Java 类示例与前面的构造器注入示例一致。

启动代码：

package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Car car = (Car) context.getBean("car");
        car.start();
    }
}

优缺点

优点：
- 配置集中、外部化，所有 Bean 定义和依赖关系都写在 XML 中，便于在不修改代码的情况下调整配置。
- 易于文档化和审查，对于复杂的依赖关系，XML 结构较为清晰。
弊端：
- 配置冗长，随着项目规模增大，XML 文件可能变得庞大，维护成本较高。
- 缺乏编译时类型检查，错误只能在运行时发现。

2. 基于注解的配置方式

示例

通过在类上使用注解标记 Bean，并在字段或方法上使用 @Autowired 自动注入依赖，同时利用 @ComponentScan 自动扫描注册 Bean。

代码示例：

// Engine 接口及实现
package com.example.di;
public interface Engine {
    void start();
}

package com.example.di;
import org.springframework.stereotype.Component;
@Component
public class ElectricEngine implements Engine {
    @Override
    public void start() {
        System.out.println("电动引擎启动...");
    }
}

// Car 类，使用字段注入
package com.example.di;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Car {
    @Autowired
    private Engine engine;
    public void start() {
        engine.start();
    }
}

配置类：

package com.example.di;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.example.di")
public class AppConfig {
}

启动代码：

package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

优缺点

优点：
- 代码简洁，无需额外编写 XML 文件，开发效率较高。
- 依赖关系通过注解直接标注在代码中，利用组件扫描自动注册 Bean，便于重构。
弊端：
- 配置细节隐藏在代码中，依赖关系可能不如 XML 那样直观，特别是当使用字段注入时。
- 过多的注解会增加与 Spring 框架的耦合，在非容器环境下使用时需要额外处理。

3. 基于 Java 配置的方式

示例

利用 @Configuration 与 @Bean 注解，以纯 Java 代码配置 Bean 及其依赖关系，无需 XML。

代码示例：

// Engine 接口及实现
package com.example.di;
public interface Engine {
    void start();
}

package com.example.di;
public class CombustionEngine implements Engine {
    @Override
    public void start() {
        System.out.println("燃油引擎启动...");
    }
}

// Car 类，通过构造器注入依赖
package com.example.di;
public class Car {
    private Engine engine;
    public Car(Engine engine) {
        this.engine = engine;
    }
    public void start() {
        engine.start();
    }
}

配置类：

package com.example.di;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
    @Bean
    public Engine engine() {
        return new CombustionEngine();
    }
    @Bean
    public Car car() {
        return new Car(engine());
    }
}

启动代码：

package com.example.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

优缺点

优点：
- 类型安全，借助 IDE 的代码提示和重构工具，能够在编译时捕捉错误。
- 配置以 Java 代码形式存在，更易于管理、调试和维护，且不依赖于 XML 文件。
- 适合模块化管理大型项目。
弊端：
- 对于简单项目可能显得冗长；对于习惯 XML 配置的团队来说，转换需要一定学习成本。
- 当配置逻辑复杂时，配置类可能会变得庞大。

四、总结

依赖注入基本思想：
通过将 Bean 的创建和依赖关系管理交给 Spring 容器，实现对象间的松耦合，提高系统的测试性和扩展性。
DI 的实现方式：
- 构造器注入：在对象创建时即传入所有必需依赖，清晰且不可变，但当依赖较多时参数列表臃肿。
- Setter 注入：灵活性高，适用于可选依赖，但对象在初始化前可能不完全且无法使用 final。
- 字段注入：实现简单、代码简洁，但隐藏依赖关系、测试不便且依赖容器环境。
DI 的配置方式：
- XML 配置：外部化配置，便于文档化和审查，但配置冗长且缺乏编译期检查。
- 基于注解配置：开发效率高、代码简洁，依赖自动扫描，但依赖关系可能不够直观，且增加与 Spring 的耦合。
- 基于 Java 配置：类型安全、易于重构，集中管理 Bean 定义，但学习成本较高，对简单项目略显冗长。

以上就是对 Spring 依赖注入的实现方式和配置方式的全面整理，通过具体示例及其优缺点对比，希望能帮助你深入理解 Spring DI 的不同实现及配置选项。

Spring 依赖注入实战指南：XML、注解、Java 配置全面对比