Java Interceptor如何實現AOP編程

在Java中，AOP（面向切面編程）是一種編程范式，它允許開發者將橫切關注點（cross-cutting concerns）與業務邏輯分離，從而提高代碼的可重用性和可維護性。攔截器（Interceptor）是實現AOP的一種方式，它可以在方法調用前后執行特定的邏輯。

要在Java中使用攔截器實現AOP編程，你可以使用動態代理或者第三方庫（如Spring AOP）。下面是一個簡單的示例，展示了如何使用Java動態代理實現攔截器：

1. 首先，創建一個接口：

public interface MyInterface {
    void doSomething();
}

2. 實現該接口：

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyInterfaceImpl: doSomething");
    }
}

3. 創建一個攔截器類，實現InvocationHandler接口：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInterceptor implements InvocationHandler {
    private Object target;

    public MyInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

4. 使用Proxy.newProxyInstance()方法創建代理對象：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        MyInterface target = new MyInterfaceImpl();
        MyInterceptor interceptor = new MyInterceptor(target);
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                interceptor
        );
        proxy.doSomething();
    }
}

運行上述代碼，你將看到以下輸出：

Before method: doSomething
MyInterfaceImpl: doSomething
After method: doSomething

這就是一個簡單的使用攔截器實現AOP編程的例子。在實際項目中，你可能需要處理更復雜的情況，例如多個攔截器的順序執行、異常處理等。這時，你可以考慮使用成熟的第三方庫（如Spring AOP）來實現AOP編程。