S02L01 - 依赖注入入门

html

掌握 Spring 框架中的依赖注入：全面指南
目录

介绍 ....................................................................................................... 1
理解依赖注入 ........................................ 3

什么是依赖注入？
依赖注入的好处
何时何地使用依赖注入


设置 Spring 项目 .................................................... 6

创建项目结构
使用 AppConfig.java 配置 Spring


实现依赖注入 ........................................... 10

定义 Car 接口
创建 Car 实现：Swift 和 Corolla
使用注解配置进行依赖注入


分析代码 ...................................................................................... 15

App.java：主类
AppConfig.java：配置类
Swift.java 和 Corolla.java：具体实现


执行应用程序 .................................................................... 20

无依赖注入运行
有依赖注入运行


结论 ......................................................................................................... 25
附加资源 ................................................................................ 26


介绍
欢迎阅读 “掌握 Spring 框架中的依赖注入：全面指南。” 在软件开发领域，尤其是在 Java 生态系统中，理解依赖注入 (DI) 对于构建可扩展、可维护和可测试的应用程序至关重要。本电子书深入探讨了依赖注入的概念，通过一个实际项目示例展示了如何使用 Spring 框架实现 DI。
您将学习到

依赖注入的基础知识及其在 Spring 框架中的作用。
设置 Spring 项目以实现 DI 的分步指南。
通过代码示例进行 DI 的实际实现。
使用 DI 的最佳实践和常见陷阱。

通过本指南，您将牢固掌握依赖注入，并了解如何利用 Spring 提升您的 Java 应用程序。

理解依赖注入
什么是依赖注入？
依赖注入 (DI) 是一种设计模式，促进了硬编码依赖关系的消除，使应用程序更加模块化和可测试。简单来说，DI 允许对象从外部来源接收其依赖，而不是自行创建它们。
关键概念：

控制反转 (IoC)： DI 是 IoC 的一种形式，其中创建和管理依赖关系的控制权从对象本身转移到外部实体（如 Spring）。
依赖项：这些是类在运行时所需的对象。例如，Car 类可能依赖于 Engine 类。

依赖注入的好处

增强的可测试性：通过模拟依赖，可以隔离地测试组件。
松耦合：减少类之间的相互依赖，使系统更加灵活。
可维护性：更容易管理和更新组件而不影响其他部分。
可复用性：组件可以在应用程序的不同部分重复使用。

何时何地使用依赖注入
DI 尤其适用于大型复杂应用程序，在这些应用程序中，手动管理依赖关系变得繁琐。适用的场景包括：

需要高模块化和可扩展性的应用程序。
具有多种配置选项的系统。
强调测试驱动开发 (TDD) 的项目。

比较表：手动依赖管理 vs. 依赖注入


方面
手动依赖管理
依赖注入


耦合
紧耦合
松耦合


可测试性
难以隔离测试
易于模拟依赖


灵活性
低
高


代码可维护性
低
高


配置
硬编码
外部配置（例如，XML，注解）



设置 Spring 项目
创建项目结构
首先，我们将设置一个基本的 Spring 项目结构。确保您拥有以下文件和目录：




		
		
			
			
Java
			
			S02L01-Dependency Injection/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── App.java
│   │   │   ├── AppConfig.java
│   │   │   └── org/studyeasy/
│   │   │       ├── car/
│   │   │       │   ├── Corolla.java
│   │   │       │   └── Swift.java
│   │   │       └── interfaces/
│   │   │           └── Car.java
│   │   └── webapp/
│   │       └── index.jsp
└── pom.xml
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						S02L01-Dependency Injection/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── App.java
│   │   │   ├── AppConfig.java
│   │   │   └── org/studyeasy/
│   │   │       ├── car/
│   │   │       │   ├── Corolla.java
│   │   │       │   └── Swift.java
│   │   │       └── interfaces/
│   │   │           └── Car.java
│   │   └── webapp/
│   │       └── index.jsp
└── pom.xml
					
				
			
		


使用 AppConfig.java 配置 Spring
AppConfig.java 类作为 Spring 的配置中心，启用了组件扫描并定义了 bean。




		
		
			
			
Java
			
			import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("org.studyeasy")
public class AppConfig {
    // 配置类，用于启用组件扫描
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@ComponentScan("org.studyeasy")
public class AppConfig {
    // 配置类，用于启用组件扫描
}
					
				
			
		


解释：

@Configuration： 表示该类包含 @Bean 定义或导入。
@ComponentScan： 告诉 Spring 在哪里查找组件、配置和服务。


实现依赖注入
定义 Car 接口
Car 接口声明了 specs 方法，该方法将由具体的汽车类实现。




		
		
			
			
Java
			
			package org.studyeasy.interfaces;

public interface Car {
    void specs();
}
			
				
					
				
					1
2
3
4
5
				
						package org.studyeasy.interfaces;
 
public interface Car {
    void specs();
}
					
				
			
		


创建 Car 实现：Swift 和 Corolla
Swift.java




		
		
			
			
Java
			
			package org.studyeasy.car;

import org.springframework.stereotype.Component;
import org.studyeasy.interfaces.Car;

@Component
public class Swift implements Car {
    @Override
    public void specs() {
        System.out.println("Suzuki 的掀背车");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						package org.studyeasy.car;
 
import org.springframework.stereotype.Component;
import org.studyeasy.interfaces.Car;
 
@Component
public class Swift implements Car {
    @Override
    public void specs() {
        System.out.println("Suzuki 的掀背车");
    }
}
					
				
			
		


Corolla.java




		
		
			
			
Java
			
			package org.studyeasy.car;

import org.springframework.stereotype.Component;
import org.studyeasy.interfaces.Car;

@Component
public class Corolla implements Car {
    @Override
    public void specs() {
        System.out.println("Toyota 的轿车");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						package org.studyeasy.car;
 
import org.springframework.stereotype.Component;
import org.studyeasy.interfaces.Car;
 
@Component
public class Corolla implements Car {
    @Override
    public void specs() {
        System.out.println("Toyota 的轿车");
    }
}
					
				
			
		


解释：

@Component： 将类标记为 Spring 管理的组件，使其有资格进行组件扫描和 DI。

使用注解配置进行依赖注入
在 App.java 中，我们利用 Spring 的 ApplicationContext 来管理和注入依赖。




		
		
			
			
Java
			
			import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.studyeasy.interfaces.Car;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        Car myCar = context.getBean(Car.class);
        myCar.specs();
        
        ((AnnotationConfigApplicationContext) context).close();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.studyeasy.interfaces.Car;
 
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        Car myCar = context.getBean(Car.class);
        myCar.specs();
        
        ((AnnotationConfigApplicationContext) context).close();
    }
}
					
				
			
		


解释：

ApplicationContext： 管理 bean 及其依赖的 Spring 容器。
getBean()： 从 Spring 上下文中检索指定类型的 bean。
关闭上下文： 确保所有资源被正确释放。


分析代码
App.java：主类
App.java 是应用程序的入口点。它初始化 Spring 上下文，检索 Car bean，并调用其 specs 方法。
代码拆解：

初始化 Spring 上下文：

    



		
		
			
			
Java
			
			ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
			
				
					
				
					1
				
						ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
					
				
			
		



    基于 AppConfig 配置创建新的上下文。
  
检索并使用 Bean：

    



		
		
			
			
Java
			
			Car myCar = context.getBean(Car.class);
myCar.specs();
			
				
					
				
					1
2
				
						Car myCar = context.getBean(Car.class);
myCar.specs();
					
				
			
		



    检索 Car bean（Swift 或 Corolla）并调用 specs 方法。
  
关闭上下文：

    



		
		
			
			
Java
			
			((AnnotationConfigApplicationContext) context).close();
			
				
					
				
					1
				
						((AnnotationConfigApplicationContext) context).close();
					
				
			
		



    关闭 Spring 上下文以释放资源。
  

AppConfig.java：配置类
AppConfig.java 使 Spring 能够扫描指定的包以查找组件，促进了自动依赖注入。
关键注解：

@Configuration： 将类标记为 bean 定义的来源。
@ComponentScan： 指定要扫描的 Spring 组件包。

Swift.java 和 Corolla.java：具体实现
Swift.java 和 Corolla.java 都实现了 Car 接口，并使用 @Component 注解，使其有资格进行 Spring 的组件扫描。
代码亮点：

实现 specs 方法以打印特定的汽车详情。
使用 @Component 将其注册到 Spring 应用上下文中。


执行应用程序
无依赖注入运行
最初，没有 DI 时，对象在 App.java 类中手动创建。
代码片段：




		
		
			
			
Java
			
			public class App {
    public static void main(String[] args) {
        Car swift = new Swift();
        swift.specs(); // 输出：Suzuki 的掀背车

        Car corolla = new Corolla();
        corolla.specs(); // 输出：Toyota 的轿车
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public class App {
    public static void main(String[] args) {
        Car swift = new Swift();
        swift.specs(); // 输出：Suzuki 的掀背车
 
        Car corolla = new Corolla();
        corolla.specs(); // 输出：Toyota 的轿车
    }
}
					
				
			
		


优点：

对于小型应用程序而言简单。

缺点：

类之间紧密耦合。
在较大项目中难以管理依赖关系。
需要修改代码并重新部署以进行更改。

有依赖注入运行
通过利用 Spring 的 DI，对象创建和依赖管理被外包给框架。
修改后的代码片段：




		
		
			
			
Java
			
			public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        Car myCar = context.getBean(Car.class);
        myCar.specs(); // 输出取决于 bean 配置
        
        ((AnnotationConfigApplicationContext) context).close();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        Car myCar = context.getBean(Car.class);
        myCar.specs(); // 输出取决于 bean 配置
        
        ((AnnotationConfigApplicationContext) context).close();
    }
}
					
				
			
		


好处：

松耦合： 类不负责创建它们的依赖。
灵活性： 可以轻松切换不同的实现，而无需更改客户端代码。
可扩展性： 更适合大型和复杂的应用程序。

输出解释：

当应用程序运行时，Spring 根据可用的 bean 注入适当的 Car 实现（Swift 或 Corolla）。specs 方法输出相应的汽车详情。

示例输出：




		
		
			
			
Java
			
			Suzuki 的掀背车
			
				
					
				
					1
				
						Suzuki 的掀背车
					
				
			
		



结论
依赖注入 是 Spring 框架的基石，促进了 Java 应用程序的模块化、可扩展性和可维护性。通过外部化依赖关系的创建和管理，DI 促进了更清晰的代码架构并增强了可测试性。
在本指南中，我们探讨了依赖注入的基础知识，设置了 Spring 项目，通过实际的代码示例实现了 DI，并分析了其相对于传统依赖管理的优势。拥抱 DI 不仅简化了您的开发过程，还为构建强大而灵活的应用程序铺平了道路。
SEO 关键词： Dependency Injection, Spring Framework, Java Development, Spring DI Tutorial, Inversion of Control, Spring Components, Spring ApplicationContext, Spring Beans, Car Interface Example, Spring Configuration, Modular Java Applications, Testable Code, Spring ComponentScan, Spring @Component, Spring @Configuration, Loose Coupling Java, Spring Dependency Management, Spring Bean Lifecycle, Spring IoC Container, Spring Annotations

附加资源

Spring 框架文档
理解控制反转 (IoC) 和依赖注入 (DI)
Spring 初学者教程
《Effective Java》作者 Joshua Bloch

注意：本文为 AI 生成。
方面	手动依赖管理	依赖注入
耦合	紧耦合	松耦合
可测试性	难以隔离测试	易于模拟依赖
灵活性	低	高
代码可维护性	低	高
配置	硬编码	外部配置（例如，XML，注解）