java javassist使用实例

package foo;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtField.Initializer;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.util.proxy.MethodFilter;
import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyFactory;

public class JavassistLearn {

	public static void main(String[] args) throws Exception {

		/*testaop();

		if(true)
		{
			return ;
		}*/
		
		ClassPool cp = ClassPool.getDefault();

		CtClass ctClass = cp.makeClass("foo.Student");

		StringBuffer body = null;
		// 参数 1：属性类型 2：属性名称 3：所属类CtClass
		CtField ctField = new CtField(cp.get("java.lang.String"), "name",
				ctClass);
		ctField.setModifiers(Modifier.PRIVATE);
		// 设置name属性的get set方法
		ctClass.addMethod(CtNewMethod.setter("setName", ctField));
		ctClass.addMethod(CtNewMethod.getter("getName", ctField));
		ctClass.addField(ctField, Initializer.constant("default"));

		// 参数 1：参数类型 2：所属类CtClass
		CtConstructor ctConstructor = new CtConstructor(new CtClass[] {},
				ctClass);
		body = new StringBuffer();
		body.append("{\n name=\"me123\";\n}");
		ctConstructor.setBody(body.toString());
		ctClass.addConstructor(ctConstructor);

		// 参数： 1：返回类型 2：方法名称 3：传入参数类型 4：所属类CtClass
		CtMethod ctMethod = new CtMethod(CtClass.voidType, "execute",
				new CtClass[] {}, ctClass);
		ctMethod.setModifiers(Modifier.PUBLIC);
		body = new StringBuffer();
		body.append("{\n System.out.println(name);");
		body.append("\n System.out.println(\"execute ok\");");
		body.append("\n return ;");
		body.append("\n}");
		ctMethod.setBody(body.toString());
		ctClass.addMethod(ctMethod);
		Class<?> c = ctClass.toClass();
		Object o = c.newInstance();
		Method method = o.getClass().getMethod("execute", new Class[] {});
		// 调用字节码生成类的execute方法
		method.invoke(o, new Object[] {});
	}

	private static void testaop() throws Exception {
		ProxyFactory factory = new ProxyFactory();
		// 设置父类，ProxyFactory将会动态生成一个类，继承该父类
		factory.setSuperclass(Student.class);
		// 设置过滤器，判断哪些方法调用需要被拦截
		factory.setFilter(new MethodFilter() {
			@Override
			public boolean isHandled(Method m) {
				if (m.getName().equals("getName")) {
					
					return true;
				}
				return false;
			}
		});
		// 设置拦截处理
		factory.setHandler(new MethodHandler() {
			@Override
			public Object invoke(Object self, Method thisMethod,
					Method proceed, Object[] args) throws Throwable {
				// 拦截后前置处理，改写name属性的内容
				// 实际情况可根据需求修改
				Student o = (Student) self;
				o.setName("haha测试");
				return proceed.invoke(self, args);
			}
		});

		Class<?> c = factory.createClass();
		Student object = (Student) c.newInstance();
		System.out.println(object.getName());

	}

}

package foo;

public class Student {
	
	private String name = "default";

	public Student() {
		name = "me";
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void execute() {
		System.out.println(name);
		System.out.println("execute ok");
	}
}

package foo;


import java.lang.reflect.Method;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtField.Initializer;
import javassist.CtNewMethod;
import javassist.Modifier;

//http://blog.csdn.net/sadfishsc/article/details/9999169
public class JavassistGenerator {

	public static void main(String[] args) throws Exception {
		
		ClassPool pool = ClassPool.getDefault();
		//创建类
		CtClass cls = pool.makeClass("cn.ibm.com.TestClass");

		// 添加私有成员name及其getter、setter方法
		CtField param = new CtField(pool.get("java.lang.String"), "name", cls);
		
		param.setModifiers(Modifier.PRIVATE);
		
		cls.addMethod(CtNewMethod.setter("setName", param));
		cls.addMethod(CtNewMethod.getter("getName", param));
		
		cls.addField(param, Initializer.constant(""));

		// 添加无参的构造体
		CtConstructor cons = new CtConstructor(new CtClass[] {}, cls);
		cons.setBody("{name = \"Brant\";}");
		cls.addConstructor(cons);

		// 添加有参的构造体
		cons = new CtConstructor(
				new CtClass[] { pool.get("java.lang.String") }, cls);
		cons.setBody("{$0.name = $1;}");
		cls.addConstructor(cons);

		// 打印创建类的类名
		System.out.println(cls.toClass());

		// 通过反射创建无参的实例，并调用getName方法
		Object o = Class.forName("cn.ibm.com.TestClass").newInstance();
		Method getter = o.getClass().getMethod("getName");
		System.out.println(getter.invoke(o));

		// 调用其setName方法
		Method setter = o.getClass().getMethod("setName",
				new Class[] { String.class });
		setter.invoke(o, "Adam");
		System.out.println(getter.invoke(o));

		// 通过反射创建有参的实例，并调用getName方法
		o = Class.forName("cn.ibm.com.TestClass").getConstructor(String.class).newInstance("Liu wjh");
		
		getter = o.getClass().getMethod("getName");
		System.out.println(getter.invoke(o));
	}

}