我目前正在尝试代理一些现有的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一开始可能有点难以掌握。