javaassist动态修改注解的值 javassist动态修改方法

  网上有网友已经实现了该功能，我只是把我的理解说出来，希望对大家有帮助！     

  主要思路：创建一个拦截器接口，里面有有一个invoke方法,再创建一个能够生成代理的类，该类的主要作用是生成了一个新类，该新类实现了被代理类接口的每个方法(生成新类的实例时是用javassist)。这个新类里每个方法都通过反射去调用拦截器中的invoke方法，（而invoke方法中我们会去调用被代理类的方法），所以我们说在代理类里如果调用了某个方法，它会自动去调用被代理类的方法。不同的是我们可以在invoke方法中调用其它的服务。 比如说我有一个UserManager的接口

  该接口代理：

    

public interface UserManager {
 
 public void addUser(String name,String password);
 
 public void deleteUser(String userID);
 
 public void modifyUser(String userID);
 
 public String findByID(String userID);
}
有一个实现了UserManager的接口类
 public class UserManagerImpl implements UserManager { 
 public void addUser(String name, String password) { System.out.println("--------------------adduser----------------------"); } public void deleteUser(String userID) { System.out.println("--------------------deleteUser----------------------"); } 
 public String findByID(String userID) { System.out.println("--------------------findByID----------------------"); return userID; } public void modifyUser(String userID) { System.out.println("--------------------modifyUser----------------------"); }
 } 
    那么我们新生成的类，也就是代理类生成的代码要是这样的
 public Class userManagerImpl {
 
public void addUser(java.lang.String a0 ,java.lang.String a1){
MyInvocationHandler handle = new SecurityHandler();
Object returnObje = handle.invoke(Class.forName("UserManagerImpl").newInstance(),Class.forName("UserManagerImpl").getMethods()[0],new Object[]{($w)a0,($w)a1});
}
public java.lang.String findByID(java.lang.String a0){
MyInvocationHandler handle = new SecurityHandler();
Object returnObje = handle.invoke(Class.forName("UserManagerImpl").newInstance(),Class.forName("UserManagerImpl").getMethods()[1],new Object[]{($w)a0});
return (java.lang.String)returnObje;
}
public void deleteUser(java.lang.String a0){
MyInvocationHandler handle = new SecurityHandler();
Object returnObje = handle.invoke(Class.forName("UserManagerImpl").newInstance(),Class.forName("UserManagerImpl").getMethods()[2],new Object[]{($w)a0});
}
public void modifyUser(java.lang.String a0){
MyInvocationHandler handle = new SecurityHandler();
Object returnObje = handle.invoke(Class.forName("UserManagerImpl").newInstance(),Class.forName("UserManagerImpl").getMethods()[3],new Object[]{($w)a0});
}
 
}
 
 返回该类的实例，也就是代理类的实例，它其实就是实现了UserManager接口的类，在调用它相应的方法，就会去调用实现了个人拦截器中的invoke方法。也就是达到代理的目的。
 
      小例子：
 
         第一步：创建一个MyInvocationHandler类，拦截器接口类
     import java.lang.reflect.Method;
/**
 * 构建拦截器接口
 *
 */
public interface MyInvocationHandler {
 
 public Object invoke(Object Proxy,Method method,Object args[]);
 
 
}
 
 
               第二步：创建一个MyProxy类，代理类，生成目标类的代理。
              public class MyProxy {
 
 // 生成代理类的后缀名
 public final static String PROXY_SUFFIX_NAME = "$proxy";
 
 // 防止生成的代理类重名
 public static int proxyIndex = 1;
 
 public Object newInstance(Object target,MyInvocationHandler invocationHandler) throws SecurityException, NotFoundException, InstantiationException, IllegalAccessException, CannotCompileException, ClassNotFoundException{
 // targetInte 被代理类接口的名字
 String targetInte = target.getClass().getInterfaces()[0].getName();
 // invocationInte 拦截器接口的名字
 String invocationInte = invocationHandler.getClass().getInterfaces()[0].getName();
 // nvocationImpl 拦截器实现类的名字
 String invocationImpl = invocationHandler.getClass().getName();
 // 被代理类的名字
 String targetImpl = target.getClass().getName();
 
 return generProxy(targetInte,invocationInte,invocationImpl,targetImpl);
 }
 /**
 * @param targetInte
 *            被代理类接口的名字
 * @param invocationInte
 *            拦截器接口的名字
 * @param invocationImpl
 *            拦截器实现类的名字
 * @param targetImpl
 *            被代理类的名字
 * @return Object 返回代理类
 * 
 * 
 * @throws NotFoundException
 * @throws CannotCompileException
 * @throws IllegalAccessException
 * @throws InstantiationException
 * @throws ClassNotFoundException
 * @throws SecurityException
 * 
 */
 
 public static Object generProxy(String targetInte,String invocationInte,String invocationImpl,String targetImpl) throws NotFoundException, InstantiationException, IllegalAccessException, CannotCompileException, SecurityException, ClassNotFoundException {
 ClassPool cp = ClassPool.getDefault();
 // 根据接口名得到该接口的一个instance
 CtClass proxyInte = cp.getCtClass("UserManager");
 // 代理的名字
 String proxyName = targetInte + PROXY_SUFFIX_NAME + proxyIndex++;
 // 生成一个类的instance
 CtClass proxy = cp.makeClass(proxyName);
 proxy.addInterface(proxyInte);
 // 循环遍历接口中的方法，并把每个生成的每个方法加入到代理类中
 Method methods[] = Class.forName(targetInte).getMethods();
 for(int i=0;i<methods.length;i++) {
 generMethod(proxy,methods[i],invocationInte,invocationImpl,targetImpl,i);
 }
 return (Object)proxy.toClass().newInstance();
 }
 /**
 * 在动态生成的类里添加方法
 * 
 * @param proxy
 *            动态类的代理
 * @param method
 *            接口中要修改的方法
 * @param InvocationInte
 *            拦截器的接口名字
 * @param InvocationImpl
 *            拦截器的实现类的名字
 * @param targetImpl
 *            被代理类的方法名
 * @param index
 *            接口中的第几个方法
 * @return
 * @throws CannotCompileException
 */
 public static void generMethod(CtClass proxy,Method method,String invocationInte,String invocationImpl,String targetImpl,int index) throws CannotCompileException{
 String methodBody = generMethodBody(method,invocationInte,invocationImpl,targetImpl,index);
 CtMethod newMethod = CtNewMethod.make(methodBody,proxy);
 proxy.addMethod(newMethod);
 }
 
 /*
 * 构建方法体 @param method 接口中要重写的方法 @param InvocationInte 拦截器的接口名字 @param
 * InvocationImpl 拦截器的实现的名字 @param targetImpl 被代理类的方法名 @param index
 * 接口中的第几个方法 @return String 生成的方法
 */
 public static String generMethodBody(Method method,String invocationInte,String invocationImpl,String targetImpl,int index){
 StringBuffer methodCode = new StringBuffer();
 // 方法的访问类型，因为是接口中的方法，所以一律是public
 String visit = new String("public");
 methodCode.append(visit);
 
 // 得到该方法的返回值类型
 String returnType = method.getReturnType().getName();
 methodCode.append(" "+returnType);
 
 // 得到该方法的名字
 String methodName = method.getName();
 methodCode.append(" "+methodName + "(");
 
 // 得到该方法的参数类型和
 Class parameterType[] = method.getParameterTypes();
 for(int i=0; i<parameterType.length; i++) {
 if(i == parameterType.length - 1) {
 methodCode.append(parameterType[i].getName()+" a"+i);
 }else {
 methodCode.append(parameterType[i].getName()+" a"+i+" ,");
 }
 }
 methodCode.append(")");
 // 得到该方法的异常
 Class ExceptionType[] = method.getExceptionTypes();
 if(ExceptionType.length > 0) {
 methodCode.append("throws");
 for(int i=0;i<ExceptionType.length;i++) {
 if(i == ExceptionType.length - 1) {
 methodCode.append(" "+ExceptionType[i]);
 }else {
 methodCode.append(" "+ExceptionType[i]+",");
 }
 }
 }
 // 构建方法体
 methodCode.append("{/n");
 methodCode.append(invocationInte+" handle = new "+ invocationImpl + "();/n");
 methodCode.append("Object returnObje = handle.invoke(Class.forName(/""+targetImpl+"/""+").newInstance(),Class.forName(/""+targetImpl+"/").getMethods()["+index+"],");
 // 构建参数的Object[]
 if(parameterType.length>0) {
 methodCode.append("new Object[]{");
 for(int i=0;i<parameterType.length;i++) {
 if(i == parameterType.length - 1) methodCode.append("($w)a" + i );   
            else methodCode.append("($w)a" + i + ",");
 }
 }
 if(parameterType.length>0) methodCode.append("});/n");
 else methodCode.append("null});/n");
 // 处理返回值
 if(method.getReturnType().isPrimitive()) {   
            if(method.getReturnType().equals(Boolean.TYPE)) methodCode.append("return ((Boolean)returnObj).booleanValue();/n");   
            else if(method.getReturnType().equals(Integer.TYPE)) methodCode.append("return ((Integer)returnObj).intValue();/n");   
            else if(method.getReturnType().equals(Long.TYPE)) methodCode.append("return ((Long)returnObj).longValue();/n");   
            else if(method.getReturnType().equals(Float.TYPE)) methodCode.append("return ((Float)returnObj).floatValue();/n");   
            else if(method.getReturnType().equals(Double.TYPE)) methodCode.append("return ((Double)returnObj).doubleValue();/n");   
            else if(method.getReturnType().equals(Character.TYPE)) methodCode.append("return ((Character)returnObj).charValue();/n");   
            else if(method.getReturnType().equals(Byte.TYPE)) methodCode.append("return ((Byte)returnObj).byteValue();/n");   
            else if(method.getReturnType().equals(Short.TYPE)) methodCode.append("return ((Short)returnObj).shortValue();/n");   
        } else {   
         methodCode.append("return (" + returnType + ")returnObje;/n");   
        }
 methodCode.append("}");
 System.out.println(methodCode);
 return methodCode.toString();
 }
}
 
第三步：创建一个实现了MyInvocationHandler的拦截器
   import java.lang.reflect.Method;
 
public class SecurityHandler implements MyInvocationHandler {
 
 public Object invoke(Object Proxy, Method method, Object[] args) {
 //System.out.println(method.getName()+" Start-----------------------");
 
 Object ret = null;
 try{
check();
//在目标方法调用之前做什么
 ret = method.invoke(Proxy, args);
//在目标方法调用之后又做什么
check();
 }catch(Exception e) {
 throw new java.lang.RuntimeException(e);
 }
 //System.out.println(method.getName()+" end-----------------------")
return ret;
 }
 
 public void check() {
 System.out.println("------------check---------------------");
 }
}
 
第四步，创建一个接口UserManager接口，上面已有代码
 
第五步，创建一个实现了UserManager接口的类，UserManagerImpl
 
第六步，写一个测试类  Client
 
 
import java.lang.reflect.Method;
 
 
public class Client {
 
 public static void main(String args[]) throws Exception{
 MyProxy proxy = new MyProxy();
 //测试生成的方法
// Class log = Class.forName("LoggerOperation");
// System.out.println(handler.generMethodBody(log.getMethod("add", new Class[]{int.class}),"InvocationInte","InvocationImpl","targetImpl",1));
 SecurityHandler handler = new SecurityHandler();
 UserManager userManager = (UserManager)proxy.newInstance(new UserManagerImpl(), handler) ;
 
 userManager.addUser("zhangsan", "123456");
 System.out.println(userManager.findByID("123"));
 }
}
 
 
运行结果：
 
------------check---------------------
--------------------adduser----------------------
------------check---------------------
------------check---------------------
--------------------findByID----------------------
------------check---------------------
123
 
 
不足之处：1、如果一个类实现了多个接口，则只能实现第一个接口中的方法
               2、如果我的一个实现了MyinvocationHandler类是这样的，那么调用时，有错
 
 
import java.lang.reflect.Method;
 
import javassist.CannotCompileException;
import javassist.NotFoundException;
 
public class SecurityHandler implements MyInvocationHandler {
 
 private Object target;
 private Object operator;
 
 /*
 * @param interfaceClassName String 要动态代理的接口类名, e.g test.StudentInfoService
 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g
 * test.StudentInfoServiceImpl @param interceptorHandlerImplClassName String
 * 用户提供的拦截器接口的实现类的类名 @return Object 返回某个接口的动态代理对象 @throws
 * InstantiationException @throws IllegalAccessException @throws
 * NotFoundException @throws CannotCompileException @throws
 * ClassNotFoundException
 */
 public Object newProxy(Object target, Object operator, MyInvocationHandler invocationHandler) throws Exception {
 this.target = target;
 this.operator = operator;
 return new MyProxy().newInstance(operator,this);
 }
 
 public Object invoke(Object obj, Method method, Object[] args)
 throws Throwable {
 Object ret = null;
 try {
 //方法执行前，用反射调用before方法
Method before = this.operator.getClass().getDeclaredMethod("insertBefore", new Class[]{Method.class});
before.invoke(this.operator, method);
 //方法执行时
 if(method.getName().equals("addUser")){
 securityHandler();
 }
 
 ret = method.invoke(obj, args);
 //方法执行后
Method after = this.operator.getClass().getDeclaredMethod("insertAfter", new Class[]{Method.class});
after.invoke(this.operator, method);
 }catch(Exception e) {
 e.printStackTrace();
 throw new java.lang.RuntimeException(e);
 }
 return ret;
 }
 
 public void securityHandler(){
 System.out.println("---------------securityHandler()-----------------------");
 }
}

不懂之处：为什么方法中的参数前要加个$w呢？