如何使用标准java功能拦截方法调用(没有AspectJ等)？

要使用标准Java功能拦截方法调用，而不使用AspectJ等第三方库，您可以使用Java的动态代理。动态代理允许您在运行时创建代理对象，以拦截方法调用并在执行原始方法之前或之后添加自定义逻辑。以下是如何使用动态代理的示例：

创建一个接口，表示要拦截的方法。

public interface MyInterface {
    void myMethod();
}

创建一个实现接口的类。

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Method called");
    }
}

创建一个代理工厂，用于生成代理对象。

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

public class MyProxyFactory {
    public static <T> T createProxy(Class<T> interfaceClass, T target) {
        return (T) java.lang.reflect.Proxy.newProxyInstance(
                interfaceClass.getClassLoader(),
                new Class<?>[]{interfaceClass},
                new MyInvocationHandler(target)
        );
    }

    private static class MyInvocationHandler implements InvocationHandler {
        private final Object target;

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

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

使用代理工厂创建代理对象并调用方法。

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

在这个示例中，当调用proxy.myMethod()时，代理对象会在原始方法执行之前和之后添加自定义逻辑。您可以根据需要修改MyInvocationHandler类中的invoke方法，以添加您需要的拦截逻辑。

请注意，动态代理的性能可能不如AspectJ等第三方库。如果您需要更高级的功能和性能，可以考虑使用这些库。