Java高新技术-反射

------- android培训、java培训、期待与您交流！ ----------

java的反射技术，其具体用途就是框架，不过作为初学者，对于框架是什么还很模糊，所以对于反射的理解有不够深入。似乎很多编程模式都有用到反射的技术，不过对于什么是编程模式，我也只有一个很模糊的认识，买了一本java编程模式，发现根本看不懂。同样吐槽一下《人月神话》，表示没到一定的阶段，这种书完全是天书。

好了，下面开始总结一下自己所学的：

一、反射的基础是类，也就是Class.class，里面有很多方法，有些方法可以获得内存中的字节码文件。而从这个字节码文件又可以获得对应类的构造方法、成员变量、成员方法、内部类。

先说一下拿到字节码文件的3种方法：

String obja = "abc";
Class clazz1 = obja.getClass();
Class clazz2 = Class.forName("java.lang.String");
Class clazz3 = String.class;

以上3个Class对象指向的是同一份字节码文件，所以三者是相等的。
拿到了Class对象，就可以调用一些方法获得其构造方法、成员变量、成员方法、内部类。

构造方法：

 Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
          返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 
 Constructor<?>[] getDeclaredConstructors() 
          返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。 
 Constructor<T> getConstructor(Class<?>... parameterTypes) 
          返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
 Constructor<?>[] getConstructors() 
          返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。 

成员变量

 Field getDeclaredField(String name) 
          返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 
 Field[] getDeclaredFields() 
          返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 
 Field getField(String name) 
          返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。 
 Field[] getFields() 
          返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。 

成员方法

 Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
          返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 
 Method[] getDeclaredMethods() 
          返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 
 Method getMethod(String name, Class<?>... parameterTypes) 
          返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
 Method[] getMethods() 
          返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 

虽然看起来方法很多，可是只要记住以下几点即可：
Method表示方法，Field表示成员变量，Constructor表示构造方法；后面加s表示一次获取多个。
因为类中的成员如果public修饰符，外部不能直接访问，所以有Declared的方法是可以获取到public和非public的成员的。如果没有Declared则表明获取public的。
因为java中允许有多个同名的方法（普通方法和构造方法），只要其传入参数的类型（包括）不同即可，所以在获取单个方法的时候，不光要指定方法的名称，还要指定参数的类型。

以下方法估计用的较少，就不额为写内容了。
内部类：（成员内部类）

 Class<?>[] getDeclaredClasses() 
          返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。 
 Class<?> getDeclaringClass() 
          如果此 Class 对象所表示的类或接口是另一个类的成员，则返回的 Class 对象表示该对象的声明类。 
 Class<?>[] getClasses() 
          返回一个包含某些 Class 对象的数组，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口。 

注解

 <A extends Annotation> A getAnnotation(Class<A> annotationClass) 
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。 
 Annotation[] getAnnotations() 
          返回此元素上存在的所有注释。 
 Annotation[] getDeclaredAnnotations() 
          返回直接存在于此元素上的所有注释。 

判定

 boolean isAnnotation() 
          如果此 Class 对象表示一个注释类型则返回 true。 
 boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 
          如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。 
 boolean isAnonymousClass() 
          当且仅当底层类是匿名类时返回 true。 
 boolean isArray() 
          判定此 Class 对象是否表示一个数组类。 
 boolean isAssignableFrom(Class<?> cls) 
          判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。 
 boolean isEnum() 
          当且仅当该类声明为源代码中的枚举时返回 true。 
 boolean isInstance(Object obj) 
          判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。 
 boolean isInterface() 
          判定指定的 Class 对象是否表示一个接口类型。 
 boolean isLocalClass() 
          当且仅当底层类是本地类时返回 true。 
 boolean isMemberClass() 
          当且仅当底层类是成员类时返回 true。 
 boolean isPrimitive() 
          判定指定的 Class 对象是否表示一个基本类型。 
 boolean isSynthetic() 
          如果此类是复合类，则返回 true，否则 false。 

一些复杂的方法

 Constructor<?> getEnclosingConstructor() 
          如果该 Class 对象表示构造方法中的一个本地或匿名类，则返回 Constructor 对象，它表示底层类的立即封闭构造方法。 
 Method getEnclosingMethod() 
          如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 Method 对象，它表示底层类的立即封闭方法。 
<U> Class<? extends U>  asSubclass(Class<U> clazz) 
          强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。 
 T cast(Object obj) 
          将一个对象强制转换成此 Class 对象所表示的类或接口。 
 boolean desiredAssertionStatus() 
          如果要在调用此方法时将要初始化该类，则返回将分配给该类的断言状态。 
 String getCanonicalName() 
          返回 Java Language Specification 中所定义的底层类的规范化名称。 
 Class<?> getComponentType() 
          返回表示数组组件类型的 Class。 
 Class<?> getEnclosingClass() 
          返回底层类的立即封闭类。 
 T[] getEnumConstants() 
          如果此 Class 对象不表示枚举类型，则返回枚举类的元素或 null。 
 Type[] getGenericInterfaces() 
          返回表示某些接口的 Type，这些接口由此对象所表示的类或接口直接实现。 
 Type getGenericSuperclass() 
          返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。 
 Class<?>[] getInterfaces() 
          确定此对象所表示的类或接口实现的接口。 
 ProtectionDomain getProtectionDomain() 
          返回该类的 ProtectionDomain。 
 URL getResource(String name) 
          查找带有给定名称的资源。 
 InputStream getResourceAsStream(String name) 
          查找具有给定名称的资源。 
 Object[] getSigners() 
          获取此类的标记。 
 Class<? super T> getSuperclass() 
          返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。 
 TypeVariable<Class<T>>[] getTypeParameters() 
          按声明顺序返回 TypeVariable 对象的一个数组，这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。 

几个比较简单的方法：

 int getModifiers() 
          返回此类或接口以整数编码的 Java 语言修饰符。 //参见java.lang.reflect.Modifier
 Package getPackage() 
          获取此类的包。 //简单
 ClassLoader getClassLoader() 
          返回该类的类加载器。 //后面的类加载器和讲代理的时候要用。
 T newInstance() 
          创建此 Class 对象所表示的类的一个新实例。 //用该类的空参数的构造方法。

二、自己研究反射方法的一些代码：

import java.lang.reflect.*;
import java.util.Arrays;
public class ReflectMethod {

    public static void main(String[] args) throws Exception {
        String obja = "abc";
        Class clazz1 = obja.getClass();
        Class clazz2 = Class.forName("java.lang.String");
        Class clazz3 = String.class;
        //证明是同一份字节码
        System.out.println(clazz1==clazz2);
        System.out.println(clazz1==clazz3);
        
        //想了解一下String.class中有哪些方法。
        int publicMethodsInString = 0;
        int otherMethodsInString = 0;
        int allMethodsInString = 0;
        //用增强for循环获取public方法
        for (Method c : clazz1.getMethods()  ){
            //打印各种方法。
            //System.out.println(c);
            publicMethodsInString++;
        }
        System.out.println("----------------------");
        //获取Declared方法。
        for (Method c : clazz1.getDeclaredMethods() ){
            //打印各种方法,包括私有,但打印后发现前者并不是后者的子集，发现此方法不会返回此类从父类继承的方法
            //System.out.println(c);
            otherMethodsInString++;
        }
        System.out.println("----------------------");
        //自己定义了一个静态方法，尝试获取类中所有的方法。
        for (Method c : allMethods(clazz1) ){
            //打印所有方法
            //System.out.println(c);
            allMethodsInString++;
        }
        //从下列语句看看获取的方法的数量
        System.out.println("publicMethods：" + publicMethodsInString + "  otherMethodsAtString:"+ otherMethodsInString +"  AllMethods:"+ allMethodsInString);
        System.out.println("+++++++++++++++++++++");
        for (Method c : allMethods(clazz1) ){
            //打印所有方法
            if (!Modifier.isPublic(c.getModifiers()))
                System.out.println(c);
            //79 -72 == 7 也打印了7条语句，说明是正确的。
        }
        System.out.println("");
        //来尝试一下理由反射使用String类中的非public方法。看了一下，决定尝试hash32这个方法（其他的参数太多，而且不懂是什么意思）。
        //第一遍写成了 clazz1.getMethod("hash32")抛出没有这个方法的异常;
        Method hash32Method = clazz1.getDeclaredMethod("hash32");
        //要暴力反射
        hash32Method.setAccessible(true);
        //每次打印结果都不一样，还真猜不出来这个是做什么的。就不去看源代码了。
        System.out.println(hash32Method.invoke("abc"));
    }
    //返回一个类的所有的方法的自定义方法。感觉过程略显罗嗦。
    public static Method[] allMethods(Class cla){
        int pubLength =  cla.getMethods().length;
        int otherLength = 0;
        Method[] pubM = cla.getMethods();
        Method[] otherM = cla.getDeclaredMethods();
        for (int x = 0 ; x < otherM.length; x++){
            if (!Modifier.isPublic(otherM[x].getModifiers())){
                otherLength++;
            }
        }
        int allLength = otherLength + pubLength;
        Method[] allM = new Method[allLength];
        for (int x = 0 ; x < pubLength; x++){
            allM[x] = pubM[x];
        }
        for (int x = 0 ,y =0; x < otherM.length; x++){
            if (!Modifier.isPublic(otherM[x].getModifiers())){
                allM[y + pubLength] = otherM[x];
                y++;
            }
        }
        return allM;
    }
}

三、反射成员变量的代码：

import java.io.*;
import java.lang.reflect.*;
public class ReflectField {
    //本来想在java中自带的类中找一个类做成员变量的反射的。结果发现，成员变量要么很麻烦，
    public static void main(String[] args) throws Exception {
        //在D盘上建了一个new.txt，里面的内容为：单行小写，双行大写：如
        //abcdefghijklmnopqrstuvwxyz0123456789
        //ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
        BufferedInputStream bufr = new BufferedInputStream(new FileInputStream("d:/new.txt"));
        Class clazz = bufr.getClass();
        //getFields()没有结果，试试getDeclaredFields()
        for (Field f : clazz.getDeclaredFields()){
            f.setAccessible(true);
            //System.out.println(f);
        }
        //需要暴力反射才行
        /*
        Field posField = clazz.getDeclaredField("pos");
        posField.setAccessible(true);
        //初始pos在0上，read一次之后，pos到了1.
        System.out.println(posField.get(bufr));
        System.out.println(bufr.read());
        System.out.println(posField.get(bufr));
        */
        //上面太麻烦了。我想了解一下所有的成员变量的变化情况
        for (Field f : clazz.getDeclaredFields()){
            f.setAccessible(true);
            System.out.println(f.getName()+":  "+f.get(bufr));
        }
        bufr.read();
        for (Field f : clazz.getDeclaredFields()){
            f.setAccessible(true);
            System.out.println(f.getName()+":  "+f.get(bufr));
        }
        //从运行结果可以看出一些BufferedInputStream的运作原理：
        //默认的buf是8k的。
        //在第一次read的时候，才会去硬盘读取文件。因为read前，count为0，read后，count为378（我的文件共10行，每行38个byte，26个字母、10个数字、换行符、回车符，而且我最后一行没有换行）
        //猜测count是文件的大小。为例进一步研究，必须找一个大于8k的文件，我从系统目录下复制了Explorer.exe作为实验载体。
        bufr.close();
        
        BufferedInputStream bufr2 = new BufferedInputStream(new FileInputStream("d:/explorer.exe"));
        for (Field f : clazz.getDeclaredFields()){
            f.setAccessible(true);
            System.out.println(f.getName()+":  "+f.get(bufr2));
        }
        //x< 1;x< 100;x< 8192;x< 8193;x< 10000;表示分别读x次。
        for(int x = 0;x <10000;x++)
            bufr2.read();
        for (Field f : clazz.getDeclaredFields()){
            f.setAccessible(true);
            System.out.println(f.getName()+":  "+f.get(bufr2));
        }
        bufr.close();
        //查看打印结果后发现，count其实不是文件大小。为了搞清楚。必须多read几次。研究后发现只有pos在变化count其实=bufr2.read(buf);
        //还是尝试更改pos的值试试。
        BufferedInputStream bufr3 = new BufferedInputStream(new FileInputStream("d:/new.txt"));
        Class clazz3 = bufr3.getClass();        
        Field posField2 = clazz3.getDeclaredField("pos");
        posField2.setAccessible(true);
        System.out.println(bufr3.read());//97
        posField2.get(bufr3);
        System.out.println(bufr3.read());//98
        posField2.get(bufr3);
        //更改pos的值为0，看read的结果
        posField2.set(bufr3,0);
        System.out.println(bufr3.read());//97,证实pos和和read方法有关系
        bufr3.close();
    }
}

四、反射构造方法的代码（简单的）：

import java.lang.reflect.*;
public class ReflectConstrator {
    //Sting.class的构造方法比较多，我们来看一下
    public static void main(String[] args) throws Exception {
        Class clazz = String.class;
        //getDeclaredConstructors()发现Constructors()比多2个构造方法。
        //java.lang.String(int,int,char[])
        //java.lang.String(char[],boolean)
        Constructor[] cons = clazz.getDeclaredConstructors();
        for (Constructor con: cons){
            System.out.println(con);
        }
        //试试这两个方法
        char[] chs = {'a','b','c','w','x','y','z','9'};
        Constructor con1 =clazz.getDeclaredConstructor(int.class,int.class,char[].class);
        con1.setAccessible(true);
        String str1 = (String) con1.newInstance(2,5,chs);
        System.out.println(str1);
        //发现此构造方法的使用应该和public java.lang.String(char[],int,int)一致，只是参数顺序不同。所以没有必要对外提供。
        /*Constructor con3 =clazz.getDeclaredConstructor(char[].class,int.class,int.class);
        con3.setAccessible(true);
        String str3 = (String) con3.newInstance(chs,2,5);
        System.out.println(str3);*/
        //试一下第二种构造方法，
        Constructor con2 =clazz.getDeclaredConstructor(char[].class,boolean.class);
        con2.setAccessible(true);
        String str2 = (String)con2.newInstance(chs, true);
        System.out.println(str2);
        String str4 = (String)con2.newInstance(chs, false);
        System.out.println(str4);
        //第二个参数设置为true和false打印结果居然一致，奇怪。那么其用法英格和public java.lang.String(char[])一致。
        Constructor con4 =clazz.getDeclaredConstructor(char[].class);
        String str6 = (String)con4.newInstance(chs);
        System.out.println(str6);
        //的确如此
    }
}

五、总结

反射的基础应用还是很简单的。尤其Constructor Field Method这3个类中的方法，看一下api文档就知道是干什么的了。

但是高级应用，就比较复杂了，需要多学习几遍张老师的视频，虽然张老师讲得不是特别适合初学者，不过多听几遍应该能懂。

转载于:https://www.cnblogs.com/qinbin/archive/2013/01/03/java-reflect.html