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 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()); } }