什么是反射机制

简略来说，反射能够协助咱们在动态运转的时候，对于任意一个类，能够取得其一切的办法（包含 public protected private 默认状况的），一切的变量（包含 public protected private 默认状况的）。是不是很强大呢。

反射机制有什么作用呢？

获取某些类的一些变量，调用某些类的私有办法。（例如在Android开发中咱们能够用来敞开 WiFi 热点，调用 WifiManager 中的 setWifiApEnabled() 办法）增加代码的灵活性。很多干流结构都运用了反射技能.像ssh结构都选用两种技能 xml做配置文件+反射技能.

假设有这样一个类 Person，它具有多个成员变量，country,city,name,province,height,age 等，一起它具有多个结构办法，多个办法，这些变量，办法的拜访权限既有 public 也有 private 的。下面咱们以这个为比如，一同看怎样运用反射取得相应的 Filed，Constructor，Method。

public class Person {
    public String country;
    public String city;
    private String name;
    private String province;
    private Integer height;
    private Integer age;
    public Person() {
        System.out.println("调用Person的无参结构办法");
    }
    private Person(String country, String city, String name) {
        this.country = country;
        this.city = city;
        this.name = name;
    }
    public Person(String country, Integer age) {
        this.country = country;
        this.age = age;
    }
    private String getMobile(String number) {
        String mobile = "010-110" + "-" + number;
        return mobile;
    }
    private void setCountry(String country) {
        this.country=country;
    }
    public void getGenericHelper(HashMap<String, Integer> hashMap) {
    }
    public Class getGenericType() {
        try {
            HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
            Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return null;
            }
            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return null;
            }
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {
        }
        return null;
    }
    @Override
    public String toString() {
        return "Person{" +
                "country='" + country + '\'' +
                ", city='" + city + '\'' +
                ", name='" + name + '\'' +
                ", province='" + province + '\'' +
                ", height=" + height +
                '}';
    }
}

运用反射取得一切结构办法（包含私有的，非私有的）

默认权限的指的是没有修饰符修饰的

几个重要的办法解说

看了上面的几个办法，其实很好区分

后缀带 s 的返回目标时数组类型，是能够取得相应权限的一切办法的，如 Constructor getConstructor() 办法和 Constructor<?>[] getConstructors() 办法。几乎能够这样说，java 99% 的代码风格是这样的。一起这儿也引申出一个问题，平常你在开发中有没有遵循一定的开发规范。
getConstructor() 办法和 getDeclaredConstructor 中间只相差一个单词 Declared ，区别在与是取得 public 权限的办法仍是一切权限的办法。

这儿为什么要强调这一点呢？由于以下要解说的getMethods(),getDeclaredMethod(),getDelcaredMethods() 等办法与这个类似，下面不再论述。

取得一切的结构办法

public static void printConstructor(String className) {
    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?>[] constructors = aClass.getConstructors();
        print(constructors);
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        print(declaredConstructors);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

比照 Person 里边一切的结构办法，能够知道咱们代码的逻辑是正确的

取得指定的结构办法

public static Constructor getConstructor(String className, Class<?>... clzs) {
    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
        print(declaredConstructor);
        //   if Constructor is not public,you should call this
        declaredConstructor.setAccessible(true);
        return declaredConstructor;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    return null;
}
public class TestHelper {
    public static  final String TAG="xujun";
    public static final String CLASS_NAME = "com.example.reflectdemo.Person";
    public static final String CHINA = "China";
    public static void testConstructor(){
        ReflectHelper.printConstructor(CLASS_NAME);
        Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
        try {
            Object meinv = constructor.newInstance(CHINA, 12);
            Person person = (Person) meinv;
            Log.i(TAG, "testConstructor: =" + person.toString());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

咱们将能够看到以下的输出成果

testConstructor: =Person [country=China, city=null, name=null, province=null, height=null, age=12] 能够看到 country=China，age=12 这说明咱们成功经过反射调用 Person 带两个参数的沟改造办法。

注意事项

如果该办法，或者该变量不是 public 拜访权限的，咱们应该调用相应的 setAccessible(true) 办法，才干拜访得到

//if Constructor is not public,you should call this
declaredConstructor.setAccessible(true);

运用反射取得一切的 Field 变量

取得一切的 Field 变量

public static void printField(String className) {
    try {
        Class<?> aClass = Class.forName(className);
        Field[] fields = aClass.getFields();
        PrintUtils.print(fields);
        Field[] declaredFields = aClass.getDeclaredFields();
        PrintUtils.print(declaredFields);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

取得指定的成员变量

现在假设咱们要取得 Person 中的私有变量 age ，咱们能够经过以下的代码取得，一起并打印出一切的成员变量。

public static Field getFiled(String className, String filedName) {
    Object o = null;
    try {
        Class<?> aClass = Class.forName(className);
        Field declaredField = aClass.getDeclaredField(filedName);
        //   if not public,you should call this
        declaredField.setAccessible(true);
        return declaredField;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
    return null;
}
public  static void testFiled(){
    ReflectHelper.printFileds(CLASS_NAME);
    Person person = new Person(CHINA, 12);
    Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
    try {
        Integer integer = (Integer) field.get(person);
        PrintUtils.print("integer="+integer);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

运用反射履行相应的 Method

主要有以下几个办法，

public Method[] getDeclaredMethods() public Method[] getMethods() throws SecurityException public Method getDeclaredMethod() public Method getMethod(String name, Class<?>… parameterTypes) 几个办法的作用我就不一一论述了，由于上面在解说运用反射取得一切结构办法（包含私有的，非私有的）的时候现已说到过了。

获取一切的 Method

    public static void printMethods(String className) {
        try {
            Class<?> aClass = Class.forName(className);
            Method[] declaredMethods = aClass.getDeclaredMethods();
            PrintUtils.print(declaredMethods);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

获取指定的 Method

咱们能够运用 getDeclaredMethod(String name, Class… parameterTypes) 或者 getMethod(String name, Class… parameterTypes) 取得指定的办法，只不过 getMethod 办法只能取得 public 拜访权限的办法，getDeclaredMethod 能够取得任何拜访权限的办法。

注意一下办法参数， name 代表的是办法的名称，Class<?>… parameterTypes 代表的是办法参数的类型，至于为什么是 … 数组类型的，由于咱们参数可能是一个也可能是多个的。

这儿咱们以 Person 类里边的 private void setCountry(String country) 办法为比如解说，能够看到办法名称为 setCountry ，办法参数的类型为 String ,所以咱们在传递参数的时候 name 为 setCountry ，parameterTypes 为 String.class 。如果有多个参数，在加上该参数的 Class 类型即可。

   public static void testMethod(){
    	ReflectHelper.printMethods(CLASS_NAME);
        Person person=new Person();
        Method method = ReflectHelper.getMethod(CLASS_NAME,
                "setCountry", String.class);
        try {
           // 履行办法，成果保存在 person 中
            Object o = method.invoke(person, CHINA);
           // 拿到咱们传递进步的参数 country 的值 China          
            String country=person.country;
            PrintUtils.print(country);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
public class ReflectHelper {
    private static final String TAG = "ReflectHelper";
    public static Method getMethod(String className, String methodName, Class<?>... clzs) {
        try {
            Class<?> aClass = Class.forName(className);
            Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
            declaredMethod.setAccessible(true);
            return declaredMethod;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }
}

履行上面的函数，将能够看到下面的成果

> print:China

运用反射操作数组

/**
     * 利用反射操作数组
     * 1 利用反射修改数组中的元素
     * 2 利用反射获取数组中的每个元素
     */
    public static void testArrayClass() {
        String[] strArray = new String[]{"5","7","暑期","美人","女生","女神"};
        Array.set(strArray,0,"帅哥");
        Class clazz = strArray.getClass();
        if (clazz.isArray()) {
            int length = Array.getLength(strArray);
            for (int i = 0; i < length; i++) {
                Object object = Array.get(strArray, i);
                String className=object.getClass().getName();
                System.out.println("----> object=" + object+",className="+className);
            }
        }
    }

----> object=帅哥,className=java.lang.String
----> object=7,className=java.lang.String
----> object=暑期,className=java.lang.String
----> object=美人,className=java.lang.String
----> object=女生,className=java.lang.String
----> object=女神,className=java.lang.String

从成果能够说明，咱们成功经过 Array.set(strArray,0,“帅哥”) 改动数组的值。

运用反射取得泛型类型

public static void getGenericHelper(HashMap<String, Person> map) {
    }

现在假设咱们有这样一个办法，那咱们要怎样取得 HashMap 里边的 String，Person 的类型呢？
public static  void getGenericType() {
        try {
            Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            // 检验是否为空
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return ;
            }
            // 取 getGenericHelper 办法的第一个参数
            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return ;
            }
            //  打印出每一个类型          
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {
        }
    }

履行上面的代码，输出成果

----> rawType=class java.util.HashMap
----> type=class java.lang.String
----> type=class com.example.reflectdemo.Person

怎样取得 Metho,Field,Constructor 的拜访权限（ public,private,ptotected 等）

其实很简略，咱们阅读文档能够发现他们都有 getModifiers() 办法，该办法放回 int 数字，咱们在利用 Modifier.toString() 就能够得到他们的拜访权限

int modifiers = method.getModifiers();
Modifier.toString(modifiers);

JAVA反射机制

什么是反射机制

反射机制有什么作用呢？

运用反射取得一切结构办法（包含私有的，非私有的）

几个重要的办法解说

取得一切的结构办法

取得指定的结构办法

运用反射取得一切的 Field 变量

取得一切的 Field 变量

取得指定的成员变量

运用反射履行相应的 Method

获取一切的 Method

获取指定的 Method

运用反射操作数组

运用反射取得泛型类型

作者信息

JAVA反射机制

什么是反射机制

反射机制有什么作用呢？

运用反射取得一切结构办法（包含私有的，非私有的）

几个重要的办法解说

取得一切的结构办法

取得指定的结构办法

运用反射取得一切的 Field 变量

取得一切的 Field 变量

取得指定的成员变量

运用反射履行相应的 Method

获取一切的 Method

获取指定的 Method

运用反射操作数组

运用反射取得泛型类型

相关文章

Apache Doris 基于 Job Scheduler 实现秒级触发任务调度能力

Java、Kotlin泛型全面解析

23种设计模式之解释器模式（Interpreter Pattern）

Java 中那些绕不开的内置接口 — 函数式编程和 Java 的内置函数式接口

作者信息