【你了解 Java 反射机制吗？】

希望此篇博客可以对您有所帮助，了解反射的奇妙！

反射

1.什么是反射

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。）语言的一个关键性质

2.反射能做什么

我们知道反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括包括其modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变fields内容或调用methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！

3.反射的具体实现

3.1 获取 Class 的三种方式

我们先来创建一个 Person 类，里面包含私有和非私有的一些属性和方法

class Person{
    
    
    //私有属性
    private String name = "Tom";
    //共有属性
    public int age  = 18;
    //构造
    public Person(){
    
    

    }
    //私有方法
    public void say(){
    
    
        System.out.println("私有方法");
    }
    //公有方法
    public void work(){
    
    
        System.out.println("公有方法");
    }
}

然后分别用三种方式去获得当前的 Person 类

public class Test {
    
    
    public static void main(String[] args) {
    
    
        //1、
        Person p = new Person();
        Class c1 = p.getClass();
        System.out.println("c1:"+c1);
        //2、
        Class c2 = Person.class;
        System.out.println("c2:"+c2);
        //3、
        try {
    
    
            Class c3 = Class.forName("tulun.HUAWEI.Person");
            System.out.println("c3:"+c3);
        } catch (ClassNotFoundException e) {
    
    
            e.printStackTrace();
        }
    }
}

运行结果：

c1:class tulun.HUAWEI.Person
c2:class tulun.HUAWEI.Person
c3:class tulun.HUAWEI.Person

我们来解析解析上面得到 Class 的三种方式：

1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object类型的对象，而我不知道你具体是什么类，用这种方法：

Person p1 = new Person();
Class c1 = p1.getClass();

2、直接通过类名.class 的方式得到,该方法最为安全可靠，程序性能更高这说明任何一个类都有一个隐含的静态成员变量 class

Class c2 = Person.class;

3、通过 Class 对象的 forName() 静态方法来获取，用的最多，但可能抛出 ClassNotFoundException 异常

Class c3 = Class.forName("类的全路径");

注意：一个类在 JVM 中只会有一个Class实例，很好验证：我们用上面的 c1、c2、c3进行 equals比较，结果都为 true

3.2 Class 类获取成员变量、成员方法、接口、超类、构造方法

通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

常用方法如下：

getName()：获得类的完整名字。

getFields()：获得类的public类型的属性。

getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类

getMethods()：获得类的public类型的方法。

getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类

getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。

getConstructors()：获得类的public类型的构造方法。

getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。

newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

栗子：

public class Test {
    
    
    public static void main(String[] args) throws Exception {
    
    
        Class c2 = Person.class;
        String className = c2.getName();
        System.out.println("获取类完整的名字：" + className);

        Field[] fields = c2.getFields();
        for (Field field : fields) {
    
    
            System.out.println("获取类的public属性：" + field);
        }

        Field[] fields1 = c2.getDeclaredFields();
        for (Field field : fields1) {
    
    
            System.out.println("获取类的所有属性：" + field);
        }

        Method[] methods = c2.getMethods();
        for (Method method : methods) {
    
    
            System.out.println("获取类的public方法：" + method);
        }

        Method[] methods1 = c2.getDeclaredMethods();
        for (Method method : methods1) {
    
    
            System.out.println("获取类的所有方法：" + method);
        }


        Field f1 = c2.getField("age");
        System.out.println("获取指定属性 age:" + f1);


        Field f2 = c2.getDeclaredField("name");
        System.out.println("获取指定私有属性 f2:" + f2);

        //启动和禁用访问安全检查开关，true：表示反射的对象在使用是应该取消
        //java语言检查；反之则不取消
        f2.setAccessible(true);
        //创建这个类的一个对象
        Object p2 = c2.newInstance();
        //将 p2 对象的 f2 属性赋值为 Bob，f2 属性即为 私有属性 name
        f2.set(p2, "Bob");
        //使用反射机制可以打破封装性，导致了java对象的属性不安全
        System.out.println(f2.get(p2));//Bob

        //获取构造
        Constructor[] constructors = c2.getConstructors();
        for (Constructor constructor : constructors) {
    
    
            System.out.println(constructor.toString());//public com.ys.reflex.Person()
        }
    }
}

运行结果：

获取类完整的名字：tulun.HUAWEI.Person
获取类的public属性：public int tulun.HUAWEI.Person.age
获取类的所有属性：private java.lang.String tulun.HUAWEI.Person.name
获取类的所有属性：public int tulun.HUAWEI.Person.age
获取类的public方法：public void tulun.HUAWEI.Person.work()
获取类的public方法：public void tulun.HUAWEI.Person.say()
获取类的public方法：public final void java.lang.Object.wait() throws java.lang.InterruptedException
获取类的public方法：public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
获取类的public方法：public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
获取类的public方法：public boolean java.lang.Object.equals(java.lang.Object)
获取类的public方法：public java.lang.String java.lang.Object.toString()
获取类的public方法：public native int java.lang.Object.hashCode()
获取类的public方法：public final native java.lang.Class java.lang.Object.getClass()
获取类的public方法：public final native void java.lang.Object.notify()
获取类的public方法：public final native void java.lang.Object.notifyAll()
获取类的所有方法：public void tulun.HUAWEI.Person.work()
获取类的所有方法：public void tulun.HUAWEI.Person.say()
获取指定属性 age:public int tulun.HUAWEI.Person.age
获取指定私有属性 f2:private java.lang.String tulun.HUAWEI.Person.name
Bob
public tulun.HUAWEI.Person()

获取父类属性：

方式1：栗子：创建一个son继承father 类

public class Test{
    
    
    public static void main(String[] args) throws Exception {
    
    
        son son = new son();
        Field[]fields = getAllFields(son);
        System.out.println(Arrays.toString(fields));
    }
    public static Field[] getAllFields(Object object){
    
    
        Class clazz = object.getClass();
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null){
    
    
            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
            clazz = clazz.getSuperclass();
        }
        Field[] fields = new Field[fieldList.size()];
        fieldList.toArray(fields);
        return fields;
    }

}
class Parent {
    
    
    public String publicField = "parent_publicField";
    protected String protectField = "parent_protectField";
    String defaultField = "parent_defaultField";
    private String privateField = "parent_privateField";
}
class son extends Parent{
    
    
    
}

结果：

[public java.lang.String tulun.HUAWEI.Parent.publicField, protected java.lang.String tulun.HUAWEI.Parent.protectField, java.lang.String tulun.HUAWEI.Parent.defaultField, private java.lang.String tulun.HUAWEI.Parent.privateField]

上面的 getAllFields 方法通过while循环及getSuperClass()方法获取当前类的父类再进行getDeclaredFields()即可,注意这个方法返回的是一个Field数组,然后如果我们想要把这些属性拼接到一起,当然是使用链表更方便一些,利用Arrays.asList()方法将数组转化为链表

方式2：栗子

父类 Parent.java

public class Parent {
    
    
  public String publicField = "parent_publicField";
  protected String protectField = "parent_protectField";
  String defaultField = "parent_defaultField";
  private String privateField = "parent_privateField";
}

子类 Son.java

public class Son extends Parent {
    
    
}

测试：

public class ReflectionTest {
    
    
  @Test
  public void testGetParentField() throws Exception{
    
    
    Class c1 = Class.forName("com.ys.model.Son");
    //获取父类私有属性值
    System.out.println(getFieldValue(c1.newInstance(),"privateField"));
  }
  public static Field getDeclaredField(Object obj,String fieldName) {
    
    
    Field field = null;
    Class c = obj.getClass();
    for(; c != Object.class ; c = c.getSuperclass()){
    
    
      try {
    
    
        field = c.getDeclar4edField(fieldName);
        field.setAccessible(true);
        return field;
      }catch (Exception e){
    
    
        //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
        //如果这里的异常打印或者往外抛，则就不会执行c = c.getSuperclass(),最后就不会进入到父类中了
      }
    }
    return null;
  }
  public static Object getFieldValue(Object object,String fieldName) throws Exception{
    
    
    Field field = getDeclaredField(object,fieldName);
    return field.get(object);
  }
}

通过执行上述代码，我们获得了父类的私有属性值，这里要注意的是直接通过反射获取子类的对象是不能得到父类的属性值的，必须根据反射获得的子类 Class 对象在调用 getSuperclass() 方法获取父类对象，然后在通过父类对象去获取父类的属性值

4、反射总结

灵活使用反射能让我们代码更加灵活，这里比如JDBC原生代码注册驱动，hibernate 的实体类，Spring 的 AOP等等都有反射的实现。但是凡事都有两面性，反射也会消耗系统的性能，增加复杂性等，合理使用才是真！

【你了解 Java 反射机制 吗？】

反射