JAVA基础知识|反射

一、理解反射

1.1、基础概念

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

“运行状态”，如何理解？

"运行状态"体现了反射的应用场景，当一些类，不需要提前加载进JVM内存，而是在运行时根据需要进行加载的时候，就可以通过反射进行动态加载

1.2、如何理解反射？

学习过java的童鞋，肯定对spring、hibernate一点也不会陌生。在进行底层配置的时候，会涉及到不同类型的数据库问题。例如sqlserver，可能会这样配置方言“org.hibernate.dialect.SQLServer2008Dialect”，而oracle，可以能会这样配置“org.hibernate.dialect.OracleDialect”。不同的数据库，只需要修改配置文件中的方言即可，这就是利用了反射的功能。程序在编译时，并不知道会使用哪种类型的数据库，只有在运行时，动态读取方言的配置，加载相应的类，运行类中定义的方法和属性，从而实现相应的功能。

其实说简单点，反射就是一种机制，可以让你仅知道类的名字的情况下，了解整个类的内部的结构，并且访问内部的成员和方法等

spring中的依赖注入、反转控制使用的都是这种机制

二、反射API及使用

反射机制的实现需要四个类：Class、Constructor、Field、Method

Class类：在程序运行期间，系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行，保存这些信息的类被称为Class

Constructor、Field、Method：分别用于描述类的构造器、域、方法

下面我们用一个简单的例子来演示反射的使用：

package com.my.po;

/**
 * description:{description}
 * author:jyy
 * date:2018-02-06 16:28
 * modify:{modify}
 */
public interface InterFace {
    void read();
}

package com.my.po;

/**
 * description:{description}
 * author:jyy
 * date:2018-02-03 13:20
 * modify:{modify}
 */
public class Person implements InterFace {

    private String id;

    private String name;

    public String age;

    //构造函数1
    public Person() {

    }

    //构造函数2
    public Person(String id) {
        this.id = id;
    }

    //构造函数3
    public Person(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    /**
     * 静态方法
     */
    public static void update() {

    }

    @Override
    public void read() {

    }
}

1）三种方式获取Class类对象

        //第一种方法：forName
        try {
            Class<?> class1 = Class.forName("com.my.po.Person");
            System.out.println( class1 );
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //第二张方法：class
        Class<?> class2 = Person.class;
        System.out.println( class2 );

        //第三种方法：getClass
        Person person = new Person();
        Class<?> class3 = person.getClass();

        System.out.println( class3 );

执行结果：

class com.my.po.Person
class com.my.po.Person
class com.my.po.Person

2）获取类中方法

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //getMethods()获取当前类及其父类所有的public方法
            Method[] methods1 = class1.getMethods();
            for (Method method : methods1) {
                System.out.println(method);
            }
            System.out.println("==================");

            //getDeclaredMethods()获取当前类所有的方法，包括private、protected修饰的方法，但不可以获取父类的方法
            Method[] methods2 = class1.getDeclaredMethods();
            for (Method method : methods2) {
                System.out.println(method);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

执行结果：

public static void com.my.po.Person.update()
public java.lang.String com.my.po.Person.getName()
public void com.my.po.Person.read()
public java.lang.String com.my.po.Person.getId()
public void com.my.po.Person.setName(java.lang.String)
public java.lang.String com.my.po.Person.getAge()
public void com.my.po.Person.setId(java.lang.String)
public void com.my.po.Person.setAge(java.lang.String)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
==================
public static void com.my.po.Person.update()
public java.lang.String com.my.po.Person.getName()
public void com.my.po.Person.read()
public java.lang.String com.my.po.Person.getId()
public void com.my.po.Person.setName(java.lang.String)
public java.lang.String com.my.po.Person.getAge()
public void com.my.po.Person.setId(java.lang.String)
public void com.my.po.Person.setAge(java.lang.String)

3）获取实现的接口

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //获取所有的接口
            Class<?>[] interfaces = class1.getInterfaces();

            for (Class<?> class2 : interfaces) {
                System.out.println(class2);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

运行结果：

interface com.my.po.InterFace

4）获取父类

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //获取父类
            Class<?> superClass = class1.getSuperclass();

            System.out.println(superClass);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

运行结果：

class java.lang.Object

5）获取构造函数

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //getConstructors()获取当前类所有的公有构造器
            Constructor<?>[] constructors1 = class1.getConstructors() ;

            for (Constructor<?> constructor : constructors1) {
                System.out.println( constructor );
            }
            System.out.println("================");
            //getDeclaredConstructors获取当前类所有的构造器，不包括父类构造器
            Constructor<?>[] constructors2 = class1.getDeclaredConstructors() ;
            for (Constructor<?> constructor : constructors2) {
                System.out.println( constructor );
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

public com.my.po.Person(java.lang.String,java.lang.String)
public com.my.po.Person(java.lang.String)
public com.my.po.Person()
================
public com.my.po.Person(java.lang.String,java.lang.String)
public com.my.po.Person(java.lang.String)
public com.my.po.Person()

6）获取属性

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //getDeclaredFields()取得当前类的全部属性，包括private、protected修饰的属性
            Field[] field1 = class1.getDeclaredFields();

            for (Field field : field1) {
                System.out.println( field );
            }

            System.out.println("==================");

            //getFields()取得当前类和父类所有public修饰的属性
            Field[] field2 = class1.getFields();

            for (Field field : field2) {
                System.out.println( field );
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

运行结果：

private java.lang.String com.my.po.Person.id
private java.lang.String com.my.po.Person.name
public java.lang.String com.my.po.Person.age
==================
public java.lang.String com.my.po.Person.age

7）使用获取到的Class对象，创建实例

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //创建实例化：相当于 new 了一个对象
            Object object = class1.newInstance();

            //向下转型
            Person person;
            if (object instanceof Person) {
                person = (Person) object;
                person.setAge("20");
                System.out.println(person.getAge());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

运行结果：20

三、实战项目

一个简单的例子，使用上面所列的api

        try {
            //创建类
            Class<?> class1 = Class.forName("com.my.po.Person");

            //创建实例
            Object obj = class1.newInstance();
            Person person;
            if (obj instanceof Person) {
                person = (Person) obj;
            } else {
                person = null;
            }

            //给id,name,age赋值
            Field idField = class1.getDeclaredField("id");
            idField.setAccessible(true);//打破私有属性封装
            idField.set(person, "1001");
            Field nameField = class1.getDeclaredField("name");
            nameField.setAccessible(true);//打破私有属性封装
            nameField.set(person, "李明");
            Field ageField = class1.getDeclaredField("age");
            ageField.setAccessible(true);//打破私有属性封装
            ageField.set(person, "30");

            //通过执行方法给id,name,age赋值
            Method setNameMethod = class1.getDeclaredMethod("setName", String.class);
            setNameMethod.invoke(person, "王立");

            //查询属性值
            String id = (String) idField.get(person);
            System.out.println(id);
            String name = (String) nameField.get(person);
            System.out.println(name);

        } catch (Exception e) {
            e.printStackTrace();
        }

下面是一个模拟配置文件的例子

新建两个类Bird、Dragonfly

public class Bird {

    public void fly() {
        System.out.println("小鸟正在飞");
    }
}
public class Dragonfly {

    public void fly() {
        System.out.println("蜻蜓正在飞");
    }
}

新建配置文件configure.properties

animal.forclass=com.my.po.Dragonfly
animal.method=fly

        try {
            //读取配置文件
            ResourceBundle resource = ResourceBundle.getBundle("configure");
            String className = resource.getString("animal.forclass");
            String methodName = resource.getString("animal.method");

            //获取类
            Class<?> class1 = Class.forName(className);
            //根据方法名称，获取方法对象
            Method m = class1.getMethod(methodName);
            //获取构造器
            Constructor<?> constructor = class1.getDeclaredConstructor();
            //根据构造器，实例化出对象
            Object obj = constructor.newInstance();
            //调用对象的指定方法
            m.invoke(obj);

        } catch (Exception e) {
            e.printStackTrace();
        }

执行结果：

蜻蜓正在飞

修改configure.properties文件中的animal.forclass=com.my.po.Bird

执行结果：

小鸟正在飞

分享结束，如果还想对反射有更深入的理解，可以搜索ObjectAnalyzer或ReflectionToStringBuilder，试着重写toString方法