content: package com.liyi.sutils.utils;
  
  import java.lang.reflect.AccessibleObject;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.Member;
  import java.lang.reflect.Modifier;
  
  /**
   * 反射相关工具类
   */
  public class ReflectUtil {
      private final Class<?> type;
      private final Object object;
  
      private ReflectUtil(Class<?> type) {
          this(type, type);
      }
  
      private ReflectUtil(Class<?> type, Object object) {
          this.type = type;
          this.object = object;
      }
  
      /**************************************************************************
       **** reflect
       **************************************************************************/
  
      public static ReflectUtil reflect(String className) {
          return reflect(forName(className));
      }
  
      public static ReflectUtil reflect(String name, ClassLoader classLoader) {
          return reflect(forName(name, classLoader));
      }
  
      public static ReflectUtil reflect(Class<?> clazz) {
          return new ReflectUtil(clazz);
      }
  
      public static ReflectUtil reflect(Object object) {
          return new ReflectUtil(object == null ? Object.class : object.getClass(), object);
      }
  
      private ReflectUtil reflect(Class<?> type, Object object) {
          return new ReflectUtil(type, object);
      }
  
      private ReflectUtil reflect(Constructor<?> constructor, Object... args) {
          try {
              return new ReflectUtil(constructor.getDeclaringClass(), accessible(constructor).newInstance(args));
          } catch (Exception e) {
              throw new ReflectException(e);
          }
      }
  
      private static Class<?> forName(String className) {
          try {
              return Class.forName(className);
          } catch (ClassNotFoundException e) {
              throw new ReflectException(e);
          }
      }
  
      private static Class<?> forName(String name, ClassLoader classLoader) {
          try {
              return Class.forName(name, true, classLoader);
          } catch (ClassNotFoundException e) {
              throw new ReflectException(e);
          }
      }
  
      @SuppressWarnings("unchecked")
      public <T> T get() {
          return (T) object;
      }
  
      public ReflectUtil field(String name) {
          try {
              Field field = field0(name);
              return reflect(field.getType(), field.get(object));
          } catch (IllegalAccessException e) {
              throw new ReflectException(e);
          }
      }
  
      private Field field0(String name) {
          Class<?> t = type();
          try {
              return accessible(t.getField(name));
          } catch (NoSuchFieldException e) {
              do {
                  try {
                      return accessible(t.getDeclaredField(name));
                  } catch (NoSuchFieldException ignore) {
                  }
                  t = t.getSuperclass();
              }
              while (t != null);
              throw new ReflectException(e);
          }
      }
  
      public ReflectUtil create() {
          return create(new Object[0]);
      }
  
      public ReflectUtil create(Object... args) {
          Class<?>[] types = types(args);
          try {
              Constructor<?> constructor = type().getDeclaredConstructor(types);
              return reflect(constructor, args);
          } catch (NoSuchMethodException e) {
              for (Constructor<?> constructor : type().getDeclaredConstructors()) {
                  if (match(constructor.getParameterTypes(), types)) {
                      return reflect(constructor, args);
                  }
              }
              throw new ReflectException(e);
          }
      }
  
      private boolean match(Class<?>[] declaredTypes, Class<?>[] actualTypes) {
          if (declaredTypes.length == actualTypes.length) {
              for (int i = 0; i < actualTypes.length; i++) {
                  if (actualTypes[i] == NULL.class
                          || wrapper(declaredTypes[i]).isAssignableFrom(wrapper(actualTypes[i]))) {
                      continue;
                  }
                  return false;
              }
              return true;
          } else {
              return false;
          }
      }
  
      private static Class<?>[] types(Object... values) {
          if (values == null) return new Class[0];
  
          Class<?>[] result = new Class[values.length];
  
          for (int i = 0; i < values.length; i++) {
              Object value = values[i];
              result[i] = value == null ? NULL.class : value.getClass();
          }
  
          return result;
      }
  
      public Class<?> type() {
          return type;
      }
  
      public static Class<?> wrapper(Class<?> type) {
          if (type == null) {
              return null;
          } else if (type.isPrimitive()) {
              if (boolean.class == type) {
                  return Boolean.class;
              } else if (int.class == type) {
                  return Integer.class;
              } else if (long.class == type) {
                  return Long.class;
              } else if (short.class == type) {
                  return Short.class;
              } else if (byte.class == type) {
                  return Byte.class;
              } else if (double.class == type) {
                  return Double.class;
              } else if (float.class == type) {
                  return Float.class;
              } else if (char.class == type) {
                  return Character.class;
              } else if (void.class == type) {
                  return Void.class;
              }
          }
          return type;
      }
  
  
      @Override
      public int hashCode() {
          return object.hashCode();
      }
  
      @Override
      public boolean equals(Object obj) {
          return obj instanceof ReflectUtil && object.equals(((ReflectUtil) obj).get());
      }
  
      @Override
      public String toString() {
          return object.toString();
      }
  
      /**
       * @param accessible
       * @param <T>
       * @return
       */
      public static <T extends AccessibleObject> T accessible(T accessible) {
          if (accessible == null) return null;
          if (accessible instanceof Member) {
              Member member = (Member) accessible;
              if (Modifier.isPublic(member.getModifiers()) &&
                      Modifier.isPublic(member.getDeclaringClass().getModifiers())) {
                  return accessible;
              }
          }
          if (!accessible.isAccessible()) accessible.setAccessible(true);
          return accessible;
      }
  
  
      private static class NULL {
      }
  
      public static class ReflectException extends RuntimeException {
  
          public ReflectException(String message) {
              super(message);
          }
  
          public ReflectException(String message, Throwable cause) {
              super(message, cause);
          }
  
          public ReflectException(Throwable cause) {
              super(cause);
          }
      }
  }
  