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:文章待完善，如存在不正之处欢迎大佬指出。