黑马程序员---Java反射

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

2015.10.15

Class类

Class类的实例表示正在运行的类和接口。Class实例不可以显示创建，而是在类被加载时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
JVM的内存区，除了包含栈，堆外，还有方法区，这是系统分配给JVM的一个存储类型信息的逻辑内存。存储的类型信息包括以下几部分：
1：类的基本信息：使用的JDK版本号。
2：类的详细信息：
（1）常量池：存储与该类有关的所有常量，例如final变量、类名、方法名等。
（2）字段信息：类中声明的每一个字段的信息。如名称、类型、修饰符。例如：private String name=”Most_want” ;字段名是name，类型是String，修饰符是private。
（3）方法信息：类中声明的每一个方法。包含修饰符、返回值类型、方法名、参数类型、异常、方法的字节码文件。
（4）静态区：类中声明的静态变量。
（5）类的ClassLoader引用：该类的类加载器的引用。
（6）Class实例：该类在被JVM加载时生成的Class实例，用来代表被加载的类。
JVM启动后，要使用的类的.class二进制文件就会被加载到方法区生成以上信息。所以可以看到，Class实例是在JVM加载类时候就被自动创建了。在Java中数组也有Class实例，所有具有相同元素类型、维度的数组都共享一个Class实例。基本的Java数据类型（boolean byte short char int long float double）和关键字void也表示为一个Class对象。

获取这个实例有以下几个方法：
通过Object类的getClass()获取。
通过Class类的静态方法：forName()得到。
通过.class获取。
例如获取String类的Class对象：

public class Test{
    public static void main(String[] args)throws Exception{
        String str="Most_want"; 
        Class c1=str.getClass();
        Class c2=Class.forName("java.lang.String");
        Class c3=String.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

打印结果均为：class java.lang.String

反射

Java中的所有类都是Class类的对象。我们知道类是结构相同的对象的一种抽象，类中包含字段和方法。同理，Class类是所有类的抽象，所以它包含每个类的构造属性(Constructor)字段属性(Field)和方法属性(Method)。其实，Constructor、Field、Method都是一个类，它们以数组存储Class实例代表的类型信息。Filed类中包含有有关类或接口的单个字段的信息，Constructor类提供关于类的单个构造方法的信息以及对它的访问权限，Method类提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。因此，通过Class实例访问该Class实例对象所代表的的类的类型信息就是反射的基础。
理解了上述之后，再来看下反射机制：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
**所以反射的使用过程大致如下步骤：
A：获取类的Class对象
B：获取需要的属性：构造属性(Constructor对象)字段属性：(Field对象)和方法属性：(Method对象)
C：同过属性对象调方法来创建对象、获取字段或调用方法**

例如：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Person类的Class实例
        Person p = new Person();
        Class c = p.getClass();
        // 获取Person类的有参构造属性对象
        Constructor con = c.getConstructor(String.class);
        // 新建一个Person对象
        Person p2 = (Person) con.newInstance("Most_want");
        p2.show();
        // 获取Person类的名为"name"字段属性对象
        Field field = c.getField("name");
        // 把p2的name字段设置为“小李”
        field.set(p2, "小李");
        p2.show();
        // 获取Person类的名为"show"，无参的方法
        Method method = c.getMethod("show", null);
        //通过p2调用Person类的method所表示的方法
        method.invoke(p2, null);
    }
}
//自定义Person类
class Person {
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("Person  name=" + name);
    }
}

我们知道这个JVM加载时把被加载类的所有信息加载到内存，那么private修饰的字段或方法能不能被获取
例如获取当把Person类的”name”私有化后要怎么获取：

import java.lang.reflect.*;

public class Test {
    public static void main(String[] args) throws Exception {
                Person p = new Person();
        Class c = p.getClass();
        //直接获取会抛出异常
        //Field field = c.getField("name");
        //用下面的方法可以获取任何Method属性
        Field field=c.getDeclaredField("name");
        //设置忽略语法检查
        field.setAccessible(true);
        field.set(p, "小李");
        p.show();
    }
}
class Person {
    pricate String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("Person  name=" + name);
    }
}

上面的例子演示了获取私有字段的方法，获取私有方法私有构造的等同。
下面探讨下private 、protected 、public 三种权限的方法属性的获取差别：

public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Person类的Class实例
        Person p = new Person();
        Class<? extends Person> c = p.getClass();
        Method m1 = null;
        Method m2 = null;
        Method m3 = null;
        Method m4 = null;
        // 私有方法的获取
        m1 = c.getDeclaredMethod("show1", null);
        m1.setAccessible(true);
        m1.invoke(p, null);

        // 受保护方法的获取
        m2 = c.getDeclaredMethod("show3", null);
        // 无需进行语法设置
        // m2.setAccessible(true);
        m2.invoke(p, null);

        // 最高权限方法的获取
        // 普通方法即可
        m3 = c.getMethod("show2", null);
        // m3 = c.getDeclaredMethod("show2", null);
        // m3.setAccessible(true);
        m3.invoke(p, null);

        // 默认权限方法的获取
        // 此方法抛出异常
        // m4=c.getMethod("show4", null);
        m4 = c.getDeclaredMethod("show4", null);
        // 无需语法设置
        // m4.setAccessible(true);
        m4.invoke(p, null);
    }
}

class Person {
    public Person() {
    }

    private void show1() {
        System.out.println("这是 private viod show1()");
    }

    public void show2() {
        System.out.println("这是 public void show2()");
    }

    protected void show3() {
        System.out.println("这是 protected void show2()");
    }

    void show4() {
        System.out.println("这是 void show2()");
    }

}

由以上例子可以总结：
public修饰的方法，直接获取。
private修饰的方法，需要getDeclaredMethod()获取，并关闭语法检查。
protected修饰的方法，需要getDeclaredMethod()获取，无需关闭语法检查。
默认权限的方法，需要getDeclaredMethod()获取，无需关闭语法检查。
在使用反射的时候，一般我们不知道被反射使用的类型信息，所以etDeclaredMethod()和setAccessible()联用，同理Filed和Constructor的获取一致。

例如：用反射原理制作一个修改任意类对象的字段的方法。

public static void setField(Object obj,String fieldname,Object args)throws Exception{
    Class c=obj.getClass();
    Field field=c.getDeclaredField(fieldname);
    field.setAccessible(true);
    field.set(obj, args);       
}   

---

动态代理

利用代理可以提供原对象类不具有的额外的功能，例如日志记录，权限检查。Java中利用反射实现的代理就是动态代理。Java中默认包中提供了对接口的代理。代理主要使用java.lang.reflect包中的proxy类和HandlerInvocation接口
用到的方法：
Object invoke(Object proxy, Method method,Object[] args)throws Throwable
在代理实例上处理方法调用并返回结果。proxy是在其上调用方法的代理实例，method是被代理的方法，args是方法的参数如果有的话。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
loader是被代理对象的类加载器，interfaces是被代理类的接口数组，h是实现HandlerInvocation接口的引用变量。

以下例子演示了利用代理统计List集合add()耗时：

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;
//自定义InvocationHandler实现类
class MyInvocationHandler implements InvocationHandler {
    //被代理的类
    Object target;

    public MyInvocationHandler(Object target){
        this.target=target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.setAccessible(true);
        //添加自定义语句
        long start=System.currentTimeMillis();
        //调用被代理类的方法
        Object result=method.invoke(target, args);
        //添加自定义语句
        long end=System.currentTimeMillis();
        System.out.println("方法调用耗时: "+(end-start)+" (millisecond)");
        return result;
    }
}

public class 静态方法对象调用 {
    public static void main(String[] args) throws Exception {
        //创建接口引用类变量
        List list=new ArrayList();
        //创建自定义InvocationHandler引用变量
        InvocationHandler i=new MyInvocationHandler(list);
        //获取list的代理类
        List proxy=(List)Proxy.newProxyInstance(list.getClass().getClassLoader(), list.getClass().getInterfaces(), i);
        //用代理对象调用方法
        proxy.add("Most_want");

    }
}

由此我们可以总结出代理的基本使用步骤：
A：创建自定义InvocationHandler实现类并重写invoke();
B：创建InvocationHandler引用变量并实例化；
C：创建Proxy实例对象
D：通过C步骤获取的代理对象调用方法。

Class类的 API中常用的几个方法：
创建一个此Class对象代表的类的一个新实例。此方法和调用该类型的空的构造方法创建实例效果一样。
public T newInstance()例如：String a=String.class.newInstance();

获取Class实例代表的（类、接口、数组、基本类型或void）的名称：
String getName()

获取Class实例代表的实体的类加载器：
ClassLoader getClassLoader()

判断Class实例代表的类是否为数组
boolean isArray()

判断Class实例代表的类是否为枚举类
boolean isEnum ( )

获取Class实例代表的实体的超类
Class< ? super T > getSuperclass()

示例
下面的代码利用反射技术打印出一个类的信息：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//输入一个完全限定类名，打印出该类的所有字段
public class PrintClass {
    // 被反射的Class对象
    private Class target;

    // 带Class类型参数的构造器
    public PrintClass(Class target) {
        this.target = target;
    }

    // 方法参数为String的构造器，如果指定的字符串无法转换为Class对象，那么抛出异常
    public PrintClass(String target) throws IllegalStateException {
        try {
            this.target = Class.forName(target);
        } catch (Exception e) {
            throw new IllegalStateException("cannot found this Class");
        }
    }

    // 打印该Class的所有信息
    public void printAllMsg() {
        printFields();
        System.out.println("\n\n");
        printConstructors();
        System.out.println("\n\n");
        printMethods();
    }

    // 打印target对象代表的类的所有构造方法
    public void printConstructors() {
        // 获取target的构造器对象数组
        Constructor[] constructors = target.getDeclaredConstructors();
        if (constructors.length == 0)
            return;
        // 遍历该数组，打印每一个构造器的信息
        for (Constructor con : constructors) {
            // 对该构造器对象取消语法检查
            con.setAccessible(true);
            // 构造器的修饰符
            int mod = con.getModifiers();
            String mods = Modifier.toString(mod);
            System.out.print("  " + mods);// 打印修饰符
            // 构造器的名字
            String name = con.getName();
            System.out.print("  " + name);
            // 构造器的参数
            Class[] paramClasses = con.getParameterTypes();
            System.out.print("(");
            // 参数至少为1个才进行打印
            if (paramClasses.length > 0) {
                for (int i = 0; i < paramClasses.length; i++) {
                Class c = paramClasses[i];
                    if (c.isArray()) {
                        Class componentType = c.getComponentType();
                        String[] names = componentType.toString().split("\\.");
                        int index = names.length - 1;
                        String arrName = names[index];
                        System.out.print(" " + arrName + "[]");
                    } else {
                        int off = c.toString().lastIndexOf('.') + 1;
                        String paramClassName = c.toString().substring(off);
                        System.out.print(" " + paramClassName);
                    }
                    if (i < paramClasses.length - 1) {
                        System.out.print(",");
                    }
                }
            }
            System.out.println(");");
        }

    }

    // 打印target对象代表的类的所有字段
    public void printFields() {
        // 获取target的字段对象数组
    Field[] fields = target.getDeclaredFields();
        if (fields.length == 0)
            return;
        // 遍历该数组，打印每一个字段的信息
        for (Field fie : fields) {
            // 对该字段对象取消语法检查
            fie.setAccessible(true);
            // 字段的修饰符
            int mod = fie.getModifiers();
            String mods = Modifier.toString(mod);
            System.out.print("  " + mods);// 打印修饰符
            // 字段的类型
            Class c = fie.getType();
            if (c.isArray()) {
                Class componentType = c.getComponentType();
                String[] names = componentType.toString().split("\\.");
                int index = names.length - 1;
                String arrName = names[index];
                System.out.print(" " + arrName + "[]");
            } else {
                String fieldClassName = c.toString();
                Pattern p = Pattern.compile("[a-zA-Z]+$");
                Matcher m = p.matcher(fieldClassName);
                if (m.find())
                    fieldClassName = m.group();
                System.out.print(" " + fieldClassName);
            }
            // 字段的名字
            String name = fie.getName();
            System.out.println(" " + name + ";");

        }

    }

    // 打印target对象代表的类的所有方法
    public void printMethods() {
        // 获取target的方法对象数组
        Method[] methods = target.getDeclaredMethods();
        if (methods.length == 0)
            return;
        // 遍历该数组，打印每一个方法信息
        for (Method method : methods) {
            // 对该方法对象取消语法检查
            method.setAccessible(true);

            // 方法的修饰符
            int mod = method.getModifiers();
            String modifiers = Modifier.toString(mod);
            System.out.print("  " + modifiers);// 打印修饰符

            // 方法的返回类型
            Class returnClass = method.getReturnType();
            String returnClassName = null;
            if (returnClass.equals(void.class)) {
                returnClassName = "void";
            } else if (returnClass.isArray()) {
                Class componentType = returnClass.getComponentType();
                String[] names = componentType.toString().split("\\.");
                int index = names.length - 1;
                String arrName = names[index];
                returnClassName = arrName + "[]";
            } else {
                int offset = returnClass.toString().lastIndexOf('.') + 1;
                returnClassName = returnClass.toString().substring(offset);
            }
            System.out.print(" " + returnClassName);

            // 方法名
            String name = method.getName();
            System.out.print(" " + name);

            // 方法参数
            Class[] paramClasses = method.getParameterTypes();
            System.out.print("(");
            // 参数至少为1个才进行打印
            if (paramClasses.length > 0) {
                for (int i = 0; i < paramClasses.length; i++) {
                    Class c = paramClasses[i];
                    if (c.isArray()) {
                        Class componentType = c.getComponentType();
                        String[] names = componentType.toString().split("\\.");
                        int index = names.length - 1;
                        String arrName = names[index];
                        System.out.print(" " + arrName + "[]");
                    } else {
                        int off = c.toString().lastIndexOf('.') + 1;
                        String paramClassName = c.toString().substring(off);
                        System.out.print(" " + paramClassName);
                    }
                    if (i < paramClasses.length - 1) {
                        System.out.print(",");
                    }
                }
            }
            System.out.println(" )");

        }
    }

        public static void main(String[] args) throws IllegalStateException {
        new PrintClass(String.class).printAllMsg();
        // new PrintClass("java.lang.Object").printAllMsg();
    }

}