Java 反射机制详解（三）

Java 反射机制详解（三）

3.反射

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法，Java反射机制主要提供了以下功能： 

• 在运行时构造任意一个类的对象Class
• 在运行时获取任意一个类所具有的成员变量Filed和方法Method
• 在运行时调用任意一个对象的方法（属性）Constructor
• 生成动态代理

3.1 如何描述方法-method

public class ReflectionTest {
    @Test
    public void testMethod() throws Exception{
        Class clazz = Class.forName("com.atguigu.java.fanshe.Person");
        
        // 1.获取方法
        // 1.1 获取取clazz对应类中的所有方法--方法数组（一）
        // 不能获取private方法,且获取从父类继承来的所有方法
        Method[] methods = clazz.getMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
        }
        System.out.println();
        
        // 1.2.获取所有方法，包括私有方法 --方法数组（二）
        // 所有声明的方法，都可以获取到，且只获取当前类的方法
        methods = clazz.getDeclaredMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
        }
        System.out.println();

        // 1.3.获取指定的方法
        // 需要参数名称和参数列表，无参则不需要写
        // 对于方法public void setName(String name) {  }
        Method method = clazz.getDeclaredMethod("setName", String.class);
        System.out.println(method);
        // 而对于方法public void setAge(int age) {  }
        method = clazz.getDeclaredMethod("setAge", Integer.class);
        System.out.println(method);
        // 这样写是获取不到的，如果方法的参数类型是int型
        // 如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) {  }
　　　　 // 要么获取方法的参数写成int.class
        
        // 2.执行方法
        // invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
        Object obje = clazz.newInstance();
        method.invoke(obje,2);

　　　　// 如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行
　　　　// 私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;
    }
}

主要用到的两个方法： 

/**
         * @param name the name of the method
         * @param parameterTypes the list of parameters
         * @return the {@code Method} object that matches the specified
         */
        public Method getMethod(String name, Class<?>... parameterTypes){
            
        }
        
        /**
         * @param obj  the object the underlying method is invoked from
         * @param args the arguments used for the method call
         * @return  the result of dispatching the method represented by
         */
        public Object invoke(Object obj, Object... args){
            
        }

自定义工具方法: 

比如Person里有一个方法：

public void test(String name,Integer age){
        System.out.println("调用成功");
    }

 a. 把类对象和类方法名作为参数，执行方法：

/**
     * 
     * @param obj: 方法执行的那个对象. 
     * @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法. 
     * @param args: 调用该方法需要传入的参数
     * @return: 调用方法后的返回值
     *  
     */
      public Object invoke(Object obj, String methodName, Object ... args) throws Exception{
        //1. 获取 Method 对象
        //   因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。
        
        Class [] parameterTypes = new Class[args.length];
        for(int i = 0; i < args.length; i++){
            parameterTypes[i] = args[i].getClass();
            System.out.println(parameterTypes[i]); 
        }
        
        Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);
        //如果使用getDeclaredMethod，就不能获取父类方法，如果使用getMethod，就不能获取私有方法
　　　　
　　　　　//
　　　　　//2. 执行 Method 方法
        //3. 返回方法的返回值
        return method.invoke(obj, args);
      }

调用： 

        @Test
        public void testInvoke() throws Exception{
            Object obj = new Person();            
            invoke(obj, "test", "wang", 1);             
        }

这样就通过对象名，方法名，方法参数执行了该方法。

b.把全类名和方法名作为参数，执行方法：

/**
         * @param className: 某个类的全类名
         * @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法. 
         * @param args: 调用该方法需要传入的参数
         * @return: 调用方法后的返回值
         */
        public Object invoke(String className, String methodName, Object ... args){
            Object obj = null;
            
            try {
                obj = Class.forName(className).newInstance();
                //调用上一个方法
                return invoke(obj, methodName, args);
            }catch(Exception e) {
                e.printStackTrace();
            }            
            return null;
        }

 调用：

        @Test
        public void testInvoke() throws Exception{
                
            invoke("com.atguigu.java.fanshe.Person", 
                    "test", "zhagn", 12);         
        }

调用系统方法（此类需有一个无参的构造器）：

        @Test
        public void testInvoke() throws Exception{
            Object result = 
                    invoke("java.text.SimpleDateFormat", "format", new Date());
            System.out.println(result);          
        }

这种反射实现的主要功能是可配置和低耦合，只需要类名和方法名，而不需要一个类对象就可以执行一个方法，如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法。

拓展问题：如何获取父类定义的（私有）方法？

前面说一般使用getDeclaredMethod获取方法（因为此方法可以获取类的私有方法，但是不能获取父类方法），那如何获取父类方法呢，上一个例子format方法其实就是父类的方法（获取的时候用到的是getMethod），首先我们要知道，如何获取类的父类。

比如有一个类Student，继承自Person 类：

public class ReflectionTest {
    @Test
    public void testGetSuperClass() throws Exception{
        String className = "com.atguigu.java.fanshe.Student";
        
        Class clazz = Class.forName(className);
        Class superClazz = clazz.getSuperclass();
        
        System.out.println(superClazz); 
    }
}
//结果是 “ class com.atguigu.java.fanshe.Person ”

此时如果Student中有一个方法是私有方法method1(int age)，Person中有一个私有方法method2()，怎么调用？

定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法 ：

/**
     * 
     * @param obj: 某个类的一个对象
     * @param methodName: 类的一个方法的方法名. 
     * 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法
     * @param args: 调用该方法需要传入的参数
     * @return: 调用方法后的返回值
     */
    public Object invoke2(Object obj, String methodName, 
            Object ... args){
        //1. 获取 Method 对象
        Class [] parameterTypes = new Class[args.length];
        for(int i = 0; i < args.length; i++){
            parameterTypes[i] = args[i].getClass();
        }
        
        try {
            Method method = getMethod(obj.getClass(), methodName, parameterTypes);
            method.setAccessible(true);
            //2. 执行 Method 方法
            //3. 返回方法的返回值
            return method.invoke(obj, args);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
    /**
     * 获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法)
     * 如果在该类中找不到此方法，就向他的父类找，一直到Object类为止
　　　* 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法
     * @param clazz
     * @param methodName
     * @param parameterTypes
     * @return
     */
    public Method getMethod(Class clazz, String methodName, 
            Class ... parameterTypes){
        
        for(;clazz != Object.class; clazz = clazz.getSuperclass()){
            try {
                Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
                return method;
            } catch (Exception e) {}            
        }
        
        return null;
    }

3.2如何描述字段Field 

 

    @Test
    public void testField() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";        
        Class clazz = Class.forName(className); 
        
        // 1.获取字段
        // 1.1 获取所有字段 -- 字段数组
        // 可以获取公用和私有的所有字段，但不能获取父类字段
        Field[] fields = clazz.getDeclaredFields();
        for(Field field: fields){
            System.out.print(" "+ field.getName());
        }
        System.out.println();
        
        // 1.2获取指定字段
        Field field = clazz.getDeclaredField("name");
        System.out.println(field.getName());
        
        Person person = new Person("ABC",12);
        
        // 2.使用字段
        // 2.1获取指定对象的指定字段的值
        Object val = field.get(person);
        System.out.println(val);
        
        // 2.2设置指定对象的指定对象Field值
        field.set(person, "DEF");
        System.out.println(person.getName());
        
        // 2.3如果字段是私有的，不管是读值还是写值，都必须先调用setAccessible（true）方法
        // 比如Person类中，字段name字段是公用的，age是私有的
        field = clazz.getDeclaredField("age");
        field.setAccessible(true);
        System.out.println(field.get(person));        
    }

如果需要访问父类中的（私有）字段：

     // 创建 className 对应类的对象, 并为其 fieldName 赋值为 val
     // Student继承自Person,age是Person类的私有字段/
     public void testClassField() throws Exception{
        String className = "com.atguigu.java.fanshe.Student";
        String fieldName = "age"; // 可能为私有, 可能在其父类中. 
        Object val = 20;        
        
        Object obj = null;
        // 1.创建className 对应类的对象
        Class clazz = Class.forName(className);
        // 2.创建fieldName 对象字段的对象
        Field field = getField(clazz, fieldName);
        // 3.为此对象赋值
        obj = clazz.newInstance();
        setFieldValue(obj, field, val);
        // 4.获取此对象的值
        Object value = getFieldValue(obj,field);
    }
    
    public Object getFieldValue(Object obj, Field field) throws Exception{
        field.setAccessible(true);
        return field.get(obj);
    }

    public void setFieldValue(Object obj, Field field, Object val) throws Exception {
        field.setAccessible(true);
        field.set(obj, val);
    }

    public Field getField(Class clazz, String fieldName) throws Exception {
        Field field = null;
        for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 = clazz2.getSuperclass()) 
        {        
            field = clazz2.getDeclaredField(fieldName);
        }
        return field;
    }

3.3如何描述构造器-Constructor

    @Test
    public void testConstructor() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";
        Class<Person> clazz = (Class<Person>) Class.forName(className);
        
        // 1. 获取 Constructor 对象
        // 1.1 获取全部
        Constructor<Person> [] constructors = 
                (Constructor<Person>[]) Class.forName(className).getConstructors();
        
        for(Constructor<Person> constructor: constructors){
            System.out.println(constructor); 
        }
        
        // 1.2获取某一个，需要参数列表
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor); 
        
        // 2. 调用构造器的 newInstance() 方法创建对象
        Object obj = constructor.newInstance("zhagn", 1);                
    }

3.4 如何描述注解-Annotation 

定义一个Annotation：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
public @interface AgeValidator {
    public int min();
    public int max();
}

此注解只能用在方法上：

    @AgeValidator(min=18,max=35)
    public void setAge(int age) {
        this.age = age;
    }

在给Person类对象的age赋值时，是感觉不到注解的存在的 ：

    @Test
    public void testAnnotation() throws Exception{
        Person person = new Person();    
        person.setAge(10);
    }

必须通过反射的方式为属性赋值，才能获取到注解：

    /** Annotation 和 反射:
     * 1. 获取 Annotation
     * getAnnotation(Class<T> annotationClass) 
     * getDeclaredAnnotations() 
     */
    @Test
    public void testAnnotation() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";
        
        Class clazz = Class.forName(className);
        Object obj = clazz.newInstance();    
        
        Method method = clazz.getDeclaredMethod("setAge", int.class);
        int val = 6;
        
        //获取指定名称的注解
        Annotation annotation = method.getAnnotation(AgeValidator.class);
        if(annotation != null){
            if(annotation instanceof AgeValidator){
                AgeValidator ageValidator = (AgeValidator) annotation;                
                if(val < ageValidator.min() || val > ageValidator.max()){
                    throw new RuntimeException("年龄非法");
                }
            }
        }        
        method.invoke(obj, 20);
        System.out.println(obj);          
    }

如果在程序中要获取注解，然后获取注解的值进而判断我们赋值是否合法，那么类对象的创建和方法的创建必须是通过反射而来的 

原文链接：https://www.cnblogs.com/tech-bird/p/3525336.html