二、Spring Framework基础：IoC（控制反转）和DI（依赖注入）
Spring Core：深入理解 IoC 和 DI 原理
在 Java 开发中，Spring Framework 是一个极为重要的框架，而 IoC（控制反转）和 DI（依赖注入）是 Spring 的核心特性。它们不仅帮助开发者简化代码的复杂性，还极大地提高了代码的可维护性和可扩展性。本文将深入探讨 IoC 和 DI 的原理，并通过实际代码示例帮助你更好地理解。
1. IoC（控制反转）是什么？
1.1 定义
IoC（Inversion of Control，控制反转）是一种设计思想，用于降低代码之间的耦合度。它的核心思想是：将对象的创建和管理交给框架，而不是由程序员手动创建和管理。
在传统的编程中，对象的创建和依赖关系是由程序员手动管理的。例如：
public class Client {
private Service service = new Service(); // 客户端直接创建服务对象
public void doSomething() {
service.doService();
}
}
在这个例子中，Client 类直接依赖于 Service 类，这种依赖关系是硬编码的，耦合度很高。如果 Service 类的实现发生变化，Client 类也需要修改。
而 IoC 的模式下，对象的创建和管理由 Spring 容器负责，客户端不再直接创建服务对象：
public class Client {
private Service service; // 服务对象由外部注入
public Client(Service service) {
this.service = service;
}
public void doSomething() {
service.doService();
}
}
在这种模式下，Client 类不再直接创建 Service 对象，而是通过外部注入的方式获取依赖。这种方式将对象的控制权从程序员手中“反转”到了框架，因此得名“控制反转”。
1.2 IoC 的优势
- 降低耦合度：对象之间的依赖关系由 Spring 容器管理，减少了类之间的直接依赖。
- 提高可维护性：代码更加清晰，依赖关系通过配置管理，易于修改和扩展。
- 便于测试：依赖关系可以通过 Mock 对象注入，便于单元测试。
2. DI（依赖注入）是什么？
2.1 定义
DI（Dependency Injection，依赖注入）是 IoC 的一种实现方式。它通过外部配置（如 XML、注解或 Java 配置类）将依赖关系注入到目标对象中。DI 的目的是让对象的依赖关系由外部容器管理，而不是由对象自己创建。
2.2 DI 的实现方式
DI 有以下几种常见的实现方式：
2.2.1 构造器注入
构造器注入是通过构造方法将依赖注入到目标对象中。这种方式的优点是依赖关系明确，且对象在创建时必须提供所有依赖，保证了对象的不可变性。
public class Client {
private final Service service;
public Client(Service service) {
this.service = service;
}
public void doSomething() {
service.doService();
}
}
2.2.2 Setter 方法注入
Setter 方法注入是通过 Setter 方法将依赖注入到目标对象中。这种方式的优点是灵活性高，可以在对象创建后动态修改依赖。
public class Client {
private Service service;
public void setService(Service service) {
this.service = service;
}
public void doSomething() {
service.doService();
}
}
2.2.3 字段注入
字段注入是通过注解直接将依赖注入到字段中。这种方式的优点是代码简洁，但缺点是破坏了封装性，且依赖关系不明显。
public class Client {
@Autowired
private Service service;
public void doSomething() {
service.doService();
}
}
2.3 DI 的优势
- 解耦：对象的依赖关系由外部容器管理，减少了类之间的直接依赖。
- 灵活性：依赖关系可以通过配置动态修改，而不必修改代码。
- 便于测试：依赖关系可以通过 Mock 对象注入，便于单元测试。
3. Spring IoC 容器的实现原理
Spring 的 IoC 容器是整个 Spring 框架的核心。它负责管理对象的生命周期、依赖注入和配置管理。
3.1 BeanFactory
BeanFactory 是 Spring IoC 容器的最基础实现，它提供了基本的依赖注入功能。它是一个接口，通常通过其实现类（如 ClassPathXmlApplicationContext 或 FileSystemXmlApplicationContext）来使用。
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class IoCDemo {
public static void main(String[] args) {
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
Service service = factory.getBean("service", Service.class);
service.doService();
}
}
3.2 ApplicationContext
ApplicationContext 是 BeanFactory 的扩展，提供了更多高级功能，如事件传播、国际化支持等。它通常用于实际开发中。
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IoCDemo {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Service service = context.getBean("service", Service.class);
service.doService();
}
}
3.3 Bean 的生命周期
Spring 容器管理 Bean 的生命周期，从创建到销毁的整个过程。以下是 Bean 生命周期的主要阶段：
- 实例化：Spring 容器调用无参构造方法实例化 Bean。
- 依赖注入：通过构造器或 Setter 方法注入依赖。
- 初始化：调用
@PostConstruct注解的方法或实现InitializingBean接口的afterPropertiesSet方法。 - 使用：Bean 可以被其他 Bean 使用。
- 销毁：调用
@PreDestroy注解的方法或实现DisposableBean接口的destroy方法。
3.4 配置方式
Spring 提供了多种配置方式，包括 XML 配置、注解配置和 Java 配置。
3.4.1 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 id="service" class="com.example.Service"/>
beans>
3.4.2 注解配置
Spring 提供了注解来简化配置，如 @Component、@Service、@Controller、@Repository 等。
import org.springframework.stereotype.Service;
@Service
public class Service {
public void doService() {
System.out.println("Service is running...");
}
}
然后通过 @ComponentScan 扫描注解：
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.example")
public class AppConfig {
}
3.4.3 Java 配置
除了注解，还可以通过 Java 配置类来定义 Bean：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public Service service() {
return new Service();
}
}
4. 实现一个简单的 IoC 容器
为了更好地理解 Spring 的 IoC 容器，我们可以尝试实现一个简单的 IoC 容器。
4.1 定义一个简单的 Bean
public class Service {
public void doService() {
System.out.println("Service is running...");
}
}
4.2 定义一个简单的 BeanFactory
import java.util.HashMap;
import java.util.Map;
public class SimpleBeanFactory {
private Map<String, Object> beans = new HashMap<>();
public void registerBean(String name, Object bean) {
beans.put(name, bean);
}
public Object getBean(String name) {
return beans.get(name);
}
}
4.3 测试 IoC 容器
public class IoCDemo {
public static void main(String[] args) {
SimpleBeanFactory factory = new SimpleBeanFactory();
factory.registerBean("service", new Service());
Service service = (Service) factory.getBean("service");
service.doService();
}
}
5. 构造器注入与 Setter 方法注入的对比
5.1 构造器注入
- 优点：
- 依赖关系明确，对象在创建时必须提供所有依赖。
- 保证对象的不可变性。
- 缺点：
- 如果依赖关系较多，构造器参数会变得复杂。
5.2 Setter 方法注入
- 优点：
- 灵活性高，可以在对象创建后动态修改依赖。
- 代码简洁，易于理解。
- 缺点：
- 对象的依赖关系不明显，可能导致对象在未完全初始化时被使用。
6. 实践案例：使用 Spring IoC 和 DI
6.1 定义一个业务逻辑类
import org.springframework.stereotype.Service;
@Service
public class BusinessService {
public void doSomething() {
System.out.println("Business logic is running...");
}
}
6.2 定义一个客户端类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Client {
private final BusinessService service;
@Autowired
public Client(BusinessService service) {
this.service = service;
}
public void execute() {
service.doSomething();
}
}
6.3 配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public BusinessService businessService() {
return new BusinessService();
}
@Bean
public Client client(BusinessService service) {
return new Client(service);
}
}
6.4 测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class IoCDemo {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
Client client = context.getBean(Client.class);
client.execute();
}
}
7. 总结
通过本文的介绍，你应该对 Spring 的 IoC 和 DI 原理有了更深入的理解。IoC 和 DI 是 Spring 框架的核心思想，它们通过将对象的创建和管理交给框架，极大地降低了代码的耦合度，提高了代码的可维护性和可扩展性。
在实际开发中，你可以根据需求选择合适的依赖注入方式（构造器注入、Setter 方法注入或字段注入），并利用 Spring 提供的强大功能来简化开发。
如果你在学习过程中有任何疑问，欢迎随时交流！