什么是反射机制
- 反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。
- 在运行时,可以直接得到这个类的构造器对象：Constructor
- 在运行时,可以直接得到这个类的成员变量对象：Field
- 在运行时,可以直接得到这个类的成员方法对象：Method
- 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。
反射机制的本质
区分类对象和类的对象，记住一句话万物皆对象：类也可以是一个对象。
反射的关键：反射的第一步都是先得到编译以后的class文件对象。然后就可以得到Class的全部成分。
反射如何获取类对象
- 方式一：Class c1 = Class.forName(“全类名[1]”);
- 方式二：Class c2 = 类名.class
- 方式三：Class c3 = 对象.getClass();
可以看到，一个类的类对象有且只有一个【只编译产生一个.class文件】
获取到类对象又有啥用
反射是双向的，我们可以通过类对象获取类的对象
使用反射技术获取构造器对象并使用
- 利用反射技术获取构造器对象的方式【Declared：无视权限获取，去掉的话只能获取公开的构造器】
getDeclaredConstructors()【返回数组】getDeclaredConstructor (Class<?>... parameterTypes)【获取指定的构造器（tip：参数是类对象）】
- 反射得到的构造器可以做什么？依然是创建对象的
public newInstance(Object... initargs)
如果是非public的构造器，需要打开权限（暴力反射[2]），然后再创建对象setAccessible(boolean)
反射可以破坏封装性，私有的也可以执行了。
注意：通过构造器返回的对象类型是Object类型，需要强制转换，参考示例
/**
目标: 反射_获取Constructor构造器然后通过这个构造器初始化对象。
反射获取Class中的构造器对象Constructor作用：
也是初始化并得到类的一个对象返回。
Constructor的API:
1. T newInstance(Object... initargs)
创建对象，注入构造器需要的数据。
2. void setAccessible(true)
修改访问权限，true代表暴力攻破权限，false表示保留不可访问权限(暴力反射)
小结：
可以通过定位类的构造器对象。
如果构造器对象没有访问权限可以通过：void setAccessible(true)打开权限
构造器可以通过T newInstance(Object... initargs)调用自己，传入参数！
*/
public class TestStudent02 {
// 1.调用构造器得到一个类的对象返回。
@Test
public void getDeclaredConstructor() throws Exception {
// a.第一步：获取类对象
Class c = Student.class;
// b.定位单个构造器对象 (按照参数定位无参数构造器)
Constructor cons = c.getDeclaredConstructor();
System.out.println(cons.getName() + "===>" + cons.getParameterCount());
// 如果遇到了私有的构造器，可以暴力反射
cons.setAccessible(true); // 权限被打开
Student s = (Student) cons.newInstance();
System.out.println(s);
System.out.println("-------------------");
// c.定位某个有参构造器
Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
Student s1 = (Student) cons1.newInstance("孙悟空", 1000);
System.out.println(s1);
}
}
使用反射技术获取成员变量对象并使用
- 获取类中成员变量对象的方法
- getDeclaredFields()
- getDeclaredField (String name)
- 反射得到成员变量可以做什么？依然是在某个对象中取值和赋值。
- void set(Object obj, Object value)：
- Object get(Object obj)
如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值
参考代码
/**
目标：反射获取成员变量: 取值和赋值。
Field的方法：给成员变量赋值和取值
void set(Object obj, Object value)：给对象注入某个成员变量数据
Object get(Object obj):获取对象的成员变量的值。
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。
String getName(); 获取属性的名称。
*/
public class FieldDemo02 {
@Test
public void setField() throws Exception {
// a.反射第一步，获取类对象
Class c = Student.class;
// b.提取某个成员变量
Field ageF = c.getDeclaredField("age");
ageF.setAccessible(true); // 暴力打开权限
// c.赋值
Student s = new Student();
ageF.set(s , 18); // s.setAge(18);
System.out.println(s);
// d、取值
int age = (int) ageF.get(s);
System.out.println(age);
}
}
使用反射技术获取方法对象并使用
- 获取类中成员方法对象
getDeclaredMethods()getDeclaredMethod (String name, Class<?>... parameterTypes)
- 反射得到成员方法可以做什么？依然是在某个对象中触发该方法执行。
Object invoke(Object obj, Object... args)
如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
参考代码
/**
目标：反射——获取Method方法对象
反射获取类的Method方法对象：
1、Method getMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，只能获得public的
2、Method getDeclaredMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，包括private的
3、Method[] getMethods();
获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
4、Method[] getDeclaredMethods();
获得类中的所有成员方法对象，返回数组,只获得本类申明的方法。
Method的方法执行：
Object invoke(Object obj, Object... args)
参数一：触发的是哪个对象的方法执行。
参数二： args：调用方法时传递的实际参数
*/
public class MethodDemo01 {
/**
* 1.获得类中的所有成员方法对象
*/
@Test
public void getDeclaredMethods(){
// a.获取类对象
Class c = Dog.class;
// b.提取全部方法；包括私有的
Method[] methods = c.getDeclaredMethods();
// c.遍历全部方法
for (Method method : methods) {
System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
}
}
/**
* 2. 获取某个方法对象
*/
@Test
public void getDeclardMethod() throws Exception {
// a.获取类对象
Class c = Dog.class;
// b.提取单个方法对象
Method m = c.getDeclaredMethod("eat");
Method m2 = c.getDeclaredMethod("eat", String.class);
// 暴力打开权限了
m.setAccessible(true);
m2.setAccessible(true);
// c.触发方法的执行
Dog d = new Dog();
// 注意：方法如果是没有结果回来的，那么返回的是null.
Object result = m.invoke(d);
System.out.println(result);
Object result2 = m2.invoke(d, "骨头");
System.out.println(result2);
}
}
反射究竟有啥作用
反射的作用-绕过编译阶段为集合添加数据
泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。也就是说泛型只是输入层面限制了，底层没限制。甚至没有必要使用反射，我们直接引用地址就可以达到我们的目的参考代码如下：
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 需求：反射实现泛型擦除后，加入其他类型的元素
ArrayList<String> lists1 = new ArrayList<>();
ArrayList<Integer> lists2 = new ArrayList<>();
System.out.println(lists1.getClass());
System.out.println(lists2.getClass());
System.out.println(lists1.getClass() == lists2.getClass()); // ArrayList.class
System.out.println("---------------------------");
ArrayList<Integer> lists3 = new ArrayList<>();
lists3.add(23);
lists3.add(22);
// lists3.add("黑马");
Class c = lists3.getClass(); // ArrayList.class ===> public boolean add(E e)
// 定位c类中的add方法
Method add = c.getDeclaredMethod("add", Object.class);
boolean rs = (boolean) add.invoke(lists3, "黑马");
System.out.println(rs);
System.out.println(lists3);
ArrayList list4 = lists3;
list4.add("白马");
list4.add(false);
System.out.println(lists3);
}
}
反射的作用-通用框架的底层原理
现假设我们有一个需求案例：给你任意一个对象，在不清楚对象字段的情况可以，可以把对象的字段名称和对应值存储到文件中去。效果如下图所示：
分析：
- 定义一个方法，可以接收任意类的对象。
- 每次收到一个对象后，需要解析这个对象的全部成员变量名称。
- 这个对象可能是任意的，那么怎么样才可以知道这个对象的全部成员变量名称呢？
- 使用反射获取对象的Class类对象，然后获取全部成员变量信息。
- 遍历成员变量信息，然后提取本成员变量在对象中的具体值
- 存入成员变量名称和值到文件中去即可。
参考代码：
public class MybatisUtil {
/**
保存任意类型的对象
* @param obj
*/
public static void save(Object obj){
try (
PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt", true));
){
// 1、提取这个对象的全部成员变量：只有反射可以解决
Class c = obj.getClass(); // c.getSimpleName()获取当前类名 c.getName获取全限名：包名+类名
ps.println("================" + c.getSimpleName() + "================");
// 2、提取它的全部成员变量
Field[] fields = c.getDeclaredFields();
// 3、获取成员变量的信息
for (Field field : fields) {
String name = field.getName();
// 提取本成员变量在obj对象中的值（取值）
field.setAccessible(true);
String value = field.get(obj) + "";
ps.println(name + "=" + value);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Interactive Graph