共计 5398 个字符，预计需要花费 14 分钟才能阅读完成。
看完上一个章节，相信你已经掌握了一些编写并发代码编写的要领了。今天我们来聊一个新的话题。
猿思考是一个原创系列文章，帮助你从一个小白快速掌握基础知识，很多基础知识，在于思考的变通，更多精彩内容，敬请大家关注公主号 猿人工厂 ，点击 猿人养成获取！
开动你的小脑筋，你怎样才能代替我去卖面膜？先看下面的代码, 卖面膜是一种行为，定义成一个接口，MaiMianMo, 还有一个实现类 MaiMianMoImpl，具体怎么卖面膜由 MaiMianMoImpl 去做。
package com.pz.se.demo;
public interface MaiMianMo {public Object maiMianMo(Object obj);
}
packagecom.pz.se.demo;
public class MaiMianMoImpl implements MaiMianMo {
@Override
public Object maiMianMo(Object obj) {System.out.println("我正在售卖 面米："+obj);
return obj;
}
}嗯，你的意思是代替你去卖面膜，这还不简单，编写一个类实现 MaiMianMo 接口，代替你嘛，我就是你的代理，我直接在新的类中使用 MaiMianMoImpl 的方法就好了，名字嘛就叫 MaiMianMoProxy 好了，talk is cheap show me your code…
package com.pz.se.demo;
public class MaiMianMoProxyimplements MaiMianMo {private MaiMianMo maiMianMoImpl = new MaiMianMoImpl();
@Override
public Object maiMianMo(Object obj) {System.out.println("我是微商，我卖面膜");
return maiMianMoImpl.maiMianMo(obj);
}
public static void main(String args[]){MaiMianMo maiMianMo = newMaiMianMoProxy();
maiMianMo.maiMianMo(new Object());
}
}
所谓动态代理，是指利用 Java 的反射技术 (JavaReflection) 生成字节码，在运行时创建一个新的类给指定接口或接口引用，从而实现代理了或接口的职责。
JDK 提供了动态代理，都在 Java.lang.reflect 包下，一个接口 InvocationHandler，一个类 Proxy。
InvocationHandler：该接口中仅定义了一个方法 Object：invoke(Object obj,Method method,Object[] args）。在实际使用时，第一个参数 obj 一般是指代理类，method 是被代理的方法，args 为该方法的参数数组。这个抽象方法在代理类中动态实现。
Proxy 类就是动态代理类，用于在程序运行时，生产生产代理对象。我们可以看下使用 JDK 的动态代理，来帮助我们成为微商，售卖面膜。
第一步，实现 InvocationHandler 接口。
package com.pz.se.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MaiMianMoInvocationHandler implements InvocationHandler {
private MaiMianMo maiMianMo;
publicMaiMianMoInvocationHandler(MaiMianMo maiMianMo) {this.maiMianMo = maiMianMo;}
@Override
public Object invoke(Object proxy, Methodmethod, Object[] args) throws Throwable {
// 微商嘛自然喜欢干点别的事情
// 做还是不做都在于你
Object invoke =method.invoke(maiMianMo, args);
System.out.println("我是微商我想干嘛干嘛的");
System.out.println("我甚至不调用你能拿我怎样？");
System.out.println("到了我手里我想干嘛就干嘛的");
return invoke;
}
}第二步，使用 Proxy 类生产代理对象，然后调用就好。
package com.pz.se.demo;
importjava.lang.reflect.Proxy;
public classTestProxyMaiMianMo {public static void main(String args[]){MaiMianMoInvocationHandler handler =new MaiMianMoInvocationHandler(new MaiMianMoImpl());
MaiMianMo maiMianMo= (MaiMianMo)Proxy.newProxyInstance(MaiMianMo.class.getClassLoader(),newClass[]{MaiMianMo.class},handler);
maiMianMo.maiMianMo(new Object());
}
}
根据 JDK 提供的动态代理，看起来只是针对接口来说的，我们可以想想一下，代理到底是什么？无非是代替某个类的功能而已，一个类有属性和方法，那么编写一个类继承要实现的类不就好了? 结合反射来看，可以拿到太多的信息了，无非输出一个源程序文件，然后吧，假如编译了呢？然后吧，编译，然后加载然后创建了对象了呢？下面就是个例子稍微改改，妙用无穷噢。
public class ProxyUtil {public static Object proxyClass(Class clazz){String packageNam=clazz.getPackage().getName();
return null;
}
private static StringappendPackageStr(Class clazz){return "package"+clazz.getPackage().getName()+";\n";}
private static StringappendClassBodyBegin(Class clazz){return "public class"+clazz.getSimpleName()+"Proxy extends" +clazz.getName()+"{\n";}
private static String getFileName(Class clazz){returnclazz.getSimpleName()+"Proxy.java";
}
private static String appendClassBodyEnd(){return "}\n";
}
private static String appendImports(Classclazz) {StringBuilder builder = newStringBuilder();
for(Method method:clazz.getDeclaredMethods()){Class<?>[] parameterTypes=method.getParameterTypes();
for(Class param:parameterTypes){builder.append("import"+param.getName()+";\n");
}
}
return builder.toString();}
private static String appendMethod(Methodmethod,String codes) {StringBuilder builder = newStringBuilder();
builder.append("public");
builder.append(method.getReturnType().getName() +" ");
builder.append(method.getName()+"");
builder.append("(");
Class<?>[] parameterTypes=method.getParameterTypes();
for(int i =0;i<parameterTypes.length;i++){if(i==parameterTypes.length-1){builder.append(parameterTypes[i].getName() +" "+parameterTypes[i].getSimpleName());
builder.append(")");
}
}
builder.append("{\n");
builder.append(codes);
builder.append("}\n");
return builder.toString();}
public static ObjectcomplierAndReturnProxyObject(Class clazz, String content) throws IOException {StringfileName=System.getProperty("user.dir")+"/target/classes"+"/"+clazz.getPackage().getName().replace(".","/")+"/"+getFileName(clazz);
File file = new File(fileName);
if(!file.exists()){file.createNewFile();
}
FileOutputStream fos = newFileOutputStream(fileName);
fos.write(content.getBytes());
fos.close();
try {
// 动态编译
JavaCompiler javac =ToolProvider.getSystemJavaCompiler();
int status = javac.run(null, null,null, "-d",System.getProperty("user.dir")+"/target/classes",fileName);
if(status!=0){System.out.println("没有编译成功！");
}
return Class.forName(clazz.getName()+"Proxy").newInstance();} catch (Exception e) {e.printStackTrace();
}
return null;
}
public static void main(String args[])throws IOException {StringBuilder builder = newStringBuilder();
builder.append(appendPackageStr(MaiMianMoImpl.class));
builder.append(appendImports(MaiMianMoImpl.class));
builder.append(appendClassBodyBegin(MaiMianMoImpl.class));
Method[] methods=MaiMianMoImpl.class.getDeclaredMethods();
for(Method method: methods){builder.append(appendMethod(method,"return null;\n"));
}
builder.append(appendClassBodyEnd());
String codes =builder.toString();
System.out.println(codes);
MaiMianMo maiMianMo = (MaiMianMo)complierAndReturnProxyObject(MaiMianMoImpl.class,codes);
maiMianMo.maiMianMo(new Object());
}
}
以上的方式都是运行时期来生产代理类的。当然除了 jdk 的代理之外，还有很多工具也可以做到这一点。比如经常提到的开源项目 cglib,ASM,Javassist, 这些框架能够更容易的做到，在运行时期，扩展一个类，总比咱自己 JDK 硬写编译要强吧？
那还有没有是什么时候可以做手脚去扩展一个代理类出来呢？我们之前学过 java 代码的执行套路，一个代码需要执行，是需要编译的吧？我们也可以在编译时期做一些手脚嘛，反正原理无非就是，读取一个类的内容，然后加入自己想加入的内容就好了。Java 也有一些开源项目，比如 AspectJ 可以轻松的做到这一点。
介于篇幅，以上的开源项目的使用，我就暂时不做展示了。后续的内容，我会给出例子的。
不过最重要的一点需要记住，代理后，做任何事情都可以，被代理的方法只关心返回值，要不你可能学 AOP 只能停留在打日志的阶段了噢。