Cyanix Blog

切换主题

Spring IoC（控制反转） ​

字数
1284 字
阅读时间
6 分钟

Spring IoC（Inversion of Control）是 Spring 框架的核心模块之一，旨在通过容器管理对象的创建、初始化、依赖注入和生命周期。IoC 的核心思想是将对象的控制权从应用程序代码转移到 Spring 容器，由容器负责管理对象及其依赖关系。

1 1. 什么是 IoC（控制反转）？ ​

IoC 是一种设计思想，强调对象的依赖关系由外部容器负责注入，而不是在对象内部手动管理。
通过 IoC，程序员不需要显式创建对象或管理依赖关系，而是由容器通过**依赖注入（DI: Dependency Injection）**的方式自动完成。

简单来说：

  • 传统方式：对象自己创建依赖。
  • IoC：容器负责创建对象和注入依赖。

2 2. IoC 的核心概念 ​

2.1 2.1 Bean ​

  • Spring IoC 容器中管理的对象被称为 Bean。
  • 每个 Bean 都是一个由容器实例化、组装并管理的对象。
  • Bean 的定义通常包含类名、作用域、初始化方法、销毁方法等。

2.2 2.2 Spring 容器 ​

  • 容器是 IoC 的核心，负责管理 Bean 的生命周期和依赖。
  • 容器实现了 Bean 的创建、配置、装配和销毁。

Spring 提供了两种主要容器：

  1. BeanFactory：基本的 IoC 容器，懒加载 Bean，资源消耗较低。
  2. ApplicationContext：功能更强大的 IoC 容器，支持国际化、事件机制、Bean 自动扫描等。

2.3 2.3 配置方式 ​

Spring IoC 支持三种主要配置方式：

  1. XML 配置：早期使用的主流方式，通过 XML 文件定义 Bean。
  2. 注解配置：通过注解（如 @Component、@Autowired）简化配置。
  3. Java 配置：基于 Java 类和 @Configuration 注解提供的类型安全配置方式。

2.4 2.4 依赖注入（DI） ​

依赖注入是实现 IoC 的核心机制，主要方式有：

  1. 构造器注入：通过构造器传递依赖。
  2. Setter 注入：通过 Setter 方法注入依赖。
  3. 字段注入：直接在字段上注解（不推荐，难以测试）。

3 3. IoC 的实现过程 ​

Spring IoC 的基本实现过程如下：

  1. 定义 Bean
    在配置文件或注解中定义 Bean，包括类、作用域和依赖关系等。

  2. 启动容器
    通过 Spring 容器（如 ApplicationContext）加载配置，实例化并初始化所有 Bean。

  3. 依赖注入
    容器解析 Bean 的依赖关系，自动注入到目标对象中。

  4. 管理 Bean 生命周期
    容器负责管理 Bean 的完整生命周期，包括创建、初始化、销毁等。

4 4. 示例 ​

4.1 4.1 XML 配置方式 ​

4.1.1 配置文件（applicationContext.xml） ​

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 -->
    <bean id="exampleService" class="com.example.ExampleService">
        <property name="exampleDao" ref="exampleDao"/>
    </bean>

    <bean id="exampleDao" class="com.example.ExampleDao"/>
</beans>

4.1.2 使用容器加载配置并获取 Bean ​

java
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
ExampleService service = context.getBean("exampleService", ExampleService.class);
service.doSomething();

4.2 4.2 注解方式 ​

4.2.1 Bean 定义 ​

java
@Component
public class ExampleService {

    @Autowired
    private ExampleDao exampleDao;

    public void doSomething() {
        System.out.println("Service is working!");
        exampleDao.query();
    }
}

@Repository
public class ExampleDao {
    public void query() {
        System.out.println("DAO is querying!");
    }
}

4.2.2 启动容器 ​

java
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ExampleService service = context.getBean(ExampleService.class);
        service.doSomething();
    }
}

4.3 4.3 Java 配置方式 ​

4.3.1 配置类 ​

java
@Configuration
public class AppConfig {

    @Bean
    public ExampleDao exampleDao() {
        return new ExampleDao();
    }

    @Bean
    public ExampleService exampleService() {
        return new ExampleService(exampleDao());
    }
}

4.3.2 使用容器 ​

java
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ExampleService service = context.getBean(ExampleService.class);
        service.doSomething();
    }
}

5 5. IoC 的优势 ​

  1. 松耦合

    • 通过依赖注入，组件之间的依赖关系由容器管理，降低耦合度。

  2. 代码清晰

    • 对象创建和管理的逻辑从业务代码中分离，代码更简洁可维护。

  3. 易于测试

    • 通过依赖注入，可以轻松替换或模拟依赖，方便单元测试。

  4. 可扩展性强

    • 容器支持不同类型的依赖管理，灵活性高。

  5. 集中管理

    • 所有 Bean 的定义和依赖关系在一个地方集中管理，方便修改和维护。

6 6. 总结 ​

Spring IoC 是现代 Java 企业级开发的重要基础，通过容器管理对象和依赖关系，大幅降低了代码的耦合度，提高了项目的可维护性和扩展性。在实际开发中，可以根据场景选择合适的配置方式（XML、注解或 Java 配置）来实现 IoC，并结合依赖注入机制充分利用 Spring 的强大功能。