Java Jakarta EE CDI依赖注入与生命周期管理

讲座开场：Java Jakarta EE CDI依赖注入与生命周期管理

大家好，欢迎来到今天的讲座！今天我们要探讨的是Java Jakarta EE中的CDI（Contexts and Dependency Injection），这是一个非常强大的框架，用于简化Java应用程序的开发。如果你曾经在Java世界中摸爬滚打过，你一定知道依赖注入（Dependency Injection, DI）和生命周期管理的重要性。它们不仅让代码更加模块化、可测试，还能极大地提高开发效率。

想象一下，你正在编写一个大型的企业级应用，涉及到多个模块、服务和组件。如果没有一个好的依赖管理和生命周期控制机制，你的代码可能会变得像一团乱麻，难以维护和扩展。而CDI正是为了解决这些问题而生的。它提供了一种优雅的方式来管理对象的创建、依赖关系的注入以及对象的生命周期。

在这次讲座中，我们将深入探讨以下几个方面：

1. 什么是CDI？
   我们将从基础开始，解释CDI的核心概念，包括上下文（Context）、依赖注入（Dependency Injection）和事件（Events）。通过这些概念，你可以更好地理解CDI的工作原理。

2. 如何使用CDI进行依赖注入？
   我们会通过具体的代码示例，展示如何在Java类中注入依赖，并解释不同类型的注入方式，如构造器注入、字段注入和方法注入。

3. CDI的生命周期管理
   了解对象的生命周期是非常重要的，尤其是在企业级应用中。我们将讨论CDI如何管理对象的生命周期，包括不同的作用域（Scope），如@ApplicationScoped、@RequestScoped等。

4. CDI的高级特性
   CDI不仅仅是一个简单的依赖注入框架，它还提供了许多高级特性，如拦截器（Interceptors）、装饰器（Decorators）和生产者方法（Producer Methods）。我们会在讲座的后半部分详细介绍这些功能。

5. 最佳实践与常见问题
   最后，我们会分享一些使用CDI的最佳实践，并讨论一些常见的陷阱和问题，帮助你在实际开发中避免踩坑。

无论你是刚刚接触Java EE的新手，还是已经有一定经验的开发者，相信今天的讲座都会对你有所帮助。接下来，让我们正式进入正题，开始探讨CDI的世界吧！

---

第一部分：什么是CDI？

1.1 CDI的历史与发展

CDI（Contexts and Dependency Injection for the Java EE platform）是Java EE（现为Jakarta EE）的一部分，最早出现在Java EE 6中。它的目标是为Java EE平台提供一个统一的依赖注入和上下文管理机制。在此之前，Java EE的各个组件（如EJB、JSF等）都有自己独立的依赖注入机制，这导致了代码的不一致性，增加了学习曲线。

CDI的出现解决了这个问题，它提供了一个标准化的API，使得开发者可以在不同的Java EE组件之间共享依赖注入和上下文管理的功能。随着Java EE的发展，CDI也不断进化，引入了许多新的特性和改进。

1.2 CDI的核心概念

要理解CDI，首先需要掌握几个核心概念：

• Bean：在CDI中，Bean是指任何可以通过CDI容器管理的对象。它可以是普通的Java类、EJB、JSF Managed Bean等。CDI会负责Bean的创建、销毁以及依赖注入。

• 依赖注入（Dependency Injection, DI）：DI是一种设计模式，允许对象之间的依赖关系由外部容器来管理，而不是在对象内部硬编码。这样可以提高代码的灵活性和可测试性。CDI通过注解（如@Inject）来实现依赖注入。

• 上下文（Context）：上下文定义了Bean的生命周期范围。不同的上下文决定了Bean在何时创建、何时销毁。CDI提供了多种内置的上下文，如@ApplicationScoped、@RequestScoped等。

• 事件（Event）：CDI允许你通过事件机制在不同的Bean之间传递消息。你可以发布事件，其他Bean可以通过观察者模式监听并处理这些事件。

• 拦截器（Interceptor）：拦截器可以用来在方法调用前后执行某些逻辑，例如日志记录、事务管理等。CDI提供了对拦截器的支持，使得你可以轻松地为Bean添加横切关注点。

• 装饰器（Decorator）：装饰器可以用来增强或修改现有Bean的行为。它类似于面向对象编程中的装饰器模式，允许你在不修改原始代码的情况下添加新功能。

1.3 CDI的作用

CDI的主要作用可以总结为以下几点：

• 简化依赖管理：通过自动化的依赖注入，CDI可以帮助你减少手动管理依赖的工作量，使代码更加简洁和易于维护。

• 提升代码的可测试性：由于依赖关系是由CDI容器管理的，你可以很容易地为单元测试创建模拟对象，而不必担心复杂的依赖链。

• 统一的生命周期管理：CDI提供了统一的生命周期管理机制，使得你可以轻松地控制Bean的创建和销毁，确保资源的合理使用。

• 事件驱动的架构：通过事件机制，CDI可以让你构建更加松耦合的系统，不同模块之间可以通过事件进行通信，而不需要直接调用对方的方法。

---

第二部分：如何使用CDI进行依赖注入？

2.1 基本的依赖注入

在CDI中，依赖注入是最常用的功能之一。它允许你通过注解的方式，将一个对象的依赖关系交给CDI容器来管理。下面我们通过一个简单的例子来演示如何使用CDI进行依赖注入。

假设我们有一个UserService类，它依赖于UserRepository类来获取用户数据。我们可以使用@Inject注解来注入UserRepository的实例。

import jakarta.inject.Inject;

public class UserService {

    @Inject
    private UserRepository userRepository;

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

在这个例子中，@Inject注解告诉CDI容器，UserService类需要一个UserRepository的实例。当UserService被创建时，CDI会自动为我们注入一个UserRepository的实例。

2.2 构造器注入 vs 字段注入 vs 方法注入

CDI支持三种主要的注入方式：构造器注入、字段注入和方法注入。每种方式都有其优缺点，选择哪种方式取决于你的具体需求。

2.2.1 构造器注入

构造器注入是最推荐的方式，因为它可以确保依赖关系在对象创建时就已经初始化。此外，构造器注入还可以与不可变对象一起使用，提高代码的安全性。

import jakarta.inject.Inject;

public class UserService {

    private final UserRepository userRepository;

    @Inject
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

2.2.2 字段注入

字段注入是最简单的方式，但它也有一些缺点。由于依赖关系是在字段上注入的，因此你无法在构造函数中强制要求依赖项的存在。此外，字段注入也不适用于不可变对象。

import jakarta.inject.Inject;

public class UserService {

    @Inject
    private UserRepository userRepository;

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

2.2.3 方法注入

方法注入允许你在对象创建后动态地注入依赖项。它通常用于那些依赖项可能在运行时发生变化的场景。

import jakarta.inject.Inject;

public class UserService {

    private UserRepository userRepository;

    @Inject
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

2.3 依赖注入的优先级

在某些情况下，你可能会有多个实现类满足同一个接口的依赖。为了指定应该使用哪个实现类，你可以使用@Qualifier注解来标记不同的实现类，并在注入时指定具体的实现。

例如，假设我们有两个UserRepository的实现类：InMemoryUserRepository和DatabaseUserRepository。我们可以使用@Qualifier注解来区分它们。

import jakarta.inject.Qualifier;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;

@Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface InMemory {}

import jakarta.inject.Singleton;

@Singleton
@InMemory
public class InMemoryUserRepository implements UserRepository {
    // 实现逻辑
}

import jakarta.inject.Singleton;

@Singleton
public class DatabaseUserRepository implements UserRepository {
    // 实现逻辑
}

然后，在注入时，你可以使用@InMemory注解来指定使用哪个实现类。

import jakarta.inject.Inject;

public class UserService {

    @Inject
    @InMemory
    private UserRepository userRepository;

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

---

第三部分：CDI的生命周期管理

3.1 什么是Bean的作用域？

在CDI中，Bean的作用域决定了它的生命周期。不同的作用域会影响Bean的创建和销毁时机，进而影响性能和资源管理。CDI提供了几种内置的作用域，下面我们将逐一介绍。

3.1.1 @ApplicationScoped

@ApplicationScoped是最广泛使用的作用域之一。它表示Bean在整个应用程序的生命周期内只创建一次，并且在整个应用程序中共享。这意味着所有请求都会共享同一个Bean实例。

import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class AppConfig {
    // 配置信息
}

3.1.2 @RequestScoped

@RequestScoped作用域表示Bean在每次HTTP请求中创建一次，并在请求结束时销毁。它通常用于Web应用程序中，确保每个请求都有自己独立的Bean实例。

import jakarta.enterprise.context.RequestScoped;

@RequestScoped
public class UserSession {
    // 用户会话信息
}

3.1.3 @SessionScoped

@SessionScoped作用域表示Bean在整个用户会话期间存在。它通常用于Web应用程序中，确保同一用户的多个请求可以共享同一个Bean实例。

import jakarta.enterprise.context.SessionScoped;

@SessionScoped
public class ShoppingCart {
    // 购物车信息
}

3.1.4 @Dependent

@Dependent是默认的作用域，表示Bean的生命周期完全依赖于它的父Bean。也就是说，每当父Bean创建时，@Dependent作用域的Bean也会被创建；当父Bean销毁时，@Dependent作用域的Bean也会被销毁。

import jakarta.enterprise.context.Dependent;

@Dependent
public class Logger {
    // 日志记录器
}

3.2 自定义作用域

除了内置的作用域，CDI还允许你创建自定义的作用域。这可以通过实现jakarta.enterprise.context.NormalScope接口来实现。自定义作用域可以用于特定的业务场景，例如基于事务的作用域或基于线程的作用域。

3.3 Bean的销毁

在某些情况下，你可能希望在Bean销毁时执行一些清理操作。CDI提供了@PreDestroy注解，允许你在Bean销毁之前执行回调方法。

import jakarta.annotation.PreDestroy;

@RequestScoped
public class UserSession {

    @PreDestroy
    public void cleanup() {
        // 清理资源
    }
}

---

第四部分：CDI的高级特性

4.1 拦截器（Interceptors）

拦截器允许你在方法调用前后执行某些逻辑，例如日志记录、事务管理等。你可以通过@Interceptor注解定义拦截器，并使用@Intercepts注解将其绑定到特定的方法上。

例如，假设我们想要为所有的UserService方法添加日志记录功能。我们可以定义一个拦截器：

import jakarta.interceptor.AroundInvoke;
import jakarta.interceptor.Interceptor;
import jakarta.interceptor.InvocationContext;

@Interceptor
@Loggable
public class LoggingInterceptor {

    @AroundInvoke
    public Object logMethod(InvocationContext context) throws Exception {
        System.out.println("Calling method: " + context.getMethod().getName());
        try {
            return context.proceed();
        } finally {
            System.out.println("Method completed.");
        }
    }
}

然后，我们在UserService类上使用@Loggable注解来启用拦截器：

import jakarta.interceptor.Interceptors;

@Interceptors(LoggingInterceptor.class)
public class UserService {

    public void getUserById(Long id) {
        // 方法逻辑
    }
}

4.2 装饰器（Decorators）

装饰器允许你在不修改原始代码的情况下，增强或修改现有Bean的行为。你可以通过@Decorator注解定义装饰器，并使用@Delegate注解将装饰器绑定到原始Bean上。

例如，假设我们想要为UserService添加缓存功能。我们可以定义一个装饰器：

import jakarta.decorator.Decorator;
import jakarta.decorator.Delegate;
import jakarta.inject.Inject;

@Decorator
public class CachedUserService implements UserService {

    @Inject
    @Delegate
    private UserService delegate;

    @Override
    public void getUserById(Long id) {
        // 检查缓存
        if (cache.contains(id)) {
            return cache.get(id);
        }

        // 如果缓存中没有，则调用原始方法
        User user = delegate.getUserById(id);
        cache.put(id, user);
        return user;
    }
}

4.3 生产者方法（Producer Methods）

生产者方法允许你动态地创建Bean实例。你可以通过@Produces注解定义生产者方法，并使用@Named注解为Bean指定名称。

例如，假设我们想要根据配置文件动态地创建UserRepository的实现类。我们可以定义一个生产者方法：

import jakarta.enterprise.inject.Produces;
import jakarta.inject.Named;

public class RepositoryFactory {

    @Produces
    @Named("inMemory")
    public UserRepository createInMemoryRepository() {
        return new InMemoryUserRepository();
    }

    @Produces
    @Named("database")
    public UserRepository createDatabaseRepository() {
        return new DatabaseUserRepository();
    }
}

然后，我们可以在注入时指定使用哪个实现类：

import jakarta.inject.Inject;

public class UserService {

    @Inject
    @Named("inMemory")
    private UserRepository userRepository;

    public void getUserById(Long id) {
        return userRepository.findById(id);
    }
}

---

第五部分：最佳实践与常见问题

5.1 最佳实践

• 优先使用构造器注入：构造器注入可以确保依赖关系在对象创建时就已经初始化，避免了空指针异常。此外，构造器注入还可以与不可变对象一起使用，提高代码的安全性。

• 避免过度依赖全局状态：虽然@ApplicationScoped作用域很方便，但过度使用它可能导致全局状态的滥用，增加代码的复杂性和调试难度。尽量将状态封装在更小的作用域中，如@RequestScoped或@SessionScoped。

• 使用拦截器管理横切关注点：拦截器可以很好地分离业务逻辑和横切关注点（如日志记录、事务管理等），使得代码更加清晰和易于维护。

• 避免循环依赖：循环依赖会导致CDI容器无法正确创建Bean。尽量避免两个Bean之间相互依赖的情况，或者使用生产者方法来打破循环依赖。

5.2 常见问题

• Bean未被发现：如果你遇到“Bean not found”错误，可能是由于CDI容器无法扫描到你的Bean类。确保你的Bean类位于正确的包中，并且项目配置了CDI扫描路径。

• 依赖注入失败：如果你在注入依赖时遇到问题，可能是由于依赖项的类型不匹配，或者是缺少必要的注解（如@Inject或@Qualifier）。检查你的依赖项是否正确声明，并确保它们是可注入的。

• Bean的作用域不正确：如果你发现Bean的行为不符合预期，可能是由于选择了不正确的作用域。确保你选择了合适的作用域，以满足你的业务需求。

---

总结

通过今天的讲座，我们深入了解了Java Jakarta EE中的CDI框架。我们从基础概念出发，探讨了依赖注入、上下文管理、事件机制等核心功能，并介绍了CDI的生命周期管理机制。此外，我们还探讨了一些高级特性，如拦截器、装饰器和生产者方法，帮助你在实际开发中构建更加灵活和可维护的系统。

CDI不仅是一个强大的依赖注入框架，它还提供了一系列工具，帮助你更好地管理应用程序的复杂性。希望今天的讲座能够为你提供一些有价值的见解，帮助你在未来的开发中更加得心应手。

感谢大家的聆听，如果有任何问题或建议，欢迎随时交流！