JAVA高级特性——反射

概述

反射是JAVA中最强大的技术之一，其可以将类的各个组成部分封装为其他对象，即在运行状态中，对于任意的类，都能够获取其构造方法、成员变量和成员方法；对于任意的对象，都能够调用其任意一个方法或属性。在编写框架时可以用反射技术实现很多常规操作难以实现的功能。

1.引入

假设你正在编写一个MOBA类游戏，其中创建两个类：Hero（英雄类）、Creeps（野怪类），代码如下：

package ReflectDemo;

public class Hero {
    private String name;     // 英雄姓名
    private int hp;         // 英雄生命值
    private int mana;       // 英雄法力值

    public Hero() {
    }

    public Hero(String name, int hp, int mana) {
        this.name = name;
        this.hp = hp;
        this.mana = mana;
    }

    public void Q(String skill){        // Q技能
        System.out.println(this.name + "施放" + skill + "!");
    }

    public void Big(String big){
        System.out.println("大招：" + big);
    }

}

package ReflectDemo;

public class Creeps {
    private String name;
    private int position;   // 野怪刷新位置
    private int atn;        // 物理攻击力
    private int hp;         // 野怪血量

    public Creeps() {
    }

    public Creeps(String name, int position, int atn, int hp) {
        this.name = name;
        this.position = position;
        this.atn = atn;
        this.hp = hp;
    }

    public void attack(){
        System.out.println(this.name + "攻击了你，英雄血量-" + this.atn);    // 假设英雄没有护甲
    }
}

对于任意的英雄和野怪，想要实现他们的任意技能或攻击，若通过创建不同的类对象实现，则例子如下：

package ReflectDemo;

public class reflectMain {
    public static void main(String[] args) {
        Hero hero1 = new Hero("盖伦", 1000,0);
        hero1.Q("致命打击");
    }
}

如果想让三狼攻击盖伦，那么只能再创建Creeps的对象，调用attack方法。为了更加方便地实现这一模块，降低程序耦合性，我们可以尝试创建一个“框架”，在框架中进行操作。这时要用到所谓的反射机制。

2.基础知识

2.1 获取Class对象

首先来了解一下Class对象的概念：在JAVA这门“万物皆对象”的语言中，我们自己定义的类，如Hero（英雄类）、==Creeps（野怪类）==本身实际上是java.lang.Class类的实例对象，这些对象称作Class对象，Class 类的实例对象表示正在运行的 Java 应用程序中的类和接口。因此，反射机制的实现是离不开对Class对象的操作的。
要获取Class对象，有三种方式：

• Class.forName(“全类名”)：将字节码文件加载到内存中。返回Class对象（常用于配置文件中）；
• 类名.class：通过类名的属性class获取（多用于参数传递）；
• 对象.getClass()：所有的对象实际上都是Object类的实例，可以用Object类中的getClass()方法获取Class对象（用于实例对象获取Class的方式）。
  不管用哪一种方式，实际上获取的Class对象都是同一个。

2.2 Class对象的功能

Class对象的功能，无非就是在程序运行过程中，获取类的成员变量、构造方法、成员方法等，下面依次进行介绍：

2.2.1 获取成员变量

常用的方法有四个，以Hero类的Class对象heroClass为例：

 - Field[] fields = heroClass.getFields();
 - Field[] declaredFields = heroClass.getDeclaredFields();
 - Field field = heroClass.getField(String fieldname);
 - Field declaredField = heroClass.getDeclaredField(String fieldname);

• 方法1获取所有public属性的成员变量，返回一个数组
• 方法2获取所有的成员变量，不考虑权限修饰符
• 方法3获取指定名字的成员变量
• 方法4获取指定名字的成员变量，不考虑权限修饰符
  获取到成员变量后，可以对实例对象进行成员变量的get()和set()操作：

package ReflectDemo;
import java.lang.reflect.Field;

public class reflectMain {
    public static void main(String[] args) throws Exception {
        Class<Hero> heroClass = Hero.class;
        Hero hero = new Hero("阿狸",650,330);
        Field name = heroClass.getDeclaredField("name");

        // 注意：要忽略访问权限修饰符的安全检查，也即进行暴力反射
        name.setAccessible(true);
        // get获取成员变量
        Object o = name.get(hero);      // 获取hero对象的name
        System.out.println(o);          // 执行结果为：阿狸
        // set设置成员变量
        name.set(hero,"轮子妈");
        System.out.println(name.get(hero));     // 执行结果为：轮子妈
    }
}

Hero中的成员变量均为private类型，获取时要注意忽略访问权限修饰符的安全检查，也即进行暴力反射。

2.2.2 获取构造方法

常用的方法依然是四个：

// 获取构造方法，一般包括无参构造和有参构造
Constructor<?>[] constructors = heroClass.getConstructors();
Constructor<?>[] declaredConstructors = heroClass.getDeclaredConstructors();
// 获取指定的构造方法
// 注意区分构造方法的依据：参数
heroClass.getConstructor(Class<?>... parameterTypes)
heroClass.getDeclaredConstructor(Class<?>... parameterTypes)
// 获取heroClass有参构造方法的方式如：
Constructor<Hero> constructor = heroClass.getConstructor(String.class,int.class,int.class);

获取到构造方法，可以用于创建新的对象（通过newInstance()方法），如：

package ReflectDemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class reflectMain {
    public static void main(String[] args) throws Exception {
        Class<Hero> heroClass = Hero.class;

        Constructor<Hero> constructor = heroClass.getConstructor(String.class,int.class,int.class);

        Hero hero = constructor.newInstance("阿mumu",610,280);
        System.out.println(hero);		// Hero{name='阿mumu', hp=610, mana=280}
    }
}

若使用空参构造方法，可以更加简化，使用heroClass内的newInstance方法直接构造，其原理是访问Class对象空参的构造器。

package ReflectDemo;

public class reflectMain {
    public static void main(String[] args) throws Exception {
        Class<Hero> heroClass = Hero.class;

        Hero hero = heroClass.newInstance();
        System.out.println(hero);
    }
}

2.2.3 获取成员方法

成员方法依然是四个：

        // 方法列表中也包括Object类的方法
        Method[] methods = heroClass.getMethods();
        Method[] declaredMethods = heroClass.getDeclaredMethods();
        // 注意传入方法参数类型
        Method method = heroClass.getMethod("Q", String.class);
        Method declaredMethod = heroClass.getDeclaredMethod("Q", String.class);

获取成员方法后，可以通过invoke()方法执行所获取的方法对象：

package ReflectDemo;
import java.lang.reflect.Method;

public class reflectMain {
    public static void main(String[] args) throws Exception {
        Class<Hero> heroClass = Hero.class;

        Hero hero = new Hero("墨菲特",710,200);

        Method method = heroClass.getMethod("Big", String.class);

        method.invoke(hero,"势不可挡");		// 大招：势不可挡
    }
}

3.“框架”实现

在引入部分我们提到，利用反射机制创建一个框架，对于任意的英雄和野怪，实现他们的任意技能或攻击。
在此处我们建立一个配置文件，在其中配置：传入的类对象是“Hero”或是“Creeps”（即全类名）、要实现的方法，过Properties读入配置文件，使用反射技术实现所需的功能。

className=ReflectDemo.Creeps
methodName=attack

package ReflectDemo;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

public class reflectMain {
    public static void main(String[] args) throws Exception {
        // 加载配置文件
        Properties properties = new Properties();
        File file = new File("moba.properties");
        properties.load(new FileInputStream(file));
        // 获取配置文件数据
        String className = (String) properties.get("className");     // 全类名
        String methodName = (String) properties.get("methodName");   // 方法名

        // 创建Class对象
        Class aClass = Class.forName(className);
        // 构造方法
        Constructor aClassConstructor = aClass.getConstructor(String.class,int.class,int.class,int.class);
        Creeps wolf = (Creeps) aClassConstructor.newInstance("三狼", 1, 89, 400);
        // 获取方法对象
        Method aMethod = aClass.getDeclaredMethod(methodName);

        // 执行方法
        aMethod.invoke(wolf);		//三狼攻击了你，英雄血量-89

    }
}