Java android 反射

package com.tbi.app.lib.util;

//註解使用
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PACKAGE;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
* 反射輔助類
* @author Hocean  @version 2016年5月30日 下午3:14:22.  2016-10-12 16:16:37
*
*/
public class ReflectUtil {
   public static void main(String[] args) {
      //Demo
      VReflectObject.main();
   }

   private static final String GET = "get";
   private static final String SET = "set";

   
   //關於類
   /**
    * 得到參數類型
    * @param args
    * @return
    */
   public static Class<?>[] getTypeClassFromParms(Object[] args) {
      Class<?>[] argsClass = new Class[args.length];
      for (int i = 0, j = args.length; i < j; i++) {
         argsClass[i] = args[i].getClass();
      }
      return argsClass;
   }
   /**
    * 得到類
    * @param className
    * @return
    */
   public static Class<?> getClassFromName(String className) {
      Class<?> newoneClass = null;
      try {
         newoneClass = Class.forName(className);
      }
      catch (ClassNotFoundException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      return newoneClass;
   }

   
   //關於構造
   /**
    * 新建實例
    * @param newOneClass 類名
    * @param args 構造函數的參數
    * @return新建的實例
    * @throws Exception
    */
   public static <T> T newInstance(Class<T> newOneClass, Class<?>[] argsClass, Object[] args) {
      T t = null;
      try {
         Constructor<T> cons = newOneClass.getConstructor(argsClass);
         //Constructor<?> cons = newoneClass.getDeclaredConstructor(argsClass);  //可使用 私有構造
         t = cons.newInstance(args);
      }
      catch (Exception e) {
         // TODO 自動生成的 catch 塊
         e.printStackTrace();
      }
      return t;
   }
   /**
    * 私有構造方法  新建實例
    * @param newOneClass
    * @param args
    * @return
    */
   public static <T> T newInstanceInner(Class<T> newOneClass, Class<?>[] argsClass, Object[] args) {
      T t = null;
      try {
         //Constructor<?> cons = newoneClass.getConstructor(argsClass);
         Constructor<T> cons = newOneClass.getDeclaredConstructor(argsClass); //可使用 私有構造
         cons.setAccessible(true);
         t = cons.newInstance(args);
      }
      catch (Exception e) {
         // TODO 自動生成的 catch 塊
         e.printStackTrace();
      }
      return t;
   }
   /**
    * 新建實例
    * @param newOneClass 類名
    * @param args 構造函數的參數
    * @return新建的實例
    * @throws Exception
    */
   public static Object newInstanceObj(Class<?> newOneClass, Class<?>[] argsClass, Object[] args) {
      return newInstance(newOneClass,argsClass,args);
   }
   /**
    * 私有構造方法  新建實例
    * @param newOneClass
    * @param args
    * @return
    */
   public static Object newInstanceObjInner(Class<?> newOneClass, Class<?>[] argsClass, Object[] args) {
      return newInstanceInner(newOneClass,argsClass,args);
   }

   
   //關於註解
   /**
    * 獲得註解 當前類字段
    * @param cls
    * @param ctag
    * @return
    */
   public static <T extends Annotation> T[] getTags(Class<?> cls, Class<T> ctag) {
      return newTagsListThis(ReflectUtil.getFields(cls), cls, ctag);
   }
   /**
    * 獲得註解  全部類字段
    * @param cls
    * @param ctag
    * @return
    */
   public static <T extends Annotation> List<T[]> getTagsAll(Class<?> cls, Class<T> ctag) {
      return newTagsListSupper(ReflectUtil.getFieldsAll(cls), cls, ctag);
   }
   /**
    * 獲得註解 可見類字段
    * @param cls
    * @param ctag
    * @return
    */
   public static <T extends Annotation> List<T[]> getTagsVisit(Class<?> cls, Class<T> ctag) {
      return newTagsListSupper(ReflectUtil.getFieldsVisit(cls), cls, ctag);
   }
   /**
    * 獲得註解 當前可見類字段
    * @param cls
    * @param ctag
    * @return
    */
   public static <T extends Annotation> T[] getTagsLocal(Class<?> cls, Class<T> ctag) {
      return newTagsListThis(ReflectUtil.getFieldsLocal(cls), cls, ctag);
   }
   /**
    * 新建數組標記
    * @param fields
    * @param cls
    * @param ctag
    * @return
    */
   private static <T  extends Annotation> T[] newTagsListThis(Field[] fields, Class<?> cls, Class<T> ctag){
      List<T> lt = new ArrayList<>();
      for (Field field : fields) {
         if (field.isAnnotationPresent(ctag)) {
            T t = (T) field.getAnnotation(ctag);
            lt.add(t);
         }
      }
      @SuppressWarnings("unchecked")    
      T[] ts = (T[])Array.newInstance(ctag, lt.size());
      for (int i = 0; i < ts.length; i++)
      {
         ts[i] = lt.get(i);
      }
      return ts;
   }
   /**
    * 新建 列表標記
    * @param list
    * @param cls
    * @param ctag
    * @return
    */
   private static <T  extends Annotation> List<T[]> newTagsListSupper(List<Field[]> list, Class<?> cls, Class<T> ctag){
      List<T[]> lts = new ArrayList<>();
      for(Field[] fs : list) {
         lts.add(newTagsListThis(fs,cls,ctag));
      }
      return lts;
   }

   
   //關於字段
   /**
    * 遞歸查找字段的  回調接口
    * @author Hocean  @version 2016年10月12日 下午2:32:31.
    *
    */
   private static interface IFieldValuePoint {
      Object invoke(Object o, String fieldName);
   }
   /**
    * 用來遞歸 查找 字段
    * @param o
    * @param fieldName
    * @param inv
    * @return
    */
   private static Object getFieldValuePoint(Object o, String fieldName, IFieldValuePoint inv) {
      try {
         if (!fieldName.contains(".")) { //不包含           
            return inv.invoke(o, fieldName);
         }
         String fnb = fieldName.substring(0, fieldName.indexOf("."));
         Object vob = getFieldValuePoint(o, fnb, inv);
         return getFieldValuePoint(vob, fieldName.substring(fieldName.indexOf(".") + 1), inv);
      }
      catch (Exception e) {
         return null;
      }
   }

   /**
    * 得到類的當前所有字段
    * @param cls
    * @return
    */
   public static Field[] getFields(Class<?> cls) {
      //Class<?> c = o.getClass(); //反射
      Field[] fields = cls.getDeclaredFields(); //屬性
      for (int i = 0; i < fields.length; i++) {
         fields[i].setAccessible(true); //反射私有屬性 權限
         /*Field field = fields[i]; //第幾個參數
         Class<?> type = field.getType(); //反射類型
         String typeName = type.getName();//得到類型
         System.out.println(typeName);
         String fieldName = field.getName(); //反射字段
         System.out.println(fieldName); //字段名
         tableRow[i] = fieldName;
         try
         {
            Object value = field.get(t); //字段值
            System.out.println(value);
         
         }
         catch (IllegalArgumentException | IllegalAccessException e1)
         {
            e1.printStackTrace();
         }*/
      }
      return fields;
   }

   /**
    * 搜索全部字段  包括私有字段
    * @param clazz
    * @return
     */
   public static List<Field[]> getFieldsAll(Class<?> clazz) {
      List<Field[]> list = new ArrayList<>();
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Field[] fields = mclazz.getDeclaredFields(); //屬性
            for (int i = 0; i < fields.length; i++) {
               fields[i].setAccessible(true); //反射私有屬性 權限             
            }
            list.add(fields);
         }
         catch (Exception e) {
         }
      }
      return list;
   }

   /**
    * 搜索全部可見字段
    * @param clazz
    * @return
     */
   public static List<Field[]> getFieldsVisit(Class<?> clazz) {
      List<Field[]> list = new ArrayList<>();
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Field[] fields = mclazz.getFields(); //屬性
            for (int i = 0; i < fields.length; i++) {
               fields[i].setAccessible(true); //反射私有屬性 權限             
            }
            list.add(fields);
         }
         catch (Exception e) {
         }
      }
      return list;
   }

   /**
    * 對象當前字段
    * @param clazz
    * @return
     */
   public static Field[] getFieldsLocal(Class<?> clazz) {
      Field[] fields = clazz.getFields(); //屬性
      for (int i = 0; i < fields.length; i++) {
         fields[i].setAccessible(true); //反射私有屬性 權限
      }
      return fields;
   }

   /**
    * 得到類的當前字段
    * @param cls
    * @param fieldName
     * @return
     */
   public static Field getField(Class<?> cls, String fieldName) {
      Field fields = null;
      try {
         fields = cls.getDeclaredField(fieldName);
         fields.setAccessible(true); //反射私有屬性 權限          
      }
      catch (NoSuchFieldException | SecurityException e) {
         e.printStackTrace();
      } //屬性
      return fields;
   }

   /**
    * 搜索全部字段  包括私有字段
    * @param clazz
    * @param fieldName
     * @return
     */
   public static Field getFieldAll(Class<?> clazz, String fieldName) {
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Field field = mclazz.getDeclaredField(fieldName);
            field.setAccessible(true); //反射私有屬性 權限
            return field;
         }
         catch (Exception e) {
         }
      }
      return null;
   }

   /**
    * 搜索全部可見字段
    * @param clazz
    * @param fieldName
     * @return
     */
   public static Field getFieldVisit(Class<?> clazz, String fieldName) {
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Field field = mclazz.getField(fieldName);
            field.setAccessible(true); //反射私有屬性 權限
            return field;
         }
         catch (Exception e) {
         }
      }
      return null;
   }

   /**
    * 對象當前字段
    * @param clazz
    * @param fieldName
     * @return
     */
   public static Field getFieldLocal(Class<?> clazz, String fieldName) {
      try {
         Field field = clazz.getDeclaredField(fieldName);
         field.setAccessible(true); //反射私有屬性 權限
         return field;
      }
      catch (Exception e) {
      }
      return null;
   }

   /**
    * 得到字段的值
    * @param field
    * @param obj
    * @return
    */
   public static Object getFieldValue(Object obj, Field field) {
      try {        
         return field.get(obj);
      }
      catch (Exception e) {
      }
      return null;
   }
   /**
    * 設置字段
    * @param field
    * @param obj
    * @param value
    */
   public static void setFieldValue(Object obj, Field field, Object value) {
      try {        
         field.set(obj,value);
      }
      catch (Exception e) {
      }
   }
   
   /**
    * 得到類的當前 靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static Object getStaticFieldValue(Class<?> ownerClass, String fieldName) {
      
      return getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getField((Class<?>)o, fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }
   /**
    * 得到全部字段  包括私有字段  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static Object getStaticFieldValueAll(Class<?> ownerClass, String fieldName) {
      
      return getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldAll((Class<?>)o, fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }
   /**
    * 得到全部可見字段  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static Object getStaticFieldValueVisit(Class<?> ownerClass, String fieldName) {
      
      return getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldVisit((Class<?>)o, fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }
   /**
    * 得到類的當前  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static Object getStaticFieldLocal(Class<?> ownerClass, String fieldName) {
      
      return getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldLocal((Class<?>)o, fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }

   /**
    * 設置類的 當前靜態屬性值 
    * @param ownerClass
    * @param fieldName
    * @param value
    */
   public static void setStaticFieldValue(final Class<?> ownerClass, String fieldName, final Object value) {
      getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getField((Class<?>)o, fieldName);
            try {
               f.set(ownerClass, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }
   /**
    * 設置全部字段  包括私有字段  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static void setStaticFieldValueAll(final Class<?> ownerClass, String fieldName, final Object value) {
      getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldAll((Class<?>)o, fieldName);
            try {
               f.set(ownerClass, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }
   /**
    * 設置全部可見字段  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static void setStaticFieldValueVisit(final Class<?> ownerClass, String fieldName, final Object value) {
      
        getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldVisit((Class<?>)o, fieldName);
            try {
               f.set(ownerClass, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }
   /**
    * 設置類的當前  靜態屬性值
    * @param   ownerClass   類名
    * @param   fieldName   屬性名
    * @return  該屬性對象
    * @throws  Exception      
   */
   public static void setStaticFieldLocal(final Class<?> ownerClass, String fieldName, final Object value) {
      
        getFieldValuePoint(ownerClass, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldLocal((Class<?>)o, fieldName);
            try {
               f.set(ownerClass, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }

   /**
    * 得到對象當前字段
    * @param o
    * @param fieldName
     * @return
     */
   public static Object getFieldValue(Object o, String fieldName) {
      return getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getField(o.getClass(), fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }

   /**
    * 得到對象全部字段  包括私有字段
    * @param o
    * @param fieldName
     * @return
     */
   public static Object getFieldValueAll(Object o, String fieldName) {
      return getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldAll(o.getClass(), fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }

   /**
    * 得到對象全部可見字段
    * @param o
    * @param fieldName
     * @return
     */
   public static Object getFieldValueVisit(Object o, String fieldName) {
      return getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldVisit(o.getClass(), fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }

   /**
    * 得到對象當前字段
    * @param o
    * @param fieldName
     * @return
     */
   public static Object getFieldValueLocal(Object o, String fieldName) {
      return getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldLocal(o.getClass(), fieldName);
            Object vo = null;
            try {
               vo = f.get(o);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return vo;
         }
      });
   }

   /**
    * 設置類的當前字段
    * @param o
    * @param fieldName
    * @param value
     */
   public static void setFieldValue(Object o, String fieldName, final Object value) {
      getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getField(o.getClass(), fieldName);
            try {
               f.set(o, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }

   /**
    * 設置類的全部字段  包括私有字段
    * @param o
    * @param fieldName
    * @param value
     */
   public static void setFieldValueAll(Object o, String fieldName, final Object value) {
      getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldAll(o.getClass(), fieldName);
            try {
               f.set(o, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }

   /**
    * 設置類的全部可見字段
    * @param o
    * @param fieldName
    * @param value
     */
   public static void setFieldValueVisit(Object o, String fieldName, final Object value) {
      getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldVisit(o.getClass(), fieldName);
            try {
               f.set(o, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }

   /**
    * 設置類的當前字段
    * @param o
    * @param fieldName
    * @param value
     */
   public static void setFieldValueLocal(Object o, String fieldName, final Object value) {
      getFieldValuePoint(o, fieldName, new IFieldValuePoint() {
         @Override
         public Object invoke(Object o, String fieldName) {
            Field f = getFieldLocal(o.getClass(), fieldName);
            try {
               f.set(o, value);
            }
            catch (IllegalArgumentException | IllegalAccessException e) {
            }
            return null;
         }
      });
   }

   
   //關於方法
   /**
    * 執行對象方法 搜索當前類
    * @param owner
    * @param methodName
    * @param args
    * @param argsClass
    * @return
    */
   public static Object invokeMethod(Object owner, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethod(owner.getClass(), methodName, argsClass).invoke(owner, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行對象方法 搜索全部父類
    * @param owner
    * @param methodName
    * @param args
    * @param argsClass
    * @return
    */
   public static Object invokeMethodAll(Object owner, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodAll(owner.getClass(), methodName, argsClass).invoke(owner, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行對象可見方法 搜索全部父類
    * @param owner
    * @param methodName
    * @param args
    * @param argsClass
    * @return
    */
   public static Object invokeMethodVisit(Object owner, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodVisit(owner.getClass(), methodName, argsClass).invoke(owner, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行對象 的本地方法
    * @param owner
    * @param methodName
    * @param argsClass
    * @param args
    * @return
    * @throws Exception
    */
   public static Object invokeMethodLocal(Object owner, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodLocal(owner.getClass(), methodName, argsClass).invoke(owner, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }

   /**
    * 執行類的靜態方法    搜索當前類                                                     
    * @param   ownerClass 類名
    * @param   methodName 方法名                                 
    * @param   args 參數數組                                      
    * @return                                                           
    *  執行方法返回的結果                                                        
    */
   public static Object invokeStaticMethod(Class<?> ownerClass, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethod(ownerClass, methodName, argsClass).invoke(null, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行類的靜態方法     搜索全部父類                                                    
    * @param   ownerClass 類名
    * @param   methodName 方法名                                 
    * @param   args 參數數組                                      
    * @return                                                           
    *  執行方法返回的結果                                                        
    */
   public static Object invokeStaticMethodAll(Class<?> ownerClass, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodAll(ownerClass, methodName, argsClass).invoke(null, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行類的靜態可見方法   搜索全部父類                                                     
    * @param   ownerClass 類名
    * @param   methodName  方法名                                 
    * @param   args  參數數組                                      
    * @return                                                           
    *  執行方法返回的結果                                                        
    */
   public static Object invokeStaticMethodVisit(Class<?> ownerClass, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodVisit(ownerClass, methodName, argsClass).invoke(null, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }
   /**
    * 執行類的靜態的本地方法         搜索當前類
    * @param   ownerClass 類名
    * @param   methodName 方法名                                 
    * @param   args 參數數組                                      
    * @return                                                           
    *  執行方法返回的結果                                                        
    */
   public static Object invokeStaticMethodLocal(Class<?> ownerClass, String methodName, Class<?>[] argsClass, Object[] args) {
      try {
         return getMethodLocal(ownerClass, methodName, argsClass).invoke(null, args);
      }
      catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      }
      return null;
   }

   /**
    * 對象當前函數   包括私有函數
    * @param clazz
    * @param methodName
    * @param parameterTypes
    * @return
    */
   public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
      try {
         Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
         method.setAccessible(true);
         return method;
      }
      catch (Exception e) {

      }
      return null;
   }

   /**
    * 搜索全部函數  包括私有函數
    * @param clazz
    * @param methodName
    * @param parameterTypes
     * @return
     */
   public static Method getMethodAll(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Method method = mclazz.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return method;
         }
         catch (Exception e) {

         }
      }
      return null;
   }

   /**
    * 搜索全部可見函數
    * @param clazz
    * @param methodName
    * @param parameterTypes
     * @return
     */
   public static Method getMethodVisit(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
      for (Class<?> mclazz = clazz; mclazz != Object.class; mclazz = mclazz.getSuperclass()) {
         try {
            Method method = mclazz.getMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return method;
         }
         catch (Exception e) {

         }
      }
      return null;
   }

   /**
    * 對象當前函數   不包括私有函數
    * @param clazz
    * @param methodName
    * @param parameterTypes
     * @return
     */
   public static Method getMethodLocal(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
      try {
         Method method = clazz.getMethod(methodName, parameterTypes);
         method.setAccessible(true);
         return method;
      }
      catch (Exception e) {

      }
      return null;
   }

   /**
    * 得到字段的值
    * @param method
    * @param obj
    * @param args
     * @return
     */
   public static Object invoke(Method method, Object obj, Object... args) {
      try {        
         return method.invoke(obj, args);
      }
      catch (Exception e) {
      }
      return null;
   }
   
   
   //關於 get set

   /**
    *
    * 得到對象的  get 方法      建議使用駝峯命名法     如果不是標準的屬性 請參考 invokeMethod?（）方法
    * 如  private String firstName 則 invokeGet(？,firstName)   private String CPU 這樣的 請 把第一個單詞小寫    cpu 則 invokeGet(？,cPU)
    * @param object
    * @param propertiesName
     * @return
     */
   public static Object invokeGet(Object object, String propertiesName) {
      String point = ".";
      String pointFree = "\\."; //必須轉義
      try {
         String[] pns = new String[] {propertiesName};
         if (propertiesName.contains(point)) { //包含
            pns = propertiesName.split(pointFree); //必須轉義
         }
         Object obj = object;
         for (int i = 0; i < pns.length; i++) {
            String pn = pns[i];
            String methodName = GET + getMethodName(pn);
            Method method = ReflectUtil.getMethodVisit(obj.getClass(), methodName, new Class[] {});
            obj = method.invoke(obj);
         }
         return obj;
      }
      catch (Exception e) {
         return null;
      }
   }

   /**
    * 調用對象的 set 方法      建議使用駝峯命名法     如果不是標準的屬性 請參考 invokeMethod?（）方法
    * 如  private String firstName 則 invokeSet(？,firstName，？，？)   private String CPU 這樣的 請 把第一個單詞小寫    cpu 則 invokeSet(？,cPU，？，？)
    * @param object
    * @param propertiesName
    * @param argClass
    * @param value
    * @return
    */
   public static Object invokeSet(Object object, String propertiesName, Class<?> argClass, Object... value) {
      String point = ".";
      int lastPoint = propertiesName.lastIndexOf(point); //最後一個點的位置
      try {
         Object obj = object;
         if (propertiesName.contains(point)) { //包含
            String fieldName = propertiesName.substring(0, lastPoint);
            obj = invokeGet(obj, fieldName);
         }        
         String methodName = SET + getMethodName(propertiesName.substring(lastPoint + 1));
         Method method = ReflectUtil.getMethodVisit(obj.getClass(), methodName, argClass);
         return method.invoke(obj, value);        
      }
      catch (Exception e) {
         return null;
      }
   }

   /**
    * 轉換爲 駝峯命名法的方法  get set
    * @param fildeName
    * @return
    */
   private static String getMethodName(String fildeName) {
      byte[] items = fildeName.getBytes();
      items[0] = (byte) ((char) items[0] - 'a' + 'A');
      return new String(items);
   }

   
   //其他
   /**
   * 得到數組中的某個元素
   * @param    array 數組
   * @param    index 索引
   * @return 返回指定數組對象中索引組件的值
   */
   public static Object getByArray(Object array, int index) {
      return Array.get(array, index);
   }
   /**
    * 是不是某個類的實例
    * @param obj 實例
    * @param cls 類
    * @return 如果 obj 是此類的實例，則返回 true
    */
   public static boolean isInstance(Object obj, Class<?> cls) {
      return cls.isInstance(obj);
   }
   
   
   //Demo
   protected static class VReflectObject {

      public static void main() {
         Object vro = ReflectUtil.newInstanceInner(VReflectObject.class, new Class[] {}, new Object[] {}); //私有方法構造
         System.out.println("==========================>>> 屬性");
         System.out.println("獲取: " + ReflectUtil.invokeGet(vro, "id"));
         System.out.println("獲取嵌套: " + ReflectUtil.invokeGet(vro, "vr2.id"));
         System.out.println("設置嵌套: " + ReflectUtil.invokeSet(vro, "vr2.id", String.class, "2.0"));
         System.out.println("獲取嵌套: " + ReflectUtil.invokeGet(vro, "vr2.id"));
         System.out.println("==========================>>> 方法");
         System.out.println("推薦 調用私有公有本類方法: " + ReflectUtil.invoke(ReflectUtil.getMethodAll(VReflectObject.class, "sum", new Class[] { int.class, int.class })  , vro,   new Object[] { 2, 6 }));
         System.out.println("調用私有公有本類方法: " + ReflectUtil.invokeMethod(vro, "sum", new Class[] { int.class, int.class }, new Object[] { 2, 6 }));
         System.out.println("調用私有公有本類父類方法: " + ReflectUtil.invokeMethodAll(vro, "sum", new Class[] { int.class, int.class }, new Object[] { 2, 6 }));
         System.out.println("調用共有本類父類方法: " + ReflectUtil.invokeMethodVisit(vro, "sub", new Class[] { int.class, int.class }, new Object[] { 2, 6 }));
         System.out.println("調用公有本類方法: " + ReflectUtil.invokeMethodLocal(vro, "sub", new Class[] { int.class, int.class }, new Object[] { 2, 6 }));
         System.out.println("==========================>>> 字段");
         System.out.println("推薦 靜態私有字段: " + ReflectUtil.getFieldValue(  VReflectObject.class, ReflectUtil.getFieldAll(VReflectObject.class, "staticField")));
         ReflectUtil.setFieldValue(  VReflectObject.class, ReflectUtil.getFieldAll(VReflectObject.class, "staticField"), "我是靜態私有字段2");
         System.out.println("推薦 私有字段: " + ReflectUtil.getFieldValue(  vro, ReflectUtil.getFieldAll(VReflectObject.class, "id")));
         ReflectUtil.setFieldValue(  vro, ReflectUtil.getFieldAll(VReflectObject.class, "id"), "00");
         System.out.println("靜態私有字段: " + ReflectUtil.getStaticFieldValue(VReflectObject.class, "staticField"));
         ReflectUtil.setStaticFieldValue(VReflectObject.class, "staticField","設置後的 靜態字段");
         System.out.println("設置後靜態私有字段: " + ReflectUtil.getStaticFieldValue(VReflectObject.class, "staticField"));
         ReflectUtil.setFieldValue(vro, "id", "22222222222222");
         System.out.println("私有字段: " + ReflectUtil.getFieldValue(vro, "id"));
         ReflectUtil.setFieldValue(vro, "vr2.id", "888");
         System.out.println("私有字段嵌套: " + ReflectUtil.getFieldValue(vro, "vr2.id"));
         System.out.println("私有字段嵌套: " + ReflectUtil.getFieldValue(vro, "vr2.vr3.id"));
         System.out.println("==========================>>> 註解");
         System.out.println("獲取註解: " + ReflectUtil.getTags(VReflectObject.class, ATag.class)[0].value()    );
         System.out.println("獲取全部類註解: " + ReflectUtil.getTagsAll(VReflectObject.class, ATag.class).get(0)[0].id()    );
         
         
      }

      private VReflectObject() {
         super();
         vr2 = new VReflectObject2();
      }

      public String getId() {
         return id;
      }

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

      public String getName() {
         return name;
      }

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

      public VReflectObject2 getVr2() {
         return vr2;
      }

      public void setVr2(VReflectObject2 vr2) {
         this.vr2 = vr2;
      }

      @SuppressWarnings("unused") //私有  但反射可以從外部調用
      private String sum(int l, int r) {
         return (l + r) + "";
      }

      public String sub(int l, int r) {
         return (l - r) + "";
      }
      @ATag(id=666,value="我是id")
      private String id = "0";
      @ATag("我是姓名")
      private String name = "";
      private VReflectObject2 vr2;      
      @SuppressWarnings("unused") //私有  但反射可以從外部調用
      private static String staticField = "我是靜態私有字段";
   }
   protected static class VReflectObject2 {
      private String id = "id22222222222222222";
      @SuppressWarnings("unused")  //私有  但反射可以從外部調用
      private VReflectObject3 vr3;      
      private VReflectObject2() {
         super();
         vr3 = new VReflectObject3();
      }     
      public String getId() {
         return id;
      }
      public void setId(String id) {
         this.id = id;
      }
   }
   protected static class VReflectObject3 {
      private String id = "333333333333333333333  我是  VReflectObject 中的  VReflectObject2  中的  VReflectObject3 的 id 字段";     
      public String getId() {
         return id;
      }
      public void setId(String id) {
         this.id = id;
      }
   }
   @Retention(RetentionPolicy.RUNTIME) //提供反射
   @Target(value = { CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE }) //此處成爲元註解 ，註解的定義需要元註解
   private static @interface ATag{
      public int id() default 0; //此處需要注意寫法
      public String value() default "我是默認值的 註解";  //缺省註解 主要標註
      public String comment() default "";  //複合特殊類型

   }
}

//demo 反射測試
/*
static String[] tableRow;
private static void fanshe()
   {
      VCarUser vu = new VCarUser(); //測試對象      
      Class<?> c = vu.getClass(); //反射
      Field[] fields = c.getDeclaredFields(); //屬性
      tableRow = new String[fields.length];
      for (int i = 0; i < fields.length; i++)
      {
         fields[i].setAccessible(true); //反射私有屬性 權限
         Field field = fields[i]; //第幾個參數
         Class<?> type = field.getType(); //反射類型
         String typeName = type.getName();//得到類型
         System.out.println(typeName);
         String fieldName = field.getName(); //反射字段
         System.out.println(fieldName); //字段名
         tableRow[i] = fieldName;
         try
         {
            Object value = field.get(vu); //字段值
            System.out.println(value);

         }
         catch (IllegalArgumentException | IllegalAccessException e1)
         {
            e1.printStackTrace();
         }

         if ("java.lang.String".equals(typeName))
         {
            try
            {
               field.set(vu, "1");

            }
            catch (IllegalArgumentException | IllegalAccessException e)
            {
               e.printStackTrace();
            }
         }
      }

      System.out.println(vu.getClass().getName());

   }
   */