在Quarkus中实现类似Spring @After的后置处理逻辑

import javax.interceptor.InterceptorBinding;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@InterceptorBinding
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AfterMethodEvent {
}

import io.quarkus.arc.Priority;
import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;
import javax.enterprise.event.Event; // 假设我们要发布事件
import javax.inject.Inject;
import javax.enterprise.context.ApplicationScoped;

@AfterMethodEvent // 绑定到我们定义的注解
@Interceptor
@Priority(Interceptor.Priority.APPLICATION + 100) // 定义优先级
@ApplicationScoped // 拦截器通常是ApplicationScoped
public class MethodAfterInterceptor {

    @Inject
    Event<MethodCompletionEvent> eventPublisher; // 注入事件发布器

    @AroundInvoke
    public Object intercept(InvocationContext context) throws Exception {
        Object result = null;
        Throwable caughtException = null;

        try {
            // 1. 在目标方法执行之前（可选的预处理）
            // System.out.println("Invoking method: " + context.getMethod().getName());

            result = context.proceed(); // 调用目标业务方法
            return result; // 正常返回，将结果传递给调用者
        } catch (Exception e) {
            caughtException = e;
            throw e; // 重新抛出异常，确保业务逻辑的异常传播
        } finally {
            // 2. 在目标方法执行之后，无论成功或失败
            System.out.println("Method " + context.getMethod().getName() + " finished.");

            // 根据结果或异常发布事件
            MethodCompletionEvent completionEvent = new MethodCompletionEvent(
                context.getMethod().getName(),
                context.getTarget().getClass().getName(),
                result,
                caughtException
            );
            eventPublisher.fire(completionEvent);

            // 可以在这里对结果进行修改或替换 (如果目标方法没有抛出异常)
            // if (caughtException == null) {
            //    return modifyResult(result);
            // }
        }
    }

    // 假设的事件类
    public static class MethodCompletionEvent {
        private final String methodName;
        private final String className;
        private final Object result;
        private final Throwable exception;

        public MethodCompletionEvent(String methodName, String className, Object result, Throwable exception) {
            this.methodName = methodName;
            this.className = className;
            this.result = result;
            this.exception = exception;
        }

        // Getter methods
        public String getMethodName() { return methodName; }
        public String getClassName() { return className; }
        public Object getResult() { return result; }
        public Throwable getException() { return exception; }
    }
}

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class MyService {

    @AfterMethodEvent // 应用拦截器到此方法
    public String processData(String input) {
        System.out.println("Processing data: " + input);
        if ("error".equals(input)) {
            throw new IllegalArgumentException("Simulated error for input: " + input);
        }
        return "Processed: " + input.toUpperCase();
    }

    @AfterMethodEvent // 也可以应用到另一个方法
    public int calculate(int a, int b) {
        System.out.println("Calculating " + a + " + " + b);
        return a + b;
    }

    public String anotherMethod(String data) {
        System.out.println("This method is not intercepted after completion.");
        return data;
    }
}