AOP(Aspect-Oriented Programming)是一种编程范式,它通过将横切关注点(如日志、事务、安全等)从业务逻辑中分离出来,以模块化的方式进行开发和维护。Spring AOP是基于代理模式实现的,它通过动态代理技术,在目标对象的方法执行前后插入增强代码,实现横切关注点的功能。
下面是一个简单的AOP源码示例:
```java
// 定义一个接口
public interface HelloService {
    void sayHello(String name);
}
// 实现接口
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}
// 定义切面类
public class LogAspect {
    // 前置通知
    public void before() {
        System.out.println("Before method...");
    }
    
    // 后置通知
    public void after() {
        System.out.println("After method...");
    }
}
// 创建代理对象
public class ProxyFactory {
    private Object target; // 目标对象
    private LogAspect aspect; // 切面对象
    
    public ProxyFactory(Object target, LogAspect aspect) {
        this.target = target;
        this.aspect = aspect;
    }
    
    public Object getProxy() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                aspect.before(); // 前置通知
                Object result = method.invoke(target, args); // 执行目标方法
                aspect.after(); // 后置通知
                return result;
            }
        );
    }
}
// 测试代码
public class Test {
    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        LogAspect logAspect = new LogAspect();
        ProxyFactory proxyFactory = new ProxyFactory(helloService, logAspect);
        HelloService proxy = (HelloService) proxyFactory.getProxy();
        proxy.sayHello("World");
    }
}
```