Java 类org.apache.commons.lang3.reflect.MethodUtils 实例源码

private <T> ValueExtractor provideExtractorForValue(Class<T> clazz, int target, List<String> chainOfProperties) {
    Class<?> propertyClass = clazz;
    List<ValueExtractor> chainedExtractors = Lists.newArrayList();

    for (String property : chainOfProperties) {
        Class<?> finalPropertyClass = propertyClass;

        Optional<Method> matchingMethod = Stream.of(property,
                "get" + WordUtils.capitalize(property),
                "is" + WordUtils.capitalize(property))
                .map(token -> MethodUtils.getMatchingMethod(finalPropertyClass, token))
                .findFirst();

        Method method = matchingMethod.orElseThrow(
                () -> new InvalidQueryException(
                        String.format("Cannot find appropriate method for property [%s] on class [%s]",
                                property, finalPropertyClass)));

        ReflectionExtractor extractor = new ReflectionExtractor(method.getName());
        chainedExtractors.add(extractor);
        propertyClass = method.getDeclaringClass();
    }

    return new ChainedExtractor(chainedExtractors.toArray(new ValueExtractor[chainedExtractors.size()]));
}

/** 
 * 
 * 快捷调用公共方法（性能较差） 
 *  
 * @param host 
 *            宿主对象 
 * @param name 
 *            方法名 
 * @param args 
 *            方法参数 
 * @return 执行结果 
 * @throws NoSuchMethodException 
 *             如果没有相应的方法 
 */
public static Object invokePublic(Object host, String name, Object... args) throws NoSuchMethodException {
    final Class<?> clazz = host instanceof Class ? (Class<?>) host : host.getClass();
    args = args == null ? new Object[] { null } : args;
    Class<?>[] paramTypes = new Class[args.length];
    for (int i = 0; i < paramTypes.length; i++) {
        paramTypes[i] = args[i] == null ? null : args[i].getClass();
    }
    int[] keys = new int[3];
    keys[0] = clazz.hashCode();
    keys[1] = name.hashCode();
    keys[2] = Arrays.hashCode(paramTypes);
    int key = Arrays.hashCode(keys);
    Invoker invoker = PUBLIC_INVOKER_MAP.get(key);
    if (invoker == null) {
        Method method = MethodUtils.getMatchingAccessibleMethod(clazz, name, paramTypes);
        if (method == null) {
            throw new NoSuchMethodException(clazz.getName() + "." + name + argumentTypesToString(paramTypes));
        }
        invoker = newInvoker(method);
        PUBLIC_INVOKER_MAP.put(key, invoker);
    }
    return invoker.invoke(host, args);
}

private void checkCommands(final String os, final String... command) throws ReflectiveOperationException {
    final URL[] urLs = ((URLClassLoader) Main.class.getClassLoader()).getURLs();
    ThreadClassLoaderScope scope = null;
    try {
        System.setProperty("os.name", os);
        final URLClassLoader urlClassLoader = new URLClassLoader(urLs, null);
        scope = new ThreadClassLoaderScope(urlClassLoader);
        final Object terra = urlClassLoader.loadClass("org.ligoj.app.plugin.prov.terraform.TerraformUtils").newInstance();
        final Object mock = MethodUtils.invokeStaticMethod(urlClassLoader.loadClass("org.mockito.Mockito"), "mock",
                urlClassLoader.loadClass("org.ligoj.bootstrap.resource.system.configuration.ConfigurationResource"));
        FieldUtils.writeField(terra, "configuration", mock, true);
        Assert.assertEquals(Arrays.asList(command),
                ((ProcessBuilder) MethodUtils.invokeMethod(terra, true, "newBuilder", new Object[] { new String[] { "terraform" } }))
                        .command());
    } finally {
        IOUtils.closeQuietly(scope);
    }
}

/**
 * 匹配模块中复合HTTP请求路径的方法
 * 匹配方法的方式是：HttpMethod和HttpPath全匹配
 *
 * @param path          HTTP请求路径
 * @param httpMethod    HTTP请求方法
 * @param uniqueId      模块ID
 * @param classOfModule 模块类
 * @return 返回匹配上的方法，如果没有找到匹配方法则返回null
 */
private Method matchingModuleMethod(final String path,
                                    final Http.Method httpMethod,
                                    final String uniqueId,
                                    final Class<?> classOfModule) {

    for (final Method method : MethodUtils.getMethodsListWithAnnotation(classOfModule, Http.class)) {
        final Http httpAnnotation = method.getAnnotation(Http.class);
        if(null == httpAnnotation) {
            continue;
        }
        final String pathPattern = "/"+uniqueId+httpAnnotation.value();
        if (ArrayUtils.contains(httpAnnotation.method(), httpMethod)
                && SandboxStringUtils.matching(path, pathPattern)) {
            return method;
        }
    }

    // 找不到匹配方法，返回null
    return null;
}

@Override
public String formatObjectGraph(Object graph) throws ReflectiveOperationException, ClassCastException {
    StringBuilder out = new StringBuilder();
    Enumeration attrs = (Enumeration) MethodUtils.invokeExactMethod(graph, "getAttributeNames");
    @SuppressWarnings("unchecked")
    ArrayList<String> attrList = Collections.list(attrs);
    Collections.sort(attrList);
    out.append("{");
    int size = attrList.size();
    for (int i = 0; i < size; i++) {
        String attrName = attrList.get(i);
        Object attrValue = MethodUtils.invokeExactMethod(graph, "getAttribute", attrName);
        out.append(attrName);
        out.append('=');
        out.append(attrValue);
        if (i != size - 1) {
            out.append(",\n\n");
        }
    }
    out.append("}");
    return out.toString();
}

private T applyRemoversToOriginal(T original, Mutant<T> mutant) {
    try {
        T modifiedOriginal = (T) MethodUtils.invokeMethod(original, "duplicate");
        List<Mutant<T>> list = Arrays.asList(new Mutant<>(modifiedOriginal, ""));
        for (MutantRemover mutantRemover : mutant.getRemoversApplied()) {
            list = mutantRemover.removeMutants(list);
        }
        if (list.size() != 1) {
            throw new RuntimeException("Applying the MutantRemovers used for a "
                    + "mutant on the original schema did not produce only 1 "
                    + "schema (expected: 1, actual: " + list.size() + ")");
        }
        return list.get(0).getMutatedArtefact();
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
        throw new RuntimeException("Unable to execute the 'duplicate' "
                + "method in a class that appears to have an accessible "
                + "duplicate method to call", ex);
    }
}

private T applyRemoversToOriginal(T original, Mutant<T> mutant) {
    try {
        T modifiedOriginal = (T) MethodUtils.invokeMethod(original, "duplicate");
        List<Mutant<T>> list = Arrays.asList(new Mutant<>(modifiedOriginal, ""));
        for (MutantRemover mutantRemover : mutant.getRemoversApplied()) {
            list = mutantRemover.removeMutants(list);
        }
        if (list.size() != 1) {
            throw new RuntimeException("Applying the MutantRemovers used for a "
                    + "mutant on the original schema did not produce only 1 "
                    + "schema (expected: 1, actual: " + list.size() + ")");
        }
        return list.get(0).getMutatedArtefact();
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
        throw new RuntimeException("Unable to execute the 'duplicate' "
                + "method in a class that appears to have an accessible "
                + "duplicate method to call", ex);
    }
}

private T applyRemoversToOriginal(T original, Mutant<T> mutant) {
    try {
        T modifiedOriginal = (T) MethodUtils.invokeMethod(original, "duplicate");
        List<Mutant<T>> list = Arrays.asList(new Mutant<>(modifiedOriginal, ""));
        for (MutantRemover mutantRemover : mutant.getRemoversApplied()) {
            list = mutantRemover.removeMutants(list);
        }
        if (list.size() != 1) {
            throw new RuntimeException("Applying the MutantRemovers used for a "
                    + "mutant on the original schema did not produce only 1 "
                    + "schema (expected: 1, actual: " + list.size() + ")");
        }
        return list.get(0).getMutatedArtefact();
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
        throw new RuntimeException("Unable to execute the 'duplicate' "
                + "method in a class that appears to have an accessible "
                + "duplicate method to call", ex);
    }
}

private void injectValueInFirstArg(List<SlimAssertion> assertions, boolean not, Object contentToCheck) {
    SlimAssertion.getInstructions(assertions).forEach(instruction -> {
        try {
            String valueToInject = FitnesseMarkup.SELECTOR_VALUE_SEPARATOR + (not ? FitnesseMarkup.SELECTOR_VALUE_DENY_INDICATOR : StringUtils.EMPTY) + contentToCheck;
            Object args = FieldUtils.readField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_ARGS_FIELD, true);
            Object[] argsToInject;
            if (args instanceof Object[] && ArrayUtils.getLength(args) > NumberUtils.INTEGER_ZERO) {
                argsToInject = (Object[]) args;
                argsToInject[NumberUtils.INTEGER_ZERO] += valueToInject;
            } else {
                argsToInject = ArrayUtils.toArray(valueToInject);
            }
            String methodName = Objects.toString(FieldUtils.readField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_METHODNAME_FIELD, true));
            if (Objects.isNull(MethodUtils.getAccessibleMethod(SeleniumFixture.class, Objects.toString(methodName), ClassUtils.toClass(argsToInject)))) {
                SeleniumScriptTable.LOGGER.fine("Method for instruction not found on SeleniumFixture, injection aborted: " + instruction);
                return;
            }
            FieldUtils.writeField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_ARGS_FIELD, argsToInject, true);
        } catch (IllegalArgumentException | ReflectiveOperationException e) {
            SeleniumScriptTable.LOGGER.log(Level.FINE, "Failed to inject check value using reflection", e);
        }
    });
}

/**
 * 获得运行的annotaion.
 * 
 * <h3>代码流程:</h3>
 * 
 * <blockquote>
 * <ol>
 * <li>先基于 {@link org.aspectj.lang.reflect.MethodSignature},获得其 method,然后继续这个method 调用
 * {@link org.springframework.core.annotation.AnnotationUtils#findAnnotation(Method, Class)}解析</li>
 * <li>如果第一步找不到相应的annotation,那么会通过 {@link org.aspectj.lang.JoinPoint#getTarget()} 构建target method,并解析</li>
 * </ol>
 * </blockquote>
 *
 * @param <T>
 *            the generic type
 * @param joinPoint
 *            the join point
 * @param annotationClass
 *            the annotation class
 * @return the annotation
 */
public static <T extends Annotation> T findAnnotation(JoinPoint joinPoint,Class<T> annotationClass){
    Validate.notNull(joinPoint, "joinPoint can't be null!");
    Validate.notNull(annotationClass, "annotationClass can't be null!");

    //---------------------------------------------------------------

    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    Method method = methodSignature.getMethod();

    T annotation = AnnotationUtils.findAnnotation(method, annotationClass);
    if (null != annotation){
        return annotation;
    }

    //---------------------------------------------------------------
    Method targetMethod = MethodUtils
                    .getAccessibleMethod(joinPoint.getTarget().getClass(), method.getName(), method.getParameterTypes());
    annotation = AnnotationUtils.findAnnotation(targetMethod, annotationClass);
    if (null != annotation){
        return annotation;
    }
    return null;
}

/**
 * Gets the logger.
 *
 * @param name the name
 * @return the logger
 */
public Jdk14LoggerAccessor getLogger(String name) {
  try {
    Object logger = MethodUtils.invokeMethod(getTarget(), "getLogger", name);
    if (logger == null) {
      throw new NullPointerException(
          getTarget().getClass().getName() + "#getLogger(\"" + name + "\") returned null");
    }
    Jdk14LoggerAccessor accessor = new Jdk14LoggerAccessor();
    accessor.setTarget(logger);
    accessor.setApplication(getApplication());
    return accessor;
  } catch (Exception e) {
    logger.error("{}#getLogger('{}') failed", getTarget().getClass().getName(), name, e);
  }
  return null;
}

/**
 * Gets the handlers.
 *
 * @return the handlers
 */
@SuppressWarnings("unchecked")
public List<LogDestination> getHandlers() {
  List<LogDestination> allHandlers = new ArrayList<>();
  try {
    for (String name : Collections
        .list((Enumeration<String>) MethodUtils.invokeMethod(getTarget(), "getLoggerNames"))) {
      Jdk14LoggerAccessor accessor = getLogger(name);
      if (accessor != null) {
        allHandlers.addAll(accessor.getHandlers());
      }
    }
  } catch (Exception e) {
    logger.error("{}#getLoggerNames() failed", getTarget().getClass().getName(), e);
  }
  return allHandlers;
}

/**
 * Gets the handlers.
 *
 * @return the handlers
 */
public List<LogDestination> getHandlers() {
  List<LogDestination> handlerAccessors = new ArrayList<>();
  try {
    Object[] handlers = (Object[]) MethodUtils.invokeMethod(getTarget(), "getHandlers");
    for (int h = 0; h < handlers.length; h++) {
      Object handler = handlers[h];
      Jdk14HandlerAccessor handlerAccessor = wrapHandler(handler, h);
      if (handlerAccessor != null) {
        handlerAccessors.add(handlerAccessor);
      }
    }
  } catch (Exception e) {
    logger.error("{}#handlers inaccessible", getTarget().getClass().getName(), e);
  }
  return handlerAccessors;
}

/**
 * Gets the level.
 *
 * @return the level
 */
public String getLevel() {
  try {
    Object level = null;
    Object target = getTarget();
    while (level == null && target != null) {
      level = getLevelInternal(target);
      target = MethodUtils.invokeMethod(target, "getParent");
    }
    if (level == null && isJuliRoot()) {
      return "INFO";
    }
    return (String) MethodUtils.invokeMethod(level, "getName");
  } catch (Exception e) {
    logger.error("{}#getLevel() failed", getTarget().getClass().getName(), e);
  }
  return null;
}

/**
 * Returns the appender of this logger with the given name.
 * 
 * @param name the name of the appender to return
 * @return the appender with the given name, or null if no such appender exists for this logger
 */
public LogbackAppenderAccessor getAppender(String name) {
  try {
    Object appender = MethodUtils.invokeMethod(getTarget(), "getAppender", name);
    if (appender == null) {
      List<LogbackAppenderAccessor> appenders = getAppenders();
      for (LogbackAppenderAccessor wrappedAppender : appenders) {
        if (wrappedAppender.getIndex().equals(name)) {
          return wrappedAppender;
        }
      }
    }
    return wrapAppender(appender);
  } catch (Exception e) {
    logger.error("{}#getAppender() failed", getTarget().getClass().getName(), e);
  }
  return null;
}

/**
 * Gets the sifted appenders.
 *
 * @param appender the appender
 * @return the sifted appenders
 * @throws Exception the exception
 */
@SuppressWarnings("unchecked")
private List<Object> getSiftedAppenders(Object appender) throws Exception {
  if ("ch.qos.logback.classic.sift.SiftingAppender".equals(appender.getClass().getName())) {
    Object tracker = MethodUtils.invokeMethod(appender, "getAppenderTracker");
    if (tracker != null) {
      try {
        return (List<Object>) MethodUtils.invokeMethod(tracker, "allComponents");
      } catch (final NoSuchMethodException e) {
        // XXX Legacy 1.0.x and lower support for logback
        logger.trace("", e);
        return (List<Object>) MethodUtils.invokeMethod(tracker, "valueList");
      }
    }
    return new ArrayList<>();
  }
  return null;
}

/**
 * Attempts to initialize a Logback logger factory via the given class loader.
 *
 * @param cl the ClassLoader to use when fetching the factory
 * @throws ClassNotFoundException the class not found exception
 * @throws IllegalAccessException the illegal access exception
 * @throws InvocationTargetException the invocation target exception
 */
public LogbackFactoryAccessor(ClassLoader cl)
    throws ClassNotFoundException, IllegalAccessException, InvocationTargetException {

  // Get the singleton SLF4J binding, which may or may not be Logback, depending on the binding.
  Class<?> clazz = cl.loadClass("org.slf4j.impl.StaticLoggerBinder");
  Method getSingleton = MethodUtils.getAccessibleMethod(clazz, "getSingleton", new Class[0]);
  Object singleton = getSingleton.invoke(null);
  Method getLoggerFactory =
      MethodUtils.getAccessibleMethod(clazz, "getLoggerFactory", new Class[0]);

  Object loggerFactory = getLoggerFactory.invoke(singleton);

  // Check if the binding is indeed Logback
  Class<?> loggerFactoryClass = cl.loadClass("ch.qos.logback.classic.LoggerContext");
  if (!loggerFactoryClass.isInstance(loggerFactory)) {
    throw new RuntimeException("The singleton SLF4J binding was not Logback");
  }
  setTarget(loggerFactory);
}

/**
 * Returns a list of wrappers for all Logback appenders that have an associated logger.
 * 
 * @return a list of {@link LogbackAppenderAccessor}s representing all appenders that are in use
 */
@SuppressWarnings("unchecked")
public List<LogbackAppenderAccessor> getAppenders() {
  List<LogbackAppenderAccessor> appenders = new ArrayList<>();
  try {
    Class<? extends Object> clazz = getTarget().getClass();
    Method getLoggerList = MethodUtils.getAccessibleMethod(clazz, "getLoggerList", new Class[0]);

    List<Object> loggers = (List<Object>) getLoggerList.invoke(getTarget());
    for (Object logger : loggers) {
      LogbackLoggerAccessor accessor = new LogbackLoggerAccessor();
      accessor.setTarget(logger);
      accessor.setApplication(getApplication());

      appenders.addAll(accessor.getAppenders());
    }
  } catch (Exception e) {
    logger.error("{}.getLoggerList() failed", getTarget(), e);
  }
  return appenders;
}

/**
 * Gets the appenders.
 *
 * @return the appenders
 */
@SuppressWarnings("unchecked")
public List<Log4JAppenderAccessor> getAppenders() {
  List<Log4JAppenderAccessor> appenders = new ArrayList<>();
  try {
    for (Object unwrappedAppender : Collections
        .list((Enumeration<Object>) MethodUtils.invokeMethod(getTarget(), "getAllAppenders"))) {
      Log4JAppenderAccessor appender = wrapAppender(unwrappedAppender);
      if (appender != null) {
        appenders.add(appender);
      }
    }
  } catch (Exception e) {
    logger.error("{}#getAllAppenders() failed", getTarget().getClass().getName(), e);
  }
  return appenders;
}

/**
 * Gets the appenders.
 *
 * @return the appenders
 */
@SuppressWarnings("unchecked")
public List<Log4JAppenderAccessor> getAppenders() {
  List<Log4JAppenderAccessor> appenders = new ArrayList<>();
  try {
    appenders.addAll(getRootLogger().getAppenders());

    Class<?> clazz = (Class<?>) getTarget();
    Method getCurrentLoggers =
        MethodUtils.getAccessibleMethod(clazz, "getCurrentLoggers", new Class[0]);

    for (Object currentLogger : Collections
        .list((Enumeration<Object>) getCurrentLoggers.invoke(null))) {
      Log4JLoggerAccessor accessor = new Log4JLoggerAccessor();
      accessor.setTarget(currentLogger);
      accessor.setApplication(getApplication());

      appenders.addAll(accessor.getAppenders());
    }
  } catch (Exception e) {
    logger.error("{}#getCurrentLoggers() failed", getTarget().getClass().getName(), e);
  }
  return appenders;
}

/**
 * Attempts to initialize a TomcatSlf4jLogback logger factory via the given class loader.
 *
 * @param cl the ClassLoader to use when fetching the factory
 * @throws ClassNotFoundException the class not found exception
 * @throws IllegalAccessException the illegal access exception
 * @throws InvocationTargetException the invocation target exception
 */
public TomcatSlf4jLogbackFactoryAccessor(ClassLoader cl)
    throws ClassNotFoundException, IllegalAccessException, InvocationTargetException {

  // Get the singleton SLF4J binding, which may or may not be Logback, depending on the binding.
  Class<?> clazz = cl.loadClass("org.apache.juli.logging.org.slf4j.impl.StaticLoggerBinder");
  Method getSingleton = MethodUtils.getAccessibleMethod(clazz, "getSingleton", new Class[0]);
  Object singleton = getSingleton.invoke(null);
  Method getLoggerFactory =
      MethodUtils.getAccessibleMethod(clazz, "getLoggerFactory", new Class[0]);

  Object loggerFactory = getLoggerFactory.invoke(singleton);

  // Check if the binding is indeed Logback
  Class<?> loggerFactoryClass =
      cl.loadClass("org.apache.juli.logging.ch.qos.logback.classic.LoggerContext");
  if (!loggerFactoryClass.isInstance(loggerFactory)) {
    throw new RuntimeException("The singleton SLF4J binding was not Logback");
  }
  setTarget(loggerFactory);
}

/**
 * Returns a list of wrappers for all TomcatSlf4jLogback appenders that have an associated logger.
 * 
 * @return a list of {@link TomcatSlf4jLogbackAppenderAccessor}s representing all appenders that
 *         are in use
 */
@SuppressWarnings("unchecked")
public List<TomcatSlf4jLogbackAppenderAccessor> getAppenders() {
  List<TomcatSlf4jLogbackAppenderAccessor> appenders = new ArrayList<>();
  try {
    Class<? extends Object> clazz = getTarget().getClass();
    Method getLoggerList = MethodUtils.getAccessibleMethod(clazz, "getLoggerList", new Class[0]);

    List<Object> loggers = (List<Object>) getLoggerList.invoke(getTarget());
    for (Object logger : loggers) {
      TomcatSlf4jLogbackLoggerAccessor accessor = new TomcatSlf4jLogbackLoggerAccessor();
      accessor.setTarget(logger);
      accessor.setApplication(getApplication());

      appenders.addAll(accessor.getAppenders());
    }
  } catch (Exception e) {
    logger.error("{}.getLoggerList() failed", getTarget(), e);
  }
  return appenders;
}

/**
 * Returns the appender of this logger with the given name.
 * 
 * @param name the name of the appender to return
 * @return the appender with the given name, or null if no such appender exists for this logger
 */
public TomcatSlf4jLogbackAppenderAccessor getAppender(String name) {
  try {
    Object appender = MethodUtils.invokeMethod(getTarget(), "getAppender", name);
    if (appender == null) {
      List<TomcatSlf4jLogbackAppenderAccessor> appenders = getAppenders();
      for (TomcatSlf4jLogbackAppenderAccessor wrappedAppender : appenders) {
        if (wrappedAppender.getIndex().equals(name)) {
          return wrappedAppender;
        }
      }
    }
    return wrapAppender(appender);
  } catch (Exception e) {
    logger.error("{}#getAppender() failed", getTarget().getClass().getName(), e);
  }
  return null;
}

/**
 * Gets the sifted appenders.
 *
 * @param appender the appender
 * @return the sifted appenders
 * @throws Exception the exception
 */
@SuppressWarnings("unchecked")
private List<Object> getSiftedAppenders(Object appender) throws Exception {
  if ("org.apache.juli.logging.ch.qos.logback.classic.sift.SiftingAppender"
      .equals(appender.getClass().getName())) {

    Object tracker = MethodUtils.invokeMethod(appender, "getAppenderTracker");
    if (tracker != null) {
      try {
        return (List<Object>) MethodUtils.invokeMethod(tracker, "allComponents");
      } catch (final NoSuchMethodException e) {
        // XXX Legacy 1.0.x and lower support for logback
        logger.trace("", e);
        return (List<Object>) MethodUtils.invokeMethod(tracker, "valueList");
      }
    }
    return new ArrayList<>();
  }
  return null;
}

private void addItemToCollection(Object object, String fieldName, Object value)
    throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
  Object collection = null;
  try {
    collection = FieldUtils.readField(object, fieldName);
    if (!(collection instanceof Collection)) {
      collection = null;
    }
  } catch (Exception e) {
    // Do nothing -> just using this to check if we have to use the field or the addXxxx() method
  }

  if (collection != null) {
    MethodUtils.invokeExactMethod(collection, "add", new Object[]{value}, new Class[]{Object.class});
  } else {
    MethodUtils.invokeExactMethod(object, "add" + StringUtils.capitalize(fieldName), value);
  }
}

@Test
public void mustFindLocalVariableNodeForInstruction() {
    MethodNode methodNode = findMethodsWithName(classNode.methods, "localVariablesTest").get(0);
    List<AbstractInsnNode> insns = findInvocationsOf(methodNode.instructions,
            MethodUtils.getAccessibleMethod(PrintStream.class, "println", String.class));

    AbstractInsnNode insnNode = insns.get(0);

    LocalVariableNode lvn0 = findLocalVariableNodeForInstruction(methodNode.localVariables, methodNode.instructions, insnNode, 0);
    LocalVariableNode lvn1 = findLocalVariableNodeForInstruction(methodNode.localVariables, methodNode.instructions, insnNode, 1);
    LocalVariableNode lvn2 = findLocalVariableNodeForInstruction(methodNode.localVariables, methodNode.instructions, insnNode, 2);

    assertEquals(lvn0.name, "this");
    assertEquals(lvn1.name, "val1");
    assertEquals(lvn2.name, "val2");
}

@Test
public void mustNotCrashOnMarker() throws Exception {
    // Augment signature
    methodNode.desc = Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { });

    // Initialize variable table
    VariableTable varTable = new VariableTable(classNode, methodNode);

    methodNode.instructions
            = merge(
                    // test marker of each type
                    debugMarker(MarkerType.NONE, "marker1"),
                    debugMarker(MarkerType.CONSTANT, "marker2"),
                    debugMarker(MarkerType.STDOUT, "marker3"),
                    returnVoid()
            );

    // Write to JAR file + load up in classloader -- then execute tests
    try (URLClassLoader cl = createJarAndLoad(classNode)) {
        Object obj = cl.loadClass(STUB_CLASSNAME).newInstance();
        MethodUtils.invokeMethod(obj, STUB_METHOD_NAME);
    }
}

@Test
public void mustNotCrashOnDebugPrint() throws Exception {
    // Augment signature
    methodNode.desc = Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { });

    // Initialize variable table
    VariableTable varTable = new VariableTable(classNode, methodNode);

    methodNode.instructions
            = merge(
                    // test marker of each type
                    debugPrint(loadStringConst("marker1")),
                    returnVoid()
            );

    // Write to JAR file + load up in classloader -- then execute tests
    try (URLClassLoader cl = createJarAndLoad(classNode)) {
        Object obj = cl.loadClass(STUB_CLASSNAME).newInstance();
        MethodUtils.invokeMethod(obj, STUB_METHOD_NAME);
    }
}

/**
 * @param dbEntities
 * @param aEntity
 * @throws SdiException
 */
private void saveEntity( List<Object> dbEntities, Object aEntity ) throws SdiException
{
    if ( myDryRun )
    {
        myLog.trace( "DryRun: Going to save entity: " + aEntity );

        try
        {
            MethodUtils.invokeExactMethod( aEntity, "setId", new Object[] { Long.valueOf( myDummyId ) } );
        }
        catch ( Throwable t )
        {
            throw new SdiException( "Entity has no 'setId( Long )' method", t, SdiException.EXIT_CODE_UNKNOWN_ERROR );
        }

        myDummyId++;
    }
    else
    {
        myLog.trace( "Going to save entity: " + aEntity );
        myEntityManager.persist( aEntity );
    } // if..else myDryRun

    dbEntities.add( aEntity );
}

/**
 * some column data need special procession, eg. jsonb, hstore, etc.
 *
 * @param fieldAccessor
 * @param entity
 * @param propertyValue
 * @return
 */
public static Object getDataForSqlWrite(FieldAccessor fieldAccessor, Object entity, Object propertyValue) {
    Column columnAnno = fieldAccessor.getPropertyAnnotation(Column.class);
    if ((columnAnno != null && !columnAnno.nullable()) && fieldAccessor.getPropertyType() == String.class && propertyValue == null) {
        return "";
    }
    if (propertyValue == null) {
        return null;
    }
    if (fieldAccessor.getPropertyAnnotation(Jsonb.class) != null) {
        try {
            Class<?> pgObjectCls = Class.forName("org.postgresql.util.PGobject");
            String jsonText = JSON.toJSONString(propertyValue);
            Object pgObject = pgObjectCls.newInstance();
            // TODO: cache this method call or direct use PGobject by injection
            MethodUtils.invokeMethod(pgObject, "setType", "text");
            MethodUtils.invokeMethod(pgObject, "setValue", jsonText);
            return pgObject;
        } catch (Exception e) {
            throw new JdbcRuntimeException(e);
        }
    }
    // may need more annotation processor
    return propertyValue;
}

/**
 * Get property value from an object with the getter method.
 *
 * @param object the object where the property live in
 * @param fieldName property name
 * @return property value. {@code null} if the common java bean accessor method has tried.
 */
public static Object getter(final Object object,String fieldName){
    Object property = null;

    StringBuilder s = new StringBuilder("get");
    s.append(StringUtils.capitalize(fieldName));
    try{
        property = MethodUtils.invokeExactMethod(object,s.toString());
    }catch (Exception e){
        //try with isXXX
        StringBuilder s2 = new StringBuilder("is");
        s2.append(StringUtils.capitalize(fieldName));
        try{
            property = MethodUtils.invokeExactMethod(object,s2.toString());
        }catch (Exception ee){
            LOG.error("Exception",ee);
        }
    }
    return property;
}

public static Object sendMessage(String extensionID, String message, Object... args)
{
    ExtensionWrapper ext = SW.get().getExtensionManager().getExtensions().get(extensionID);
    if(!ext.isActivated())
    {
        return null;
    }

    try
    {
        return MethodUtils.invokeMethod(ext.getExtension(), message, args);
    }
    catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e2)
    {
        e2.printStackTrace();
    }

    return null;
}

@Test
public void testIsRegistered() throws Exception {
    final Object firstObject = new Object();
    final Object secondObject = new Object();

    try {
        final Method registerMethod = MethodUtils.getMatchingMethod(EqualsBuilder.class, "register", Object.class, Object.class);
        registerMethod.setAccessible(true);
        registerMethod.invoke(null, firstObject, secondObject);

        assertTrue(EqualsBuilder.isRegistered(firstObject, secondObject));
        assertTrue(EqualsBuilder.isRegistered(secondObject, firstObject)); // LANG-1349
    } finally {
        final Method unregisterMethod = MethodUtils.getMatchingMethod(EqualsBuilder.class, "unregister", Object.class, Object.class);
        unregisterMethod.setAccessible(true);
        unregisterMethod.invoke(null, firstObject, secondObject);
    }
}

protected Object convertFromStringUnresolved(Class parameterClass, String paramValueStr) {
    try {
        Constructor constructor = ConstructorUtils.getAccessibleConstructor(parameterClass, String.class);
        if (constructor != null) {
            return constructor.newInstance(paramValueStr);
        } else {
            Method valueOf = MethodUtils.getAccessibleMethod(parameterClass, "valueOf", String.class);
            if (valueOf != null) {
                return valueOf.invoke(null, paramValueStr);
            }
        }
    } catch (ReflectiveOperationException e) {
        throw new ReportingException(
                String.format("Could not instantiate object with class [%s] from [%s] string.",
                        parameterClass.getCanonicalName(),
                        paramValueStr));
    }
    return paramValueStr;
}

@Override
public T validate(String input) {
    Object result = null;
    V validator = getValidator();

    try {
        result = (Boolean) MethodUtils.invokeExactMethod(
                validator, VALIDATE_METHOD_NAME, input);
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
        Logger.getLogger(AbstractFormValidator.class.getName()).log(Level.SEVERE, null, ex);
    }

    if (result != null) {
        return (T) result;
    }

    return null;
}

/**
 * 执行补偿
 *
 * @param transactionRecover 补偿信息
 */
@SuppressWarnings("unchecked")
private void compensatoryTransfer(TransactionRecover transactionRecover) {
    if (Objects.nonNull(transactionRecover)) {
        final TransactionInvocation transactionInvocation = transactionRecover.getTransactionInvocation();
        if (Objects.nonNull(transactionInvocation)) {
            final Class clazz = transactionInvocation.getTargetClazz();
            final String method = transactionInvocation.getMethod();
            final Object[] argumentValues = transactionInvocation.getArgumentValues();
            final Class[] argumentTypes = transactionInvocation.getArgumentTypes();
            final Object bean = SpringBeanUtils.getInstance().getBean(clazz);
            try {
                CompensationLocal.getInstance().setCompensationId(CommonConstant.COMPENSATE_ID);
                MethodUtils.invokeMethod(bean, method, argumentValues, argumentTypes);
                //通知tm自身已经完成提交 //删除本地信息
                final Boolean success = txManagerMessageService.completeCommitTxTransaction(transactionRecover.getGroupId(),
                        transactionRecover.getTaskId(), TransactionStatusEnum.COMMIT.getCode());
                if (success) {
                    transactionRecoverRepository.remove(transactionRecover.getId());
                }

            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
                LogUtil.error(LOGGER, "补偿方法反射调用失败！{}", e::getMessage);
            }

        }
    }

}

private Descriptors.Descriptor getDescriptor(Class<M> messageClass) {
    try {
        return (Descriptors.Descriptor) MethodUtils.invokeStaticMethod(
                messageClass, "getDescriptor");
    } catch (NoSuchMethodException | IllegalAccessException
            | InvocationTargetException ex) {
        throw new RuntimeException(ex);
    }
}

/**
 * get Builder from messageClass
 *
 * @param messageClass
 * @return
 * @throws InvocationTargetException
 * @throws IllegalAccessException
 * @throws NoSuchMethodException
 */
public static <T extends Message> T.Builder newBuilder(Class<T> messageClass) {
    T.Builder builder = null;
    try {
        builder = (T.Builder) MethodUtils.invokeStaticMethod(messageClass,
                "newBuilder");
    } catch (NoSuchMethodException | IllegalAccessException
            | InvocationTargetException e) {
        throw new RuntimeException(e);
    }
    return builder;
}

private void invokeSingleCommand(Command command) {

        try {
            MethodUtils.invokeExactMethod(commandService, "handle", command);
        }
        catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

@SuppressWarnings("unchecked")
private void executeCoordinator(TccInvocation tccInvocation) throws Exception {
    if (Objects.nonNull(tccInvocation)) {
        final Class clazz = tccInvocation.getTargetClass();
        final String method = tccInvocation.getMethodName();
        final Object[] args = tccInvocation.getArgs();
        final Class[] parameterTypes = tccInvocation.getParameterTypes();
        final Object bean = SpringBeanUtils.getInstance().getBean(clazz);
        MethodUtils.invokeMethod(bean, method, args, parameterTypes);
        LogUtil.debug(LOGGER, "执行本地协调事务:{}", () -> tccInvocation.getTargetClass()
                + ":" + tccInvocation.getMethodName());
    }
}