JDK、CGLib、Javassist实现动态代理
一、类加载
1.类加载过程模拟（先明白类加载过程，方可模拟类运行期间加载-创建代理类，调用目标方法）
public class Programmer {
public void code() {
System.out.println("I'm a Programmer,Just Coding.....");
}
}/**
* 自定义一个类加载器，用于将字节码转换为class对象
*/
public class MyClassLoader extends ClassLoader {
public Class defineMyClass(byte[] b, int off, int len) {
//TODO SOURCE CODE
return super.defineClass(null,b, off, len);
}
}public class MyTest {
public static void main(String[] args) throws IOException {
//读取本地的class文件内的字节码，转换成字节码数组
File file = new File(".");
InputStream input = new FileInputStream(file.getCanonicalPath() +
"\\target\\classes\\com\\max\\dproxy\\loadseq\\Programmer.class");
byte[] result = new byte[1024];//字节型
int count = input.read(result);
// 使用自定义的类加载器将 byte字节码数组转换为对应的class对象
MyClassLoader loader = new MyClassLoader();
Class clazz = loader.defineMyClass(result, 0, count);
//测试加载是否成功，打印class 对象的名称
System.out.println(clazz.getCanonicalName());
try {
//实例化一个Programmer对象
Object o = clazz.newInstance();
//调用Programmer的code方法
clazz.getMethod("code", null).invoke(o, null);
} catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
2.类加载过程
注：绿色椭圆内即JVM虚拟机状态，具体不做赘述。
二、动态代理
代理模式：
静态代理：手动编写代理类代理目标类方法。缺点：手动创建；代理类越来越多，系统规模增大，不易维护；
动态代理：由于JVM通过字节码的二进制（byte-code）信息加载类的，那么，如果我们在运行期系统中，1.遵循Java编译系统组织.class文件的格式和结构，2.生成相应的二进制数据，3.然后再把这个二进制数据加载转换成对应的类，这样，就完成了在代码中，动态创建一个类的能力了。
JDK实现动态代理
public interface Vehicle {
void drive();
}public interface Rechargable {
void recharge();
}public class ElectricCar implements Rechargable, Vehicle {
@Override
public void drive() {
System.out.println("Electric Car is Moving silently...");
}
@Override
public void recharge() {
System.out.println("Electric Car is Recharging...");
}
}public class InvocationHandlerImpl implements InvocationHandler {
private ElectricCar car;
public InvocationHandlerImpl(ElectricCar car) {
this.car = car;
}
@Override
public Object invoke(Object paramObject, Method paramMethod, Object[] paramArrayOfObject) throws Throwable {
System.out.println("You are going to invoke " + paramMethod.getName() + " ...");
paramMethod.invoke(car, null);
System.out.println(paramMethod.getName() + " invocation Has Been finished...");
return null;
}
}public class Test {
public static void main(String[] args) {
ElectricCar car = new ElectricCar();
// 1.获取对应的ClassLoader
ClassLoader classLoader = car.getClass().getClassLoader();
// 2.获取ElectricCar 所实现的所有接口
Class[] interfaces = car.getClass().getInterfaces();
// 3.设置一个来自代理传过来的方法调用请求处理器，处理所有的代理对象上的方法调用
InvocationHandler handler = new InvocationHandlerImpl(car);
/*
4.根据上面提供的信息，创建代理对象 在这个过程中，
a.JDK会通过根据传入的参数信息动态地在内存中创建和.class文件等同的字节码
b.然后根据相应的字节码转换成对应的class，
c.然后调用newInstance()创建实例
*/
Object o = Proxy.newProxyInstance(classLoader, interfaces, handler);
Vehicle vehicle = (Vehicle) o;
vehicle.drive();
Rechargable rechargeable = (Rechargable) o;
rechargeable.recharge();
}
}
newProxyInstance过程做了3件事：
1.通过传入的类信息（加载器、接口、处理器-增强方法）动态的在内存中创建和.class文件同等的字节码（代理类字节码）
2.将该字节码转换成对应类（生成代理类的步骤）
3.通过newInstance创建类，而后调用1中传入的所有接口方法。
对比类的加载过程，123步骤。
cglib实现动态代理
public class Programmer {
public void code() {
System.out.println("I'm a Programmer,Just Coding.....");
}
}/*
* 实现了方法拦截器接口 Spring AOP实现方式
*/
public class Hacker implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("**** I am a hacker,Let's see what the poor programmer is doing Now...");
proxy.invokeSuper(obj, args);
System.out.println("**** Oh,what a poor programmer.....");
return null;
}
}public class Test {
public static void main(String[] args) {
Programmer progammer = new Programmer();
Hacker hacker = new Hacker();
//cglib 中加强器，用来创建动态代理
Enhancer enhancer = new Enhancer();
//设置要创建动态代理的类
enhancer.setSuperclass(progammer.getClass());
// 设置回调，这里相当于是对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实行intercept()方法进行拦截
enhancer.setCallback(hacker);
Programmer proxy = (Programmer) enhancer.create();
proxy.code();
}
}
javassist实现动态代理
public class Programmer {
public void code() {System.out.println("I'm a Programmer,Just Coding.....");
}
}
public class MyGenerator {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
//创建Programmer类
CtClass cc = pool.makeClass("com.max.dproxy.javassist.Programmer");
//定义code方法
CtMethod method = CtNewMethod.make("public void code(){}", cc);
//插入方法代码 增强
method.insertBefore("System.out.println(\"I'm a Programmer,Just Coding.....\");");
cc.addMethod(method);
//保存生成的字节码
cc.writeFile("d://temp");
}
}以上先简单显示一下javassist的用法。（其实insertBefore就已经是在针对code方法的增强，上述代码补充上cc字节码的load和创建过程【如下下例中的】及完整的显示了javassist创建代理的步骤）。
//获取动态生成的class
Class c = cc.toClass();
//获取构造器
Constructor constructor = c.getConstructor(TicketServiceImpl.class);
//通过构造器实例化
TicketService o = (TicketService) constructor.newInstance(new TicketServiceImpl());
o.sellTicket();以下显示使用javassist实现动态代理的完整步骤
public interface TicketService {
//售票
void sellTicket();
//问询
void inquire();
//退票
void withdraw();
}public class TicketServiceImpl implements TicketService {
@Override
public void sellTicket() {
System.out.println("\n\t售票.....\n");
}
@Override
public void inquire() {
System.out.println("\n\t问询。。。。\n");
}
@Override
public void withdraw() {
System.out.println("\n\t退票......\n");
}
}public class Test {
public static void main(String[] args) throws Exception {
createProxy();
}
/*
* 手动创建字节码
*/
private static void createProxy() throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("com.max.dproxy.staticproxy.StationProxy");
//设置接口
CtClass interface1 = pool.get("com.max.dproxy.staticproxy.TicketService");
cc.setInterfaces(new CtClass[] { interface1 });
//设置Field
CtField field = CtField.make("private com.max.dproxy.staticproxy.TicketServiceImpl station;", cc);
cc.addField(field);
CtClass stationClass = pool.get("com.max.dproxy.staticproxy.TicketServiceImpl");
CtClass[] arrays = new CtClass[] { stationClass };
CtConstructor ctc = CtNewConstructor.make(arrays, null, CtNewConstructor.PASS_NONE, null, null, cc);
//设置构造函数内部信息
ctc.setBody("{this.station=$1;}");
cc.addConstructor(ctc);
//创建5个方法
//创建收取手续方法
CtMethod takeHandlingFee = CtMethod.make("private void takeHandlingFee() {}", cc);
takeHandlingFee.setBody("System.out.println(\"收取手续费，打印发票。。。。。\");");
cc.addMethod(takeHandlingFee);
//创建showAlertInfo方法
CtMethod showInfo = CtMethod.make("private void showAlertInfo(String info) {}", cc);
showInfo.setBody("System.out.println($1);");
cc.addMethod(showInfo);
//创建sellTicket
CtMethod sellTicket = CtMethod.make("public void sellTicket(){}", cc);
//"{this.showAlertInfo 都是在调用这些方法，括号中传入需print的string
//但proxy对象中，sellTicket方法并未执行，而是执行的动态代理中method的流程
sellTicket.setBody("{this.showAlertInfo(\"showAlertInfo********\");" + "station.sellTicket();"
+ "this.takeHandlingFee();" + "this.showAlertInfo(\"××××BYBY！××××\");}");
cc.addMethod(sellTicket);
//创建inquire方法
CtMethod inquire = CtMethod.make("public void inquire() {}", cc);
inquire.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，问询服务不会收取任何费用，本问询信息仅供参考，具体信息以车站真实数据为准！××××\");"
+ "station.inquire();" + "this.showAlertInfo(\"××××欢迎您的光临，再见！××××\");}");
cc.addMethod(inquire);
//创建widthraw方法
CtMethod withdraw = CtMethod.make("public void withdraw() {}", cc);
withdraw.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，退票除了扣除票额的20%外，本代理处额外加收2元手续费！××××\");"
+ "station.withdraw();" + "this.takeHandlingFee();}");
cc.addMethod(withdraw);
//获取动态生成的class
Class c = cc.toClass();
//获取构造器
Constructor constructor = c.getConstructor(TicketServiceImpl.class);
//通过构造器实例化
TicketService o = (TicketService) constructor.newInstance(new TicketServiceImpl());
o.sellTicket();
}
}
这里的Proxy代理类即可删除，动态生成代理，取代以下的代理类创建。
public class StationProxy implements TicketService {
private TicketServiceImpl station;
public StationProxy(TicketServiceImpl station) {
this.station = station;
}
@Override
public void sellTicket() {
// 1.做真正业务前，提示信息
this.showAlertInfo("××××showAlertInfo before sellTicket××××");
// 2.调用真实业务逻辑
station.sellTicket();
// 3.后处理
this.takeHandlingFee();
this.showAlertInfo("××××sellTicket over××××\n");
}
@Override
public void inquire() {
// 1做真正业务前，提示信息
this.showAlertInfo("××××showAlertInfo before inquire××××");
// 2.调用真实逻辑
station.inquire();
// 3。后处理
this.showAlertInfo("××××inquire over××××\n");
}
@Override
public void withdraw() {
// 1。真正业务前处理
this.showAlertInfo("××××howAlertInfo before withdraw××××");
// 2.调用真正业务逻辑
station.withdraw();
// 3.后处理
this.takeHandlingFee();
}
// TODO 除了实现public接口，代理类新增private方法，在test中仍添加进method中
/*
* 展示额外信息
*/
private void showAlertInfo(String info) {
System.out.println(info);
}
/*
* 收取手续费
*/
private void takeHandlingFee() {
System.out.println("takeHandlingFee......\n");
}
}三、总结
1.类的加载：
.java编译形成.class bytecode；而后将byte code通过类加载期load到运行期中进行解释、编译、运行
2.动态代理
实现原理：在运行期模拟类的加载过程，将增强类生成字节码，加载转成类（代理类）
jdk：基于接口？从何说起？因为在newPorxy创建代理类时，传入被代理类的所有接口。
InvocationHandler作用？
1）自定义的方法处理器，在invoke方法中加入被代理类的增强逻辑。
2）通过InvocationHandler统一管理器，在调用接口方法（drive、recharge时）进行拦截，统一调用invoke方法，根据invoke中传入的method参数，确定调用被代理类的具体方法。
缺点：被代理类与代理类都继承自同一接口，无法实现随机自由组合增强。
cglib：两个无关类，增强类只需实现MethodInterceptor，通过enhancer的setCallback，调用intercept增强方法。intercept写法与jdk类似。
javassist：采用类的包名加载类，编译形成字节码，设置接口、字段信息，添加构造方法、接口方法，最后使用构造器实例化类，调用接口方法。