最近看到很多人在分享动态代理的实现，想到上次在公司分享过一次字节码增强方面的技术，这里随便写写，做个总结。
什么叫做字节码增强技术？
个人理解，是在Java字节码生成之后，运行期对其进行修改，增强其功能，这种方式相当于对应用程序的二进制文件进行修改。Java字节码增强主要是为了减少冗余代码，提高性能等。
何为运行期？
有哪些与字节码相关的技术?
- 动态代理 java自身使用的动态代理
- CGLIB
- javassist
- asm
接下来，具体看看为什么说这些都与字节码增强有关。
动态代理
- 实质是动态生成字节码与反射机制结合。
- 运行期根据不同的入参生成不同的字节码文件，继承于Proxy对象，实现传入对象的实现接口。
举个例子：
public class LogProxy implements InvocationHandler{
private Object object;
public Object getProxyObject(Object o){
object=o;
try{
return Proxy.newProxyInstance(this.getClass().getClassLoader(),o.getClass().getInterfaces(),this);
}catch (IllegalArgumentException e){
throw new RuntimeException(e);
}
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before invoke ...");
Object result= method.invoke(object,args);
System.out.println("after invoke ...");
return result;
}
}
这是一个简单的例子，实现了invocationHandler接口,该代理类只做了一件事情，凡是被该类代理的对象，在调用之和之后都会输出两行日志在console，其他什么都没做。
public interface HelloWorldInteface {
public void sayHello();
}
public class HelloWorldImpl implements HelloWorldInteface{
public void sayHello() {
System.out.println("hello world");
}
}
定义接口和实现类，并对该类做代理，执行sayHello方法
public class Main {
public static void main(String[] args) {
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
HelloWorldInteface helloWorldInteface = (HelloWorldInteface) logProxy.getProxyObject(new HelloWorldImpl());
helloWorldInteface.sayHello();
dateUtils.getCurrentDate();
}
}
我们能看到日志如下：
before invoke ...
hello world
after invoke ...
为什么会出现两行日志，到底程序在执行的过程中做了些什么？
其实在调用过程中，真正执行的对象不是HelloWorldImpl，而是生成了一个proxy对象，这个helloWorldInteface对象实质是通过字节码增强技术产生的一个proxy对象，具体如下：
public final class $Proxy1 extends Proxy implements HelloWorldInteface {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy1(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void sayHello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.github.jettyrun.monitor.client.jdkproxy.HelloWorldInteface").getMethod("sayHello", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
我们能看到，生成的这个proxy对象，实质是实现了HelloWorldInteface接口，在调用sayHello()方法时，实质是调用了invocationHandler.invoke方法。
public final void sayHello() throws {
try {
//proxy的h方法。
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public class Proxy implements java.io.Serializable {
protected InvocationHandler h;
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h){
return cons.newInstance(new Object[]{h});
}
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
}
能看到，实质调用的是父类InvocationHandler的invoker方法，invocationHandler是什么时候初始化的?不由的想到了我们自己定义的LogProxy，logProxy对象本身就是invocationHandler的实现类，且在获取代理对象的时候，初始化了proxy对象并返回了。
Proxy.newProxyInstance(this.getClass().getClassLoader(),o.getClass().getInterfaces(),this);
真正调用的InvocationHandler的invoker就是调用了我们自己定义的invoke方法。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before invoke ...");
Object result= method.invoke(object,args);
System.out.println("after invoke ...");
return result;
}
总结：
java动态代理，实质是通过运行期生成字节码文件的方式，基于实现被代理对象的接口实现代理的功能，所以如果要对非实现接口的类做代理，实质是做不到的。如果要做到，则需要看下面的博客了。
