【回归系列】反射

反射就是动态加载对象，并对对象进行剖析。在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法，这种动态获取信息以及动态调用对象方法的功能成为Java反射机制。

 

一、基本操作

package com.slp.springbootelasticsearch.test;

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

/**
 * @author sanglp
 * @create 2018-07-05 17:30
 * @desc 测试类
 **/
public class Student {
    private long id;
    private String name;

    public long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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


    public static  void  main(String[] args){
        try {
            //初始化指定的类
            Class<?> claz= Class.forName("com.slp.springbootelasticsearch.test.Student");
            //获取类中所有的方法（包括其继承类的方法）
            Method[] methods = claz.getMethods();
            for(Method method :methods){
                System.out.println("方法名："+method.getName());
            }
            System.out.println("------------------");
            //获取加载类中的方法，不要父类的方法
            methods = claz.getDeclaredMethods();
            for(Method method :methods){
                System.out.println("方法名："+method.getName());
                System.out.println("方法返回类型："+method.getReturnType().getName());
                System.out.println("方法修饰符："+ Modifier.toString(method.getModifiers()));
                System.out.println("方法参数信息："+ method.getParameters());
                System.out.println("方法上的注解："+method.getAnnotations());
            }
            System.out.println("--------------------");
            //使用反射调用方法 通过class的newInstance()方法构造一个Student对象，然后调用getName()方法，这个时候输出的是null,然后通过方法名获取到setName方法，通过invoke调用方法，传入参数，然后调用getName()方法就可以看到输出的就是我们设置的值“大小”
            Student stu = (Student)claz.newInstance();
            System.out.println(stu.getName());
            Method method = claz.getMethod("setName",String.class);
            method.invoke(stu,"大小");
            System.out.println(stu.getName());
            System.out.println("--------------------");
            //获取类中所有属性 getFields只能获取public的属性，包括父类的
            Field[]  fields = claz.getFields();
            for(Field field:fields){
                System.out.println("属性名"+field.getName());
            }
            //获取自己声明的各种字段要使用getDeclaredFields()
            fields = claz.getDeclaredFields();
            for(Field field:fields){
                System.out.println("属性名"+field.getName());
                System.out.println("属性类型"+field.getType().getName());
                System.out.println("属性修饰符"+Modifier.toString(field.getModifiers()));
                System.out.println("属性上的注解"+field.getAnnotations());
            }
            //操作属性
            Field field = claz.getDeclaredField("name");
            //取消java控制权限，让访问时可以访问私有变量
            field.setAccessible(true);
            System.out.println(field.get(stu));
            field.set(stu,"大小");
            System.out.println(field.get(stu));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

输出：

方法名：main
方法名：getName
方法名：getId
方法名：setName
方法名：setId
方法名：wait
方法名：wait
方法名：wait
方法名：equals
方法名：toString
方法名：hashCode
方法名：getClass
方法名：notify
方法名：notifyAll
------------------
方法名：main
方法返回类型：void
方法修饰符：public static
方法参数信息：[Ljava.lang.reflect.Parameter;@49097b5d
方法上的注解：[Ljava.lang.annotation.Annotation;@37a71e93
方法名：getName
方法返回类型：java.lang.String
方法修饰符：public
方法参数信息：[Ljava.lang.reflect.Parameter;@7e6cbb7a
方法上的注解：[Ljava.lang.annotation.Annotation;@37a71e93
方法名：getId
方法返回类型：long
方法修饰符：public
方法参数信息：[Ljava.lang.reflect.Parameter;@7c3df479
方法上的注解：[Ljava.lang.annotation.Annotation;@37a71e93
方法名：setName
方法返回类型：void
方法修饰符：public
方法参数信息：[Ljava.lang.reflect.Parameter;@7106e68e
方法上的注解：[Ljava.lang.annotation.Annotation;@37a71e93
方法名：setId
方法返回类型：void
方法修饰符：public
方法参数信息：[Ljava.lang.reflect.Parameter;@7eda2dbb
方法上的注解：[Ljava.lang.annotation.Annotation;@37a71e93
--------------------
null
大小
--------------------
属性名id
属性类型long
属性修饰符private
属性上的注解[Ljava.lang.annotation.Annotation;@37a71e93
属性名name
属性类型java.lang.String
属性修饰符private
属性上的注解[Ljava.lang.annotation.Annotation;@37a71e93
大小
大小

二、优点和缺点

1、优点

反射提高了程序的灵活性和扩展性，在底层框架中用的比较多，业务层面的开发过程中尽量少用。

2、缺点

反射是一种解释操作，用于字段和方法接入时要远慢于直接代码。

程序逻辑有影响。

   使用反射操作会模糊下程序的内部逻辑，从维护的角度来讲，我们更希望在源码的程序中看到程序的逻辑，反射相当于绕过了源码的方式，因此会带来维护难度比较大的问题。

三、反射使用场景

1、实现RPC框架

RPC是远程过程调用的简称，广泛应用在大规模分布式应用中。提到RPC框架首先想到的是Dubbo,远程过程调用的实现原理是放客户端调用的时候通过动态代理向服务提供方发送调用的信息，服务提供方收到后根据客户端需要调用的方法，调用本地方法，拿到结果后组装返回。

 

2、实现ORM框架

3、拷贝属性值（BeanUtils.copyProperties）

 

private static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException {
        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");
        Class actualEditable = target.getClass();
        if(editable != null) {
            if(!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");
            }

            actualEditable = editable;
        }

        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List ignoreList = ignoreProperties != null?Arrays.asList(ignoreProperties):null;
        PropertyDescriptor[] var7 = targetPds;
        int var8 = targetPds.length;

        for(int var9 = 0; var9 < var8; ++var9) {
            PropertyDescriptor targetPd = var7[var9];
            Method writeMethod = targetPd.getWriteMethod();
            if(writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if(sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if(readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                        try {
                            if(!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                readMethod.setAccessible(true);
                            }

                            Object ex = readMethod.invoke(source, new Object[0]);
                            if(!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                writeMethod.setAccessible(true);
                            }

                            writeMethod.invoke(target, new Object[]{ex});
                        } catch (Throwable var15) {
                            throw new FatalBeanException("Could not copy property \'" + targetPd.getName() + "\' from source to target", var15);
                        }
                    }
                }
            }
        }

    }