在Java中，代理模式（Proxy Pattern）是一種設計模式，它允許你在不修改原始類的情況下，通過創建一個代理類來實現對原始類的功能擴展。AOP（面向切面編程）是一種編程范式，它允許你在不修改源代碼的情況下，將橫切關注點（如日志記錄、安全性、事務管理等）與業務邏輯分離。

要在Java中實現AOP，你可以使用動態代理技術。Java提供了兩種動態代理方式：JDK動態代理和CGLIB動態代理。下面是一個使用JDK動態代理實現AOP的簡單示例：

1. 首先，定義一個接口：

public interface MyInterface {
    void doSomething();
}

2. 然后，創建一個實現該接口的類：

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

3. 接下來，創建一個切面類，用于定義橫切關注點：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class MyAspect {
    @Before("execution(* MyInterface.doSomething(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before advice: Before calling doSomething()");
    }

    @After("execution(* MyInterface.doSomething(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After advice: After calling doSomething()");
    }
}

在這個例子中，我們使用了AspectJ的注解來定義切面。@Before注解表示在目標方法執行之前執行切面代碼，@After注解表示在目標方法執行之后執行切面代碼。

4. 最后，創建一個代理類，并使用java.lang.reflect.Proxy類的newProxyInstance方法創建代理對象：

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

public class MyProxy implements InvocationHandler {
    private Object target;

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

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

    public static Object createProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new MyProxy(target)
        );
    }
}

5. 在主類中使用代理對象調用目標方法：

public class Main {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        MyInterface proxy = (MyInterface) MyProxy.createProxy(myInterface);
        proxy.doSomething();
    }
}

運行這個程序，你將看到以下輸出：

Proxy: Before method call
Doing something...
Proxy: After method call

這個示例展示了如何使用JDK動態代理實現AOP。你可以根據需要修改切面類和代理類，以實現不同的橫切關注點。