Java 反射

说起反射，每次学习后每次忘，在现在的工作中可能没他关注过，希望这次学习后，能明白现在哪些code是可以进行优化的。

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 每一个类都会生成一个Class类型的对象。

要正确使用Java反射机制就得使用java.lang.Class 这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。

1、Class类

Class是一个类，封装了当前对象所对应的类的信息。一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等。Class是用来描述类的类。

对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。

Class 对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例

获取Class对象的三种方式：

1：通过类名获取  类名.class()

2：通过对象获取   对象.getClass()

3：通过全类名获取   Class.forName(全类名)

package lesson1214;

public class Person {
    
    private String name;
    private int age;
    
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public Person(String name, int age){
        super();
        this.name = name;
        this.age = age;        
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }


    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }


    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }


    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }

}

package lesson1214;

import java.lang.reflect.Field;

public class ReflectionTest {

    public static void main(String[] args) throws ClassNotFoundException {
        // TODO Auto-generated method stub
        Class clazz = null;
        
        //1：通过类名.class获取Class对象
        clazz = Person.class;        
        Field []field = clazz.getDeclaredFields();
        
        //2：通过对象获取Class对象
        Person p1 = new Person();
        //这种方式是用在传进来一个对象，却不知道对象类型的时候使用
        Class clazz1 = p1.getClass();
        
        //上面这个例子的意义不大，因为已经知道person类型是Person类，再这样写就没有必要了
        //如果传进来是一个Object类，这种做法就是应该的
        Object obj = new Person();
        clazz1 = obj.getClass();
        
        //3.通过全类名(会抛出异常)
        //一般框架开发中这种用的比较多，因为配置文件中一般配的都是全类名，通过这种方式可以得到Class实例
        String name = "lesson1214.Person";
        Class clazz2 = Class.forName(name);   
        
        System.out.println(clazz2.getName());  //lesson1214.Person
        System.out.println(clazz==clazz1);  //true  在运行期间，每个类只有一个Class对象产生。
           System.out.println(clazz==clazz2);  //true
        //字符串的例子
        clazz = String.class;           
        clazz = "javaTest".getClass();           
        clazz = Class.forName("java.lang.String");
           
        System.out.println();

    }

}

Class 对象就是放在方法区中。并且只有一个。

Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该Class对象的一个实例
Object newInstance(Object []args)	调用当前格式构造函数，返回该Class对象的一个实例    （没有这个方法）
getName()	返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class [] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此Class所表示的实体的超类的Class

　Class类的newInstance（）方法

    public static void testRF() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        //1.获取Class对象
        Class clazz = Class.forName("lesson1214.Person");
        //2. 利用Class对象的newInstance方法创建一个类的实例
        Object obj = clazz.newInstance();  //对应Person类的无参构造函数，若没有无参构造函数，会出现抛异常。
        System.out.println(obj);
        
    }

可以看出确实是创建了一个Person实例
　　但是Person类有两个构造方法，到底是调用的哪一个构造方法呢？

　　实际调用的是类的无参数的构造器。所以在我们在定义一个类的时候，定义一个有参数的构造器，作用是对属性进行初始化，还要写一个无参数的构造器，作用就是反射时候用。一般地、一个类若声明一个带参的构造器，同时要声明一个无参数的构造器。想要通过newInstance()来创建类对象，必须有无参构造函数。

到现在大家对Class类应该有一点了解了。下面说Classloader

2: ClassLoader

 关于ClassLoader可以查看另一片介绍Java ClassLoader，里面解析清晰。这个地方只给出一个例子。理解双亲委托机制。

package lesson1214;

public class TestClassLoader {

    public static void main(String[] args) throws ClassNotFoundException {
        
        //1、获取一个系统类加载器，当前类就是通过它加载的        
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器： " + classLoader.getClass().getSimpleName());  //注意下这个打印
        
        //2、获取系统类加载器的父类加载器:扩展类加载器
        classLoader = classLoader.getParent();
        System.out.println("系统类加载器的父类加载器： " + classLoader);
        
        //3、获取扩展类加载器的父类加载器：引导类加载器 （不可获取，C语言编写）
        classLoader = classLoader.getParent();
        System.out.println("扩展类加载器的父类加载器： " + classLoader);
        
        //4、测试当前类由哪个加载器加载：系统类加载器
        classLoader = TestClassLoader.class.getClassLoader();
        System.out.println("当前类用的加载器： " + classLoader);
        
        //5. 测试 JDK 提供的 Object 类由哪个类加载器负责加载（引导类,不可获取）
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println("JDK 提供的 Object 类加载器 ：" + classLoader);     //引导类，获取不到，输出为null

    }
}

运行结果：看过ClassLoader总结后，应该对这个输出结果理解。

系统类加载器： AppClassLoader
系统类加载器的父类加载器： sun.misc.Launcher$ExtClassLoader@305f387c
扩展类加载器的父类加载器： null
当前类用的加载器： sun.misc.Launcher$AppClassLoader@4d885088
JDK 提供的 Object 类加载器 ：null

3：反射

Reflection(反射)是Java被视为动态语言的关键。反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并且直接操作任意对象的内部属性及方法。

Java反射机制主要提供了一下功能：

1）在运行时构造任意一个类的对象

2）在运行时获取任意一个类的所具有的成员变量和方法

3）生成动态代理

Class是一个类，一个描述类的类。封装了描述方法的Method, 描述字段的Filed,描述构造器的Constructor等属性。

3.1 如何描述字段filed

　　getField(String name);         getDeclaredField(String name);         getFields();         getDeclaredFields();

其中带有Declared的表示获取所有申明的字段，不管是"public"，"protected"，默认的还是"private"，

而不带Declared的表示获取的是申明为"public"的内容。

提供的构造方法不能获取父类的字段，如果字段是私有的，不管是读值还是写值，都必须先调用setAccessable(true)方法

package lesson1214;

import java.lang.reflect.Field;

public class TestFiled {

    public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
        //通过类名.class获取Class对象
        Class clazz = Person.class;
        
        //1、获取字段,获取所有字段，不管是public和private. 但不能获取父类字段
        Field [] fields = clazz.getDeclaredFields();
        for(Field field : fields){
            System.out.println(field.getName());   //name  age
        }
        
        //1.2可以获取指定字段
        Field field = clazz.getDeclaredField("name");
        System.out.println(field.getName());    //name
        
        
        Person person = new Person("zhangsan", 20);        
        //2 、使用字段
        //2.1获取指定对象的指定字段
        Object val = field.get(person);
        System.out.println(val);    //zhangsan
        
        //2.2设置指定对象的指定字段
        field.set(person, "zhaosi");
        System.out.println(person.getName());   //zhaosi
        
        //2.3如果字段是私有的，不管是读值还是写值，都必须先调用setAccessable(true)方法            
        field = clazz.getDeclaredField("age");  //注意age是private
        //System.out.println(field.getName()); //会报指正异常，无法访问。必须先调用setAccessable(true)

        field.setAccessible(true);
        System.out.println(field.getName());        //age
        System.out.println(field.get(person));      //20   
        
        //如果要访问父类中的变量，就必须自己实现
    }

}

3.2 描述构造

package lesson1214;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class TestConstructor {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //获取Class
        Class<Person> clazz = Person.class;
        
        //1.1通过getDeclaredConstructors()得到所有构造函数
        Constructor<Person>[] conds = (Constructor<Person>[]) clazz.getDeclaredConstructors();
        System.out.println("getDeclaredConstructors():");
        for(Constructor<Person> con : conds){            
            System.out.println(con);
        }
        
        System.out.println("getDeclaredConstructor():");
        //1.2通过getDeclaredConstructor()得到无参构造函数
        Constructor<Person> cond  = clazz.getDeclaredConstructor();
        System.out.println(cond);
        //1.3通过getDeclaredConstruetor(Class<?>... parameterTypes) 获取指定有参构造函数
        cond = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(cond);
        cond = clazz.getDeclaredConstructor(String.class);  //private构造函数
        System.out.println(cond);        
        
        
        System.out.println("getConstructors():");
        //1.4通过getConstructors()得到所有构造函数
        Constructor<Person>[] cons2 = (Constructor<Person>[]) clazz.getConstructors();
        for(Constructor<Person> con : cons2){
            System.out.println(con);
        }
        
        System.out.println("getConstructor():");
        //1.5通过getConstructor()获取无参构造函数
        Constructor<Person> con = clazz.getConstructor();
        System.out.println(con);
        //调用构造器的newInstance()方法创建对象
        Object obj = con.newInstance();
        
        //1.6通过getConstructor(Class<?>... parameterTypes)获取指定有参构造函数
        con = clazz.getConstructor(String.class,int.class);
        System.out.println(con);        
        //调用构造器的newInstance()方法创建对象        
        Object obj2 = con.newInstance("zhangsan",30);
        
        //con = clazz.getConstructor(String.class);  抛异常，get不到private 构造函数
        //System.out.println(con);    

    }

}

上面运行结果：

getDeclaredConstructors():==================
private lesson1214.Person(java.lang.String)
public lesson1214.Person(java.lang.String,int)
public lesson1214.Person()
getDeclaredConstructor():===================
public lesson1214.Person()
public lesson1214.Person(java.lang.String,int)
private lesson1214.Person(java.lang.String)
getConstructors():==========================
public lesson1214.Person(java.lang.String,int)
public lesson1214.Person()
getConstructor():===========================
public lesson1214.Person()
public lesson1214.Person(java.lang.String,int)

一种是获取所有的构造函数，getConstructors()和getDeclaredContructors()。

一种是获取指定的构造函数，getConstructor()和getDeclaredConstructor()。

在这么多的方法中，其中带有Declared的表示获取所有申明的构造方法，不管是"public"，"protected"，默认的还是"private"，

                                 而不带Declared的表示获取的是申明为"public"的内容。不带参数的表示获取所有能获取的构造方法，而带参数的表示构造方法的参数类型。

Class类中的newInstance()只能够调用无参的构造函数。 但是通过反射得到构造函数类Constructor中的newInstance(args[])是可以带参数的。

3.3 如何描述方法

　　 getMethod(String name,Class<?>...parameterTypes);

         getDeclaredMethod(String name,Class<?>...parameterTypes);

         getMethods();

         getDeclaredMethods();

         和前面介绍的差不多，这里介绍一下参数，第一个String name表示的是方法名，第二个是参数类型，若是无参函数，可以写null。

package lesson1214;

import java.lang.reflect.Method;

public class TestMethod {

    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("lesson1214.Person");
        
        //1.1通过getDlaredMethods()获取方法
        System.out.println("'getDeclaredMethods()=====all method=========");
        Method [] methods = clazz.getDeclaredMethods();
        for(Method method : methods){            
            System.out.println(method);            
        }
        
        //1.2通过getDeclaredMethod()获取指定方法
        System.out.println("getDeclaredMethod()=====specific method===========");
        Method methodd = clazz.getDeclaredMethod("getAge", null);
        System.out.println(methodd);    
        
        //1.3通过getMethods()获取所有public方法
        System.out.println("getMethods()===public all method=============");
        methods = clazz.getMethods();
        for(Method method : methods){            
            System.out.println(method);            
        }
        
        //1.4通过getMethod()获取指定public方法
        System.out.println("getMethod()===public specific method========");
        methodd = clazz.getMethod("setName", String.class);
        System.out.println(methodd);
        
    }
}

运行结果：

'getDeclaredMethods()=====all method=========
public java.lang.String lesson1214.Person.getName()
public void lesson1214.Person.setName(java.lang.String)
public int lesson1214.Person.getAge()
public void lesson1214.Person.setAge(int)
private void lesson1214.Person.getprivatemethod()
getDeclaredMethod()=====specific method===========
public int lesson1214.Person.getAge()
getMethods()===public all method=============
public java.lang.String lesson1214.Person.getName()
public void lesson1214.Person.setName(java.lang.String)
public int lesson1214.Person.getAge()
public void lesson1214.Person.setAge(int)
public java.lang.String lesson1214.BasePerson.getAddress()
public void lesson1214.BasePerson.setAddress(java.lang.String)
public int lesson1214.BasePerson.getNum()
public void lesson1214.BasePerson.setNum(int)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
getMethod()===public specific method========
public void lesson1214.Person.setName(java.lang.String)
 

从运行结果可以得出：

   getMethods()--获取取clazz对应类中的所有方法，不能获取private方法,且获取从父类继承来的所有方法

getDeclaredMethods()--获取所有方法，包括私有方法。但不能获取父类方法。

紧接着上面的code, get出来的方法怎么执行：

        //1.5 方法执行
        //  invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
        Person p1= (Person) clazz.newInstance();
        methodd.invoke(p1, "zhangsan");
        System.out.println(p1.getName());
        //私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;

调用方法通过methodd.invoke(obj, args) 

第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数。如果是静态函数，可以填null.下面给出例子：

私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）; field也是这个样子。

反射main方法

package lesson1214;

public class Person extends BasePerson {
    
    public static void main(String[] args) {
        System.out.println("main方法执行了。。。。。。。");
    }
}

package lesson1214;

import java.lang.reflect.Method;

public class TestMethod {

    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("lesson1214.Person");
        Method methodd = clazz.getMethod("main", String[].class);   //怎么传入参数
        System.out.println(String[].class);
        System.out.println(methodd);        

        //1.5 方法执行
        //  invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
        Person p1= (Person) clazz.newInstance();
        methodd.invoke(null, (Object)new String[]{"a","b","c"});   //这个地方必须强转
        //第一个参数，对象类型，因为方法是static静态的，所以为null可以，
        //第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
        //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。        
        
    }
}

控制台输出：

main方法执行了。。。

反射小结

 1. Class: 是一个类; 一个描述类的类.

　　封装了描述方法的 Method,

　　　　   描述字段的 Filed,

              描述构造器的 Constructor 等属性.
 
 2. 如何得到 Class 对象:
  　　2.1 Person.class
  　　2.2 person.getClass()
  　　2.3 Class.forName("com.atguigu.javase.Person")
  
 3. 关于 Method:
  　　3.1 如何获取 Method:
  　　　　1). getDeclaredMethods: 得到 Method 的数组.
  　　　　2). getDeclaredMethod(String methondName, Class ... parameterTypes)
  
  　　3.2 如何调用 Method
  　　　　1). 如果方法时 private 修饰的, 需要先调用 Method 的　setAccessible(true), 使其变为可访问
  　　　　2). method.invoke(obj, Object ... args);
  
  4. 关于 Field:
  　　4.1 如何获取 Field: getField(String fieldName)
  　　4.2 如何获取 Field 的值: 
  　　　　1). setAccessible(true)
  　　　　2). field.get(Object obj)
  　　4.3 如何设置 Field 的值:
  　　　　field.set(Obejct obj, Object val)
  
  5. 了解 Constructor 和 Annotation

上面这个是反射最基本的知识，后面争取添加一个反射的项目例子。

学到这，下面我们给出两个反射的例子，加深印象。

4.1反射方法的其它使用之---通过反射运行配置文件内容

Person类：

package lesson1214;

public class Person extends BasePerson {
    private int age;

    /**
     * @return the age
     */
    public int getAge() {
        System.out.println("hehe.....");
        return age;
    }
}

配置文件以txt文件为例子（pro.txt）

className=lesson1214.Person
methodName=getAge

测试类：

package lesson1214;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo {

    public static void main(String[] args) throws Exception {
        //通过反射获取Class对象
        Class personClass = Class.forName(getValue("className"));
        //通过反射获取方法
        Method method = personClass.getDeclaredMethod(getValue("methodName"));
        //调用方法        
        method.invoke(personClass.newInstance(),null);  
        method.invoke(personClass.newInstance());//若参数不需要传进去，可以不传
        
    }
    
    //此方法接收一个key，在配置文件中获取相应的value
    public static String getValue(String key) throws IOException{
        Properties pro = new Properties();
                
        //相对路径：相对路径名必须使用取自其他路径名的信息进行解释。
        //java.io 包中的类总是根据当前用户目录来解析相对路径名。此目录可以通过System.getProperty("user.dir");获取
        System.out.println(System.getProperty("user.dir"));   //  C:WorkspaceJava01
        //通过字符流和字节流都可以，还不知道两者在这个地方区别
        //FileReader in = new FileReader("C:/Workspace/Java01/src/lesson1214/pro.txt");
        FileInputStream fis = new FileInputStream("src/lesson1214/pro.txt");  //从src目录开始        
        
        pro.load(fis);
        fis.close();            
        return pro.getProperty(key);        
    }
}

控制台输出：

C:WorkspaceJava01
C:WorkspaceJava01
hehe.....
hehe.....

如果我们系统升级了，不需要Person类了，而需要写一个Person2时，这时只需要更改pro.txt的文件。

4.2、反射方法的其它使用之---通过反射越过泛型检查

泛型用在编译期间，编译过后泛型消失。 所以可以通过反射越过泛型检查。

测试类：

package lesson1214;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
//例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
public class Demo {
    public static void main(String[] args) throws Exception {
        
        List<String> lists = new ArrayList<String>();
        lists.add("abc");
        lists.add("efg");
        //list.add(100);  
        //The method add(int, String) in the type List<String> is not applicable for the arguments (int)
        
        Class clazz = lists.getClass();
        Method method = clazz.getDeclaredMethod("add", Object.class);
        method.invoke(lists, 100);  //注意这个地方写的是lists这个类
        
        //用迭代遍历集合
        Iterator it = lists.iterator();        
        while(it.hasNext()){
            System.out.println(it.next());            
        }
        //遍历集合
        for(Object list : lists){
            System.out.println(list);
        }
        
    }
}

控制台输出：
abc
efg
100
abc
efg
100
例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？上面就是典型例子，通过反射越过泛型检查。

转载：

https://www.cnblogs.com/tech-bird/p/3525336.html   关于反省和反射，这个地方没看。

http://www.coin163.com/it/3275193761898137281

https://blog.csdn.net/sinat_38259539/article/details/71799078   给出的反射例子，经典。