如何手写一个AOP简单框架

AOP（Aspect Oriented Programming）是一种面向切面编程的编程范式，它可以在程序运行时动态地将代码插入到指定方法的前面、后面或者中间，从而实现对方法的增强。

下面是手写一个简单的AOP框架的步骤：

1. 定义注解

定义一个自定义注解，用于标注需要增强的方法。例如：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}

2. 定义切面

定义一个切面类，该类包含需要增强的方法以及增强逻辑。例如：

public class MyAspect {
    public void before() {
        System.out.println("before");
    }

    public void after() {
        System.out.println("after");
    }
}

3. 定义代理类

定义一个代理类，该类通过反射机制获取需要增强的方法以及切面类中的增强逻辑，并在方法执行前后调用切面类中的增强逻辑。例如：

public class MyProxy {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    Method targetMethod = target.getClass().getMethod(method.getName(), method.getParameterTypes());
                    if (targetMethod.isAnnotationPresent(MyAnnotation.class)) {
                        MyAspect aspect = new MyAspect();
                        aspect.before();
                        Object result = method.invoke(target, args);
                        aspect.after();
                        return result;
                    } else {
                        return method.invoke(target, args);
                    }
                });
    }
}

4. 使用代理类

通过代理类获取代理对象，并使用该对象调用需要增强的方法。例如：

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyClass myProxy = (MyClass) MyProxy.getProxy(myClass);
        myProxy.method();
    }
}

class MyClass {
    @MyAnnotation
    public void method() {
        System.out.println("method");
    }
}

当调用代理对象的`method()`方法时，会先调用`MyAspect`中的`before()`方法，然后调用原始对象`MyClass`中的`method()`方法，最后再调用`MyAspect`中的`after()`方法。