什么是反射机制？ 反射机制怎么用？(精细讲)

什么是反射机制？

在运行状态中，对于任意一个类，都能获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意的一个方法或属性（包括私有的方法和属性），这种动态的获取类信息以及动态调用对象的方法和属性的功能就称之为java语言的反射机制。
也就是说通过反射机制，这个类就是透明的，可以获取这个类的任意东西。

反射机制的使用

可以通过获取字节码文件的三种方法：

1. Class clazz1 = Class.forName(“全限定类名”);　　//通过Class类中的静态方法forName，直接获取到一个类的字节码文件对象，此时该类还是源文件阶段，并没有变为字节码文件。

2. Class clazz2 = Person.class;　　　　 //当类被加载成.class文件时，此时Person类变成了.class，在获取该字节码文件对象，也就是获取自己， 该类处于字节码阶段。

3. Class clazz3 = p.getClass();　　　　//通过类的实例获取该类的字节码文件对象，该类处于创建对象阶段

反射的详细使用代码

通过字节码对象创建实例对象

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
// 创建User对象。使用无参构造方法创建对象
User u = (User)clazz.newInstance();
// 通过User对象获取想要获取的信息
String name = u.getName();

获取指定构造器方法。constructor 如果没有无参构造，只有有参构造如何创建实例

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
// 先获取有参构造器 ， parameterTypes :表示有参列表。有多少写多少，也可以不写，不写代表的是调用无参构造器。
Constructor constructor = clazz.getConstructor(int.class,String.class);
//通过构造器来实例化对象，把实际的对象信息传进去。
User u = (User)constructor.newInstance(“校长”,“56”);

Class的newInstance()

Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(“张三”,20)方法创建对象获取全部构造方法。

获取构造函数或指定构造函数的参数类型

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
//获取所有构造方法
Constructor[] constructor = clazz.getConstructor();
// 遍历构造方法
for(int i=0,i<constructor.length,i++){
// 获取每个构造函数中的参数类型字节码对象
Class[] parameterTypes = constructor[i].getParameterTypes()
sout(“第”+i+“构造函数”);
// 获取构造函数重的参数类型
for(int j=0,j<parameterTypes .length,j++){
sout(parameterTypes[j].getName()+",");
}
}

获取成员变量并使用Field对象获取指定成员变量

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
// 创建User对象。使用无参构造方法创建对象
User u = (User)clazz.newInstance();
// 获取成员变量clazz.getField(name);通过name来获取指定的成员变量，如果改成员变量是私有的，则应该使用getDeclaredField(name)。
Field field = clazz.getDeclaredField(“id”);
// 因为属性是私有的，获得其属性对象后，需要让其打开可见权限
field.setAccessible(true);
// 对成员变量复制操作，如：赋值操作。
field.setInt(u,5);
// 获取成员变量的值 field.get(o)，o表示字段值的对象，也就是该属性对应类的实体对象。
sout(field.getInt(u));

方法讲解Class.getField

Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField(“name”)方法获取,通过set(obj, “李四”)方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值获取全部成员变量。

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
// 创建User对象。使用无参构造方法创建对象
User u = (User)clazz.newInstance();
// 赋值
u.setId(2);
u.setName(“xiaohaizi”);
//获取所有的私有属性
Field[] field = clazz.getDeclaredField();
for(int i=0,i<field.length,i++){
field[i].setAccessible(true);
sout(field[i].get(u));
}

获得方法并使用Method

// 获取字节码文件
Class clazz = Class.forName(“Reflect.User”);
// 创建User对象。使用无参构造方法创建对象
User u = (User)clazz.newInstance();
// 不带参数的方法，eat为不带参数的public方法。
// clazz.getMethod(name,parameterTypes); name:方法的名称。parameterTypes：方法的参数类型的Class类型，没有则什么都不填，比如参数是String，则填写String.class.
Method method = clazz.getMethod(“eat”);
// 调用方法，method.invoke(obj,args); obj:方法的对象。args:实际的参数值，没有则不填。
method.invoke(u);
//带参数的方法，getString为带一个String类型参数的方法。
Mothed mothed1 = clazz.getMethod(“getString”,String.class);
method1.invoke(u,“xiaohua”);
//获取私有的方法和获取私有的属性一样，getPrivate为私有方法
Mothed mothed2 = clazz.getDeclaredMethod(getPrivate");
method2.setAccessible(true);
method2.invoke(u);

Class.getMethod(String, Class…)和Class.getDeclaredMethod(String, Class…)

Class.getMethod(String, Class…) 和 Class.getDeclaredMethod(String, Class…)方法可以获取类中的指定方法,如果为私有方法，则需要打开一个权限。setAccessible(true);
用invoke(Object, Object…)可以调用该方法，跟上面同理，也能一次性获得所有的方法

Method[] methods = clazz.getMethod();
User u = (User)clazz.newInstance();
for(Method method:methods){
method.setAccessible(true);
sout(method.getName());
Class<?> parameterTypes = method.getParameterTypes();
for(int i=0,i<parameterTypes.length,i++){
sout(parameterTypes.getName()+",");
}
}

获得该类的所有接口

Class[]　getInterfaces()：
确定此对象所表示的类或接口实现的接口
返回值：接口的字节码文件对象的数组

获取指定资源的输入流

InputStream getResourceAsStream(String name)　　
return：一个 InputStream 对象；如果找不到带有该名称的资源，则返回 null
参数：所需资源的名称，如果以"/“开始，则绝对资源名为”/"后面的一部分。

动态代理的概述和实现

动态代理：一种设计模式，其非常简单，很容易理解，你自己可以做这件事，但是觉得自己做非常麻烦或者不方便，所以就叫一个另一个人(代理)来帮你做这个事情，而你就不用管了，这就是动态代理。举个例子，买火车票叫人代买。

在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象分三步，但是注意JDK提供的代理正能针对接口做代理，也就是下面的第二步返回的必须要是一个接口。

1、new出代理对象，通过实现InvacationHandler接口，然后new出代理对象来。
2、通过Proxy类中的静态方法newProxyInstance，来将代理对象假装成那个被代理的对象，也就是如果叫人帮我们代买火车票一样，那个代理就假装成我们自己本人
3、执行方法，代理成功
将代理对象中的内容进行实现

注意newProxyInstance的三个参数，第一个，类加载器，第二个被代理对象的接口，第三个代理对象。

还有很多方法，比如获得类加载器，等等

具体还需要别的，就通过查看API文档来解决。

反射机制的应用实例

利用反射，在泛型为int的arryaList集合中存放一个String类型的对象

原理：集合中的泛型只在编译器有效，而到了运行期，泛型则会失效，
List list = new ArrayList();
list.add(4);
list.add(5);

Class clazz = list.getClass();
Method method = clazz.getMethod(“add”,Object.class);
method.invoke(list,“ddd”);
sout(list); //打印出来是 4，5，ddd

利用反射，简化编写Servlet的个数。

什么意思呢？每当我们写一个功能时，就需要写一个对应的Servlet，导致最后Servlet有很多，自己都看不过来，所以对其进行了优化，两种方式，
更多内容。。。。
本文链接：
https://www.cnblogs.com/whgk/p/6122036.html
其它相关知识链接：
https://blog.csdn.net/sinat_38259539/article/details/71799078