Java 之 反射机制

反射：框架设计的灵魂

　　框架：是一个可以供我们使用的半成品软件。可以在框架的基础上进行软件开发，简化编码。

　　反射：将类的各个组成部分封装为其他对象，这就是反射机制。

　　　　好处：

　　　　　　1. 可以在程序运行过程中，操作这些对象。

　　　　　　2. 可以解耦，提供程序的可扩展性。

　　Java代码的三个阶段：

一、获取 Class对象 的方式

　　1、使用 Class.forName("全类名")：将字节码文件加载进内存，返回 class 对象

　　　　多用于配置文件，将类名定义在配置文件中，读取文件，加载类。

　　2、类名.class ：通过类名的属性 class 获取

　　　　多用于参数的传递

　　3、对象.getClass()：getClass() 方法在 Object 类中定义了

　　　　多用于对象的获取字节码的方法

　　　注意：同一字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的 Class 对象都是同一个。

　　Demo：

   //1.Class.forName("全类名")
   Class cls1 = Class.forName("cn.keshi.bean.Person");

   //2.类名.class
   Class cls2 = Person.class;

   //3.对象.getClass()
   Person p = new Person();
   Class cls3 = p.getClass();

   //== 比较三个对象
   System.out.println(cls1 == cls2);   //true
   System.out.println(cls1 == cls3);   //true

二、Class 对象功能

　　通过上面的方式获取了 Class 对象，Class 对象包含 Java 类的各个组成部分，因此可以获取里面对应的方法。

　　1、获取成员变量们

 Field[] getFields()： 获取所有 public 修饰的成员变量
 Field getField(String name)：根据字段名来获取 public 修饰的成员变量

 Field[] getDeclaredFields()： 获取所有的成员变量，不考虑修饰符
 Field getDeclaredField(String name)：根据字段名获取成员变量，不考虑修饰符

　　　　获取了对应的类的成员变量，可以进行的操作有：

void set(Object obj, Object value)  // 给成员变量设置值
get(Object obj)                     // 获取成员变量的值
setAccessible(true):暴力反射          // 忽略访问权限修饰符的安全检查

　　　Demo：

 public static void main(String[] args) throws Exception {
       // 获取Person的Class对象
       Class personClass = Person.class;

       //1.Field[] getFields()获取所有public修饰的成员变量
       Field[] fields = personClass.getFields();
       for (Field field : fields) {
           System.out.println(field);
       }

       //2.Field getField(String name)
       Field a = personClass.getField("a");
       //获取成员变量a 的值
       Person p = new Person();
       Object value = a.get(p);
       System.out.println(value);
       //设置a的值
       a.set(p,"张三");
       System.out.println(p);

       //3.Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
       Field[] declaredFields = personClass.getDeclaredFields();
       for (Field declaredField : declaredFields) {
           System.out.println(declaredField);
       }

       //4.Field getDeclaredField(String name)
       Field d = personClass.getDeclaredField("d");
       //忽略访问权限修饰符的安全检查；因为 变量d是用private修饰的，在类外面不支持对私有的变量进行更改，因此需要忽略修饰符
       d.setAccessible(true);//暴力反射
       Object value2 = d.get(p);
       System.out.println(value2);

 }        

　　2、获取构造方法们

 Constructor<?>[] getConstructors()：获取所有的 public 的构造方法
 Constructor<T> getConstructor(类<?>... parameterTypes)：根据构造方法参数的类型来获取构造方法

 Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)：
 Constructor<?>[] getDeclaredConstructors()：

　　获取了对应的类的构造方法，可以进行的操作有：

T newInstance(Object... initargs)：使用参数在创建对象
newInstance 方法：使用空参数构造方法创建对象，操作可以简化为 Class对象的 newInstance 方法
setAccessible(true):忽略访问权限修饰符的安全检查

　　Demo：

 public static void main(String[] args) throws Exception {
        // 获取Person的Class对象
         Class personClass = Person.class;

        //Constructor<T> getConstructor(类<?>... parameterTypes)
         Constructor constructor = personClass.getConstructor(String.class, int.class);   // 获取有参数的构造器
         System.out.println(constructor);
          //创建对象
         Object person = constructor.newInstance("张三", 23);       // 根据参数创建对象
         System.out.println(person);

         Constructor constructor1 = personClass.getConstructor();   // 获取无参数的构造器
         System.out.println(constructor1);
         //创建对象
         Object person1 = constructor1.newInstance();
         System.out.println(person1);

         Object o = personClass.newInstance();                     // 简化写法，调用 Class的newInstance 方法
         System.out.println(o);
 }

　

　　3、获取成员方法们

 Method[] getMethods()：
 Method getMethod(String name, 类<?>... parameterTypes)：

 Method[] getDeclaredMethods()
 Method getDeclaredMethod(String name, 类<?>... parameterTypes)

　　　获取了对应的类的成员方法，可以进行的操作有：

Object invoke(Object obj, Object... args) ：执行方法
String getName：获取方法名称

　　Demo：

 public static void main(String[] args) throws Exception {
         //获取Person的Class对象
         Class personClass = Person.class;

         //获取指定名称的方法
          Method eat_method = personClass.getMethod("eat");
          Person p = new Person();
          //执行方法
          eat_method.invoke(p);

          Method eat_method2 = personClass.getMethod("eat", String.class);
          //执行方法
         eat_method2.invoke(p,"汉堡包"); 

          //获取所有public修饰的方法
          Method[] methods = personClass.getMethods();
          for (Method method : methods) {
              System.out.println(method);
              String name = method.getName();
              System.out.println(name);
              //method.setAccessible(true);
          }
  }   

　　4、获取全类名

String getName()： 获取一个类的（包含包）全类名

　　Demo：

 //获取Person的Class对象
 Class personClass = Person.class;
 //获取类名
 String className = personClass.getName();
 System.out.println(className);//cn.java.bean.Person

三、案例

　　需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

　　实现步骤：

 实现技术
 　　 1. 配置文件
     2. 反射
  实现步骤：
     1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
     2. 在程序中加载读取配置文件
     3. 使用反射技术来加载类文件进内存
     4. 创建对象
     5. 执行方法

　　代码实现：

 // 定义的配置文件 pro.properties
 className=cn.itcast.domain.Student
 methodName=sleep
 // 框架类
 public class ReflectTest {
     public static void main(String[] args) throws Exception {
         //可以创建任意类的对象，可以执行任意方法

         /*
             前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
          */

         //1.加载配置文件
         //1.1创建Properties对象
         Properties pro = new Properties();
         //1.2加载配置文件，转换为一个集合
         //1.2.1获取class目录下的配置文件
         ClassLoader classLoader = ReflectTest.class.getClassLoader();
         InputStream is = classLoader.getResourceAsStream("pro.properties");
         pro.load(is);

         //2.获取配置文件中定义的数据
         String className = pro.getProperty("className");
         String methodName = pro.getProperty("methodName");

         //3.加载该类进内存
         Class cls = Class.forName(className);
         //4.创建对象
         Object obj = cls.newInstance();
         //5.获取方法对象
         Method method = cls.getMethod(methodName);
         //6.执行方法
         method.invoke(obj);

     }
 }