Quarkus中的依赖注入DI和面向切面aop编程

Quarkus是一个Java框架，它旨在提供快速启动和低内存消耗的微服务。而依赖注入（DI）和面向切面编程（AOP）是Quarkus的两个重要特性。

什么是依赖注入？

依赖注入是Quarkus中最基本的概念之一。它的目的是使应用程序具有可扩展性并降低组件之间的耦合度。

根据Quarkus文档的描述，依赖注入是将实例变量传递给类的技术。在Quarkus中，我们可以使用@Inject注解将一个实例（例如另一个类）注入到一个类的实例变量中。示例代码如下：

@ApplicationScoped
public class GreetingService {

    public String greeting(String name) {
        return "Hello " + name;
    }
}

@Path("/hello")
public class GreetingResource {

    @Inject
    GreetingService greetingService;

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return greetingService.greeting("Quarkus");
    }
}

在这个例子中，我们使用@Inject注解将GreetingService类注入到GreetingResource类的greetingService实例变量中，从而使得GreetingResource可以使用GreetingService类中的方法。

什么是面向切面编程？

面向切面编程是Quarkus中另一个重要的概念。它的目的是将通用任务（例如日志记录、安全性检查等）与业务逻辑分离开来。

在Quarkus中，我们可以使用@Interceptor注解和@Interceptors注解来创建切面。简单来说，拦截器就是在方法调用或其他程序事件发生时执行的代码。

以下是一个使用@Interceptor注解的示例：

import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;

@Interceptor
@Loggable
public class LoggingInterceptor {

    @AroundInvoke
    public Object logMethod(InvocationContext context) throws Exception {
        Logger logger = LoggerFactory.getLogger(context.getTarget().getClass().getName());
        logger.info("Entering method: " + context.getMethod().getName());
        Object result = context.proceed();
        logger.info("Exiting method: " + context.getMethod().getName());
        return result;
    }
}

在这个例子中，我们使用@Interceptor注解将LoggingInterceptor类标记为一个切面。此外，我们还使用@Loggable注解将使用这个拦截器的方法标记出来。在@AroundInvoke注解中，我们编写了拦截器的逻辑。在拦截器执行时，它将记录所调用的方法的信息。

示例说明

这里为了具体说明依赖注入和面向切面编程，我们给出两个示例：

示例1：使用依赖注入获取数据库连接

首先，我们添加以下依赖：

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-jdbc-postgresql</artifactId>
</dependency>

然后定义一个类，并用@Inject注解将DataSource实例注入其中，这样我们就可以在代码中使用获取的数据库连接：

@ApplicationScoped
public class DatabaseService {

    @Inject
    DataSource dataSource;

    public void query() throws SQLException {
        try (Connection conn = dataSource.getConnection()) {
            // do something
        }
    }
}

示例2：使用面向切面编程记录日志

我们定义一个@Loggable注解，并将它应用在我们希望记录日志的方法上：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable {
}

接下来，我们定义一个拦截器来实现日志记录逻辑：

@Interceptor
@Loggable
public class LoggingInterceptor {

    @AroundInvoke
    public Object logMethod(InvocationContext context) throws Exception {
        Logger logger = LoggerFactory.getLogger(context.getTarget().getClass().getName());
        logger.info("Entering method: " + context.getMethod().getName());
        Object result = context.proceed();
        logger.info("Exiting method: " + context.getMethod().getName());
        return result;
    }
}

然后，我们在需要记录日志的方法中使用@Loggable注解：

@Stateless
public class UserService {

    @Inject
    EntityManager entityManager;

    @Loggable
    public List<User> getAllUsers() {
        return entityManager.createNamedQuery("User.getAll", User.class).getResultList();
    }
}

这样在调用getAllUsers方法时，LoggingInterceptor拦截器就会执行，记录当前方法的执行情况。