Java反射详解

什么是反射(Reflection)?

Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

Class类

在程序运行期间,系统始终为所有的对象维护一个被称为运行时的类型标识。虚拟机利用运行时信息选择相应的方法执行,可以通过专门的Java类访问这些信息,保存这些信息的类被称为Class类。

将Class类中的forName和newInstance配合使用,可以根据存储在字符串中的类名创建一个对象

String s = "java.util.Date";
Object m = Class.forName(s).newInstance();

为什么需要反射?

通过反射,我们能够

  • 在运行时检测对象的类型;
  • 动态构造某个类的对象;
  • 检测类的属性和方法;
  • 任意调用对象的方法;
  • 修改构造函数、方法、属性的可见性。

反射是框架中常用的方法

JUnit

JUnit通过反射来遍历包含 @Test 注解的方法,并在运行单元测试时调用它们。

Web框架

开发人员可以在配置文件中定义对各种接口和类的实现。通过反射机制,框架能够快速地动态初始化所需要的类。

Spring框架使用如下的配置文件:


    

当Spring容器处理 bean 元素时,会使用Class.forName("com.programcreek.Foo")来初始化这个类,并再次使用反射获取 property 元素对应的setter方法,为对象的属性赋值。

Servlet


    someServlet
    com.programcreek.WhyReflectionServlet

如何使用反射?

反射的基本方法

在java.lang.reflect包中有三个重要的类:

  • Field:描述类的域
  • Method:描述类的方法
  • Constructor:描述类的构造器

对于public域(包括超类成员):

  • getFields
  • getMethods
  • getConstructors

对于其它域(包括私有和受保护的成员,不包括超类成员):

  • gettDeclaredFields
  • gettDeclaredMethods
  • gettDeclaredConstructors

下面介绍 Java 反射的使用,其中 Person 类及测试完整代码在本文最后。

加载类

// 加载类的3种方法
Class c1 = Class.forName("com.yano.reflect.Person");
Class c2 = new Person().getClass();
Class c3 = Person.class;

获取类的无参构造函数,并实例化类

Class clazz = Class.forName("com.yano.reflect.Person");
Constructor c = clazz.getConstructor(null);
Person p = (Person)c.newInstance(null);

获取类的含参私有构造函数,并实例化类

Class clazz = Class.forName("com.yano.reflect.Person");
Constructor c = clazz.getDeclaredConstructor(new Class[] { String.class });
// 由于构造函数是private的,所以需要屏蔽Java语言的访问检查
c.setAccessible(true);
Person p = (Person)c.newInstance(new Object[] { "I'm a reflect name!" });

获取并调用类的无参方法

Class clazz = Class.forName("com.yano.reflect.Person");
Constructor c = clazz.getConstructor(null);
Person p = (Person)c.newInstance(null);
Method method = clazz.getMethod("fun", null);
method.invoke(p, null);

获取并调用类的含参方法

Class clazz = Class.forName("com.yano.reflect.Person");
Constructor c = clazz.getConstructor(null);
Person p = (Person)c.newInstance(null);
Method method = clazz.getMethod("fun", new Class[] { String.class });
method.invoke(p, new Object[] { "I'm a reflect method!" });

获取类的字段

Class clazz = Class.forName("com.yano.reflect.Person");
Constructor c = clazz.getDeclaredConstructor(new Class[] { String.class });
// 由于构造函数是 private 的,所以需要获取控制权限
c.setAccessible(true);
Person p = (Person)c.newInstance(new Object[] { "I'm a reflect name!" });
Field f = clazz.getField("name");
Object value = f.get(p);
Class type = f.getType();
System.out.println(type);
if (type.equals(String.class)) {
    System.out.println((String) value);
}

完整代码

Person 类

package com.yano.reflect;

public class Person {

    public String name = "default name";
    public int[] array = new int[10];

    public Person() {
        System.out.println(name);
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
    }

    private Person(String name) {
        this.name = name;
        System.out.println(name);
    }

    public void fun() {
        System.out.println("fun");
    }

    public void fun(String name) {
        System.out.println(name);
    }

}

test类

package com.yano.reflect;

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

public class test {

    /**
     * 反射:加载类的字节码
     * 
     * @throws SecurityException
     * @throws NoSuchMethodException
     */
    public static void main(String[] args) throws Exception {

        refGetClass();

        // 获取并调用无参构造函数
        refGetPublicConstructor();

        // 获取并调用私有的含参构造函数
        refGetPrivateConstructor();

        // 获取并调用无参方法 fun
        refGetMethodWithNoArg();

        // 获取并调用有参数方法 fun
        refGetMethodWithArg();

        // 获取类的字段
        refGetField();
    }

    private static void refGetField() throws Exception {

        Class clazz = Class.forName("com.yano.reflect.Person");
        Constructor c = clazz
                .getDeclaredConstructor(new Class[] { String.class });
        // 由于构造函数是 private 的,所以需要获取控制权限
        c.setAccessible(true);
        Person p = (Person) c
                .newInstance(new Object[] { "I'm a reflect name!" });

        Field f = clazz.getField("name");
        Object value = f.get(p);
        Class type = f.getType();
        System.out.println(type);

        if (type.equals(String.class)) {
            System.out.println((String) value);
        }
        System.out.println();
    }

    private static void refGetMethodWithArg() throws Exception {

        Class clazz = Class.forName("com.yano.reflect.Person");
        Constructor c = clazz.getConstructor(null);
        Person p = (Person) c.newInstance(null);

        Method method = clazz.getMethod("fun", new Class[] { String.class });
        method.invoke(p, new Object[] { "I'm a reflect method!" });
        System.out.println();
    }

    private static void refGetMethodWithNoArg() throws Exception {

        Class clazz = Class.forName("com.yano.reflect.Person");
        Constructor c = clazz.getConstructor(null);
        Person p = (Person) c.newInstance(null);

        Method method = clazz.getMethod("fun", null);
        method.invoke(p, null);
        System.out.println();
    }

    private static void refGetPrivateConstructor() throws Exception {

        Class clazz = Class.forName("com.yano.reflect.Person");
        Constructor c = clazz
                .getDeclaredConstructor(new Class[] { String.class });

        // 由于构造函数是 private 的,所以需要屏蔽Java语言的访问检查
        c.setAccessible(true);

        Person p = (Person) c
                .newInstance(new Object[] { "I'm a reflect name!" });
        System.out.println();
    }

    private static void refGetPublicConstructor() throws Exception {

        Class clazz = Class.forName("com.yano.reflect.Person");
        Constructor c = clazz.getConstructor(null);

        Person p = (Person) c.newInstance(null);
        System.out.println();
    }

    private static void refGetClass() throws ClassNotFoundException {
        // 加载类的3种方法
        Class clazz = Class.forName("com.yano.reflect.Person");
        Class clazz1 = new Person().getClass();
        Class class2 = Person.class;
        System.out.println();
    }

}

反射的适用场景是什么?

(1)Java的反射机制在做基础框架的时候非常有用,有一句话这么说来着:反射机制是很多Java框架的基石。而一般应用层面很少用,不过这种东西,现在很多开源框架基本都已经给你封装好了,自己基本用不着写。典型的除了hibernate之外,还有spring也用到很多反射机制。经典的就是在xml文件或者properties里面写好了配置,然后在Java类里面解析xml或properties里面的内容,得到一个字符串,然后用反射机制,根据这个字符串获得某个类的Class实例,这样就可以动态配置一些东西,不用每一次都要在代码里面去new或者做其他的事情,以后要改的话直接改配置文件,代码维护起来就很方便了,同时有时候要适应某些需求,Java类里面不一定能直接调用另外的方法,这时候也可以通过反射机制来实现。
总的来说,自己写的很少,具体什么时候要用那要看需求,反射机制无非就是根据一个String来得到你要的实体对象,然后调用它原来的东西。但是如果是要自己写框架的话,那就会用得比较多了。

(2)当你做一个软件可以安装插件的功能,你连插件的类型名称都不知道,你怎么实例化这个对象呢?因为程序是支持插件的(第三方的),在开发的时候并不知道。所以无法在代码中new出来,但反射可以,通过反射,动态加载程序集,然后读出类,检查标记之后再实例化对象,就可以获得正确的类实例。

(3)在编码阶段不知道那个类名,要在运行期从配置文件读取类名, 这时候就没有办法硬编码new ClassName(),而必须用到反射才能创建这个对象。反射的目的就是为了扩展未知的应用。比如你写了一个程序,这个程序定义了一些接口,只要实现了这些接口的dll都可以作为插件来插入到这个程序中。那么怎么实现呢?就可以通过反射来实现。就是把dll加载进内存,然后通过反射的方式来调用dll中的方法。很多工厂模式就是使用的反射


性能分析

反射机制是一种程序自我分析的能力。用于获取一个类的类变量,构造函数,方法,修饰符。

  • 优点:运行期类型的判断,动态类加载,动态代理使用反射。
  • 缺点:性能是一个问题,反射相当于一系列解释操作,通知JVM要做的事情,性能比直接的Java代码要慢很多。

你可能感兴趣的:(Java反射详解)