ReflectUitls类的编写和对反射机制的解析

反射相关的类

　　反射相关的类，最基本的当然是Class类。

　　获取了Class对象之后，就可以接着生成对象实例、调用方法、查看字段等等。

　　字段(Field)、方法(Method)和构造方法(Constructor<T>)各有相应的类来表示，它们共同继承于java.lang.reflect.AccessibleObject类：

　　这三个类共同实现的还有Member接口：

　　获取字段、方法和构造方法时，需要调用Class类的getXXX()和getDeclearedXXX()方法，需要注意二者区别。

　　比如对于方法：

  1. getMethods();//获取public (包括父类中的)
  2.  
  3. getDeclaredMethods();//获取本类声明(包括各种修饰符public、private)

　　相关博文：Java中的反射机制（一）

　　API 文档：http://docs.oracle.com/javase/7/docs/api/

访问权限相关

　　利用反射，可以访问一些SDK、API中的私有方法。

　　相关博文：Java中的反射机制（四） 利用反射访问私有

　　访问私有方法有一个关键点：

  1. setAccessible(true); // 抑制Java对修饰符的检查

　　这个方法是AccessibleObject类中的。

　　前面说过，它是Field、Method和Constructor<T>的共同基类。

　　正常情况下，调用isAccessible()返回的都是false，无论你的方法是public还是private。

　　这是因为这个accessible的flag是JVM用来限制是否可以直接访问，默认情况下是需要进行访问修饰符的检查的，所以flag为false，即不能直接访问。

　　当这个flag设置为true，表明可以直接访问，不经过访问修饰符的检查。

　　辅助类中用于调用私有方法的接口：

  1. /**
  2.      * 调用私有方法
  3.      *
  4.      * @param obj
  5.      *            调用类对象
  6.      * @param methodName
  7.      *            方法名
  8.      * @param paramTypes
  9.      *            参数类型
  10.      * @param params
  11.      *            参数
  12.      * @return
  13.      * @throws Exception
  14.      */
  15.     public static Object invokePrivateMethod(Object obj, String methodName,
  16.             Class<?>[] paramTypes, Object[] params) throws Exception {
  17.  
  18.         Object value = null;
  19.         Class<?> cls = obj.getClass();
  20.  
  21.         // 注意不要用getMethod(),因为getMethod()返回的都是public方法
  22.         Method method = cls.getDeclaredMethod(methodName, paramTypes);
  23.  
  24.         method.setAccessible(true);// 抑制Java的访问控制检查
  25.  
  26.         value = method.invoke(obj, params);
  27.         return value;
  28.     }

访问修饰符

　　对访问修饰符的获取可以通过Member接口的getModifiers()方法，该方法返回一个整型值，整型值是一系列的修饰符位操作组合的结果。

　　用Modifier类可以解析这个整型值中包含的修饰符信息。

  1.     /**
  2.      * 获取修饰符信息
  3.      *
  4.      * @param member
  5.      * @return
  6.      */
  7.     private static String getModifiersInfo(Member member) {
  8.         StringBuilder sBuilder = new StringBuilder();
  9.         int modifiers = member.getModifiers();
  10.         sBuilder.append("\ngetModifiers: " + +modifiers + ", ");// 得到修饰符编码
  11.         sBuilder.append("\nisPublic: " + Modifier.isPublic(modifiers) + ", ");
  12.         sBuilder.append("\nisPrivate: " + Modifier.isPrivate(modifiers) + ", ");
  13.         sBuilder.append("\nisStatic: " + Modifier.isStatic(modifiers) + ", ");
  14.         sBuilder.append("\nisFinal: " + Modifier.isFinal(modifiers) + ", ");
  15.         sBuilder.append("\nisAbstract: " + Modifier.isAbstract(modifiers));
  16.  
  17.         return sBuilder.toString();
  18.     }

包装类与原生数据类型

　　相关博文： Java 包装类 自动装箱和拆箱

　　写了一个调用静态方法的辅助类，我本来是这么写的：

  1.     /*
  2.      * wrong:
  3.      * public static Object invokePublicStaticMethod(String className,
  4.      * String methodName, Object[] params) throws Exception {
  5.      *
  6.      * Class<?> cls = Class.forName(className);
  7.      * Class<?>[] paramTypes = new Class<?>[params.length];
  8.      * for (int i = 0; i < params.length; ++i) {
  9.      * paramTypes[i] = params[i].getClass();
  10.      *
  11.      * }
  12.      * Method method = cls.getMethod(methodName, paramTypes);
  13.      * Object value = null;
  14.      * if (isPublicStatic(method)) {
  15.      * value = method.invoke(null, params);
  16.      * }
  17.      *
  18.      * return value;
  19.      * }
  20.      */

　　意图是只传入参数数组，在内部自己根据参数获取类型数组，可以少传点参数，但是这样遇到了问题。

　　在Example类里写了这么三个测试方法：

  1.     public static void printSomething(String line) {
  2.         System.out.println(line);
  3.     }
  4.  
  5.     public static int add(int a, int b) {
  6.         return a + b;
  7.     }
  8.  
  9.     public static double getPi() {
  10.         return 3.14159d;
  11.     }

　　测试的时候发现参数是String类型的时候可以正常执行，但是参数如果是原生数据类型(int类型)，用这个方法调用时就跑出了异常：

　　java.lang.NoSuchMethodException: com.mengdd.reflect.Example.add(java.lang.Integer, java.lang.Integer)

　　

　　测试了一下：

  1. Object[] array = new Object[] { 1, 2 };
  2. System.out.println("getClass(): " + array[0].getClass());
  3. System.out.println("Integer.TYPE: " + Integer.TYPE);

　　输出：

  1. getClass(): class java.lang.Integer
  2. Integer.TYPE: int

　　而那个用于测试的add()方法：

  1. getReturnType: int
  2. getParameterTypes: [int, int]

　　可见Integer和int被认为是两种类型，所以调用方法的时候，类型参数也还是从外部传入比较科学。

　　修改后的调用方法如下：

  1.     public static Object invokePublicStaticMethod(String className,
  2.             String methodName, Class<?>[] paramTypes, Object[] params)
  3.             throws Exception {
  4.  
  5.         Class<?> cls = Class.forName(className);
  6.  
  7.         Method method = cls.getMethod(methodName, paramTypes);
  8.         Object value = null;
  9.         if (isPublicStatic(method)) {
  10.             value = method.invoke(null, params);
  11.         }
  12.  
  13.         return value;
  14.     }

　　测试代码：

  1.             Object result1 = ReflectUtils.invokePublicStaticMethod(
  2.                     "com.mengdd.reflect.Example", "add", new Class<?>[] {
  3.                             int.class, Integer.TYPE }, new Object[] { 1, 2 });
  4.  
  5.             // int.class和Integer.TYPE都行
  6.  
  7.             Assert.assertEquals(3, result1);

ReflectUtils类

　　ReflectUtils类完整代码如下：

  1. package com.mengdd.reflect;
  2.  
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Member;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Modifier;
  8. import java.util.Arrays;
  9.  
  10. /**
  11.  *
  12.  * @ClassName ReflectUtils
  13.  * @Description Reflection Helper class
  14.  *
  15.  * @author mengdandan
  16.  * @Date 2014年5月13日上午10:40:32
  17.  *
  18.  */
  19. public class ReflectUtils {
  20.  
  21.     /**
  22.      * 创建类的实例，调用类的无参构造方法
  23.      *
  24.      * @param className
  25.      * @return
  26.      */
  27.     public static Object newInstance(String className) {
  28.  
  29.         Object instance = null;
  30.  
  31.         try {
  32.             Class<?> clazz = Class.forName(className);
  33.             instance = clazz.newInstance();
  34.         }
  35.         catch (ClassNotFoundException e) {
  36.             e.printStackTrace();
  37.         }
  38.         catch (InstantiationException e) {
  39.             // if this Class represents an abstract class, an interface, an
  40.             // array class, a primitive type, or void; or if the class has no
  41.             // nullary constructor; or if the instantiation fails for some other
  42.             // reason.
  43.  
  44.             e.printStackTrace();
  45.         }
  46.         catch (IllegalAccessException e) {
  47.             // if the class or its nullary constructor is not accessible
  48.             e.printStackTrace();
  49.         }
  50.  
  51.         return instance;
  52.  
  53.     }
  54.  
  55.     /**
  56.      * 获取所有的public构造方法的信息
  57.      *
  58.      * @param className
  59.      * @return
  60.      */
  61.     public static String getPublicConstructorInfo(String className) {
  62.         StringBuilder sBuilder = new StringBuilder();
  63.  
  64.         try {
  65.             Class<?> clazz = Class.forName(className);
  66.             Constructor<?>[] constructors = clazz.getConstructors();
  67.             sBuilder.append(getConstructorInfo(constructors));
  68.         }
  69.         catch (ClassNotFoundException e) {
  70.             e.printStackTrace();
  71.         }
  72.  
  73.         return sBuilder.toString();
  74.     }
  75.  
  76.     /**
  77.      * 得到本类内声明的构造方法信息
  78.      *
  79.      * @param className
  80.      * @return
  81.      */
  82.     public static String getDeclearedConstructorInfo(String className) {
  83.         StringBuilder sBuilder = new StringBuilder();
  84.  
  85.         try {
  86.             Class<?> clazz = Class.forName(className);
  87.             Constructor<?>[] constructors = clazz.getDeclaredConstructors();
  88.             sBuilder.append(getConstructorInfo(constructors));
  89.         }
  90.         catch (ClassNotFoundException e) {
  91.             e.printStackTrace();
  92.         }
  93.  
  94.         return sBuilder.toString();
  95.     }
  96.  
  97.     /**
  98.      * 获取public的字段信息
  99.      *
  100.      * @param className
  101.      * @return
  102.      */
  103.     public static String getPublicFieldInfo(String className) {
  104.         StringBuilder sBuilder = new StringBuilder();
  105.  
  106.         try {
  107.             Class<?> clazz = Class.forName(className);
  108.  
  109.             Field[] fields = clazz.getFields();
  110.             sBuilder.append(getFieldInfo(fields));
  111.         }
  112.         catch (ClassNotFoundException e) {
  113.             e.printStackTrace();
  114.         }
  115.  
  116.         return sBuilder.toString();
  117.     }
  118.  
  119.     /**
  120.      * 获取本类内声明的字段信息
  121.      *
  122.      * @param className
  123.      * @return
  124.      */
  125.     public static String getDecleardFieldInfo(String className) {
  126.         StringBuilder sBuilder = new StringBuilder();
  127.  
  128.         try {
  129.             Class<?> clazz = Class.forName(className);
  130.  
  131.             Field[] fields = clazz.getDeclaredFields();
  132.             sBuilder.append(getFieldInfo(fields));
  133.         }
  134.         catch (ClassNotFoundException e) {
  135.             e.printStackTrace();
  136.         }
  137.  
  138.         return sBuilder.toString();
  139.     }
  140.  
  141.     /**
  142.      * 得到所有public方法信息
  143.      *
  144.      * @param className
  145.      * @return
  146.      */
  147.     public static String getPublicMethodInfos(String className) {
  148.         StringBuilder sBuilder = new StringBuilder();
  149.  
  150.         try {
  151.             Class<?> clazz = Class.forName(className);
  152.             Method[] methods = clazz.getMethods();// 得到所有的public方法，包括从基类继承的
  153.  
  154.             sBuilder.append(getMethodInfo(methods));
  155.  
  156.         }
  157.         catch (ClassNotFoundException e) {
  158.             e.printStackTrace();
  159.         }
  160.  
  161.         return sBuilder.toString();
  162.     }
  163.  
  164.     /**
  165.      * 得到类内声明的方法信息
  166.      *
  167.      * @param className
  168.      * @return
  169.      */
  170.     public static String getDeclaredMethodInfos(String className) {
  171.  
  172.         StringBuilder sBuilder = new StringBuilder();
  173.         try {
  174.             Class<?> clazz = Class.forName(className);
  175.             Method[] methods = clazz.getDeclaredMethods();// 得到本类声明的所有方法,包括私有方法
  176.             // clazz.getMethods(); 会返回所有public的方法，但是包括基类Object的方法
  177.  
  178.             sBuilder.append(getMethodInfo(methods));
  179.  
  180.         }
  181.         catch (ClassNotFoundException e) {
  182.             e.printStackTrace();
  183.         }
  184.         catch (Exception e) {
  185.             e.printStackTrace();
  186.         }
  187.  
  188.         return sBuilder.toString();
  189.     }
  190.  
  191.     /**
  192.      * 得到构造器信息
  193.      *
  194.      * @param constructor
  195.      * @return
  196.      */
  197.     private static String getConstructorInfo(Constructor<?> constructor) {
  198.  
  199.         StringBuilder sBuilder = new StringBuilder();
  200.  
  201.         sBuilder.append("name: " + constructor.getName());
  202.         sBuilder.append("\ngetParameterTypes: "
  203.                 + Arrays.toString(constructor.getParameterTypes()));
  204.         return sBuilder.toString();
  205.     }
  206.  
  207.     /**
  208.      * 将一组构造器的信息组成一个字符串返回
  209.      *
  210.      * @param constructors
  211.      * @return
  212.      */
  213.     private static String getConstructorInfo(Constructor<?>[] constructors) {
  214.  
  215.         StringBuilder sBuilder = new StringBuilder();
  216.         int i = 0;
  217.         for (Constructor<?> c : constructors) {
  218.             sBuilder.append("method: " + ++i + " : ");
  219.             sBuilder.append("\n" + getConstructorInfo(c));
  220.             sBuilder.append("\n");
  221.         }
  222.  
  223.         return sBuilder.toString();
  224.  
  225.     }
  226.  
  227.     /**
  228.      * 获取字段信息，组成一个字符串返回
  229.      *
  230.      * @param field
  231.      * @return
  232.      */
  233.     private static String getFieldInfo(Field field) {
  234.         StringBuilder sBuilder = new StringBuilder();
  235.         sBuilder.append("name: " + field.getName());
  236.         sBuilder.append("\ngetType: " + field.getType());
  237.         sBuilder.append(getModifiersInfo(field));
  238.         return sBuilder.toString();
  239.     }
  240.  
  241.     /**
  242.      * 获取一组字段的信息，返回字符串
  243.      *
  244.      * @param fields
  245.      * @return
  246.      */
  247.     private static String getFieldInfo(Field[] fields) {
  248.         StringBuilder sBuilder = new StringBuilder();
  249.         int i = 0;
  250.         for (Field field : fields) {
  251.             sBuilder.append("field: " + ++i + " : ");
  252.             sBuilder.append("\n" + getFieldInfo(field));
  253.             sBuilder.append("\n");
  254.         }
  255.  
  256.         return sBuilder.toString();
  257.     }
  258.  
  259.     /**
  260.      * 获取方法的信息，组成一个字符串返回
  261.      *
  262.      * @param method
  263.      * @return
  264.      */
  265.     private static String getMethodInfo(Method method) {
  266.  
  267.         StringBuilder sBuilder = new StringBuilder();
  268.  
  269.         sBuilder.append("name: " + method.getName());
  270.         sBuilder.append("\ngetReturnType: " + method.getReturnType());
  271.         sBuilder.append("\ngetParameterTypes: "
  272.                 + Arrays.toString(method.getParameterTypes()));
  273.         sBuilder.append(getModifiersInfo(method));
  274.         return sBuilder.toString();
  275.     }
  276.  
  277.     /**
  278.      * 获取一组方法的信息，组成一个字符串返回
  279.      *
  280.      * @param methods
  281.      * @return
  282.      */
  283.     private static String getMethodInfo(Method[] methods) {
  284.         StringBuilder sBuilder = new StringBuilder();
  285.         int i = 0;
  286.         for (Method method : methods) {
  287.  
  288.             sBuilder.append("method: " + ++i + " : ");
  289.             sBuilder.append("\n" + getMethodInfo(method));
  290.             sBuilder.append("\n");
  291.  
  292.         }
  293.  
  294.         return sBuilder.toString();
  295.     }
  296.  
  297.     /**
  298.      * 获取修饰符信息
  299.      *
  300.      * @param member
  301.      * @return
  302.      */
  303.     private static String getModifiersInfo(Member member) {
  304.         StringBuilder sBuilder = new StringBuilder();
  305.         int modifiers = member.getModifiers();
  306.         sBuilder.append("\ngetModifiers: " + +modifiers + ", ");// 得到修饰符编码
  307.         sBuilder.append("\nisPublic: " + Modifier.isPublic(modifiers) + ", ");
  308.         sBuilder.append("\nisPrivate: " + Modifier.isPrivate(modifiers) + ", ");
  309.         sBuilder.append("\nisStatic: " + Modifier.isStatic(modifiers) + ", ");
  310.         sBuilder.append("\nisFinal: " + Modifier.isFinal(modifiers) + ", ");
  311.         sBuilder.append("\nisAbstract: " + Modifier.isAbstract(modifiers));
  312.  
  313.         return sBuilder.toString();
  314.     }
  315.  
  316.     /**
  317.      * 是否是公用静态方法
  318.      *
  319.      * @param member
  320.      * @return
  321.      */
  322.     private static boolean isPublicStatic(Member member) {
  323.         boolean isPS = false;
  324.         int mod = member.getModifiers();
  325.         isPS = Modifier.isPublic(mod) && Modifier.isStatic(mod);
  326.         return isPS;
  327.     }
  328.  
  329.     /**
  330.      * 调用静态方法
  331.      *
  332.      * @param className
  333.      * @param methodName
  334.      * @param paramTypes
  335.      * @param params
  336.      * @return
  337.      * @throws Exception
  338.      */
  339.     public static Object invokePublicStaticMethod(String className,
  340.             String methodName, Class<?>[] paramTypes, Object[] params)
  341.             throws Exception {
  342.  
  343.         Class<?> cls = Class.forName(className);
  344.  
  345.         Method method = cls.getMethod(methodName, paramTypes);
  346.         Object value = null;
  347.         if (isPublicStatic(method)) {
  348.             value = method.invoke(null, params);
  349.         }
  350.  
  351.         return value;
  352.     }
  353.  
  354.     /*
  355.      * wrong:
  356.      * public static Object invokePublicStaticMethod(String className,
  357.      * String methodName, Object[] params) throws Exception {
  358.      *
  359.      * Class<?> cls = Class.forName(className);
  360.      * Class<?>[] paramTypes = new Class<?>[params.length];
  361.      * for (int i = 0; i < params.length; ++i) {
  362.      * paramTypes[i] = params[i].getClass();
  363.      *
  364.      * }
  365.      * Method method = cls.getMethod(methodName, paramTypes);
  366.      * Object value = null;
  367.      * if (isPublicStatic(method)) {
  368.      * value = method.invoke(null, params);
  369.      * }
  370.      *
  371.      * return value;
  372.      * }
  373.      */
  374.  
  375.     /**
  376.      * 调用私有方法
  377.      *
  378.      * @param obj
  379.      *            调用类对象
  380.      * @param methodName
  381.      *            方法名
  382.      * @param paramTypes
  383.      *            参数类型
  384.      * @param params
  385.      *            参数
  386.      * @return
  387.      * @throws Exception
  388.      */
  389.     public static Object invokePrivateMethod(Object obj, String methodName,
  390.             Class<?>[] paramTypes, Object[] params) throws Exception {
  391.  
  392.         Object value = null;
  393.         Class<?> cls = obj.getClass();
  394.  
  395.         // 注意不要用getMethod(),因为getMethod()返回的都是public方法
  396.         Method method = cls.getDeclaredMethod(methodName, paramTypes);
  397.  
  398.         method.setAccessible(true);// 抑制Java的访问控制检查
  399.  
  400.         value = method.invoke(obj, params);
  401.         return value;
  402.     }
  403. }

ReflectUtils.java

　　测试类和测试代码：

  1. package com.mengdd.reflect;
  2.  
  3. public class Example {
  4.  
  5.     private String mFiledOne = null;
  6.     private int mCount = 0;
  7.     private double mNum = 6;
  8.  
  9.     public int mPub = 4;
  10.  
  11.     public Example() {
  12.     }
  13.  
  14.     public Example(String filedOne, int count, double num) {
  15.         super();
  16.         this.mFiledOne = filedOne;
  17.         this.mCount = count;
  18.         this.mNum = num;
  19.     }
  20.  
  21.     public String getFiledOne() {
  22.         return mFiledOne;
  23.     }
  24.  
  25.     public void setFiledOne(String filedOne) {
  26.         this.mFiledOne = filedOne;
  27.     }
  28.  
  29.     public int getCount() {
  30.         return mCount;
  31.     }
  32.  
  33.     public void setCount(int count) {
  34.         this.mCount = count;
  35.     }
  36.  
  37.     public double getNum() {
  38.         return mNum;
  39.     }
  40.  
  41.     public void setNum(double num) {
  42.         this.mNum = num;
  43.     }
  44.  
  45.     public static void printSomething(String line) {
  46.         System.out.println(line);
  47.     }
  48.  
  49.     public static int add(int a, int b) {
  50.         return a + b;
  51.     }
  52.  
  53.     public static double getPi() {
  54.         return 3.14159d;
  55.     }
  56.  
  57.     @Override
  58.     public String toString() {
  59.         return "Example [mFiledOne=" + mFiledOne + ", mCount=" + mCount + "]";
  60.     }
  61.  
  62.     private String tellSecret(String name, int num) {
  63.         String result = name + num + toString();
  64.         return result;
  65.     }
  66.  
  67. }

Example.java

  1. package com.mengdd.reflect;
  2.  
  3. import org.junit.Assert;
  4. import org.junit.Test;
  5.  
  6. public class ReflectTest {
  7.  
  8.     @Test
  9.     public void testNewInstance() {
  10.         Object object = ReflectUtils.newInstance("com.mengdd.reflect.Example");
  11.  
  12.         Assert.assertNotNull(object);
  13.  
  14.     }
  15.  
  16.     @Test
  17.     public void testGetConstructorInfo() {
  18.         String result = ReflectUtils
  19.                 .getPublicConstructorInfo("com.mengdd.reflect.Example");
  20.  
  21.         System.out
  22.                 .println("=============testGetConstructorInfo================");
  23.         System.out.println(result);
  24.         System.out
  25.                 .println("===================================================");
  26.  
  27.         Assert.assertNotNull(result);
  28.  
  29.     }
  30.  
  31.     @Test
  32.     public void testFieldInfos() {
  33.         String result = ReflectUtils
  34.                 .getDecleardFieldInfo("com.mengdd.reflect.Example");
  35.  
  36.         System.out.println("=============testFieldInfos================");
  37.         System.out.println(result);
  38.         System.out
  39.                 .println("===================================================");
  40.  
  41.         Assert.assertNotNull(result);
  42.     }
  43.  
  44.     @Test
  45.     public void testMethodInfos() {
  46.         String result = ReflectUtils
  47.                 .getDeclaredMethodInfos("com.mengdd.reflect.Example");
  48.  
  49.         System.out.println("=============testMethodInfos================");
  50.         System.out.println(result);
  51.         System.out
  52.                 .println("===================================================");
  53.  
  54.         Assert.assertNotNull(result);
  55.     }
  56.  
  57.     @Test
  58.     public void testPublicStaticInvocation() {
  59.         System.out
  60.                 .println("=============test static invocation================");
  61.  
  62.         try {
  63.  
  64.             // 静态方法1
  65.             ReflectUtils.invokePublicStaticMethod("com.mengdd.reflect.Example",
  66.                     "printSomething", new Class<?>[] { String.class },
  67.                     new Object[] { "Hello World" });
  68.  
  69.             // 静态方法2
  70.             Object result1 = ReflectUtils.invokePublicStaticMethod(
  71.                     "com.mengdd.reflect.Example", "add", new Class<?>[] {
  72.                             int.class, Integer.TYPE }, new Object[] { 1, 2 });
  73.  
  74.             // int.class和Integer.TYPE都行
  75.  
  76.             Assert.assertEquals(3, result1);
  77.  
  78.             // 静态方法3
  79.             Object result2 = ReflectUtils.invokePublicStaticMethod(
  80.                     "com.mengdd.reflect.Example", "getPi", new Class<?>[] {},
  81.                     new Object[] {});
  82.  
  83.             Assert.assertEquals(3.14159, result2);
  84.  
  85.         }
  86.         catch (Exception e) {
  87.             e.printStackTrace();
  88.  
  89.             System.out.println("Exception!");
  90.         }
  91.  
  92.         System.out
  93.                 .println("===================================================");
  94.     }
  95.  
  96.     @Test
  97.     public void testPrivateInvocation() {
  98.         Example example = new Example("1", 5, 0);
  99.         Object secret = null;
  100.         try {
  101.             secret = ReflectUtils.invokePrivateMethod(example, "tellSecret",
  102.                     new Class<?>[] { String.class, Integer.TYPE },
  103.                     new Object[] { "Hello", 2 });
  104.         }
  105.         catch (Exception e) {
  106.             e.printStackTrace();
  107.         }
  108.  
  109.         String expected = "Hello2Example [mFiledOne=1, mCount=5]";
  110.  
  111.         Assert.assertEquals(expected, secret);
  112.     }
  113. }

ReflectTest.java

　　预计后期还会有进一步更新完善，项目地址等待补充。

参考资料

　　Java 2 SE 7 API文档：http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

　　ReflectUtils类参考：

　　参考1：https://svn.apache.org/repos/asf/webservices/muse/trunk/modules/muse-util/src/org/apache/muse/util/ReflectUtils.java

　　参考2：http://www.oschina.net/code/snippet_736664_16425

　　参考3：http://www.oschina.net/code/explore/cglib-2.2/src/proxy/net/sf/cglib/core/ReflectUtils.java

ReflectUitls类的编写和对反射机制的解析的更多相关文章

  1. Java反射机制(Reflect)解析-----https://www.cnblogs.com/fzz9/p/7738381.html

    Java反射机制(Reflect)解析-----https://www.cnblogs.com/fzz9/p/7738381.html

  2. Java反射机制(Reflect)解析

    一.导读 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力.这一概念的提出很快引发了计算机科学领域关于应用反射性的研究.它首先被程序语言的设计 ...

  3. 分享知识-快乐自己：反射机制Demo解析

    Java-Reflect专题 基本反射简介: 1):JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象能够调用它的任意方法和属性;这种动态获取信息以及动 ...

  4. Java反射机制实例解析

    1.获取想操作的访问类的java.lang.Class类的对象     2.调用Class对象的方法返回访问类的方法和属性信息     3.使用反射API来操作      每个类被加载后,系统会为该类 ...

  5. java中的反射机制，以及如何通过反射获取一个类的构造方法 ，成员变量，方法，详细。。

    首先先说一下类的加载,流程.只有明确了类这个对象的存在才可以更好的理解反射的原因,以及反射的机制. 一.  类的加载 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三 ...

  6. Java反射机制及IoC原理

    一. 反射机制概念 主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义.在java中,只要给定类的名字, 那么就可以通 ...

  7. 【Java基础】反射机制

    反射 反射可以使我们很方便的创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代码链接.反射允许我们在编写和执行时,使我们的代码能够接入装载到JVM中的类的内部信息,而不是源代码中选定的类 ...

  8. Java反射机制详解(1) -反射定义

    首先,我们在开始前提出一个问题: 1.在运行时,对于一个java类,能否知道属性和方法:能否去调用它的任意方法? 答案是肯定的. 本节所有目录如下: 什么是JAVA的反射机制 JDK中提供的Refle ...

  9. [转]Java反射机制详解

    目录 1反射机制是什么 2反射机制能做什么 3反射机制的相关API ·通过一个对象获得完整的包名和类名 ·实例化Class类对象 ·获取一个对象的父类与实现的接口 ·获取某个类中的全部构造函数 - 详 ...

随机推荐

  1. Android序列化之Serializable和Parcelable

    PS:还有几天就开学了.先来一发. 学习内容: 1.序列化的目的 2.Android中序列化的两种方式 3.Parcelable与Serializable的性能比较 4.Android中如何使用Par ...

  2. Django之路由、模板和模型系统

    一.路由系统 浏览器会自动给url后加一个"/" django会自动给路由的正则表达式前面加一个"/" django会给任何不带"/"结尾的 ...

  3. HTML语义化：HTML5的新标签及IE5.5~9的部分兼容方案

    一.前言 本文将介绍HTML5中新增的语义化标签,及在IE5.5~9(IE9已经开始支持部分HTML5新标签了)支持这些新标签的兼容性处理. 目录一坨: 二.语义化标签:article.aside.t ...

  4. Vue2.0流式渲染中文乱码问题

    在参照vue2.0中文官方文档学习服务端渲染之流式渲染时,因为响应头默认编码类型为GBK,而文件为UFT-8类型,所以出现了中文乱码问题. 解决办法:设置响应头编码类型即可 response.setH ...

  5. android studio building project info 错误

    D:\ProgramFiles\android-studio\plugins\android\lib\templates\gradle\wrapper\gradle\wrapper\gradle-wr ...

  6. AMD64和i386的区别

    下载Debian系统时,出现两个选项:ADM64和i386,那么这两者的区别是什么? i386=Intel 80386.其实i386通常被用来作为对Intel(英特尔)32位微处理器的统称. AMD6 ...

  7. 检测IP地址的正则表达式

    正则表达式: ((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?) ((2[0-4]\d|25[0-5]|[01]?\d\ ...

  8. ASP.NET发送电子邮件

    代码: using System; using System.Collections.Generic; using System.Configuration; using System.Linq; u ...

  9. Socket开发框架之数据传输协议

    我在前面一篇随笔<Socket开发框架之框架设计及分析>中,介绍了整个Socket开发框架的总体思路,对各个层次的基类进行了一些总结和抽象,已达到重用.简化代码的目的.本篇继续分析其中重要 ...

  10. CIO:让IT成为企业的一种竞争优势

    在你的公司,IT是将自己视为服务提供者,业务部门的合作伙伴,还是创新驱动者?其他部门的领导者是怎么看待IT的?在老板的眼里,IT是如何的一个定位?在过去一年的,身为企业的CIO,你是否知道哪些应用或新 ...