Example usage for org.springframework.aop.framework ReflectiveMethodInvocation ReflectiveMethodInvocation

Introduction

In this page you can find the example usage for org.springframework.aop.framework ReflectiveMethodInvocation ReflectiveMethodInvocation.

Prototype

protected ReflectiveMethodInvocation(Object proxy, @Nullable Object target, Method method,
        @Nullable Object[] arguments, @Nullable Class<?> targetClass,
        List<Object> interceptorsAndDynamicMethodMatchers) 

Source Link

Document

Construct a new ReflectiveMethodInvocation with the given arguments.

Usage

From source file:org.springframework.aop.framework.JdkDynamicAopProxy.java

/**
 * Implementation of {@code InvocationHandler.invoke}.
 * <p>Callers will see exactly the exception thrown by the target,
 * unless a hook method throws an exception.
 *///from w  w w.ja v  a 2  s . c o m
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        } else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        } else if (method.getDeclaringClass() == DecoratingProxy.class) {
            // There is only getDecoratedClass() declared -> dispatch to proxy config.
            return AopProxyUtils.ultimateTargetClass(this.advised);
        } else if (!this.advised.opaque && method.getDeclaringClass().isInterface()
                && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            // Service invocations on ProxyConfig with the proxy config...
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }

        Object retVal;

        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        // Get as late as possible to minimize the time we "own" the target,
        // in case it comes from a pool.
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);

        // Get the interception chain for this method.
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        // Check whether we have any advice. If we don't, we can fallback on direct
        // reflective invocation of the target, and avoid creating a MethodInvocation.
        if (chain.isEmpty()) {
            // We can skip creating a MethodInvocation: just invoke the target directly
            // Note that the final invoker must be an InvokerInterceptor so we know it does
            // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        } else {
            // We need to create a method invocation...
            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            // Proceed to the joinpoint through the interceptor chain.
            retVal = invocation.proceed();
        }

        // Massage return value if necessary.
        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target && returnType != Object.class && returnType.isInstance(proxy)
                && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            // Special case: it returned "this" and the return type of the method
            // is type-compatible. Note that we can't help if the target sets
            // a reference to itself in another returned object.
            retVal = proxy;
        } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            throw new AopInvocationException(
                    "Null return value from advice does not match primitive return type for: " + method);
        }
        return retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            // Must have come from TargetSource.
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // Restore old proxy.
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

---

From source file:org.springframework.aop.framework.OptimizedJdkDynamicAopProxy.java

/**
 * Implementation of InvocationHandler.invoke.
 * Callers will see exactly the exception thrown by the target, unless a hook
 * method throws an exception.//ww  w  .  j a  v a 2s.  c o m
 */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    Class declaringClass = method.getDeclaringClass();

    // Try special rules for equals() method and implementation of the
    // Advised AOP configuration interface
    if (declaringClass == Object.class && "equals".equals(method.getName())) {
        // What if equals throws exception!?

        // This class implements the equals() method itself
        return new Boolean(equals(args[0]));
    } else if (Advised.class == declaringClass) {
        // Service invocations on ProxyConfig with the proxy config
        return method.invoke(this.advised, args);
    }

    Object retVal = null;

    // Get the interception chain for this method
    List chain = this.advised.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this.advised,
            method, this.targetClass);

    // Check whether we have any advice. If we don't, we can fallback on
    // direct reflective invocation of the target, and avoid creating a MethodInvocation
    if (chain.isEmpty()) {
        // We can skip creating a MethodInvocation: just invoke the target directly
        // Note that the final invoker must be an InvokerInterceptor so we know it does
        // nothing but a reflective operation on the target, and no hot swapping or fancy proxying
        retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
    } else {
        // We need to create a method invocation...
        //invocation = advised.getMethodInvocationFactory().getMethodInvocation(proxy, method, targetClass, target, args, chain, advised);
        MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass,
                chain);

        // Proceed to the joinpoint through the interceptor chain
        retVal = invocation.proceed();
    }

    // Massage return value if necessary
    if (retVal != null && retVal == target) {
        // Special case: it returned "this"
        // Note that we can't help if the target sets
        // a reference to itself in another returned object
        retVal = proxy;
    }
    return retVal;
}

---