java - 在注释另一个方法之前调用方法

Question

我正在尝试使用注释将功能添加到接口(interface)方法签名中。

这个想法是在每个带注释的方法之前调用一些其他方法。

例如，如果我有这个方法签名:

public interface IMyInterface{

    @Entity(visibileName = "Name")
    public TextField getName();
}

我需要调用一个方法，在此方法之前、之后打印字符串名称。另外，如果有任何方法可以在运行时定义此方法的功能。

我也对结构性变化持开放态度。

Answer 1

如果您想要注释接口(interface)方法，那么无需AOP即可。
只需使用动态代理即可!

实现代理的基本接口(interface)是InitationHandler

InvocationHandler is the interface implemented by the invocation handler of a proxy instance.

<小时/>

遵循代码内注释。

static class MyInterfaceProxy implements InvocationHandler {
    private static final Map<String, Method> METHODS = new HashMap<>(16);

    static {
        // Scan each interface method for the specific annotation
        // and save each compatible method
        for (final Method m : IMyInterface.class.getDeclaredMethods()) {
            if (m.getAnnotation(YourAnnotation.class) != null) {
                METHODS.put(m.getName(), m);
            }
        }
    }

    private final IMyInterface toBeProxied;

    private MyInterfaceProxy(final IMyInterface toBeProxied) {
        // Accept the real implementation to be proxied
        this.toBeProxied = toBeProxied;
    }

    @Override
    public Object invoke(
            final Object proxy,
            final Method method,
            final Object[] args) throws InvocationTargetException, IllegalAccessException {
        // A method on MyInterface has been called!
        // Check if we need to call it directly or if we need to
        // execute something else before!
        final Method found = METHODS.get(method.getName());

        if (found != null) {
            // The method exist in our to-be-proxied list
            // Execute something and the call it
            // ... some other things
            System.out.println("Something else");
        }

        // Invoke original method
        return method.invoke(toBeProxied, args);
    }
}

要使用此 InitationHandler 实现，您需要要代理的对象的真实实例。

假设您有一个用于 MyInterface 实现的工厂

MyInterface getMyInsterface() {
   ...
   final MyInterface instance = ...

   // Create the proxy and inject the real implementation
   final IMyInterface proxy = (IMyInterface) Proxy.newProxyInstance(
        MyInterfaceProxy.class.getClassLoader(),
        new Class[] {IMyInterface.class},
        new MyInterfaceProxy(instance) // Inject the real instance
    );

   // Return the proxy!
   return proxy;
}