Java的反射機制和代理模式

1.Java反射機制

在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調(diào)用它的任意方法和屬性；這種動態(tài)獲取信息以及動態(tài)調(diào)用對象方法的功能稱為Java語言的反射機制。
反射指Java在運行時可以加載、探知、使用編譯期間完全未知的classes。

2.反射機制的基礎Class類

在JVM的角度上，所有的類比如String、Integer等Java類都有成員變量，成員方法和構(gòu)造函數(shù)，JVM把這些所有的類再進行共性提取，定義了Class類，這是所有類的類，我們可以把String、Integer都理解成Class類的一個對象。
java.lang.Class注意查看源碼可以發(fā)現(xiàn)Class的構(gòu)造函數(shù)是private的，這說明我們是不能new Class的，只有JVM可以創(chuàng)建Class的對象,但是我們可以獲取到Class的對象。

3.Java反射的相關(guān)操作

1.獲取Class對象

package com.per.Reflection;

public class ReflectionDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一種：Class c1 = 類名.class;
        Class class1=ReflectionDemo1.class;
        System.out.println(class1.getName());

        //第二種：Class c2 = 對象.getClass();
        ReflectionDemo1 demo= new ReflectionDemo1();
        Class class2 = demo.getClass();
        System.out.println(class2.getName());

        //第三種：Class c3 = Class.forName("XX");
        Class class3 = Class.forName("com.per.Reflection.ReflectionDemo1");
        System.out.println(class3.getName());
    }
}

2.獲取成員方法信息

java.lang.reflect.Method通過Method類獲取類的成員方法。

package com.per.Reflection;

import java.lang.reflect.Method;

public class ReflectionDemo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            Class c = Class.forName("java.lang.String");
            Method[] methods = c.getDeclaredMethods();
            System.out.println("不包含父類的private&pubic方法");
            for (Method m : methods) {
                System.out.println(m);
            }
            Method[] methodsPublic = c.getMethods();
            System.out.println("包含父類的pubic方法");
            for (Method m : methodsPublic) {
                System.out.println(m);
            }

            Method method1 = c.getDeclaredMethod("toString", null);
            System.out.println(method1);
            Method method2 = c.getMethod("startsWith",String.class);
            System.out.println(method2);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

①getDeclaredMethods()返回本類中定義的所有方法，不包括父類的方法。
②getMethods()返回包括父類的權(quán)限為public的方法。
③getDeclaredMethod(String name, Class... parameterTypes) 返回此Class對象對應類的、帶指定形參列表的不包含父類的方法。
④getMethod(String name, Class... parameterTypes) 返回此Class對象對應類的、帶指定形參列表的包含父類的public方法。

3.獲取構(gòu)造函數(shù)

java.lang.reflect.Constructor通過Constructor獲取類的構(gòu)造函數(shù)。

package com.per.Reflection;

import java.lang.reflect.Constructor;

public class ReflectionDemo3 {

    public static void main(String[] args) {
        try {
            Class c = Class.forName("java.lang.String");
            Constructor[] constructors = c.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }
            Constructor[] constructorsPublic = c.getConstructors();
            for (Constructor constructor : constructorsPublic) {
                System.out.println(constructor);
            }
            Constructor constructor1 = c.getDeclaredConstructor(String.class);
            constructor1.setAccessible(true);// 設置是否允許訪問，如果該構(gòu)造器是private的，所以要手動設置允許訪問，如果構(gòu)造器是public的就不需要這行了。
            Object o=constructor1.newInstance("refelect test");
            System.out.println(o);
            Method method=c.getDeclaredMethod("startsWith", String.class);
            System.out.println(method.invoke(o, "refe"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.調(diào)用成員函數(shù)

  public Object invoke(Object obj, Object... args)

①以String類為例子，首先獲取String的Class的對象
②創(chuàng)建String類的對象
③獲取String類的特定Method
④通過Method的invoke方法調(diào)用String類的成員方法

Class c = Class.forName("java.lang.String");//①
Object obj1=c.newInstance();//②
Method method=c.getDeclaredMethod("startsWith", String.class);//③
method.invoke(obj, "refe"));//④false
//根據(jù)構(gòu)造函數(shù)創(chuàng)建String對象
Constructor constructor1 = c.getDeclaredConstructor(String.class);
Object o=constructor1.newInstance("refelect test");
method.invoke(obj, "refe"));//true

4.代理模式

1.問題的背景：計算一個方法運行的時間

定義一個Moveable接口

public interface Moveable {
    void move();    
}

定義一個實現(xiàn)Moveable的類

public class Tank implements Moveable {
    @Override
    public void move() {
        System.out.println("Tank Moving...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

問題：如何計算出Tank類中move方法運行的時間

解決策略：

①直接在Tank類中修改源碼，添加計時操作；
②繼承：新建一個類繼承Tank類，并覆蓋move方法，在子類的move方法中添加計時操作，并調(diào)用父類super.move()方法；
③聚合：新建一個代理類實現(xiàn)Moveable接口，并且該類中包含一個Tank類的對象，在代理類中的move方法中調(diào)用Tank類對象的move方法。靜態(tài)代理

2.靜態(tài)代理

靜態(tài)：由程序員創(chuàng)建代理類或特定工具自動生成源代碼再對其編譯。在程序運行前代理類的.class文件就已經(jīng)存在了。
JDK代理都是面向接口的，實現(xiàn)類和代理類必須實現(xiàn)同一個接口

public class StaticProxy implements Moveable {
    private Moveable m = new Tank();//多態(tài)    
    public StaticProxy(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        System.out.println("starttime:" + start);
        m.move();
        long end = System.currentTimeMillis();
        System.out.println("time:" + (end-start));
    }
}

代理客戶端

public class Client {
    public static void main(String[] args) throws Exception {
        StaticProxy proxy=new StaticProxy();
        proxy.move();
    }
}

總結(jié)
①定義代理類和委托類的總接口
②實現(xiàn)類的具體方法
③實現(xiàn)代理類，包含委托類的一個實例，并在代理類的方法中調(diào)用委托類的方法
④客戶端，創(chuàng)建一個代理類對象，實現(xiàn)代理。
優(yōu)點
不用修改委托類的源代碼通過代理類就可以實現(xiàn)對委托類的控制。
缺點
代理類和委托類實現(xiàn)了相同的接口，代理類通過委托類實現(xiàn)了相同的方法。這樣就出現(xiàn)了大量的代碼重復。如果接口增加一個方法，除了所有實現(xiàn)類需要實現(xiàn)這個方法外，所有代理類也需要實現(xiàn)此方法。增加了代碼維護的復雜度。
靜態(tài)代理類只能為特定的接口服務。如想要為多個接口服務則需要建立很多個代理類。

3.動態(tài)代理

動態(tài)：在運行的時候才生成classes的文件。
思路：將程序的代碼保存成String類型，然后在運行的過程中將該String的內(nèi)容寫入XX.java文件中，調(diào)用JavaCompiler 編譯器將java文件在運行的時候產(chǎn)生classes文件。并將class文件加載到內(nèi)存，調(diào)用成員函數(shù)。

package com.bjsxt.compiler.test;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;

import com.bjsxt.proxy.Moveable;
import com.bjsxt.proxy.Tank;

public class Test1 {
    public static void main(String[] args) throws Exception{
        String rt = "\r\n";
        String src = 
            "package com.bjsxt.proxy;" +  rt +
            "public class TankTimeProxy implements Moveable {" + rt +
            "    public TankTimeProxy(Moveable t) {" + rt +
            "        super();" + rt +
            "        this.t = t;" + rt +
            "    }" + rt +
            
            "    Moveable t;" + rt +
                            
            "    @Override" + rt +
            "    public void move() {" + rt +
            "        long start = System.currentTimeMillis();" + rt +
            "        System.out.println(\"starttime:\" + start);" + rt +
            "        t.move();" + rt +
            "        long end = System.currentTimeMillis();" + rt +
            "        System.out.println(\"time:\" + (end-start));" + rt +
            "    }" + rt +
            "}";
        String fileName = System.getProperty("user.dir") 
                            + "/src/com/bjsxt/proxy/TankTimeProxy.java";
        File f = new File(fileName);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();
        
        //compile
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileMgr.getJavaFileObjects(fileName);
        CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
        t.call();
        fileMgr.close();
        
        //load into memory and create an instance
        URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") +"/src")};
        URLClassLoader ul = new URLClassLoader(urls);
        Class c = ul.loadClass("com.bjsxt.proxy.TankTimeProxy");
        System.out.println(c);
        
        Constructor ctr = c.getConstructor(Moveable.class);
        Moveable m = (Moveable)ctr.newInstance(new Tank());
        m.move();       
    }
}

遇到的問題 compiler一直返回null，將jdk\lib下將tools.jar復制到jre\lib下就能正確運行了，我的path中保存了jre和jdk的目錄。
程序運行結(jié)束后Window——Show view——Nivigator，然后再刷新一下項目，我們可以發(fā)現(xiàn)在程序運行的過程中生成了TankTimeProxy.java文件，并且我們調(diào)用了java的編譯器生成了TankTimeProxy.class文件。

image.png

現(xiàn)在存在的問題：1.接口是固定的；2.函數(shù)也是固定move
我們很自然的能夠想到傳入一個參數(shù)來獲取指定類型的接口
image.png

根據(jù)反射機制，我們?nèi)绻懒四硞€類的名字也就能夠獲取所有的方法。這樣我們就可以不用在代碼中寫出固定的函數(shù)了。

Method[] methods = infce.getMethods();
for(Method m : methods) {
            methodStr += "@Override" + rt + 
                         "public void " + m.getName() + "() {" + rt +
                         "    try {" + rt +
                         "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
                         "    h.invoke(this, md);" + rt +
                         "    }catch(Exception e) {e.printStackTrace();}" + rt +
                        
                         "}";
        }

假如我們還需要在函數(shù)處理前后記錄日志呢，讀取權(quán)限呢，那樣我們就有各種處理不同事物的代理，我們可以把這些代理抽象出來，這些代理全部都必須實現(xiàn)InvocationHandler這個接口。

public interface InvocationHandler {
    public void invoke(Object o, Method m);
}

package com.bjsxt.proxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TimeHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    @Override
    public void invoke(Object o, Method m) {
        long start = System.currentTimeMillis();
        System.out.println("starttime:" + start);
        System.out.println(o.getClass().getName());
        try {
            m.invoke(target);
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("time:" + (end - start));
    }

}

注意：實際上我們的代理類內(nèi)部仍然包含了一個委托類的對象，并且在代理類中調(diào)用了實際上是一個委托類的對象調(diào)用了委托類的方法。

m.invoke(target);

所以我們不但要將接口作為參數(shù)，還要將何種類型的代理也傳入進去，這樣我們就能實現(xiàn)對任意對象、任意接口，實現(xiàn)任意的代理。

package com.bjsxt.proxy;

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.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;


public class Proxy {
    public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
        String methodStr = "";
        String rt = "\r\n";
        
        Method[] methods = infce.getMethods();
        for(Method m : methods) {
            methodStr += "@Override" + rt + 
                         "public void " + m.getName() + "() {" + rt +
                         "    try {" + rt +
                         "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
                         "    h.invoke(this, md);" + rt +
                         "    }catch(Exception e) {e.printStackTrace();}" + rt +
                        
                         "}";
        }
        
        String src = 
            "package com.bjsxt.proxy;" +  rt +
            "import java.lang.reflect.Method;" + rt +
            "public class $Proxy1 implements " + infce.getName() + "{" + rt +
            "    public $Proxy1(InvocationHandler h) {" + rt +
            "        this.h = h;" + rt +
            "    }" + rt +
            
            
            "    com.bjsxt.proxy.InvocationHandler h;" + rt +
                            
            methodStr +
            "}";
        String fileName = 
            "d:/src/com/bjsxt/proxy/$Proxy1.java";
        File f = new File(fileName);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();
        
        //compile
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileMgr.getJavaFileObjects(fileName);
        CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
        t.call();
        fileMgr.close();
        
        //load into memory and create an instance
        URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
        URLClassLoader ul = new URLClassLoader(urls);
        Class c = ul.loadClass("com.bjsxt.proxy.$Proxy1");
        System.out.println(c);
        
        Constructor ctr = c.getConstructor(InvocationHandler.class);
        Object m = ctr.newInstance(h);
        //m.move();

        return m;
    }
}

客戶端的程序：

public class Client {
    public static void main(String[] args) throws Exception {
        Tank t = new Tank();
        InvocationHandler h = new TimeHandler(t);
        Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);
        m.move();
    }
}

總結(jié)：靜態(tài)代理的實現(xiàn)類和代理類都必須實現(xiàn)同一個接口，但是在動態(tài)代理中，代理類必須實現(xiàn)InvocationHandler這個接口，這個接口在指定方法時會自動的調(diào)用。

invoke(Object proxy, Method method, Object[] args)

在客戶端程序中，靜態(tài)代理直接創(chuàng)建一個代理類對象通過調(diào)用代理類的 方法實現(xiàn)代理。在動態(tài)代理中，實現(xiàn)InvocationHandler這個接口的類并不是代理類，而是代理類的必備環(huán)節(jié)。

 Tank t = new Tank();
 InvocationHandler h = new TimeHandler(t);
 Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);

注意：在Proxy文件中調(diào)用的是 h.invoke(this, md)，這里的h指的是我們實現(xiàn)InvocationHandler這個接口的對象，調(diào)用的Method是infce中的方法，實際上就是h中有一個infec的對象，是h中的infec對象調(diào)用的方法。

5.參考資料

馬士兵代理模式視頻
http://www.itdecent.cn/p/da4a20d3ab77
http://www.itdecent.cn/p/1f329f5fda9d

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關(guān)閱讀更多精彩內(nèi)容

  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關(guān)的語法，內(nèi)部類的語法，繼承相關(guān)的語法，異常的語法，線程的語...
    子非魚_t_閱讀 34,623評論 18贊 399
  • Spring Cloud為開發(fā)人員提供了快速構(gòu)建分布式系統(tǒng)中一些常見模式的工具（例如配置管理，服務發(fā)現(xiàn)，斷路器，智...
    卡卡羅2017閱讀 136,502評論 19贊 139
  • （一）Java部分 1、列舉出JAVA中6個比較常用的包【天威誠信面試題】 【參考答案】 java.lang;ja...
    獨云閱讀 7,241評論 0贊 62
  • 角色，越長大越孤單，越長大越多面，越長大越遠離自然。成人的世界，沒有一個是容易。 想哭不能哭的，因為時間地點不對，...
    任小暴閱讀 225評論 0贊 0
  • 道路如河，傘開花落 一朵云從我頭頂失陷于 蛙聲的沼澤 你是天空的精靈卻在地上曲折 我是一把傘開著 傘送給別人 傘下...
    晚樹閱讀 514評論 18贊 15

友情鏈接更多精彩內(nèi)容