Java动态性之--反射机制

1. 动态语言

程序运行时，可以改变结构或变量类型。典型的语言：

Python、ruby、javascript等

如下javascript代码

function test(){

var s = "var a=3;var b=5;alert(a+b);";

eval(s);

}

C,C++,java不是动态语言，java可以称之为“准动态语言”。但是java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性

java的动态性让编程的时候更加灵活！

2. 反射机制reflection

指的是可以于运行时加载、探知、使用编译其完全未知的类。

程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；

　　　　Class c = Class.forName(cn.stu.test.User);

加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所有，我们形象的称之为：反射

例1：

public class Demo01 {
public static void main(String[] args) {
String path = "cn.stu.ref.bean.User";

try {
//方法一
Class clazz = Class.forName(path);
//
/**
* ==================================
* 对象时表示或封装一些数据。一个类被加载后，
* JVM会创建一个对应该类的Class对象
* 类的整个结构信息会会放到对应的Class对象中。
* 这个Class对象就是一面镜子一样，
* 通过这面镜子我们可以看到对应类的全部信息
* ===================================
*/
System.out.println(clazz.hashCode());
//一个类只对应一个Class对象
Class clazz2 = Class.forName(path);
System.out.println(clazz2.hashCode());

//方法二
Class strClass = String.class;
Class strClass2 = path.getClass();
System.out.println(strClass==strClass2);

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

3. Class类介绍

当一个class被加载，或当加载器（class loader）的defineClass（）被JVM调用，JVM便自动产生一个Class对象

Class类似Reflection的根源

针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

Class类的对象如何获取？

运用getClass()

运用Class.forName() --常用

运用.class语法

例2：

public class Demo02 {

public static void main(String[] args) {
String path = "cn.stu.ref.bean.User";
try {
Class clazz = Class.forName(path);

//获取类的名称
System.out.println(clazz.getName());//类名+包名
System.out.println(clazz.getSimpleName());//类名

//获取属性名
Field[] fields = clazz.getFields(); //只能获得public的属性
Field[] fields2 = clazz.getDeclaredFields();//获得所有属性
Field field = clazz.getDeclaredField("name");//获取指定name属性

//获取方法名称
Method[] method = clazz.getDeclaredMethods();
Method m1 = clazz.getDeclaredMethod("getName", null);
//如果方法有参，则必须传递参数类型对应的class对象
Method m2 = clazz.getDeclaredMethod("setName", String.class);

//获取构造器
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

例3：

public class Demo03 {
public static void main(String[] args) {
String path = "cn.stu.ref.bean.User";

try {
Class clazz = Class.forName(path);

//通过反射API调用构造方法，构造对象
User u = (User) clazz.newInstance();//其实是调用了User的无参构造方法

Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
User u2 = (User) c.newInstance(1001,18,"张三");

//通过反射API调用普通方法
User u3 = (User) clazz.newInstance();
Method method = clazz.getDeclaredMethod("setName", String.class);
method.invoke(u3,"李四"); //u3.setName("李四")

//通过反射API操作属性
User u4 = (User) clazz.newInstance();
Field f = clazz.getDeclaredField("name");
f.setAccessible(true);//不做安全检查，直接访问
f.set(u4, "二麻子"); //通过反射直接写属性
String name = u4.getName();
String name2 = (String) f.get(u4); //通过反射直接读属性的值
} catch (Exception e) {
e.printStackTrace();
}
}
}

4. 反射机制性能问题

setAccessible

启动和金庸访问安全检查的开关，值为true 则指示反射的对象在使用时应该取消java语言访问检查，值为false 则指示反射的对象应该实施java语言访问检查。并不是true就能访问，false就不能访问。

禁止安全检查，可以提高反射的运行速度

可以考虑使用： cglib/javaassist字节码操作

例4：

/**
* 通过跳过安全检查，提高反射效率
* 三种执行方法的效率差异比较
*/
public class Demo04 {

public static void test01(){
User u = new User();

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {
u.getName();
}

long endTime = System.currentTimeMillis();
System.out.println("普通方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
}

public static void test02() throws Exception{
User u = new User();
Class clazz = u.getClass();
Method m = clazz.getDeclaredMethod("getName", null);
//        m.setAccessible(true);

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {
m.invoke(u, null);
}

long endTime = System.currentTimeMillis();
System.out.println("反射动态方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
}

public static void test03() throws Exception{
User u = new User();
Class clazz = u.getClass();
Method m = clazz.getDeclaredMethod("getName", null);
m.setAccessible(true);    //不需要执行访问安全检查

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {
m.invoke(u, null);
}

long endTime = System.currentTimeMillis();
System.out.println("反射动态方法调用，跳过安全检查，执行10亿次，耗时："+(endTime-startTime)+"ms");
}

public static void main(String[] args) throws Exception {
test01();
test02();
test03();
}
}

输出结果：

　　　　普通方法调用，执行10亿次，耗时：6665ms
　　　　反射动态方法调用，执行10亿次，耗时：62947ms
　　　　反射动态方法调用，跳过安全检查，执行10亿次，耗时：11864ms

　

5. 反射操作泛型

java采用泛型擦除的机制来引入泛型。java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的麻烦，但是，一旦编译完成，所有的和泛型有关的类型全部擦除。

为了通过反射操操作这些类型以迎合实际开发的需要，java就新增了ParameterzedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被诡异到Class类中的类型但是又和原始类型齐名的类型。

ParmterizedType: 表示一种参数化的类型，比如Collection<String>

GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardType：代表一种通配符类型表达式