org.springframework.aop.aspectj

Class AbstractAspectJAdvice

  • java.lang.Object
    • org.springframework.aop.aspectj.AbstractAspectJAdvice
    • Field Detail

      • JOIN_POINT_KEY

        protected static final java.lang.String JOIN_POINT_KEY
        Key used in ReflectiveMethodInvocation userAtributes map for the current joinpoint.
      • aspectJAdviceMethod

        protected transient java.lang.reflect.Method aspectJAdviceMethod
    • Constructor Detail

      • AbstractAspectJAdvice

        public AbstractAspectJAdvice(java.lang.reflect.Method aspectJAdviceMethod,
                                     AspectJExpressionPointcut pointcut,
                                     AspectInstanceFactory aspectInstanceFactory)
        Create a new AbstractAspectJAdvice for the given advice method.
        Parameters:
        aspectJAdviceMethod - the AspectJ-style advice method
        pointcut - the AspectJ expression pointcut
        aspectInstanceFactory - the factory for aspect instances
    • Method Detail

      • currentJoinPoint

        public static org.aspectj.lang.JoinPoint currentJoinPoint()
        Lazily instantiate joinpoint for the current invocation. Requires MethodInvocation to be bound with ExposeInvocationInterceptor.

        Do not use if access is available to the current ReflectiveMethodInvocation (in an around advice).

        Returns:
        current AspectJ joinpoint, or through an exception if we're not in a Spring AOP invocation.
      • getAspectJAdviceMethod

        public final java.lang.reflect.Method getAspectJAdviceMethod()
        Return the AspectJ-style advice method.
      • buildSafePointcut

        public final Pointcut buildSafePointcut()
        Build a 'safe' pointcut that excludes the AspectJ advice method itself.
        Returns:
        a composable pointcut that builds on the original AspectJ expression pointcut
        See Also:
        getPointcut()
      • getAspectInstanceFactory

        public final AspectInstanceFactory getAspectInstanceFactory()
        Return the factory for aspect instances.
      • getAspectClassLoader

        @Nullable
        public final java.lang.ClassLoader getAspectClassLoader()
        Return the ClassLoader for aspect instances.
      • getOrder

        public int getOrder()
        Description copied from interface: Ordered
        Get the order value of this object.

        Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet load-on-startup values).

        Same order values will result in arbitrary sort positions for the affected objects.

        Specified by:
        getOrder in interface Ordered
        Returns:
        the order value
        See Also:
        Ordered.HIGHEST_PRECEDENCE, Ordered.LOWEST_PRECEDENCE
      • setAspectName

        public void setAspectName(java.lang.String name)
        Set the name of the aspect (bean) in which the advice was declared.
      • setDeclarationOrder

        public void setDeclarationOrder(int order)
        Set the declaration order of this advice within the aspect.
      • setArgumentNames

        public void setArgumentNames(java.lang.String argNames)
        Set by creator of this advice object if the argument names are known.

        This could be for example because they have been explicitly specified in XML, or in an advice annotation.

        Parameters:
        argNames - comma delimited list of arg names
      • setArgumentNamesFromStringArray

        public void setArgumentNamesFromStringArray(java.lang.String... args)
      • setReturningName

        public void setReturningName(java.lang.String name)
      • setReturningNameNoCheck

        protected void setReturningNameNoCheck(java.lang.String name)
        We need to hold the returning name at this level for argument binding calculations, this method allows the afterReturning advice subclass to set the name.
      • getDiscoveredReturningType

        protected java.lang.Class<?> getDiscoveredReturningType()
      • getDiscoveredReturningGenericType

        @Nullable
        protected java.lang.reflect.Type getDiscoveredReturningGenericType()
      • setThrowingName

        public void setThrowingName(java.lang.String name)
      • setThrowingNameNoCheck

        protected void setThrowingNameNoCheck(java.lang.String name)
        We need to hold the throwing name at this level for argument binding calculations, this method allows the afterThrowing advice subclass to set the name.
      • getDiscoveredThrowingType

        protected java.lang.Class<?> getDiscoveredThrowingType()
      • calculateArgumentBindings

        public final void calculateArgumentBindings()
        Do as much work as we can as part of the set-up so that argument binding on subsequent advice invocations can be as fast as possible.

        If the first argument is of type JoinPoint or ProceedingJoinPoint then we pass a JoinPoint in that position (ProceedingJoinPoint for around advice).

        If the first argument is of type JoinPoint.StaticPart then we pass a JoinPoint.StaticPart in that position.

        Remaining arguments have to be bound by pointcut evaluation at a given join point. We will get back a map from argument name to value. We need to calculate which advice parameter needs to be bound to which argument name. There are multiple strategies for determining this binding, which are arranged in a ChainOfResponsibility.

      • supportsProceedingJoinPoint

        protected boolean supportsProceedingJoinPoint()
      • argBinding

        protected java.lang.Object[] argBinding(org.aspectj.lang.JoinPoint jp,
                                                @Nullable
                                                org.aspectj.weaver.tools.JoinPointMatch jpMatch,
                                                @Nullable
                                                java.lang.Object returnValue,
                                                @Nullable
                                                java.lang.Throwable ex)
        Take the arguments at the method execution join point and output a set of arguments to the advice method.
        Parameters:
        jp - the current JoinPoint
        jpMatch - the join point match that matched this execution join point
        returnValue - the return value from the method execution (may be null)
        ex - the exception thrown by the method execution (may be null)
        Returns:
        the empty array if there are no arguments
      • invokeAdviceMethod

        protected java.lang.Object invokeAdviceMethod(@Nullable
                                                      org.aspectj.weaver.tools.JoinPointMatch jpMatch,
                                                      @Nullable
                                                      java.lang.Object returnValue,
                                                      @Nullable
                                                      java.lang.Throwable ex)
                                               throws java.lang.Throwable
        Invoke the advice method.
        Parameters:
        jpMatch - the JoinPointMatch that matched this execution join point
        returnValue - the return value from the method execution (may be null)
        ex - the exception thrown by the method execution (may be null)
        Returns:
        the invocation result
        Throws:
        java.lang.Throwable - in case of invocation failure
      • invokeAdviceMethod

        protected java.lang.Object invokeAdviceMethod(org.aspectj.lang.JoinPoint jp,
                                                      @Nullable
                                                      org.aspectj.weaver.tools.JoinPointMatch jpMatch,
                                                      @Nullable
                                                      java.lang.Object returnValue,
                                                      @Nullable
                                                      java.lang.Throwable t)
                                               throws java.lang.Throwable
        Throws:
        java.lang.Throwable
      • invokeAdviceMethodWithGivenArgs

        protected java.lang.Object invokeAdviceMethodWithGivenArgs(java.lang.Object[] args)
                                                            throws java.lang.Throwable
        Throws:
        java.lang.Throwable
      • getJoinPoint

        protected org.aspectj.lang.JoinPoint getJoinPoint()
        Overridden in around advice to return proceeding join point.
      • getJoinPointMatch

        @Nullable
        protected org.aspectj.weaver.tools.JoinPointMatch getJoinPointMatch()
        Get the current join point match at the join point we are being dispatched on.
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object