反射机制概念

引用

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用，并在 Lisp 和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和Open java 等就是基于反射机制的语言。

Java 反射机制

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

代码案例

工具类

 import java.lang.reflect.Field;

public class ReflectCallField {

    /**
     * @param entryClass
     * @param fieldName
     * @param <T>
     * @return
     */
    public  static  <T> T getForStatic(Class entryClass, String fieldName) {
        if (entryClass == null) {
            return null;
        }
        T result = null;
        try {
            // 反射获取
            Field callField = entryClass.getDeclaredField(fieldName);
            callField.setAccessible(true);
            return (T) callField.get(entryClass);
        } catch ( Exception  e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * @param entryClass
     * @param fieldName
     * @param value
     */
    public  Static   void  setForStatic(Class entryClass, String fieldName, Object value) {
        if (entryClass == null) {
            return;
        }
        try {
            Field callField = entryClass.getDeclaredField(fieldName);
            callField.setAccessible(true);
            callField.set(fieldName, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @param entryObject
     * @param fieldName
     * @param <T>
     * @return
     */
    public static <T> T getForInstance(Object entryObject, String fieldName) {
        if (entryObject == null) {
            return null;
        }
        T result = null;
        try {
            // 反射获取
            Field callField = entryObject.getClass().getDeclaredField(fieldName);
            callField.setAccessible(true);
            return (T) callField.get(entryObject);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * @param entryObject
     * @param fieldName
     * @param value
     */
    public static void setForInstance(Object entryObject, String fieldName, Object value) {
        if (entryObject == null) {
            return;
        }
        try {
            Field callField = entryObject.getClass().getDeclaredField(fieldName);
            callField.setAccessible(true);
            callField.set(entryObject, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}  

类静态属性，反射取值赋值：

 import java.util. HashMap ;
import java.util.Map;

public class StaticModel {

     private  static Map<String, Object> objectMap = new HashMap<>();
    private static Map<String, Object> FILE_TYPE_MAP = new HashMap<>();

    static {
        objectMap.put("1", new Object());
        FILE_TYPE_MAP.put("fileType1", new Object());
    }

}  

 import java.util.Map;

public class StaticModelDemo {

    public static void main(String[] args) {
        // 取值
        Map<String, Object> objectMap = ReflectCallField.getForStatic(StaticModel.class, "objectMap");
        System.out.println(objectMap);
        Map<String, Object> FILE_TYPE_MAP = ReflectCallField.getForStatic(StaticModel.class, "FILE_TYPE_MAP");
        System.out.println(FILE_TYPE_MAP);
        // 赋值
        objectMap.put("2", new Object());
        FILE_TYPE_MAP.put("fileType2", new Object());
        ReflectCallField.setForStatic(StaticModel.class, "objectMap", objectMap);
        ReflectCallField.setForStatic(StaticModel.class, "FILE_TYPE_MAP", FILE_TYPE_MAP);
        // 取值
        objectMap = ReflectCallField.getForStatic(StaticModel.class, "objectMap");
        System.out.println(objectMap);
        FILE_TYPE_MAP = ReflectCallField.getForStatic(StaticModel.class, "FILE_TYPE_MAP");
        System.out.println(FILE_TYPE_MAP);
    }

}
  

类实例（成员）属性，反射取值赋值：

 import java.util.HashMap;
import java.util.Map;

public class InstanceModel {

    private Map<String, Object> objectMap = new HashMap<>();
    private Map<String, Object> FILE_TYPE_MAP = new HashMap<>();

    {
        objectMap.put("1", new Object());
        FILE_TYPE_MAP.put("fileType1", new Object());
    }

}  

 import java.util.Map;

public class InstanceModelDemo {

    public static void main(String[] args) {
        InstanceModel instanceModel = new InstanceModel();
        // 取值
        Map<String, Object> objectMap = ReflectCallField.getForInstance(instanceModel, "objectMap");
        System.out.println(objectMap);
        Map<String, Object> FILE_TYPE_MAP = ReflectCallField.getForInstance(instanceModel, "FILE_TYPE_MAP");
        System.out.println(FILE_TYPE_MAP);
        // 赋值
        objectMap.put("2", new Object());
        FILE_TYPE_MAP.put("fileType2", new Object());
        ReflectCallField.setForInstance(instanceModel, "objectMap", objectMap);
        ReflectCallField.setForInstance(instanceModel, "FILE_TYPE_MAP", FILE_TYPE_MAP);
        // 取值
        objectMap = ReflectCallField.getForInstance(instanceModel, "objectMap");
        System.out.println(objectMap);
        FILE_TYPE_MAP = ReflectCallField.getForInstance(instanceModel, "FILE_TYPE_MAP");
        System.out.println(FILE_TYPE_MAP);
    }

}