Java 之反射

Posted PS-Jerry

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 之反射相关的知识,希望对你有一定的参考价值。

反射概述

反射概述:

  • 反射(Reflection) 是被视为 动态语言 的关键,反射机制允许程序在执行期间借助于Reflection API 取得任何内部类的信息,并能直接操作任意对象的内部属性及方法。
  • 加载完类之后,在堆内存的方法区中就产生了一个Class 类的对象(一个类只有一个Class 对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以我们形象的称之为 反射

反射主要涉及到的包:

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

反射演示

比如我们有一个 Person 类,如下代码演示如何动态获取 Person 类,并对其属性和方法进行操作。

@Test
    public void test1() throws Exception {
        Class clazz = Person.class;
        //1.通过反射,创建Person 类的对象
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("Tom", 22);
        Person p = (Person) obj;
        System.out.println(p.toString());

        //2.通过反射,调用对象指定的属性、方法
        //调用属性,这里可以调用和设置私有属性
        Field age = clazz.getDeclaredField("age");
        //通过反射设置当前实例Person的age属性
        age.setAccessible(true);
        age.set(p, 10);

        //3.调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        //4.调用私有方法,指定一个参数:
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);//调用私有方法,必须去指定它的访问权限,权限为true,才可以调用该方法
        showNation.invoke(p, "China");

        //5.调用方法,带返回值的
        Method getName = clazz.getDeclaredMethod("getName");
        String name1 = (String) getName.invoke(p);//这里需要强转下返回值
        System.out.println(name1);

        //6.调用静态方法
        Method showDesc = clazz.getDeclaredMethod("showDesc", String.class);
        showDesc.setAccessible(true);
        Object returnVal = showDesc.invoke(Person.class, "Jerry description");//这里是void方法,所以返回值是null
        //Object returnVal = showDesc.invoke(null,"Jerry description");//或者填null也是可以的
        System.out.println("Return value is: " + returnVal);
    }

获取Class 的方式

  • 有四种方式可以动态获取大Class

方式1:使用.class

//方式一:调用运行时的类的属性: .class
Class clazz1 = Person.class;
System.out.println(clazz1);

方式2:使用getClass()

//方式二:通过运行时类的对象,调用getClass()
Person p2 = new Person();
Class clazz2 = p2.getClass();
System.out.println(clazz2);

方式3:使用forName(String classPath)

//方式三:调用Class 的静态方法,forName(String classPath)
Class clazz3 = Class.forName("com.jerry.reflection1.Person");
System.out.println(clazz3);

方式4:使用ClassLoader

//方式四:使用ClassLoader(作为了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class<?> clazz4 = classLoader.loadClass("com.jerry.reflection1.Person");
System.out.println(clazz4);
  • 注意: 4种方式创建的实例对象,指向同一个实例

      System.out.println(clazz1 == clazz2);
      System.out.println(clazz1 == clazz3);
      System.out.println(clazz1 == clazz4);
    

理解java.lang.Class

类的加载过程:

  • 程序通过javac.exe 命令以后,会生成一个或多个字节码文件(.class结尾的文件),
    接着我们使用java.exe命令,对某个字节码文件进行解释运行,相当于将某个字节码文件加载到内存中,此过程称为类的加载。
    加载到内存类中,我们就称为运行时类,此时运行时类,就作为Class 的一个实例。
  • 简单来说:大Class 类其实就是对应运行时类的一个实例。
  • 体现出:万事万物皆对象

可以获取Class 场景

  • 可以动态获取 Class 实例的场景如下:

      @Test
      public void test3() throws Exception {
          Class c1 = Object.class;
          Class c2 = Comparable.class;
          Class c3 = String[].class;
          Class c4 = int[][].class;
          Class c5 = ElementType.class;
          Class c6 = Override.class;
          Class c7 = int.class;
          Class c8 = void.class;
          Class c9 = Class.class;
      
          int[] a = new int[10];
          int[] b = new int[100];
          Class c10 = a.getClass();
          Class c11 = b.getClass();
      
          //只要元素类型与维度一样,就是同一个Class
          System.out.println(c10 == c11);
      }
    

示例:反射文件获取内容

例如: 我们有一个jdbc.properties 的资源文件,如下:

我们要获取其中配置文件的 userpassword 可以按如下办法:

方式1:FileInputStream

  • 通过 FileInputStream 文件流的方式,获取配置文件中的内容

      Properties props = new Properties();
      //通过读取文件方式,获取配置文件中的内容,使用这种方式配置文件前面加src\\\\
      FileInputStream fis = new FileInputStream("src\\\\jdbc.properties");
      props.load(fis);
    
      String user = props.getProperty("user");
      String password = props.getProperty("password");
      System.out.println("User: " + user + " Password: " + password);
    

方式2:getClassLoader

  • 通过反射 getClassLoader 在获取文件流方式,获取配置文件中内容

      //通过类的加载器获取资源文件中的内容,配置文件是在当前文件目录下
      Properties props = new Properties();
      ClassLoader classLoader = ReflectionTest.class.getClassLoader();
      InputStream is = classLoader.getResourceAsStream("jdbc.properties");
      props.load(is);
      String user1 = props.getProperty("user");
      String password1 = props.getProperty("password");
      System.out.println("User1: " + user1 + " Password1: " + password1);
    

创建运行时类的对象

概述:我们通常需要根据反射,来动态的创建运行时类的对象,可以按如下方法:

@Test
public void test5() throws Exception {
    Class<Person> clazz = Person.class;
    Person person = clazz.newInstance();
    System.out.println(person);

    //这里是新创建的对象,所以不相等
    Person person1 = clazz.newInstance();
    Person person2 = clazz.newInstance();
    System.out.println(person1 == person2);//false
}

注意: newInstance() 方法调用时,对应实例类中必须有对应的空参构造器,没有的话就会报错

总结:要想此方法正常的创建运行时类的对象,要求:

  • 1.运行时类必须提供空参的构造器
  • 2.空参的构造器访问权限得够,通常为public

扩展:在javabean 中通常要求提供一个public 的空参构造器,好处如下:

  • 1.便于通过反射,创建运行时类的对象
  • 2.便于子类继承此运行类时,默认调用super() 时,保证父类有此构造器

示例:体会反射的动态性

@Test
public void test6() {

    for (int i = 0; i < 50; i++) {
        int num = new Random().nextInt(3);
        String classPath = "";
        switch (num) {
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.jerry.reflection1.Person";
                break;
        }

        try {
            Object obj = getInstance(classPath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public Object getInstance(String classPath) throws Exception {
    Class clazz = Class.forName(classPath);
    return clazz.newInstance();
}

**总结: **上述代码,通过switch-case通过传入的 classPathname 不同,既可以动态创建实例,这里就体现了反射的动态性。

附录:Person 类代码

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

    public Person() {
        System.out.println("Person constructor");
    }

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

    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;
    }

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

    public void show() {
        System.out.println("This is a person");
    }

    private void showNation(String nation) {
        System.out.println("My nation is : " + nation);
    }

    private static void showDesc(String desc) {
        System.out.println("My description is: " + desc );
    }
}

以上是关于Java 之反射的主要内容,如果未能解决你的问题,请参考以下文章

Java基础之反射

反射机制

Java反射之剖析方法

细说java系列之反射

Java基础之反射

Java之Junit和反射