在Quarkus中实现方法后置逻辑：@AroundInvoke拦截器的应用

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

public class MyAfterInterceptor {

    @AroundInvoke
    public Object intercept(InvocationContext context) throws Exception {
        Object result = null;
        try {
            // 执行目标方法
            result = context.proceed();
        } finally {
            // 在这里执行方法后的逻辑，无论是否发生异常
            // 'result' 变量将包含目标方法的返回值（如果方法正常完成）
            // 或者为null（如果方法抛出异常）
            System.out.println("方法执行完毕。结果: " + result);
            // 示例：触发事件、记录日志、更新指标等
            // fireEventWithResult(result);
        }
        // 返回目标方法的原始结果或修改后的结果
        return result;
    }
}

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.interceptor.InterceptorBinding;

@Inherited
@InterceptorBinding
@Target({TYPE, METHOD})
@Retention(RUNTIME)
public @interface AfterMethodEvent {
}

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

// 定义拦截器的优先级，数字越小优先级越高
@Priority(Interceptor.APPLICATION_LEVEL)
@Interceptor
@AfterMethodEvent // 绑定到我们定义的注解
public class MyAfterInterceptor {

    @AroundInvoke
    public Object intercept(InvocationContext context) throws Exception {
        Object result = null;
        Throwable caughtException = null;
        try {
            result = context.proceed(); // 执行目标方法
        } catch (Exception e) {
            caughtException = e;
            throw e; // 重新抛出异常，确保调用者能感知到
        } finally {
            // 在这里执行方法后的逻辑
            // 无论方法成功还是失败，都会执行到这里
            String methodName = context.getMethod().getName();
            System.out.println("方法 '" + methodName + "' 执行完毕。");
            if (caughtException != null) {
                System.out.println("方法抛出异常: " + caughtException.getMessage());
                // 示例：触发一个包含异常信息的事件
                // EventBus.fire(new MethodFailedEvent(methodName, caughtException));
            } else {
                System.out.println("方法正常完成，结果: " + result);
                // 示例：触发一个包含结果的事件
                // EventBus.fire(new MethodCompletedEvent(methodName, result));
            }
        }
        return result; // 返回目标方法的原始结果
    }
}

<!-- META-INF/beans.xml -->
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
          http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/beans_2_0.xsd"
       bean-discovery-mode="annotated">
</beans>

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class MyService {

    @AfterMethodEvent // 应用拦截器绑定注解
    public String processData(String input) {
        System.out.println("正在处理数据: " + input);
        if ("error".equals(input)) {
            throw new RuntimeException("模拟处理错误!");
        }
        return "Processed: " + input.toUpperCase();
    }

    public void anotherMethod() {
        System.out.println("这是一个未被拦截的方法。");
    }
}