反射API

反射

java反射机制就是在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法，对于任意一个

对象，都能够调用它的任一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能叫java

语言的反射机制。

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

在运行时判断任意一个对象所属的类

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

在运行时判断任意一个类所具有的成员变量和方法

在运行时调用任意一个对象的方法；生成动态代理

编译和运行：编译时刻加载类是静态加载类、运行时刻加载类是动态加载类

大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。

java反射机制：程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言

Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

原理：

反射的作用：

假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。

当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。

一、反射的API

简述：我们写的所有类，都被appclassloader加载到内存的方法去，生成一个Class类型的对象，他们都

是你写的class，但同时他们也是Class的实例，也叫说明书的说明书。

Class叫说明书的说明书，告诉我们说明书该怎么写，比如可以有方法，属性等等。

Java反射所需要的类不多，主要在java.lang.class类和java,.lang.reflect包中的Field、Constructor、

Method、Annotation类。

注意：Class类是java反射的起源，针对任何一个你想探勘的类，只有先让它产生一个Class类的对象，

接下来才能通过Class对象获取他想要的信息

二、基本反射技术

1.1 根据一个字符串得到一个类

​ getClass方法

String name = "shy";
Class c1 = name.getClass();
System.out.println(c1.getName());

​ Class.forName

比如我们获取java.lang.String的类名

String name = "java.lang.String";
Class c1 = null;
try {
    c1 = Class.forName(name);
    System.out.println(c1.getName());
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

这里也通过捕获异常，因为我们传的这个字符串可能不合法，字符串合法命名是类的命名空间和类的名称组成

我们还可以通过c1.getSuperclass()获取到他的父类

​ Type属性

基本类型都有type属性，可以得到这个基本类型的类型

Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Float.TYPE;
Class c4 = Double.TYPE;

三、获取类的成员

当类中方法定义为私有的时候我们能调用？不能！当变量是私有的时候我们能获取吗？不能！但是反射可以，比如源码中有你需要用到的方法，但是那个方法是私有的，这个时候你就可以通过反射去执行这个私有方法，并且获取私有变量。

获取类的构造函数

为了便于测试，我们定义一个Test类，Test类如下：

package com.shy.entity;

public class Test {
    private String name;
    private int age;
    private int testInt;

    public Test(int age){
        this.age = age;
    }

    public Test(String name,int age){
        this.age = age;
        this.name = name;
    }

    private Test(String name){
        this.name = name;
    }

    public Test(){};
}

下面我们通过反射获取这些构造方法

​ 获取类的所有构造方法

Test test = new Test();
Class c4 = test.getClass();
Constructor[] constructors;
constructors = c4.getDeclaredConstructors();

通过getDeclaredConstructors可以返回类的所有构造方法，返回的是一个数组因为构造方法可能不止一个

通过getModifiers可以得到构造方法的类型

通过getParameterTypes可以得到构造方法的所有参数，返回的是一个Class数组

所以我们如果想获取所有构造方法以及每个构造方法的参数类型，可以有如下代码：

for (int i = 0; i < constructors.length; i++) {
     System.out.println(Modifier.toString(constructors[i].getModifiers())+"参数:");
     Class[] paramterTypes = constructors[i].getParameterTypes();
     for (int j = 0; j < paramterTypes.length; j++) {
          System.out.println(paramterTypes[j].getName() + " ");
     }
     System.out.println("");
}

结果如下：

public参数:
private参数:java.lang.String 
public参数:
java.lang.String 
int 
public参数:int 

这样我们就得到了类中所有构造方法和构造方法中的参数，那么我们如何获取特定的构造方法呢？

获取类中特定的构造方法

我们可以通过getConstructors方法获取类中 所有的public类型的构造方法，代码和上面一样就不演示了。

我们可以通过getDeclaredConstructor()方法传参获取特定参数类型的构造方法，这里注意是getDeclaredConstructor()不是 getDeclaredConstructors() ，所以返回的是一个Class对象而不是一个Class数组。

获取无参构造方法直接不传参数，这里要进行异常捕获，因为可能不存在对应的构造方法。

try {
      constructors = c4.getDeclaredConstructor();
      System.out.println(Modifier.toString(constructors.getModifiers()));
} catch (NoSuchMethodException e) {
      e.printStackTrace();
}

结果入下：

public

如果我们想获取有两个参数分别为int和String类型的构造方法，代码如下：

		Class[] p = {String.class,int.class};
        try {
            constructors = c4.getDeclaredConstructor(p);
            System.out.println(Modifier.toString(constructors.getModifiers()) + "参数：");
            Class[] parameterTypes = constructors.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++) {
                System.out.println(parameterTypes[i].getName() + "");
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

结果如下：

public参数：
java.lang.String
int

调用构造方法

从这里开始慢慢到了关键的一步，得到类的实例，我们主要借助于newInstance方法，为了方便演示我们将测试类的两个构造方法打印出来.

	public Test(String name,int age){
        this.age = age;
        this.name = name;
        System.out.println("hello " + name + "i am " + age);
    }

    private Test(String name){
        this.name = name;
        System.out.println("My name is " + name);
    }

我们先来调用public的方法，如下所示:

Class[] p = {int.class,String.class};
constructors = c4.getDeclaredConstructor(p);
constructors.newInstance("shy",18);

结果如下：

hello shyi am 18

那么调用私有构造方法呢，和上面一样，只是我们要设置constructors.setAccessible(true);代码如下

Class[] p = {String.class};
constructors = c4.getDeclaredConstructor(p);
constructors.setAccessible(true);
constructors.newInstance("shy");

结果如下：

My name is shy

调用类的私有方法

如何调用类中的私有方法呢，我们先在测试类中编写一个测试的私有方法,

private void hello(String tips){
    System.out.println(tips);
}

我们知道如果我们要正常的调用类的方法都是通过类.方法调用，所以我们调用私有方法也需要得到类的实例，而我们上面newInstace已经得到了类的实例，这样就好办了。

Class[] p = {String.class};
Method method = c4.getDeclaredMethod("hello",p);
method.setAccessible(true);

我们首先通过 getDeclaredMethod方法获取到这个私有方法，第一个参数是方法名，第二个参数是参数类型

然后通过invoke方法执行，invoke需要两个参数一个是类的实例，一个是方法参数。

Class[] p = {String.class};
Method method = c4.getDeclaredMethod("hello",p);
method.setAccessible(true);
Object args1[] = {"wo cao"};
method.invoke(test,args1);

test类的实例当不能new 获取的时候我们也可以通过反射获取，就是上面的newInstance方法。打印结果如下

wo cao

获取类的私有字段并修改值

看到这里你可能会说，有了set方法，什么私有不私有，test.set不就可以了，但是这里要注意我们是没有办法得到这个类的实例的，要不然都可以得到实例就没有反射一说了。我们在通过反射得到类的实例之后先获取字段：

Test test = new Test();
Class c4 = test.getClass();
Constructor o = null;
o = c4.getDeclaredConstructor();
Object o1 = o.newInstance();
Field field = c4.getDeclaredField("name");
field.setAccessible(true);
field.set(o1,"shy");
System.out.println(field.get(o1).toString());

o是我们上面通过反射构造方法获取的实例， 打印field.get(o).toString()的值如下:

shy

不过要注意的是我们修改了name的值只对当前的实例对象有效.

public class Reflex {
 
    /**
     * 获取无参构造函数
     * @param className
     * @return
     */
    public static Object createObject(String className) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
 
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    /**
     * 获取无参构造方法
     * @param clazz
     * @return
     */
    public static Object createObject(Class clazz) {
        Class[] pareTyple = new Class[]{};
        Object[] pareVaules = new Object[]{};
 
        return createObject(clazz, pareTyple, pareVaules);
    }
 
    /**
     * 获取一个参数的构造函数  已知className
     *
     * @param className
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object createObject(String className, Class pareTyple, Object pareVaule) {
 
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
 
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
 
    /**
     * 获取单个参数的构造方法 已知类
     *
     * @param clazz
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
 
        return createObject(clazz, pareTyples, pareVaules);
    }
 
    /**
     * 获取多个参数的构造方法 已知className
     * @param className
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
 
    /**
     * 获取构造方法
     *
     * @param clazz
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
        try {
            Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
            ctor.setAccessible(true);
            return ctor.newInstance(pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
 
    /**
     * 获取多个参数的方法
     * @param obj
     * @param methodName
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] 		pareVaules) {
        if (obj == null) {
            return null;
        }
 
        try {
            //调用一个private方法 //在指定类中获取指定的方法
            Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
            method.setAccessible(true);
            return method.invoke(obj, pareVaules);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    /**
     * 获取一个参数的方法
     * @param obj
     * @param methodName
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object 			pareVaule) {
        Class[] pareTyples = {pareTyple};
        Object[] pareVaules = {pareVaule};
 
        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }
 
    /**
     * 获取无参方法
     * @param obj
     * @param methodName
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
 
        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }
 
 
    /**
     * 无参静态方法
     * @param className
     * @param method_name
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
 
        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }
 
    /**
     * 获取一个参数的静态方法
     * @param className
     * @param method_name
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object 		pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
 
        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }
 
    /**
     * 获取多个参数的静态方法
     * @param className
     * @param method_name
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, 			Object[] pareVaules) {
        try {
            Class obj_class = Class.forName(className);
            return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    /**
     * 无参静态方法
     * @param method_name
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
 
        return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
    }
 
    /**
     * 一个参数静态方法
     * @param clazz
     * @param method_name
     * @param classType
     * @param pareVaule
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object 			pareVaule) {
        Class[] classTypes = new Class[]{classType};
        Object[] pareVaules = new Object[]{pareVaule};
 
        return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
    }
 
    /**
     * 多个参数的静态方法
     * @param clazz
     * @param method_name
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] 		pareVaules) {
        try {
            Method method = clazz.getDeclaredMethod(method_name, pareTyples);
            method.setAccessible(true);
            return method.invoke(null, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
 
    public static Object getFieldObject(String className, Object obj, String filedName) {
        try {
            Class obj_class = Class.forName(className);
            return getFieldObject(obj_class, obj, filedName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static Object getFieldObject(Class clazz, Object obj, String filedName) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
 
    public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            field.set(obj, filedVaule);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
        try {
            Class obj_class = Class.forName(className);
            setFieldObject(obj_class, obj, filedName, filedVaule);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
 
 
    public static Object getStaticFieldObject(String className, String filedName) {
        return getFieldObject(className, null, filedName);
    }
 
    public static Object getStaticFieldObject(Class clazz, String filedName) {
        return getFieldObject(clazz, null, filedName);
    }
 
    public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
        setFieldObject(classname, null, filedName, filedVaule);
    }
 
    public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
        setFieldObject(clazz, null, filedName, filedVaule);
    }