Java MethodInvocation.getMethod方法代码示例

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
private String getName(MethodInvocation mi) throws BeansException
{
    if (methodToBeanMap.get() == null)
    {
        methodToBeanMap.set(new HashMap<Method, String>());
    }
    Method method = mi.getMethod();
    String name = methodToBeanMap.get().get(method);
    if (name == null)
    {
        name = getBeanNameImpl(mi);
        methodToBeanMap.get().put(method, name);
    }
    else
    {
        if (s_logger.isDebugEnabled())
        {
            s_logger.debug("Cached look up for " + name + "." + method.getName());
        }
    }
    return name;
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    //
    Method m = invocation.getMethod();

    if (m.isAnnotationPresent(Conditioned.class)) {
        Object[] arg = invocation.getArguments();
        if (arg.length > 0 && arg[arg.length - 1] instanceof List && !((List) arg[arg.length - 1]).isEmpty() && ((List) arg[arg.length - 1]).get(0) instanceof GherkinStepCondition) {
            List<GherkinStepCondition> conditions = (List) arg[arg.length - 1];
            displayMessageAtTheBeginningOfMethod(m.getName(), conditions);
            if (!checkConditions(conditions)) {
                Context.getCurrentScenario().write(Messages.getMessage(SKIPPED_DUE_TO_CONDITIONS));
                return Void.TYPE;
            }
        }
    }

    logger.debug("NORAUI ConditionedInterceptor invoke method {}", invocation.getMethod());
    return invocation.proceed();
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
	Method method = invocation.getMethod();

	Invoker aopAllianceInvoker = new Invoker() {
		@Override
		public Object invoke() {
			try {
				return invocation.proceed();
			} catch (Throwable ex) {
				throw new ThrowableWrapper(ex);
			}
		}
	};

	try {
		return execute(aopAllianceInvoker, invocation.getThis(), method, invocation.getArguments());
	} catch (ThrowableWrapper th) {
		throw th.original;
	}
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
/**
 * 后续加上缓存，一定要加
 *
 * @param inv
 * @return dummy
 * @throws Throwable
 */
@Override
public Object invoke(MethodInvocation inv) throws Throwable {
    if (ReflectionUtils.isObjectMethod(inv.getMethod())) {
        if ("toString".equals(inv.getMethod().getName())) {
            return clazz.getName();
        }
        return ReflectionUtils.invokeMethod(inv.getMethod(), inv.getThis(), inv.getArguments());
    }
    WxApiMethodInfo wxApiMethodInfo = methodCache.get(inv.getMethod());
    if (wxApiMethodInfo == null) {
        wxApiMethodInfo = new WxApiMethodInfo(inv.getMethod(), wxApiTypeInfo);
        methodCache.put(inv.getMethod(), wxApiMethodInfo);
    }
    return wxApiExecutor.execute(wxApiMethodInfo, inv.getArguments());
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
/**
 * Retrieve the RequestHeader set in the invoked method.
 *
 * @param invocation Invoked method
 * @return RequestHeader
 */
RequestHeader getRequestHeader(MethodInvocation invocation) {
  Method method = invocation.getMethod();
  if (!isServiceMethod(method)) {
    throw new IllegalArgumentException("Invoked method is not a service method: " + method.getName());
  }

  if (invocation.getArguments()[0] == null) {
    throw new IllegalStateException("RequestHeader is not set in method: " + method.getName());
  }

  return (RequestHeader) invocation.getArguments()[0];
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    Class targetClass = methodInvocation.getThis().getClass();
    Method method = methodInvocation.getMethod();

    targetClass = ClassKits.getUsefulClass(targetClass);

    Interceptor[] finalInters = manger.buildServiceMethodInterceptor(InterceptorManager.NULL_INTERS, targetClass, method);
    JFinalBeforeInvocation invocation = new JFinalBeforeInvocation(methodInvocation, finalInters);
    invocation.invoke();
    return invocation.getReturnValue();
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    Class targetClass = methodInvocation.getThis().getClass();
    Method method = methodInvocation.getMethod();

    Object result = methodInvocation.proceed();

    CachePut cachePut = method.getAnnotation(CachePut.class);
    if (cachePut == null) {
        return result;
    }

    String unlessString = cachePut.unless();
    if (StringUtils.isNotBlank(unlessString)) {
        unlessString = String.format("#(%s)", unlessString);
        String unlessBoolString = Kits.engineRender(unlessString, method, methodInvocation.getArguments());
        if ("true".equals(unlessBoolString)) {
            return result;
        }
    }


    String cacheName = cachePut.name();
    JbootAssert.assertTrue(StringUtils.isNotBlank(cacheName),
            String.format("CachePut.name()  must not empty in method [%s]!!!", targetClass.getName() + "#" + method.getName()));

    String cacheKey = Kits.buildCacheKey(cachePut.key(), targetClass, method, methodInvocation.getArguments());

    if (cachePut.liveSeconds() > 0) {
        Jboot.me().getCache().put(cacheName, cacheKey, result, cachePut.liveSeconds());
    } else {
        Jboot.me().getCache().put(cacheName, cacheKey, result);
    }
    return result;
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    Class targetClass = methodInvocation.getThis().getClass();
    Method method = methodInvocation.getMethod();

    CacheEvict cacheEvict = method.getAnnotation(CacheEvict.class);
    if (cacheEvict == null) {
        return methodInvocation.proceed();
    }

    String unlessString = cacheEvict.unless();
    if (StringUtils.isNotBlank(unlessString)) {
        unlessString = String.format("#(%s)", unlessString);
        String unlessBoolString = Kits.engineRender(unlessString, method, methodInvocation.getArguments());
        if ("true".equals(unlessBoolString)) {
            return methodInvocation.proceed();
        }
    }


    String cacheName = cacheEvict.name();
    JbootAssert.assertTrue(StringUtils.isNotBlank(cacheName),
            String.format("CacheEvict.name()  must not empty in method [%s]!!!", targetClass.getName() + "#" + method.getName()));

    String cacheKey = Kits.buildCacheKey(cacheEvict.key(), targetClass, method, methodInvocation.getArguments());

    Jboot.me().getCache().remove(cacheName, cacheKey);
    return methodInvocation.proceed();
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
private Object invokeAttribute(PropertyDescriptor pd, MethodInvocation invocation)
		throws JMException, IOException {

	String attributeName = JmxUtils.getAttributeName(pd, this.useStrictCasing);
	MBeanAttributeInfo inf = this.allowedAttributes.get(attributeName);
	// If no attribute is returned, we know that it is not defined in the
	// management interface.
	if (inf == null) {
		throw new InvalidInvocationException(
				"Attribute '" + pd.getName() + "' is not exposed on the management interface");
	}
	if (invocation.getMethod().equals(pd.getReadMethod())) {
		if (inf.isReadable()) {
			return this.serverToUse.getAttribute(this.objectName, attributeName);
		}
		else {
			throw new InvalidInvocationException("Attribute '" + attributeName + "' is not readable");
		}
	}
	else if (invocation.getMethod().equals(pd.getWriteMethod())) {
		if (inf.isWritable()) {
			this.serverToUse.setAttribute(this.objectName, new Attribute(attributeName, invocation.getArguments()[0]));
			return null;
		}
		else {
			throw new InvalidInvocationException("Attribute '" + attributeName + "' is not writable");
		}
	}
	else {
		throw new IllegalStateException(
				"Method [" + invocation.getMethod() + "] is neither a bean property getter nor a setter");
	}
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
	Method method = invocation.getMethod();
	if (logger.isDebugEnabled()) {
		logger.debug("Incoming " + this.exporterNameClause + "remote call: " +
				ClassUtils.getQualifiedMethodName(method));
	}
	try {
		Object retVal = invocation.proceed();
		if (logger.isDebugEnabled()) {
			logger.debug("Finished processing of " + this.exporterNameClause + "remote call: " +
					ClassUtils.getQualifiedMethodName(method));
		}
		return retVal;
	}
	catch (Throwable ex) {
		if (ex instanceof RuntimeException || ex instanceof Error) {
			if (logger.isWarnEnabled()) {
				logger.warn("Processing of " + this.exporterNameClause + "remote call resulted in fatal exception: " +
						ClassUtils.getQualifiedMethodName(method), ex);
			}
		}
		else {
			if (logger.isInfoEnabled()) {
				logger.info("Processing of " + this.exporterNameClause + "remote call resulted in exception: " +
						ClassUtils.getQualifiedMethodName(method), ex);
			}
		}
		throw ex;
	}
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
/**
 * Create a {@code String} name for the given {@code MethodInvocation}
 * that can be used for trace/logging purposes. This name is made up of the
 * configured prefix, followed by the fully-qualified name of the method being
 * invoked, followed by the configured suffix.
 * @see #setPrefix
 * @see #setSuffix
 */
protected String createInvocationTraceName(MethodInvocation invocation) {
	StringBuilder sb = new StringBuilder(getPrefix());
	Method method = invocation.getMethod();
	Class<?> clazz = method.getDeclaringClass();
	if (this.logTargetClassInvocation && clazz.isInstance(invocation.getThis())) {
		clazz = invocation.getThis().getClass();
	}
	sb.append(clazz.getName());
	sb.append('.').append(method.getName());
	sb.append(getSuffix());
	return sb.toString();
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {
	Object[] handlerArgs;
	if (method.getParameterTypes().length == 1) {
		handlerArgs = new Object[] { ex };
	}
	else {
		handlerArgs = new Object[] {mi.getMethod(), mi.getArguments(), mi.getThis(), ex};
	}
	try {
		method.invoke(this.throwsAdvice, handlerArgs);
	}
	catch (InvocationTargetException targetEx) {
		throw targetEx.getTargetException();
	}
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
public Object invoke(final MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    Object obj = invocation.getThis();
    CacheInvokeConfig cac = null;
    if (obj != null) {
        String key = CachePointcut.getKey(method, obj.getClass());
        cac  = cacheConfigMap.get(key);
    }

    /*
    if(logger.isTraceEnabled()){
        logger.trace("JetCacheInterceptor invoke. foundJetCacheConfig={}, method={}.{}(), targetClass={}",
                cac != null,
                method.getDeclaringClass().getName(),
                method.getName(),
                invocation.getThis() == null ? null : invocation.getThis().getClass().getName());
    }
    */

    if (cac == null) {
        return invocation.proceed();
    }

    if (globalCacheConfig == null) {
        globalCacheConfig = applicationContext.getBean(GlobalCacheConfig.class);
    }
    CacheInvokeContext context = globalCacheConfig.getCacheContext().createCacheInvokeContext();
    context.setInvoker(invocation::proceed);
    context.setMethod(method);
    context.setArgs(invocation.getArguments());
    context.setCacheInvokeConfig(cac);
    context.setHiddenPackages(globalCacheConfig.getHiddenPackages());
    return CacheHandler.invoke(context);
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
public Object invoke(MethodInvocation invocation) throws Throwable {
	Method method=invocation.getMethod();
	Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
	this.doInterceptors(true, targetClass, method, invocation.getArguments(), null);
	Object retVal = invocation.proceed();
	this.doInterceptors(false, targetClass, method, invocation.getArguments(), retVal);
	return retVal;
}
 

import org.aopalliance.intercept.MethodInvocation; //导入方法依赖的package包/类
private Object invokeInternal(MethodInvocation invocation) throws Throwable
{
    // Get the txn start time
    long txnStartTime = AlfrescoTransactionSupport.getTransactionStartTime();
    if (txnStartTime < 0)
    {
        // There is no transaction
        return invocation.proceed();
    }
    
    // Check if the required time has passed
    long now = System.currentTimeMillis();
    long txnElapsedTime = (now - txnStartTime);
    if (txnElapsedTime < elapsedTimeBeforeActivationMillis)
    {
        // It's not been long enough
        return invocation.proceed();
    }

    // We need to start timing the method calls
    Method calledMethod = invocation.getMethod();
    long beforeNs = System.nanoTime();
    Object ret = invocation.proceed();
    long deltaNs = System.nanoTime() - beforeNs;
    
    // Get the method stats
    @SuppressWarnings("unchecked")
    Map<Method, MethodStatistics> methodStatsByMethod =
        (Map<Method, MethodStatistics>) AlfrescoTransactionSupport.getResource(resourceKey);
    if (methodStatsByMethod == null)
    {
        methodStatsByMethod = new HashMap<Method, MethodStatistics>(11);
        AlfrescoTransactionSupport.bindResource(resourceKey, methodStatsByMethod);
    }
    
    // Update method stats
    MethodStatistics calledMethodStats = methodStatsByMethod.get(calledMethod);
    if (calledMethodStats == null)
    {
        calledMethodStats = new MethodStatistics();
        methodStatsByMethod.put(calledMethod, calledMethodStats);
    }
    calledMethodStats.accumulateNs(deltaNs);
    
    // Check if we need to call the resource managers to clean up 
    if ((now - lastCallMillis) >= resourceManagerCallFrequencyMillis)
    {
        for (MethodResourceManager resourceManager : methodResourceManagers)
        {
            resourceManager.manageResources(methodStatsByMethod, txnElapsedTime, calledMethod);
        }
        lastCallMillis = now;
    }
    
    // Done
    return ret;
}