如何在java中创建一个动态代理,保留方法上的参数注释?



我目前正在尝试代理一些现有的JAX/RS资源,以便允许我使用Hibernate验证器的方法验证支持。然而,当我代理我的类(目前使用cglib 2.2)时,FormParam注释不存在于代理类的参数上,因此JAX/RS运行时(apache wink)不填充参数。下面是一些测试代码,显示了以下内容:

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import javassist.util.proxy.ProxyFactory;
public class ProxyTester {
    @Target( { PARAMETER })
    @Retention(RUNTIME)
    public static @interface TestAnnotation {
    }
    public static interface IProxyMe {
        void aMethod(@TestAnnotation int param);
    }
    public static class ProxyMe implements IProxyMe {
            public void aMethod(@TestAnnotation int param) {
        }
    }
    static void dumpAnnotations(String type, Object proxy, Object forObject,
            String forMethod) {
        String className = forObject.getClass().getName();
        System.err.println(type + " proxy for Class: " + className);
        for (Method method : proxy.getClass().getMethods()) {
            if (method.getName().equals(forMethod)) {
                final int paramCount = method.getParameterTypes().length;
                System.err.println(" Method: " + method.getName() + " has "
                        + paramCount + " parameters");
                int i = 0;
                for (Annotation[] paramAnnotations : method
                        .getParameterAnnotations()) {
                    System.err.println("  Param " + (i++) + " has "
                            + paramAnnotations.length + " annotations");
                    for (Annotation annotation : paramAnnotations) {
                        System.err.println("   Annotation "
                                + annotation.toString());
                    }
                }
            }
        }
    }
    static Object javassistProxy(IProxyMe in) throws Exception {
        ProxyFactory pf = new ProxyFactory();
        pf.setSuperclass(in.getClass());
        Class c = pf.createClass();
        return c.newInstance();
    }
    static Object cglibProxy(IProxyMe in) throws Exception {
        Object p2 = Enhancer.create(in.getClass(), in.getClass()
                .getInterfaces(), new MethodInterceptor() {
            public Object intercept(Object arg0, Method arg1, Object[] arg2,
                    MethodProxy arg3) throws Throwable {
                return arg3.invokeSuper(arg0, arg2);
            }
        });
        return p2;
    }
    static Object jdkProxy(final IProxyMe in) throws Exception {
        return java.lang.reflect.Proxy.newProxyInstance(in.getClass()
                .getClassLoader(), in.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        return method.invoke(in, args);
                    }
                });
    }
    public static void main(String[] args) throws Exception {
        IProxyMe proxyMe = new ProxyMe();
        dumpAnnotations("no", proxyMe, proxyMe, "aMethod");
        dumpAnnotations("javassist", javassistProxy(proxyMe), proxyMe,
            "aMethod");
        dumpAnnotations("cglib", cglibProxy(proxyMe), proxyMe, "aMethod");
        dumpAnnotations("jdk", jdkProxy(proxyMe), proxyMe, "aMethod");
    }
}

输出如下:

<>之前没有代理类:ProxyTester$ProxyMeMethod: Method有1个参数参数0有1个注解注释@ProxyTester.TestAnnotation ()javassist代理类:ProxyTester$ProxyMeMethod: Method有1个参数参数0有0个注解cglib代理类:ProxyTester$ProxyMeMethod: Method有1个参数参数0有0个注解jdk代理类:ProxyTester$ProxyMeMethod: Method有1个参数参数0有0个注解之前

还有其他选择吗?

我怀疑,注解不是动态添加到代理实例的。(可能是因为它并不直接)。但是,可以在调用(或过滤)期间从实际的方法实例中获得注释。例如,

import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyFactory;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyTester
{
    @Target({ PARAMETER })
    @Retention(RUNTIME)
    public static @interface TestAnnotation {}
    public static interface IProxyMe {
        void aMethod(@TestAnnotation int param);
    }
    public static class ProxyMe implements IProxyMe {
        public void aMethod(@TestAnnotation int param) {
            System.out.println("Invoked " + param);
            System.out.println("-----------------");
        }
    }
    static void dumpAnnotations(String type, Object proxy, Object forObject, String forMethod)
    {
        String className = forObject.getClass().getName();
        System.out.println(type + " proxy for Class: " + className);
        for(Method method : proxy.getClass().getMethods()) {
            if(method.getName().equals(forMethod)) {
                printAnnotations(method);
            }
        }
    }
    static void printAnnotations(Method method)
    {
        int paramCount = method.getParameterTypes().length;
        System.out.println("Method: " + method.getName() + " has "  + paramCount + " parameters");
        for(Annotation[] paramAnnotations : method.getParameterAnnotations())
        {
            System.out.println("Annotations: " + paramAnnotations.length);
            for(Annotation annotation : paramAnnotations)
            {
                System.out.println("   Annotation " + annotation.toString());
            }
        }
    }
    static Object javassistProxy(IProxyMe in) throws Exception
    {
        ProxyFactory pf = new ProxyFactory();
        pf.setSuperclass(in.getClass());
        MethodHandler handler = new MethodHandler()
            {
                public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable
                {
                    if(thisMethod.getName().endsWith("aMethod"))
                        printAnnotations(thisMethod);
                    return proceed.invoke(self, args);
                }
            };
        return pf.create(new Class<?>[0], new Object[0], handler);
    }
    static Object cglibProxy(IProxyMe in) throws Exception
    {
        Object p2 = Enhancer.create(in.getClass(), in.getClass().getInterfaces(),
            new MethodInterceptor()
            {
                public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable
                {
                    printAnnotations(arg1);
                    return arg3.invokeSuper(arg0, arg2);
                }
            });
        return p2;
    }
    static Object jdkProxy(final IProxyMe in) throws Exception
    {
        return java.lang.reflect.Proxy.newProxyInstance(in.getClass().getClassLoader(), in.getClass().getInterfaces(),
            new InvocationHandler()
            {
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
                {
                    printAnnotations(method);
                    return method.invoke(in, args);
                }
            });
    }
    public static void main(String[] args) throws Exception
    {
        IProxyMe proxyMe = new ProxyMe();
        IProxyMe x = (IProxyMe) javassistProxy(proxyMe);
        IProxyMe y = (IProxyMe) cglibProxy(proxyMe);
        IProxyMe z = (IProxyMe) jdkProxy(proxyMe);
        dumpAnnotations("no", proxyMe, IProxyMe.class, "aMethod");
        dumpAnnotations("javassist", x, IProxyMe.class, "aMethod");
        dumpAnnotations("cglib", y, IProxyMe.class, "aMethod");
        dumpAnnotations("jdk", z, IProxyMe.class, "aMethod");
        System.out.println("<<<<< ---- Invoking methods ----- >>>>>");
        x.aMethod(1);
        y.aMethod(2);
        z.aMethod(3);
    }
}

CGLib Enhancer技术上只是从你的类扩展。我不知道这对你来说是否可行(对象的数量),但是如何公开一个接口而不是类?

Object p2 = Enhancer.create(resource.getClass(),
    new Class[] { IResource.class },
    new MethodInterceptor() {
      public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3)
          throws Throwable {
            return arg3.invokeSuper(arg0, arg2);
           }
    });

从增强的类中删除注释并将它们放入接口中。根据接口验证。对于许多这样的资源来说,这可能是许多样板式接口,但仍然比将所有内容映射成支持对象或dto要好得多。

我从未使用过cglib,但是我知道使用Javassist您可以使用调用处理程序来获得类的实例,然后有各种方法可以在不更改其注释的情况下瞄准某些内容。我最喜欢的一种方法是钩入一个不在类内部的方法,而是调用它,然后当它调用类内部的方法时,它可以进行字节码级别的更改,或者使用稍微慢一些但人类可读的高级api来进行调整。

这是我生活中运行代码的一个片段,已经运行了2年多,没有任何问题。这是使用javassist。

ClassPool myPool = new ClassPool(ClassPool.getDefault());
                    myPool.appendClassPath("./mods/bountymod/bountymod.jar");
                    CtClass ctTHIS = myPool.get(this.getClass().getName());
                    ctCreature.addMethod(CtNewMethod.copy(ctTHIS.getDeclaredMethod("checkCoinBounty"), ctCreature, null));
                    ctCreature.getDeclaredMethod("modifyFightSkill").instrument(new ExprEditor() {
                        public void edit(MethodCall m)
                                throws CannotCompileException {
                            if (m.getClassName().equals("com.wurmonline.server.players.Player")
                                    && m.getMethodName().equals("checkCoinAward")) {
                                String debugString = "";
                                if (bDebug)
                                    debugString = "java.util.logging.Logger.getLogger("org.gotti.wurmunlimited.mods.bountymod.BountyMod"
                                            + "").log(java.util.logging.Level.INFO, "Overriding checkCoinAward to checkCoinBounty");n";
                                m.replace(debugString + "$_ = checkCoinBounty(player);");
                            }
                        }
                    });

它获得默认的类池。然后为我们想从中截取方法的静态类添加完成。但是,该方法不在最终类中,而是在我们在运行时注入原始jar的mod类中。然后它在那个类中获得一个方法。然后它获得与我们从myPool中获得的单个类实例相关联的每个类的所有整个classPool。为什么这样做,限制了我们搞砸或可能搞砸的程度,在代码生成期间占用了一些内存。

然后它为ctCreature添加了一个新方法,这个方法是我们之前在一个变量中初始化的一个类。该方法是在这个类中创建的,但随后将其复制到我们想要从中使用它的另一个类中。然后它钩到modifyFightSkill的声明方法,在这个例子中,它发生在我们想要调用代码的时候。因此,当它被触发时,我们启动一个新的Expression Editor。

表达式编辑器然后确保我们想要在其中的实际类,但不会弄乱它的任何原始构造,并在不改变其核心类的情况下获得我们想要做某事的类中的方法。

一旦发生这种情况,并且它都通过if和good验证了,该方法然后用我们的新方法通过replace替换原始方法。把旧的拿出来,把新的放进去。所有来自包含类的注解都是不变的因为因为我们偷偷地从旁边进来。

现在我们可以直接跳转到我们需要的类,点击那个方法,做我们想做的。然而,我们最终会遇到问题,或者搞砸了构造函数或其他东西。在处理大型项目时,处理代码注入的方式与其他任何事情一样重要。

这个答案可能有点长,但是InvokationHandler一开始可能有点难以掌握。

相关内容

  • 没有找到相关文章

最新更新