2. 程式人生 > >[Proxy] 深入理解jdk動態代理

[Proxy] 深入理解jdk動態代理

阿新 • • 發佈：2018-12-13

[Proxy] 深入理解jdk動態代理

分析

jdk的proxy主要有三個類，Proxy，Proxy.ProxyClassFactory和ProxyGenerator。Proxy是一個面向使用者的Client,主要是管理proxy class cache，jdk的proxy必須是interface，且必須傳入一個InvocationHandler介面的例項，規約比較強。Proxy.ProxyClassFactory主要是生產proxy class例項。ProxyGenerator是生產class例項的執行者。最終將生成proxy class 位元組碼，ProxyGenerator的saveGeneratedFiles屬性決定了是否儲存class檔案。檔案路徑是BaseDir+/com/sun/proxy/$xx.class。最終ClassLoader將會load此class位元組碼到JVM中。返回interface的動態代理例項。

自定義proxy

  1. 建立java檔案，儲存至工作路徑。
  2. 通過JavaCompiler將java檔案編譯成class檔案，儲存在工作路徑。
  3. 通過ClassLoader載入此class檔案
  4. 返回interface例項

Proxy

package com.yzz.study.proxy.custom;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.util.Map;
import java.util.WeakHashMap;

/**
 * author:yzz
 * date:2018/12/1
 * E-mail:
 
[email protected]
 * com.yzz.study.proxy.custom
 * {@link java.lang.reflect.Proxy}
 */
public class Proxy {

    /**
     * 快取 {@link java.lang.reflect.Proxy}
     */
    private static Map<String, Class> cachedProxyClassInstaceMap = new WeakHashMap<String, Class>();

    protected InvocationHandler h;

    private Proxy(){

    }

    protected Proxy(InvocationHandler h){
        this.h = h;
    }

    /**
     * {@link java.lang.reflect.Proxy}
     * 這裡實現比較簡單的   Class<T>[] interfaces --> Class<T> ince
     * @param loader
     * @param ince
     * @param h
     * @param <T>
     * @return
     */
    public static <T> T newInstance(MyClassLoader loader,
                                   Class<T> ince,
                                   InvocationHandler h) throws Exception {

        String className = "$proxy"+cachedProxyClassInstaceMap.size()+1;
        //1.從cache裡查詢
        Class targetClass = cachedProxyClassInstaceMap.get(ince.getName());
        if (null != targetClass){
            return (T) targetClass;
        }
        //2.建立java file
        String javaFilePth = ProxyGenerator.createProxyJavaFile(loader,className,ince);
        //3.編譯 java file
        CompileJavaCode.compile(javaFilePth);
        //4.load class 檔案
        Class<T> _class = (Class<T>) loader.findClass(className);
        //這裡加入InvocationHandler例項
        Constructor constructor = _class.getConstructor(InvocationHandler.class);
        return (T) constructor.newInstance(h);
    }
}

ProxyGenerator（負責建立java檔案）

package com.yzz.study.proxy.custom;

import javax.sound.sampled.Line;
import java.io.*;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * author:yzz
 * date:2018/12/1
 * E-mail:[email protected]
 * com.yzz.study.proxy.custom
 * 註釋:建立proxy class 檔案
 */
class ProxyGenerator {

    private static final String LINE = "\r\n";

    public static final String LEFT_CLOSE = "}";

    public static final String RIGHT_CLOSE = "{";

    public static final String INVOCATIONHANDLER = "InvocationHandler";

    public static final String PARAMATER = "var";

    public static String createProxyJavaFile(ClassLoader classLoader, String className, Class ince) {
        String filePath = classLoader.getClass().getResource("").getPath() + "/" + className + ".java";
        String packgeNmae = classLoader.getClass().getPackage().getName();
        StringBuffer sb = new StringBuffer();
        sb.append("package ").append(packgeNmae).append(";").append(LINE);
        sb.append("import ").append("java.lang.reflect.InvocationHandler;").append(LINE);
        sb.append("import java.lang.reflect.Method;").append(LINE);
        sb.append("import com.yzz.study.proxy.custom.Proxy;").append(LINE);
        createHead(sb, className,ince.getName());
        Map<String, String> methodNames = createField(sb, ince);
        createConstruct(sb, className);
        createMethods(sb, ince, methodNames);
        createStaticBlock(ince,methodNames,sb);
        sb.append(LEFT_CLOSE);
        try {
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath)));
            writer.write(sb.toString());
            writer.flush();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return filePath;
    }

    public static void createHead(StringBuffer sb, String className,String inceName) {
        sb.append("public class ")
                .append(className)
                .append(" extends Proxy implements ")
                .append(inceName)
                .append(" ")
                .append(RIGHT_CLOSE)
                .append(" ")
                .append(LINE);
    }

    public static Map<String, String> createField(StringBuffer sb, Class ince) {
        Method[] ms = ince.getMethods();
        Map<String, String> map = new HashMap<String, String>();
        for (int i = 0; i < ms.length; i++) {
            Method method = ms[i];
            sb.append("private static Method ")
                    .append("m")
                    .append(i + 1)
                    .append(";").append(LINE);
            map.put(method.getName(), "m" + (i + 1));
        }
        return map;
    }

    public static void createConstruct(StringBuffer sb, String className) {
        sb.append("public ")
                .append(className)
                .append(" (")
                .append(INVOCATIONHANDLER)
                .append(" h )")
                .append(RIGHT_CLOSE)
                .append("super(h);")
                .append(LEFT_CLOSE)
                .append(LINE);
    }

    public static void createMethods(StringBuffer sb, Class ince, Map<String, String> methodNmaes) {
        Method[] ms = ince.getMethods();
        for (Method m : ms) {
            String methodName = m.getName();
            Class returnType = m.getReturnType();
            Class[] pts = m.getParameterTypes();
            createMethod(methodName, returnType, pts, sb, ince, methodNmaes.get(m.getName()));
        }
    }

    public static void createMethod(String methodName, Class returnType, Class[] pts, StringBuffer sb, Class ince, String mName) {
        sb.append(" public ")
                .append(returnType)
                .append(" ")
                .append(methodName)
                .append("(");
        String[] args = new String[pts.length];
        for (int i = 0; i < pts.length; i++) {
            Class c = pts[i];
            sb.append(c.getName())
                    .append(" ")
                    .append(PARAMATER)
                    .append(i);
            if (i != pts.length - 1) {
                sb.append(",");
            }
            args[i] = PARAMATER + i;
        }
        sb.append(")");
        sb.append(RIGHT_CLOSE);
        createMethodBody(mName, args, sb);
        sb.append(LEFT_CLOSE)
                .append(LINE);

    }

    /***
     *  public Object invoke(Object proxy, Method method, Object[] args)
     *  throws Throwable;
     * @return
     */
    public static void createMethodBody(String methodName, String[] args, StringBuffer sb) {
        sb.append("try ")
                .append(LINE)
                .append(RIGHT_CLOSE)
                .append(LINE)
                .append("super.h.invoke(this,")
                .append(methodName)
                .append(",")
                .append("new Object[]{");
        //這裡需要構造引數
        for (int i = 0; i < args.length; i++) {
            sb.append(args[i]);
            if (i != args.length - 1) {
                sb.append(",");
            }
        }
        sb.append("});")
                .append(LINE)
                .append("}catch(Throwable e){")
                .append(LINE)
                .append("e.printStackTrace();")
                .append(LINE)
                .append(LEFT_CLOSE)
                .append(LINE);
    }

    private static void createStaticBlock(Class ince,Map<String,String> classMethodMap,StringBuffer sb){
        sb.append("static ")
                .append(RIGHT_CLOSE)
                .append("try ")
                .append(RIGHT_CLOSE);
        Method[] ms = ince.getMethods();
        for (Method method:ms){
            Class[] ps = method.getParameterTypes();
            String pcs = "";
            for (int i = 0; i < ps.length; i++) {
                pcs += "Class.forName(\""+ps[i].getName() + "\")";
                if (i != ps.length-1){
                    pcs += ",";
                }
            }
            sb.append(classMethodMap.get(method.getName()))
                    .append("=")
                    .append("Class.forName(\"")
                    .append(ince.getName())
                    .append("\")")
                    .append(".getMethod(")
                    .append("\""+method.getName()+"\"")
                    .append(",")
                    .append("new Class[]{")
                    .append(pcs)
                    .append("});")
                    .append(LINE);
        }
        sb.append("}catch(Exception e)")
                .append(RIGHT_CLOSE)
                .append(LINE)
                .append("e.printStackTrace();")
                .append(LINE)
                .append(LEFT_CLOSE);
        sb.append(LEFT_CLOSE);
        sb.append(LINE);
    }
}

CompileJavaCode(負責編譯java檔案)

編譯工作是依賴javax.tools下的資源包

package com.yzz.study.proxy.custom;

import javax.tools.*;
import java.nio.charset.Charset;

/**
 * author:yzz
 * date:2018/12/1
 * E-mail:[email protected]
 * com.yzz.study.proxy.custom
 * 註釋:
 */

public class CompileJavaCode {

    public static void compile(String javaFileName){
        try {
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, Charset.defaultCharset());
            Iterable iterable = manager.getJavaFileObjects(javaFileName);
            JavaCompiler.CompilationTask compilationTask = compiler.getTask(null, manager, null, null, null, iterable);
            compilationTask.call();
            manager.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

ClassLoader（負責裝載指定目錄下的class檔案）

package com.yzz.study.proxy.custom;

import java.io.*;

/**
 * author:yzz
 * date:2018/12/1
 * E-mail:[email protected]
 * com.yzz.study.proxy.custom
 * 註釋: 載入class檔案
 */
public class MyClassLoader extends ClassLoader{

    private static String baseDir;

    public MyClassLoader(){
        baseDir = MyClassLoader.class.getResource("").getPath();
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = MyClassLoader.class.getPackage().getName()+"."+name;
        BufferedInputStream bufferedInputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            File classFile = new File(baseDir,name.replaceAll("\\.","/") + ".class");
            bufferedInputStream = new BufferedInputStream(new FileInputStream(classFile));
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] temp = new byte[1024];
            int len;
            while((len = bufferedInputStream.read(temp)) != -1){
                byteArrayOutputStream.write(temp,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (null != bufferedInputStream){
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != byteArrayOutputStream){
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return defineClass(className,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.size());
    }
}

interface

package com.yzz.study.proxy.custom;

/**
 * author:yzz
 * date:2018/12/1
 * E-mail:[email protected]
 * com.yzz.study.proxy.jdk
 * 註釋:
 */
public interface ILog {

    void printLog(String a,Object b);
    void printLog1(String a,Object b);
    void printLog2(String a,Object b);
}

測試

package com.yzz.study.proxy.custom;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * author:yzz
 * date:2018/12/2
 * E-mail:[email protected]
 * com.yzz.study.proxy.custom
 * 註釋:
 */
public class Test {

    public static void main(String[] args) {
        try {
            ILog log = Proxy.newInstance(new MyClassLoader(), ILog.class, new InvocationHandler() {
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("==================");
                    System.out.println(method.getName());
                    return null;
                }
            });
            System.out.println(log);
            log.printLog("1","2");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

展示

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.yzz.study.proxy.custom;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class $proxy01 extends Proxy implements ILog {
    private static Method m1;
    private static Method m2;
    private static Method m3;

    public $proxy01(InvocationHandler var1) {
        super(var1);
    }

    public void printLog1(String var1, Object var2) {
        try {
            super.h.invoke(this, m1, new Object[]{var1, var2});
        } catch (Throwable var4) {
            var4.printStackTrace();
        }

    }

    public void printLog2(String var1, Object var2) {
        try {
            super.h.invoke(this, m2, new Object[]{var1, var2});
        } catch (Throwable var4) {
            var4.printStackTrace();
        }

    }

    public void printLog(String var1, Object var2) {
        try {
            super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (Throwable var4) {
            var4.printStackTrace();
        }

    }

    static {
        try {
            m1 = Class.forName("com.yzz.study.proxy.custom.ILog").getMethod("printLog1", new Class[]{Class.forName("java.lang.String"), Class.forName("java.lang.Object")});
            m2 = Class.forName("com.yzz.study.proxy.custom.ILog").getMethod("printLog2", new Class[]{Class.forName("java.lang.String"), Class.forName("java.lang.Object")});
            m3 = Class.forName("com.yzz.study.proxy.custom.ILog").getMethod("printLog", new Class[]{Class.forName("java.lang.String"), Class.forName("java.lang.Object")});
        } catch (Exception var1) {
            var1.printStackTrace();
        }

    }
}

總結

jdk的proxy嚴重依賴InvocationHandler介面，代理例項的方法都會回撥該介面的invoke()方法，在invoke()方法下，可以自定義代理邏輯。

相關推薦

[Proxy] 深入理解jdk動態代理

[Proxy] 深入理解jdk動態代理 分析 jdk的proxy主要有三個類，Proxy，Proxy.ProxyClassFactory和ProxyGenerator。Proxy是一個面向使用者的Client,主要是管理proxy class cache，jdk的proxy必須是

深入理解JDK動態代理

緩存 loader getprop manager 動態 java declared flush ont 1 package jdkproxy; 2 3 public interface Moveable { 4 void move(int i); 5 }

深入理解JDK動態代理機制

本文是基於jdk1.8來對動態代理的底層機制進行探究的 Java中代理的實現一般分為三種：JDK靜態代理、JDK動態代理以及CGLIB動態代理。在Spring的AOP實現中，主要應用了JDK動態代理以及CGLIB動態代理。但是本文著重介紹JDK動態代理機制，CGLIB動態代理後面會接著探究。

java基礎：深入理解JDK動態代理

其他更多java基礎文章： java基礎學習(目錄) 經過上一節我們講了Class物件和反射機制，這節就來講一下反射機制在java中的主要應用——動態代理。在講動態代理之前，會先講一下代理模式和靜態代理。 一、代理模式 代理模式是常用的java設計模式，他的特徵是代理類與委託類有同樣的介面，代理類主

深入理解CGLIB動態代理機制

本文是基於CGLIB 3.1進行探究的 cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and impl

深入理解 Java 動態代理

最近在讀 mybatis 原始碼的時候想研究一下 mybatis 的懶載入是怎麼工作的。 基本的原理我是知道的，用了代理物件。但是代理物件又是怎麼工作的，就不太清楚，我有自己的兩種想法但不知道具體哪一種是對的。 javassist 動態代理 demo

深入理解 Java 動態代理機制

Java 有兩種代理方式，一種是靜態代理，另一種是動態代理。對於靜態代理，其實就是通過依賴注入，對物件進行封裝，不讓外部知道實現的細節。很多 API 就是通過這種形式來封裝的。 代理模式結構圖（圖片來自《大話設計模式》） 下面看下兩者在概念上的解釋： 靜態代理 靜態代理

JDK動態代理的深入理解

引入代理模式 代理模式是框架中經常使用的一種模式，動態代理是AOP（面向切面程式設計）思想的一種重要的實現方式，在我們常用的框架中也經常遇見代理模式的身影，例如在Spring中事務管理就運用了動態代理，它將Service層原先應該進行的事務管理交給了Spring框架，大大簡化了開發流程。在H

JDK動態代理深入理解分析並手寫簡易JDK動態代理（下）

上篇分析的是JDK動態代理實現原理，這個下篇是一個自實現的動態代理案例，這一篇我們自定義代理Proxy，代理業務需要實現的Handler介面，以及類載入器ClassLoader；最終我們以自己寫的程式碼去生成代理類的程式碼，再用代理類的程式碼去代理執行我們的業務程式碼，完成一套標準的動態代理； 首先我們分析

JDK動態代理深入理解分析並手寫簡易JDK動態代理（上）

部落格真的是好幾個月沒更了，2019新年第一篇，繼續深入動態代理，前兩篇簡單分析了動態代理的實現原理之後，這次繼續深入瞭解具體的實現方式，並手寫一套簡易的動態代理已加強理解； 先接上一篇程式碼，這裡先上程式碼說話，一個簡單案列，代理找物件和找工作： JDK動態代理只能代理有介面的類，定義Persion介面

JDK動態代理[2]----JDK動態代理的底層實現之Proxy源碼分析

sco 不可 -- 例如 mis tfs err eno entity 在上一篇裏為大家簡單介紹了什麽是代理模式？為什麽要使用代理模式？並用例子演示了一下靜態代理和動態代理的實現，分析了靜態代理和動態代理各自的優缺點。在這一篇中筆者打算深入源碼為大家剖析JDK動態代理實現的

《設計模式》之一文帶你理解單例、JDK動態代理、CGLIB動態代理、靜態代理

個人認為我在動態代理方面的分析算是比較深入了，下次更新再修改一下，爭取做到最好，後續還有建造者模式、模板方法、介面卡、外觀、責任鏈、策略和原型模式的深入！各位讀者如果覺得還不錯的可以持續關注哦。謝謝各位！！！ 我的github，到時上傳例子程式碼 https://github.com

Java JDK動態代理Proxy類的原理是什麼？

什麼是代理? 先從代理開始講。 代理這種設計模式其實很好理解，基本就是最簡單的一個 “組合”。比如說下面這個例子，我們有 A 這個類，本來可以直接呼叫 A 類的 foo() 方法。但代理模式就非要把 A 類當成 B 類的一個成員欄位放在 B 類裡面。然

spring原始碼閱讀（2）-aop之jdk動態代理深入解析

續spring原始碼閱讀（2）-aop之j動態代理 我們從需求作為動態代理髮展的切入吧 現在有5個已經投產了的run100m的實現，我們新的需求需要監控不同實現的執行效能，如果我們針對這五個實現分別去新增效能監控的程式碼,如此就造成兩個問題： 一個是已經穩定的程式碼需要

10分鐘理解代理——JDK動態代理

引子： 在上一篇文章中介紹了什麼是靜態代理。本章繼續為大家講解代理的另外一個領域：JDK動態代理。動態代理的的優勢在於代理物件可以觸發被動理物件的任何方法。動態代理的JDK實現方式很容易使用。 Invoce的意思是呼叫，Invocation是Invoce 的名詞形式，ha

SpringAOP深入瞭解之jdk動態代理與CGlib

理解AOP 一般我們編寫程式的思想是縱向的，也就是一個方法程式碼從該方法第一行開始往下一步一步走，直到走完最後一行程式碼。也就是說很多業務都需要的比如使用者鑑權，資源釋放等我們都要在每個方法裡面重複再去呼叫。 public void doMethodOne() {

JDK動態代理（2）JDK動態代理的底層實現之Proxy原始碼分析

JDK動態代理（2）JDK動態代理的底層實現之Proxy原始碼分析 在上一篇裡為大家簡單介紹了什麼是代理模式？為什麼要使用代理模式？並用例子演示了一下靜態代理和動態代理的實現，分析了靜態代理和動態代理各自的優缺點。在這一篇中筆者打算深入原始碼為大家剖析JDK動態代理實現的機制，建議讀者閱

JDK動態代理（JDK dynamic proxy）

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * JDK動態代理。 * @author Bright Le

關於jdk動態代理+proxy引數作用的學習總結

首先關於具體的原始碼分析，網上很多，在此不再記錄一次。 關於JDK動態代理的學習。首先先整明白了大體的思路，一個實現了某些介面的被代理類。一個實現了InvocationHandle的代理類，然後通過Proxy類下的靜態方法newProxyInstance進行織入產生一個融合

深入理解ES6之——代理和反射（proxy）

通過呼叫new proxy()你可以建立一個代理來替代另一個物件（被稱為目標），這個代理對目標物件進行了虛擬，因此該代理與該目標物件表面上可以被當做同一個物件來對待。 建立一個簡單的代理 當你使用Proxy構造器來建立一個代理時，需要傳遞兩個引數：目標物件以及一個處理器，後者是定義了一個或多個陷阱函式的物件。