【java基础】一篇文章彻底搞懂java反射

基本介绍

反射库（reflection library)提供了一个丰富且精巧的工具集，可以用来编写能够动态操纵Java代码的程序。使用反射，Java可以支持用户界面生成器、对象关系映射器以及很多其他需要动态查询类能力的开发工具。

能够分析类能力的程序称为反射（reflective)。反射机制的功能极其强大，反射机制主要功能如下

• 在运行时分析类的能力。
• 在运行时检查对象
• 实现泛型数组操作代码。
• 利用Method对象

由于反射内容非常的多，这篇文章只做基本的介绍，以及讲解最常见的操作和一般在什么地方进行使用

Class类

在程序运行期间，Java运行时系统始终为所有对象维护一个运行时类型标识。这个信息会跟踪每个对象所属的类。虚拟机利用运行时类型信息选择要执行的正确的方法。

不过，可以使用一个特殊的Java类访问这些信息。保存这些信息的类名为Class,这个名字有些让人困惑。Object类中的getClass()方法将会返回一个Class类型的实例。

我是理解为Class就是一个普通类，只不过包含了某个类的所有信息

        String s = "hello";
        Class aClass = s.getClass();

下面是关于Class源代码中的注释

根据注释的说明，我们可以通过对象或者基本数据类型或者void构造Class对象，对于基本数据类型或者类，我们可以使用 类名(类型).class来获取Class对象

        Class intClass = int.class;
        Class doubleClass = double.class;
        Class voidClass = void.class;
        Class mathClass = Math.class;

我们也可以通过Class.forName(类名全路径)构造Class对象，这样做有上面好处呢？如下

如果类名保存在一个字符串中，这个字符串会在运行时变化，就可以使用这个方法。如
果className是一个类名或接口名，这个方法可以正常执行。

        Class str = Class.forName("java.lang.String");

对于Class这里做一些说明，一个Clss对象实际上表示的是一个类型，这可能是类，也可能不是类。例如，int不是类，但int.class是一个Class类型的对象。

我们在得到Class对象后可以通过getName方法得到表示类型或者类的名称(全类名)

        Class mathClass = Math.class;
        System.out.println(mathClass.getName()); // 输出java.lang.Math

上面这些都不是主要的，Class对象最重要的一个功能是可以构造对象

        Class aClass = Class.forName("java.util.Random");
        Object o = aClass.newInstance();
        Random random = (Random) o;

我们通过Class对象的newInstance就可以创建一个Random对象。默认是通过无参构造器创建的，如果想通过其他构造器创建，这在文章后面的Constructor会进行说明。

最后，对于Class还要一些要点进行说明

• 虚拟机为每个类型管理一个唯一的Clss对象。因此，可以利用=运算符实现两个类对象的比较
• 对于数组类型的Class对象，使用getName会返回奇怪的名称

对于Class类，主要是通过它来获取某个类的方法，字段，构造器，注解，然后进行一系列处理

Filed类

在介绍Filed类之前，先来看一下Filed类的注释

这个类就是用来描述类的字段的。

我们可以通过Class对象的getFiled或者getDeclaredFiled来获得某个字段，只需要传入参数的名称就行了。getFiled和getDeclaredFiled的区别就是前者表示获得当前类或者父类的可访问字段，后者获得当前类的全部字段，如果这2个方法多了个s，那么就表示返回所有。
下面代码就对Filed进行了基本使用

class People{
    private String name = "123";
    public int age;
}
class Man extends People {
    private String gender;

    public Man(String gender) {
        this.gender = gender;
    }
}

下面我们通过Filed获取gender的值

    @Test
    public void t1() throws Exception {
        Man man = new Man("男");
        // 由于gender是私有的，我们只能使用getDeclaredField
        Field name = man.getClass().getDeclaredField("gender");
        // 如果访问字段是无法访问的，那么必须使用setAccessible方法将其设置为可访问
        name.setAccessible(true);
        // 通过get方法获取指定对象字段的值，会返回Object类型
        Object o = name.get(man);
        System.out.println(o.getClass());
        System.out.println(o);

        // 我们还可以更改gender字段的值
        name.set(man, "女");
        System.out.println(name.get(man));
    }

输出如下

我们通过反射，就可以实现对一个类任意字段的操作。上面只演示了一个get和set方法，其实Filed拥有的方法很多，这里实在讲不完，建议参考api文档

方法非常的多，我们可以这些方法完成对字段的任意操作

Method类

我们还是先来看一下这个类上面的注释

Method用来描述方法字段的。getMethod方法和getDeclaredMethod方法区别和Filed里面的区别是一样的，就不赘述了。
对于getMethod方法，可以发现要传入2个参数，一个是方法名，还有一个就是方法参数的Class对象

Method对象最重要的一个方法就是invoke方法，通过这个方法我们可以调用某个对象的Method方法。

class Cat {

    public void eat(String food) {
        System.out.println("eat..." + food);
    }
}

下面我们就通过反射来调用Cat的eat方法

    @Test
    public void t1() throws Exception {
        Cat cat = new Cat();
        Method method = cat.getClass().getMethod("eat", String.class);
        method.invoke(cat, "fish");
    }

上面的输出如下

对于invoke方法参数说明和介绍参考下面注释

Invokes the underlying method represented by this Method object, on the specified object with the specified parameters. Individual parameters are automatically unwrapped to match primitive formal parameters, and both primitive and reference parameters are subject to method invocation conversions as necessary.
If the underlying method is static, then the specified obj argument is ignored. It may be null.
If the number of formal parameters required by the underlying method is 0, the supplied args array may be of length 0 or null.
If the underlying method is an instance method, it is invoked using dynamic method lookup as documented in The Java Language Specification, Second Edition, section 15.12.4.4; in particular, overriding based on the runtime type of the target object will occur.
If the underlying method is static, the class that declared the method is initialized if it has not already been initialized.
If the method completes normally, the value it returns is returned to the caller of invoke; if the value has a primitive type, it is first appropriately wrapped in an object. However, if the value has the type of an array of a primitive type, the elements of the array are not wrapped in objects; in other words, an array of primitive type is returned. If the underlying method return type is void, the invocation returns null.

invoke这个方法十分有用，很多框架的底层也是通过invoke进行反射调用目标方法。

对于Method，我们可以理解为它就是包含了方法全部信息的一个类，当然我们也可以获取方法的其他内容，比如参数列表，返回值，访问修饰符

        Cat tom = new Cat();
        Method eatMethod = tom.getClass().getMethod("eat", String.class);
        // 方法名
        String name = eatMethod.getName();
        // 返回类型
        Class returnType = eatMethod.getReturnType();
        // 参数个数
        int parameterCount = eatMethod.getParameterCount();
        // 访问修饰符
        int modifiers = eatMethod.getModifiers();

Constructor类

这个类拥有Contructor的全部信息，我们通过这个类可以轻松构建对象。我们还是来看一下这个类的注释

Constructor和Filed，Method用法都是类似的，我们只需要先构建起一个Constructor对象，然后就可以获取到构建对象的全部信息了，下面就使用Contructor来反射创建对象

class Dog {
    private String name;
    private Integer age;

    public Dog(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Dog(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

这个类有2个构造器，我们通过反射分别通过2个构造器来创建对象

    @Test
    public void t1() throws Exception {
        // 通过一个参数构造器构造对象
        Constructor nameConstructor = Dog.class.getConstructor(String.class);
        Object instance = nameConstructor.newInstance("旺财");
        System.out.println(instance);

        // 通过2个参数构造器构造对象
        Constructor constructor = Dog.class.getConstructor(String.class, Integer.class);
        Object o = constructor.newInstance("大黄", 1);
        System.out.println(o);
    }

我们使用getConstructor方法，传入参数列表对应的Class，然后我们就能够获取到Contructor对象，于是就可以通过反射创建对象，就好像new创建对象一样。上面代码输出如下

我们使用Constructor也可以获取到对应构造器的所有信息，这里就不演示了。

获取Annotation信息

我们可以通过反射得到对应的Annatation对象，这个类里面就包含了注解的全部信息。

不多废话，直接走代码

class A {
    @MyRequestMapping("/info/{id}")
    public int getInfoById(int id) {
        return id + 10;
    }
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyRequestMapping {
    String[] value() default "";
}

上面代码中我自定义了一个MyRequestMapping注解，里面有一个value[]类型的属性，该注解用在了A类里面的getInfoById上面。现在我们就要通过代码来获取到getInfoById方法上面注解的值。

    @Test
    public void t() throws Exception {
        // 反射得到方法
        Method method = A.class.getMethod("getInfoById", int.class);
        // 反射得到方法上的注解
        MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
        // 获取到注解的值
        String[] value = annotation.value();
        System.out.println(Arrays.toString(value));
    }

我们通过 方法.getAnnotation可以很，容易的获取到注解对象，只需要传入对应的注解类型就可以了。我们得到了注解的Class对象，自然也就可以获取到注解的value。上面代码输出如下

如果学习过springMVC的人看见这个代码应该已经感觉到反射的厉害之处了，我们上面的解析过程不就是和springMVC解析RequestMapping类似的吗，事实上，也确实是这样的。

Modify工具类

我们上面学习知道了通过反射可以获取到类，方法，字段，构造器的全部信息，当然也包括访问修饰符，我们通过getModifiers可以返回修饰符。看下面例子

class Pig {
    public String name;
    public static Integer age;
    public static final Double PI = 3.14;
}

我们使用反射获取到3个字段的修饰符，看返回什么

    @Test
    public void t() throws Exception {
        Field name = Pig.class.getField("name");
        Field age = Pig.class.getField("age");
        Field pi = Pig.class.getField("PI");

        int nameModifiers = name.getModifiers();
        int ageModifiers = age.getModifiers();
        int piModifiers = pi.getModifiers();

        System.out.println("nameModifiers--" + nameModifiers);
        System.out.println("ageModifiers--" + ageModifiers);
        System.out.println("ageModifiers--" + piModifiers);
    }

上面代码输出如下

可以发现返回的是int值，我们完全不知道是上面含义，其实getModifiers返回的就是修饰符的累加和，每个修饰符都用了一个值来代码，我们可以在Modify类中查看对应的值

老样子，我们还是来看一下Modify类注释

大概意思就是Modifier类提供静态方法和常量来解码类和成员访问修饰符。于是我们就可以通过该类方便的对getModifiers返回的修饰符进行解析，我们对上面的代码进行一下改写，利用Modify.toString方法来输出修饰符信息。这个方法传入一个int类型的修饰符，会返回对应的修饰符

    @Test
    public void t() throws Exception {
        Field name = Pig.class.getField("name");
        Field age = Pig.class.getField("age");
        Field pi = Pig.class.getField("PI");

        int nameModifiers = name.getModifiers();
        int ageModifiers = age.getModifiers();
        int piModifiers = pi.getModifiers();

        System.out.println("nameModifiers-- " + Modifier.toString(nameModifiers));
        System.out.println("ageModifiers-- " + Modifier.toString(ageModifiers));
        System.out.println("ageModifiers-- " + Modifier.toString(piModifiers));
    }

上面代码输出如下

Modify还提供了许多静态方法，比如用来判断的

利用这些方法就可以判断getModifiers是否包含了指定的修饰符，下面代码就是一个使用

    @Test
    public void t2() throws Exception {
        Field age = Pig.class.getField("age");
        int ageModifiers = age.getModifiers();
        System.out.println(Modifier.isStatic(ageModifiers)); // true
        System.out.println(Modifier.isFinal(ageModifiers)); // false
    }

实例运用(修改字符串值)

通过上面的说明，可能大家还没有感觉到反射的强大之处，现在我通过一个例子来让大家感受一下反射的强大。
我们都知道在java中的String是不可变的对象，一旦确认值就不能够修改。但是真的不能够修改吗？我们下面就先来看一下String的源代码

可以发现字符串是存储在一个char类型的数组中的，使用private和final进行修饰。我们知道，使用final修饰对象，只要引用不变即可。而对应private，我们一般情况下无法访问，但是通过反射就不一样了，我们可以使用getDeclaredField获取到私有字段，然后setAccessible(true)将其设置为可访问。下面代码就会修改字符串的值

    public static void main(String[] args) throws Exception{
        String name = "我是lucy";
        System.out.println("修改前name的值："+name);
        System.out.println("修改前name的hashcode："+name.hashCode());
        // 反射获取字符串中名称为value的字段
        Field value = String.class.getDeclaredField("value");
        // 设置私有字段可访问
        value.setAccessible(true);
        // 将返回的类型强转转换为char[]
        char[] chars = (char[]) value.get(name);
        // 修改内容
        chars[2] = 'j';
        chars[3] = 'a';
        chars[4] = 'c';
        chars[5] = 'k';
        
        System.out.println("--------------------");
        System.out.println("修改后name的值："+name);
        System.out.println("修改后name的hashcode："+name.hashCode());
    }

上面代码输出如下

可以发现我们已经修改了字符串的值，并没有创建新的对象，通过这个案例，大家应该感受到反射的厉害之处了吧。反射在框架中用的特别多。

总结

反射功能十分强大，通过反射，我们可以获得类、方法、构造器、字段、注解的全部信息，这也就使得我们拥有了在程序运行时分析对象的能力。

以Filed进行举例，在这里需要着重提醒的是，对于getFiled只能获得可访问的字段，包含父类的字段。而如果加上declared，也就是getDeclaredField就可以获取当前类的所有字段，不包含父类字段。如果访问私有字段，我们要使用setAccessible(true)，将其设置为可访问。对于Constructor和Method，上面规则也是类似的。

反射在框架中运用十分的多，建议继续阅读相关资料加强理解。