高仿JDK动态代理 底层源码实现
动态代理实现思路
实现功能：通过Proxy.newProxyInstance返回代理对象
1、创建一个处理业务逻辑的接口，我们也和JDK一样，都使用InvocationHandler作为接口名，然后接口里面一个invoke方法，jdk呢是有三个参数，我们简化了一下就只要两个参数即可。
2、声明一段java代码字符串（动态产生代理类）
3、使用IO创建代理类的java文件，将java代码字符串写入java文件
4、编译代理类，通过URLClassLoader把代理类加载到内存中
5、使用Constructor（构造器）来创建代理类的实例
6、return 代理类
一、创建一个处理业务逻辑的接口（InvocationHandler）
package com.handler;
import java.lang.reflect.Method;
public interface InvocationHandler {
public Object invoke(Method method,Object args[]);
}
二、创建一个Proxy里面只有一个静态方法newProxyInstance
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import com.handler.InvocationHandler;
public class Proxy {
/**
* 动态生成一个动态代理类
* @param interfaceClass 实现的接口
* @param handler 处理的业务逻辑
* @return
*/
public static Object newProxyInstance(Class interfaceClass,InvocationHandler handler){
String interfaceName=interfaceClass.getName();
String interfaceSimpleName=interfaceClass.getSimpleName();
String enter="\n";
String tab="\t";
//生成代码字符串1
String proxyStr1="import "+interfaceName+";\n"
+ "import com.handler.InvocationHandler;\n"
+ "import java.lang.reflect.Method;"+
enter+"public class Proxy$ implements "+interfaceSimpleName+"{"+
enter+tab+"InvocationHandler handler;"+
enter+tab+"public Proxy$("+handler.getClass().getName()+" handler){"+
enter+tab+tab+"this.handler=handler;"+
enter+tab+"}";
//生成代码字符串2
String proxyStr2="";
//获得所接口的所有方法
Method me[]=interfaceClass.getMethods();
for (Method method : me) {
String paramStr=""; //形参字符串
String paramName=""; //参数名字字符串
String paramClass="";//参数类型字符串
int i=1;
//得到方法所有参数
Class paramTypeClass[]=method.getParameterTypes();
for (Class class1 : paramTypeClass) { //遍历所有的参数
paramStr+=class1.getSimpleName()+" args"+i+","; //动态得到形参
paramName+="args"+i+","; //动态创建各个参数名字
paramClass+=class1.getSimpleName()+".class,"; //动态创建获得“参数类型”的“类对象”字符串
i++;
}
//判断该方法是否有参数，有参数的话 length一定会大于0的
if(paramStr.length()>0){
//截取掉最后一个","
paramStr=paramStr.substring(0,paramStr.length()-1);
paramName=paramName.substring(0,paramName.length()-1);
paramClass=","+paramClass.substring(0,paramClass.length()-1);
}
//得到返回值类型
String returnType=method.getReturnType().getSimpleName();
proxyStr2+=enter+tab+"public "+returnType+" "+method.getName()+"("+paramStr+") {"+
enter+tab+tab+"try{";
//判断是否有返回值
if(returnType.equals("void")){
//生成获得Method的字符串
proxyStr2+=enter+tab+tab+"Method md ="+interfaceSimpleName+".class.getMethod(\""+method.getName()+"\""+paramClass+");";
//调用传入handler的invoke方法，实现代理功能
proxyStr2+=enter+tab+tab+"handler.invoke(md,new Object[]{"+paramName+"});";
proxyStr2+=enter+tab+tab+"} catch (Exception e) {"+
enter+tab+tab+"e.printStackTrace();"+
enter+tab+tab+"}";
proxyStr2+=enter+tab+"}";
}else{
proxyStr2+=enter+tab+tab+"Method md ="+interfaceSimpleName+".class.getMethod(\""+method.getName()+"\""+paramClass+");";
proxyStr2+=enter+tab+tab+"return ("+returnType+") handler.invoke(md,new Object[]{"+paramName+"});";
proxyStr2+=enter+tab+tab+"} catch (Exception e) {"+
enter+tab+tab+"e.printStackTrace();"+
enter+tab+tab+"}";
//判断返回类型是否为基本数据类型
if( returnType.equals("int")||
returnType.equals("short")||
returnType.equals("long")||
returnType.equals("char")||
returnType.equals("float")||
returnType.equals("double")||
returnType.equals("byte")){
proxyStr2+=enter+tab+tab+"return 0;";
}else if(returnType.equals("boolean")){
proxyStr2+=enter+tab+tab+"return false;";
}else{
proxyStr2+=enter+tab+tab+"return null;";
}
proxyStr2+=enter+tab+"}";
}
}
proxyStr2+=enter+tab+"}";
//创建proxy$.java文件到项目外的一个目录下
File file=new File("C:\\Users\\Administrator\\AppData\\Local\\Temp\\Proxy$.java");
try {
file.createNewFile();
FileWriter fw=new FileWriter(file);
fw.write(proxyStr1+proxyStr2);//把生成的代码字符串写入到创建的java文件中
fw.flush();
//使用javaCompiler(java编译器)编译刚才创建的java类
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
//文件管理者
StandardJavaFileManager fileMange = compiler.getStandardFileManager(null, null, null);
//获取文件
Iterable it=fileMange.getJavaFileObjects(file.getPath());
//编译任务
CompilationTask t = compiler.getTask(null, fileMange, null, null, null, it);
//进行编译
t.call();
//使用URL得到该java类所在的路径，并放入URL数组中
URL url = new URL("file:/C:\\Users\\Administrator\\AppData\\Local\\Temp\\");
URL[] urls = new URL[]{url};
//通过URLClassLoader（URL类加载器）加载urls里面的类到内存中
URLClassLoader urlClassLoader = new URLClassLoader(urls);
//通过类全名得到类加载器中的代理类的类对象 （这里填写类全名，因为该类没有包名，所以这里的全名就是该java文件名）
Class clazzProxy =urlClassLoader.loadClass("Proxy$");
//因为我们产生的java类不是在我们的项目中，所以，我们不能使用 Class.forName()来得到该类的实例，
//那么我们可以通过“Constructor(构造器)”来得到一个类的实例
@SuppressWarnings("unchecked")
//从代理类中得到一个构造方法，通过构造方法来实例该类
Constructor constructor= clazzProxy.getConstructor(handler.getClass());
Object object =constructor.newInstance(handler);
//返回代理类
return object;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
三、好啦， 那么到这里我们的jdk动态代理已经模仿完成啦， 我们来测试一下吧
1、我们模仿的动态代理和jdk动态代理，使用时大同小异的哈。我们新建一个日志的代理类吧，让他实现我们的业务逻辑处理接口，并重写invoke方法
package com.dao;
import java.lang.reflect.Method;
import com.handler.InvocationHandler;
public class StudentDaoImplTimeProxy implements InvocationHandler{
Object obj;
public StudentDaoImplTimeProxy(Object obj) {
this.obj=obj;
}
@Override
public Object invoke(Method method, Object[] args) {
Object ob=null;
try {
System.out.println("===========开始记录日志===========");
ob=method.invoke(obj,args);
System.out.println("===========结束记录===========");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return ob;
}
}
2、我们代理的目标类
package com.dao;
public class StudentDaoImpl implements StudentDao2 {
@Override
public void query(int i, String str) {
// TODO Auto-generated method stub
System.out.println("########查询数据库#######");
}
@Override
public void add(int i) {
// TODO Auto-generated method stub
System.out.println("########添加数据#######");
}
}
3、实现的接口
package com.dao;
public interface StudentDao {
public int query(int i);
public void add();
}
package com.test;
import java.lang.reflect.Method;
import com.dao.StudentDao;
import com.dao.StudentDao2;
import com.dao.StudentDaoImpl;
import com.dao.StudentDaoImpl1;
import com.dao.StudentDaoImplLogProxy;
import com.dao.StudentDaoImplTimeProxy;
import com.handler.InvocationHandler;
import com.proxy.Proxy;
public class Test {
public static void main(String[] args) {
StudentDao sd=new StudentDaoImpl1();
//custom仿jdk动态代理
InvocationHandler h1=new StudentDaoImplTimeProxy(sd);
StudentDao dao1=(StudentDao)Proxy.newProxyInstance(StudentDao.class,h1);
System.out.println(dao1.query(1));
}
