高仿JDK动态代理 底层源码实现

Posted 2021-11-22 joey-java

动态代理实现思路

实现功能：通过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)); 
}