動態代理實現思路

實現功能：通過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)); 
}

高仿JDK動態代理 底層源碼實現