java-java動態性之反射，動態編譯，動態執行js及動態字節碼操作

反射圖示:

簡單上代碼了解一下：

1.實體類

package com.reflection;

public class Student {
    //學生實體類，包含編號，名字，所屬班級的屬性
    private int id;
    private String name;
    private String cname;

    public Student() {
        super();
    }
    //構造器
    public Student(int id, String name, String cname) {
        super();
        this.id = id;
        this.name = name;
        this.cname = cname;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    
}

2.方法示例:

package com.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

import com.sun.javafx.collections.MappingChange.Map;

/*
 * Java動態性:
 * 動態語言:
 * 程序運行時，可以改變程序結構或變量類型，Java並非動態語言，但其擁有動態性，利用反射機制以及字節碼操作獲得類似動態語言的特性.
 * 一.反射機制：可以於運行時加載，探知，使用編譯期間完全未知的類。 
 *  （1）PS：程序在運行狀態中，可以動態的加載一個只有名稱的類，對於任意一個已加載的類，都能夠知道這個類的所有屬性和方法，對於任意一個對象，都能夠調用它的任意一個方法和屬性
 *  （2）操作方式:Class c=Class.forName("com.reflection.Reflect");
 *  （3）反射：加載完類之后，在堆內存中會產生一個Class類型的對象（一個類只有一個Class對象），該對象包含了完整的類的結構信息，通過這個對象可以看到類的結構，這便是反射。
 *  （4）Class類是Reflection的根源:針對任何想要動態加載，運行的類，唯有先獲得相應的Class對象。
 *  （5）獲取Class對象的三種方式: getClass(),Class.forName(),.class語法
 *  （6）反射機制的常見作用:
 *  動態加載類，動態獲取類的信息（屬性，方法，構造器）/動態構造對象/動態調用類和對象的任意方法及構造器/
 *  動態調用和處理屬性/獲取泛型信息/處理注解
 *  （7）反射機制的性能問題:
 *  利用反射執行類方法執行速度大概為類普通方法執行速度的1/30，也就是很慢，效率低，加上setAccessible()后可提高效率
 *  setAccessible():啟用和禁用訪問安全檢查的開關，值為true,則表示取消訪問安全檢查，反之
 * 
 * 二.動態編譯:
 * 動態編譯的兩種做法:
 * （1）通過Runtime調用javac，啟動新的進程去操作
 * ->Runtime run=Runtime.getRuntime();
 *   Process process=run.exec("java -cp +類文件絕對路徑");
 * （2）通過JavaCompiler動態編譯
 * ->JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
 *   int result=compiler.run(null,null,null,sourceFile);
 *   第一個參數:為java編譯器提供參數  InputStream
 *   第二個參數:得到java編譯器的輸出信息 OutputStream
 *   第三個參數:接收編譯器的錯誤信息  
 *   第四個參數:可變參數（為String數組）能傳入一個或多個java源文件
 *   返回值:1表示編譯成功,0表示編譯失敗
 * 
 * 三.動態執行JavaScript代碼:
 * Java腳本引擎:
 *  使得java的應用程序可以通過一套固定的接口與各種腳本引擎交互，從而達到在Java平台上調用各種腳本語言的目的。
 *  可以把一些復雜異變的業務邏輯交給腳本語言處理，大大提高開發效率
 *  （1）獲得腳本引擎對象:
 *  ScriptEngineManager sem=new ScriptEngineManager();
 *  ScriptEngine engine=sem.getEngineByName("javascript");
 *  功能:
 * （1）獲取腳本程序輸入，通過腳本引擎運行腳本並返回運行結果，這是最核心的接口。 JS使用了Rhino
 * （2）通過腳本引擎的運行上下文在腳本和Java平台間交換數據。
 * （3）通過Java應用程序調用腳本函數。
 *  
 * 四.動態字節碼操作:
 * 功能:動態生成新的類，動態改變某個類的結構（增加，刪除，修改 新的屬性/方法 ）
 * 優勢:比反射的開銷小，性能高，Javassist性能高於反射，低於ASM
 * 常見的字節碼操作類庫:
 * BCEL:在實際的JVM指令層次上進行操作，擁有豐富的JVM指令級支持
 * ASM:是一個輕量級java字節碼操作框架，直接涉及到JVM底層的操作和指令
 * CGLIB:是一個強大的，高性能，高質量的code生成類庫，基於ASM實現
 * Javassist:是一個開源的分析，編輯和創建字節碼的類庫，性能較ASM差，較cglib差不多，使用簡單
 * ->最外層的API和JAVA反射包中的API頗為相似:
 * 主要由CtClass,CtMethod以及CtField幾個類組成，
 * 用以執行和JDK反射API中java.lang.Class,java.lang.reflect.Method
 * 以及java.lang.reflect.Method.Field相同的操作
 * 
 * 局限性:
 * 不支持泛型，枚舉，不支持注釋修改，但可以通過底層的javassist類解決
 * 不支持數組的初始化，內部類和匿名類，不支持continue，break語句還有部分繼承關系
 * 
 */

@SuppressWarnings("all")
public class Reflect {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ScriptException {

        try {
            getInfoByReflect();
            useConstructorByReflect();
            useReflectMethod();
            getTypeAll();
            /*testComplier();*/
            scriptEngine();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    //通過反射獲取Class對象里面對應類的屬性
    public static void getInfoByReflect() throws ClassNotFoundException {
        //獲取Student類的Class對象
        Class c=Class.forName("com.reflection.Student");
        //通過該Class對象獲取該類的具體名字（包含包名）及類名
        String realName=c.getName();
        String name=c.getSimpleName();
        System.out.println("具體名字:"+realName+" 類名:"+name);

        //獲取類的屬性
        //Field[] field=c.getFields();//只能獲取public的屬性
        Field[] fields=c.getDeclaredFields();
        //獲取所有屬性
        for(Field f:fields) {
            System.out.println("屬性:"+f);
        }
        /*獲取類所有的方法
        PS:如果方法有參，則必須參數類型對應的Class對象
        Method m1=c.getDeclaredMethod("getName", null);
        Method m2=c.getDeclaredMethod("setName", String.class);*/
        Method[] methods=c.getMethods();
        for(Method m:methods) {
            System.out.println("方法:"+m);
        }
        //獲取類所有的構造器
        Constructor[] constructors=    c.getConstructors();
        for(Constructor con:constructors) {
            System.out.println("構造器:"+con);
        }
    }

    //通過反射調用構造方法，構造對象,創建記錄並將其放入集合中,然后打印出來
    public static void useConstructorByReflect() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Class c=Class.forName("com.reflection.Student");
        Constructor<Student> cr=c.getConstructor(int.class,String.class,String.class);
        Student s1=cr.newInstance(123,"張三","軟件一班");
        Student s2=cr.newInstance(456,"李四","軟件二班");
        List<Student> list=new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
        System.out.println("編號:"+list.get(0).getId()+" 姓名:"+list.get(0).getName()+" 班級:"+list.get(0).getCname());
        System.out.println("編號:"+list.get(1).getId()+" 姓名:"+list.get(1).getName()+" 班級:"+list.get(1).getCname());
    }

    //利用對象里面的方法來對 Student實體類進行初始化數據操作
    public static void useReflectMethod() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
        Class c2=Class.forName("com.reflection.Student");
        Student s3=(Student)c2.newInstance();
        //先獲取Class對象里面的方法
        Method m2=c2.getDeclaredMethod("setName", String.class);
        //使用該方法
        m2.invoke(s3, "王五");
        System.out.println("方法實現后獲取值為:"+s3.getName());
    }

    //對包含泛型的方法進行處理
    public static void getTypeAll() throws NoSuchMethodException, SecurityException {
        //獲取指定方法泛型參數信息
        Method m3=Reflect.class.getMethod("test01",Map.class,List.class);
        Type[] types=m3.getGenericParameterTypes();
        for(Type t:types) {
            System.out.println("#"+t);
            if (t instanceof ParameterizedType) {
                Type[] generalType=((ParameterizedType) t).getActualTypeArguments();
                for(Type gtype:generalType) {
                    System.out.println("泛型類型為:"+gtype);
                }
            }
        }
        //獲取指定方法泛型返回值信息
        Method m4=Reflect.class.getMethod("test02", null);
        Type returnType=m4.getGenericReturnType();
        if(returnType instanceof ParameterizedType) {
            Type[] generalType=((ParameterizedType) returnType).getActualTypeArguments();
            for(Type gtype:generalType) {
                System.out.println("返回值泛型類型為:"+gtype);
            }
        }
    }

    //動態編譯方法實現
    public static void testComplier() {
        JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
        int result=compiler.run(null,null,null,"");
        System.out.println(result==0?"編譯成功":"編譯失敗");
    }

    //構造一個帶泛型參數的方法
    public void test01(Map<String,Student> map,List<Student> stu){
        System.out.println("測試");
    }
    //構造一個帶泛型返回值的方法
    public Map<String,Student> test02(){
        return null;
    }

    //腳本引擎簡單使用
    public static void scriptEngine() throws ScriptException {
        //獲取腳本引擎對象
        ScriptEngineManager sem=new ScriptEngineManager();
        ScriptEngine engine=sem.getEngineByName("javascript");
        //定義變量存儲到腳本引擎的上下文中
        engine.put("msg", "我很喜歡敲代碼!");
        System.out.println("獲取到的信息為:"+engine.get("msg"));

        String str="var user= {name:'張三',age:18};";
        str +="print('用戶名:'+user.name);";
        //執行腳本
        engine.eval(str);
        //利用腳本引擎執行javascript的函數
        String st="function time() { var a=10,b=a*10;print('最終結果為:'+b);}; time();";
        engine.eval(st);           
    }
}

效果截圖:

 

ps:文章待完善，如存在不正之處歡迎大佬指出。