[@徐雷frank][¥20]Java 里的反射机制

1.Java的反射机制应该都是运行时动态实现的，动态通过元数据获取类型信息，创建对象，实现调用。
2.动态反射需要知道类名或者非法名关键字，中间够基于哈希搜索，快速定位类型或者非法信息。
3.Java的反射机制现在应用比较多的是动态代理proxy,主要是在RPC和AOP领域。
4.委派，你说的意思应该是delegate，也叫委托，一种设计模式，委派方式委派其他对象干活，这个工作自己不了。
5.动态代理模式，支持的功能几乎和被代理对象一样。
6.当有严格要求需要代理和被代理类方法一致，例如RPC或者AOP中，基于接口约束，使用反射的动态代理比较好。
当有特殊的封装，比如要调用一个加密或者日志对象完成其他工作，不需要接口约束，可以使用委托，委托内部可以反射创建对象。

在默认情况下，方法的反射调用为委派实现，委派给本地实现来进行方法调用。在调用超过 15 次之后，委派实现便会将委派对象切换至动态实现。这个动态的字节码是在Java运行过程中通过ASM自动生成的，它将直接使用 invoke 指令来调用目标方法。

java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

反射不分委派不委派吧，反射就是通过动态获取class字节码信息去执行

我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。
public Object invoke(Object obj, Object... args)

    throws IllegalAccessException, IllegalArgumentException,
       InvocationTargetException
{
    // 权限检查，忽略 ...
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    // 看这里 ...
    MethodAccessor ma = methodAccessor; // read volatile
    if (ma == null) {
        ma = acquireMethodAccessor();
    }
    return ma.invoke(obj, args);
}

可以看到，这里讲方法的调用，委派给了MethodAccessor类型的ma对象来处理。它是一个接口，有两个实现类。一个委派实现(DelegatingMethodAccessorImpl)，一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用，都会使用委派实现！，但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下：

public class HowReflect {

public static void targetMethod(int i) {
    // 打印调用栈
    new Exception("version " + i)
            .printStackTrace();
}

public static void main(String[] args) throws Exception {
    Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
    Method method = howReflect.getMethod("targetMethod", int.class);
    // 执行方法
    method.invoke(null, 0);
}

}

上面的代码运行结果为：
java.lang.Exception: 版本 0

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
// 4 委派实现又委派给了本地实现
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
// 3 生成委派实现
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
// 2 反射调用方法
at java.lang.reflect.Method.invoke(Method.java:498)
// 1 执行main方法
at com.ynwa.jvm.HowReflect.main(HowReflect.java:21)

上面在结果打印的调用栈中，注释的第3步个第4步，可以看到先用的委派实现，委派实现又委派了本地实现！
那么问题来了！既然最终要用本地实现，那么为什么中间要加一层委派实现？，那么继续向下看。
其实这是因为除了以上两种以外，还有一种动态实现，而所谓的委派实现，只不过是为了能够在本地实现和动态实现之间做切换。动态实现是一种字节码技术。
但是如果只调用一次的话，本地实现要比动态实现块一点儿，这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次)，所以它设定了一个阀值：16，如果调用15此以上，也就是说第17次开始，使用动态实现。使用本地实现的时候，因为要经过Java -> c++ -> Java的过程。第17次开始，JVM会利用已经生成的字节码来进行方法调用，所以这无疑就会增速很多！

学习了

debug下你就明白了， 反射前15次是通过unsafe内置的native方法操作的， 超过15次后会生成对应的java类， 就是相当于正常调用方法实现了

反射机制
什么是反射机制
简单来说，放射可以帮助我们在动态运行的时候，对于任意一个类，可以获得其所有的方法（包括 public protected private 默认状态的），所有的变量 （包括 public protected private 默认状态的）。是不是很强大呢。

反射机制有什么作用呢？
获取某些类的一些变量，调用某些类的私有方法。（例如在Android开发中我们可以用来开启 WiFi 热点，调用 WifiManager 中的 setWifiApEnabled() 方法 ）
增加代码的灵活性。很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术.
假如有这样一个类 Person，它拥有多个成员变量，country,city,name,province,height,age 等，同时它拥有多个 构造方法，多个方法，这些变量，方法的访问权限既有 public 也有 private 的。下面我们以这个为例子，一起看怎样使用反射获得相应的 Filed，Constructor，Method。

public class Person {

public String country;
public String city;
private String name;
private String province;
private Integer height;
private Integer age;

public Person() {
    System.out.println("调用Person的无参构造方法");
}

private Person(String country, String city, String name) {
    this.country = country;
    this.city = city;
    this.name = name;
}

public Person(String country, Integer age) {
    this.country = country;
    this.age = age;
}

private String getMobile(String number) {
    String mobile = "010-110" + "-" + number;
    return mobile;
}

private void setCountry(String country) {
    this.country=country;

}

public void getGenericHelper(HashMap<String, Integer> hashMap) {
}

public Class getGenericType() {
    try {
        HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
        Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (null == genericParameterTypes || genericParameterTypes.length < 1) {
            return null;
        }

        ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
        Type rawType = parameterizedType.getRawType();
        System.out.println("----> rawType=" + rawType);
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
            return null;
        }

        for (int i = 0; i < actualTypeArguments.length; i++) {
            Type type = actualTypeArguments[i];
            System.out.println("----> type=" + type);
        }
    } catch (Exception e) {

    }
    return null;
}

@Override
public String toString() {
    return "Person{" +
            "country='" + country + '\'' +
            ", city='" + city + '\'' +
            ", name='" + name + '\'' +
            ", province='" + province + '\'' +
            ", height=" + height +
            '}';
}

}
使用反射获得所有构造方法（包括私有的，非私有的）
默认权限的指的是没有修饰符修饰的

几个重要的方法讲解
方法 描述
public Constructor getConstructor(Class… parameterTypes) 获得指定的构造方法，注意只能获得 public 权限的构造方法，其他访问权限的获取不到
public Constructor getDeclaredConstructor(Class… parameterTypes) 获得指定的构造方法，注意可以获取到任何访问权限的构造方法。
public Constructor[] getConstructors() throws SecurityException 获得所有 public 访问权限的构造方法
public Constructor[] getDeclaredConstructors() throws SecurityException 获得所有的构造方法，包括（public, private,protected,默认权限的）
看了上面的几个方法，其实很好区分

后缀带 s 的返回对象时数组类型，是可以获得相应权限的所有方法的，如 Constructor getConstructor() 方法 和 Constructor
获得所有的构造方法
public static void printConstructor(String className) {

try {
    Class<?> aClass = Class.forName(className);
    Constructor<?>[] constructors = aClass.getConstructors();
    print(constructors);
    Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
    print(declaredConstructors);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

}
print: private com.example.reflectdemo.Person(java.lang.String,java.lang.String,java.lang.String)

print: public com.example.reflectdemo.Person()

print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

对比 Person 里面所有的构造方法，可以知道我们代码的逻辑是正确的

获得指定的构造方法
public static Constructor getConstructor(String className, Class<?>... clzs) {

try {
    Class<?> aClass = Class.forName(className);
    Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
    print(declaredConstructor);
    //   if Constructor is not public,you should call this
    declaredConstructor.setAccessible(true);
    return declaredConstructor;

} catch (ClassNotFoundException e) {
    e.printStackTrace();
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}
return null;

}

public class TestHelper {

public static  final String TAG="xujun";
public static final String CLASS_NAME = "com.example.reflectdemo.Person";
public static final String CHINA = "China";

public static void testConstructor(){
    ReflectHelper.printConstructor(CLASS_NAME);
    Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
    try {
        Object meinv = constructor.newInstance(CHINA, 12);
        Person person = (Person) meinv;
        Log.i(TAG, "testConstructor: =" + person.toString());
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }

}

}
我们将可以看到以下的输出结果

testConstructor: =Person [country=China, city=null, name=null, province=null, height=null, age=12]

可以看到 country=China，age=12 这说明我们成功通过反射调用 Person 带两个参数的沟改造方法。

注意事项
如果该方法，或者该变量不是 public 访问权限的，我们应该调用相应的 setAccessible(true) 方法，才能访问得到

//if Constructor is not public,you should call this
declaredConstructor.setAccessible(true);
1
2
使用反射获得所有的 Filed 变量
获得所有的 Filed 变量
public static void printFiled(String className) {

try {
    Class<?> aClass = Class.forName(className);
    Field[] fields = aClass.getFields();
    PrintUtils.print(fields);
    Field[] declaredFields = aClass.getDeclaredFields();
    PrintUtils.print(declaredFields);

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

}
获得指定的成员变量
现在假如我们要获得 Person 中的私有变量 age ，我们可以通过以下的代码获得，同时并打印出所有的成员变量。

public static Field getFiled(String className, String filedName) {

Object o = null;
try {
    Class<?> aClass = Class.forName(className);

    Field declaredField = aClass.getDeclaredField(filedName);
    //   if not public,you should call this
    declaredField.setAccessible(true);
    return declaredField;

} catch (ClassNotFoundException e) {
    e.printStackTrace();
} catch (NoSuchFieldException e) {
    e.printStackTrace();
}
return null;

}

public static void testFiled(){

ReflectHelper.printFileds(CLASS_NAME);
Person person = new Person(CHINA, 12);
Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
try {
    Integer integer = (Integer) field.get(person);
    PrintUtils.print("integer="+integer);
} catch (IllegalAccessException e) {
    e.printStackTrace();
}

}
我们可以看到以下的输出结果

print: public java.lang.String com.example.reflectdemo.Person.country

print: public java.lang.String com.example.reflectdemo.Person.city

print: public java.lang.String com.example.reflectdemo.Person.country

print: public java.lang.String com.example.reflectdemo.Person.city

print: private java.lang.String com.example.reflectdemo.Person.name

print: private java.lang.String com.example.reflectdemo.Person.province

print: private java.lang.Integer com.example.reflectdemo.Person.height

print: private java.lang.Integer com.example.reflectdemo.Person.age

print:integer=12

使用反射执行相应的 Method
主要有以下几个方法，

public Method[] getDeclaredMethods()
public Method[] getMethods() throws SecurityException
public Method getDeclaredMethod()
public Method getMethod(String name, Class
获取所有的 Method

public static void printMethods(String className) {
    try {
        Class<?> aClass = Class.forName(className);
        Method[] declaredMethods = aClass.getDeclaredMethods();
        PrintUtils.print(declaredMethods);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

} 

print: public java.lang.String com.example.reflectdemo.Person.toString()

print: public java.lang.Class com.example.reflectdemo.Person.getGenericType()

print: private void com.example.reflectdemo.Person.setCountry(java.lang.String)

print: public void com.example.reflectdemo.Person.getGenericHelper(java.util.HashMap)

print: private java.lang.String com.example.reflectdemo.Person.getMobile(java.lang.String)

对比 Person 里面的所有方法，毫无疑问我们的代码逻辑是正确的。

获取指定的 Method
我们可以使用 getDeclaredMethod(String name, Class

public static void testMethod(){

    ReflectHelper.printMethods(CLASS_NAME);
    Person person=new Person();
    Method method = ReflectHelper.getMethod(CLASS_NAME,
            "setCountry", String.class);
    try {
       // 执行方法，结果保存在 person 中
        Object o = method.invoke(person, CHINA);
       // 拿到我们传递进取的参数 country 的值 China          
        String country=person.country;
        PrintUtils.print(country);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }

}

public class ReflectHelper {

private static final String TAG = "ReflectHelper";

public static Method getMethod(String className, String methodName, Class<?>... clzs) {
    try {
        Class<?> aClass = Class.forName(className);
        Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
        declaredMethod.setAccessible(true);
        return declaredMethod;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    return null;
}

}
执行上面的函数，将可以看到下面的结果

print:China

即我们成功利用反射调用 Person 的 setCountry 方法，并将值成功改变。

使用反射操作数组
/**

 * 利用反射操作数组
 * 1 利用反射修改数组中的元素
 * 2 利用反射获取数组中的每个元素
 */
public static void testArrayClass() {
    String[] strArray = new String[]{"5","7","暑期","美女","女生","女神"};
    Array.set(strArray,0,"帅哥");
    Class clazz = strArray.getClass();
    if (clazz.isArray()) {
        int length = Array.getLength(strArray);
        for (int i = 0; i < length; i++) {
            Object object = Array.get(strArray, i);
            String className=object.getClass().getName();
            System.out.println("----> object=" + object+",className="+className);
        }
    }
} 

—-> object=帅哥,className=java.lang.String

—-> object=7,className=java.lang.String

—-> object=暑期,className=java.lang.String

—-> object=美女,className=java.lang.String

—-> object=女生,className=java.lang.String

—-> object=女神,className=java.lang.String

从结果可以说明，我们成功通过 Array.set(strArray,0,”帅哥”) 改变数组的值。

使用反射获得泛型类型
public static void getGenericHelper(HashMap map) {

} 

现在假设我们有这样一个方法，那我们要怎样获得 HashMap 里面的 String，Person 的类型呢？

对于 Java Type还不熟悉的可以先读这一篇博客 java Type 详解

public static void getGenericType() {

    try {
        Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        // 检验是否为空
        if (null == genericParameterTypes || genericParameterTypes.length < 1) {
            return ;
        }
        // 取 getGenericHelper 方法的第一个参数

        ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
        Type rawType = parameterizedType.getRawType();
        System.out.println("----> rawType=" + rawType);
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
            return ;
        }
        //  打印出每一个类型          
        for (int i = 0; i < actualTypeArguments.length; i++) {
            Type type = actualTypeArguments[i];
            System.out.println("----> type=" + type);
        }
    } catch (Exception e) {

    }

} 

执行上面的代码，输出结果

—-> rawType=class java.util.HashMap

—-> type=class java.lang.String

—-> type=class com.example.reflectdemo.Person

怎样获得 Metho,Field,Constructor 的访问权限 （ public,private,ptotected 等）
其实很简单，我们阅读文档可以发现他们都有 getModifiers() 方法，该方法放回 int 数字， 我们在利用 Modifier.toString() 就可以得到他们的访问权限

int modifiers = method.getModifiers();
Modifier.toString(modifiers);

动态代理 ，委派实现。