JAVA基础-反射

一、反射的介绍

JAVA反射机制是在运行状态中,能够获取任意一个类的所有属性和方法，对于任意一个对象,都能够调用它的任意
一个方法。这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制。JAVA编译时是先获取到类，然
后才是类里边的属性和方法，而反射则和编译相反，他是先获取类里边的对象和方法然后在告诉他是哪个类里的。简单
来说, 就可以把.class文件比做动物的尸体, 而反射技术就是对尸体的一种解剖.通过反射技术, 我们可以拿到该字节码
文件中所有的东西, 例如成员变量, 成员方法, 构造方法, 而且还包括私有。想要反射首先要获取到程序的“尸体”也就
是.class文件。

二、字节码文件的获取

获取字节码对象有3种方式：
1、类名.class - 这是一个静态的属性, 只要知道类名, 就可以获取
2、对象名.getClass() - Object类里的getClass()方法，对象已经存在的情况下, 可以使用这种方式
3、Claire.forName("类的全类名(包名+类名)") - 通过Class类里的静态方法forName来获取节码对象
  举例：

 public static void main(String[] args) throws ClassNotFoundException {
 // 通过Object的getClass()方法获取，必须要有对象
 Student s = new Student();
 Class clazz = s.getClass();
 // 通过类名获取字节码对象
 Class clazz2 = Student.class;
 // 通过Class类里的静态方法forName来获取节码对象
 Class clazz3 = Class.forName("com.fanshe.Student");
 System.out.println(clazz == clazz2);
 System.out.println(clazz == clazz3);
 System.out.println(clazz);

 }

字节码文件其实就是描述.class文件的对象。

三、对构造方法的操作

*通过反射获取公有构造方法的两种方式：
1、返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法，可以获取无参构造也可以
根据传入的类型来匹配对应的构造方法：getConstructor(Class<?>... parameterTypes)
2、返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法：
                                                               getConstructors()
3、创建此 Class 对象所表示的类的一个新实例：
                                                               newInstance()

*暴力获取（可以获取全部权限的）：
1、返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法：
                                 getDeclaredConstructor(Class<?>... parameterTypes)
2、返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法：
                                 getDeclaredConstructors()
  举例：

 public static void main(String[] args) throws ReflectiveOperationException {
 // Class.forName()获取字节码对象
 Class<?> forName = Class.forName("com.fanshe.Student");
 // 获取所有公共构造方法
 Constructor<?>[] constructors = forName.getConstructors();
 // 遍历
 for (Constructor<?> constructor : constructors) {
 // 打印结果
 System.out.println(constructor);
 }
 System.out.println("--------------------------------------");
 // 暴力获取，可以获取所有的构造方法（包括私有的）
 Constructor<?> c1 = forName.getDeclaredConstructor();
 c1.setAccessible(true);
 System.out.println(c1);
 //获取有参构造
 Constructor<?> c2 = forName.getConstructor(String.class, int.class);
 System.out.println(c2);
 }

四、对成员变量和方法的操作

*公有成员变量获取方法：
1、返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段：
                          getField(String name) - 参数为要返回的变量名
2、返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段：
                          getFields() - 参数为要返回的变量名

*任意成员变量获取方法：
1、返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段：
                          getDeclaredField(String name) - 参数为要返回的变量名
2、返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段：
                         getDeclaredFields() - 参数为要返回的变量名
 
    *获取公有的方法：
1、返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法：
                         getMethod(String name, Class<?>... parameterTypes) - name 方法名、parameterTypes 参数列表
2、返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口
声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法：
                         getMethods()

*暴力获取方法：
1、 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法：
                         getDeclaredMethod(String name, Class<?>... parameterTypes) - name 方法名、parameterTypes
参数列表
2、返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、
默认（包）访问和私有方法，但不包括继承的方法：
                        getDeclaredMethods()
    需要注意的是想要获取私有的变量或者方法时应使用AccessibleObject类里的setAccessible(boolean flag)方法 - 参数
值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问
检查。
    Constructor, Field, Method都是AccessibleObject的子类所以可以直接使用父类的setAccessible(boolean flag)方法。

**通过反射获得变量的流程：
1. 通过反射获取该类的字节码对象
2. 创建该类对象
3. 获取该类中需要操作的字段(成员变量) 
4. 通过字段对象中的方法修改属性值

**通过反射执行方法的流程
1. 通过反射获取该类的字节码对象
2. 创建该类对象
3. 调用getMethod方法获取Method对象, 方法形参接受方法的名字
4. 调用Method方法中的invoke()将方法运行
  举例：
*被反射的学生01类

 public class Student01 {
 public String name;
 private int age;

 public Student01() {
 super();
 // TODO Auto-generated constructor stub
 }

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

 public void name() {
 System.out.println("测试");

 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public int getAge() {
 return age;
 }

 public void setAge(int age) {
 this.age = age;
 }

 private void mane1() {
 System.out.println("这是个萌萌哒私有的");

 }

 @Override
 public String toString() {
 return "Student01 [name=" + name + ", age=" + age + "]";
 }

 }

*对学生01类进行反射

 public static void main(String[] args) throws ReflectiveOperationException {
 // 获取字节码对象
 Class<?> clazz = Class.forName("com.fanshe.Student01");
 // 创建该类的对象
 Object stu = clazz.newInstance();
 // System.out.println(stu);
 // 获取学生类的name变量
 Field f1 = clazz.getField("name");
 /*
 * set将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
 * 为stu对象里的name变量赋值
 */
 f1.set(stu, "李四");
 // get()返回指定对象上此 Field 表示的字段的值。
 Object name = f1.get(stu);
 // 暴力获取age字段
 Field f2 = clazz.getDeclaredField("age");
 System.out.println(f2);
 // 让jvm不检查权限
 f2.setAccessible(true);
 // 为其赋值
 f2.set(stu, 24);
 // 获取stu对象的f2字段的值
 Object age = f2.get(stu);
 System.out.println(name);
 System.out.println(age);
 // 公有无参无返回值，name()
 Method method = clazz.getMethod("name");
 // 使用Method类的invoke方法执行name方法
 method.invoke(stu);
 // 公有代参无返回值,参数为String类型
 Method m2 = clazz.getMethod("setName", String.class);
 // 执行stu对象的setName方法，传入参数
 m2.invoke(stu, "李晨宇");
 // 公有无参有返回值
 Method m3 = clazz.getMethod("getName");
 // 返回值为invoke
 Object invoke = m3.invoke(stu);
 System.out.println(invoke);
 // 私有
 Method m4 = clazz.getDeclaredMethod("mane1");
 // 让jvm不检查权限
 m4.setAccessible(true);
 // 执行stu对象的mane1方法
 m4.invoke(stu);
 }

需要注意的是，反射无参构造时被反射的类一定要有无参构造方法，默认生成的也算。
五、反射的应用

我们在开发的时候，由于要考虑到代码的重用性，就会用反射来处理一些问题。而JAVA的一些常用jar包和主流框架的配置
都用到了反射的原理，学习反射有助于我们对源码的阅读和理解。BeanUtils工具类（Apache开发的便于操作JavaBeen的工具类）
就用到了反射的方法。
  *BeanUtils的部分实现：

 public class MyBeanUtils {
 //因为是工具类，不需要实例化。所以私有构造方法
 private MyBeanUtils() {
 super();
 // TODO Auto-generated constructor stub
 }

 /*
 * 给对象中的属性赋值 传入类的对象类型，和要修改的属性的值不确定所以用Object类型，属性名用String类型
 */
 public static void setProrerty(Object object, String name, Object values)
 throws ReflectiveOperationException, SecurityException {
 // 获取传入对象的字节码文件
 Class clazz = object.getClass();
 // 根据传入的属性获取Field对象，因为不确定属性的权限，用的暴力反射
 Field field = clazz.getDeclaredField(name);
 // 让jvm不检查权限
 field.setAccessible(true);
 // 为object对象里的name属性赋值
 field.set(object, values);

 }

 // 获取对象中的属性
 public static String getProrerty(Object object, String name)
 throws ReflectiveOperationException, SecurityException {
 // 获取传入对象的字节码文件
 Class clazz = object.getClass();
 // 根据传入的属性获取Field对象，因为不确定属性的权限，用的暴力反射
 Field field = clazz.getDeclaredField(name);
 // 让jvm不检查权限
 field.setAccessible(true);
 // 获取name属性的值
 Object object2 = field.get(object);
 // System.out.println(object);
 // 将值返回
 return object2.toString();
 }

 // 给对象中的属性赋值(通过Map的方式)，Map里key存的是属性名，value存的是要赋的值
 public static void populat(Object object, Map map) throws ReflectiveOperationException, SecurityException {
 // 获取传入对象的字节码文件
 Class clazz = object.getClass();
 // 返回此集合中的key集合
 Set keySet = map.keySet();
 // 遍历key
 for (Object object2 : keySet) {
 // 获得value值
 Object value = map.get(object2);
 try {
 // 根据传入的key(属性)获取Field对象，因为不确定属性的权限，用的暴力反射
 Field field = clazz.getDeclaredField(object2.toString());
 // 让jvm不检查权限
 field.setAccessible(true);
 // 赋值
 field.set(object, value);
 } catch (NoSuchFieldException e) {
 // 出现异常，给出友好型提示
 System.out.println("Mdzz,属性都记不住");
 }
 }
 }
 }

*测试工具类：

 public static void main(String[] args) throws RuntimeException, ReflectiveOperationException {
 // 创建学生01对象
 Student01 s1 = new Student01();
 // 使用MyBeanUtils工具类为学生01对象赋值
 MyBeanUtils.setProrerty(s1, "name", "啦啦");
 MyBeanUtils.setProrerty(s1, "age", 15);
 // 使用MyBeanUtils工具类为学生01对象取值
 String name = MyBeanUtils.getProrerty(s1, "name");
 String age = MyBeanUtils.getProrerty(s1, "age");
 // 打印出来
 System.out.println(name);
 System.out.println(age);
 System.out.println("------------------------------------ ");
 // 创建HashMap作为数据源
 HashMap<String, Object> hashMap = new HashMap<>();
 // 为HashMap赋值
 hashMap.put("qqqqq", "大大的"); // 属性不存在会给出友好型提示
 hashMap.put("name", "大大的");
 hashMap.put("age", 110);
 // 使用MyBeanUtils工具类为学生01对象赋值
 MyBeanUtils.populat(s1, hashMap);
 System.out.println(s1);
 }