Package org.springframework.aop.support

# Class AopUtils

java.lang.Object
org.springframework.aop.support.AopUtils

public abstract class AopUtils extends Object
Utility methods for AOP support code.

Mainly for internal use within Spring's AOP support.

See `AopProxyUtils` for a collection of framework-specific AOP utility methods which depend on internals of Spring's AOP framework implementation.

Author:
  Rod Johnson, Juergen Hoeller, Rob Harrop, Sebastien Deleuze
See Also:
  - `AopProxyUtils`

## Constructor Summary

Constructors
Constructor
Description
`AopUtils()`

## Method Summary

Modifier and Type
Method
Description
`static boolean`
`canApply(Advisor advisor, Class<?> targetClass)`
Can the given advisor apply at all on the given class? This is an important test as it can be used to optimize out an advisor for a class.
`static boolean`
`canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions)`
Can the given advisor apply at all on the given class?
`static boolean`
`canApply(Pointcut pc, Class<?> targetClass)`
Can the given pointcut apply at all on the given class?
`static boolean`
`canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions)`
Can the given pointcut apply at all on the given class?
`static List<Advisor>`
`findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz)`
Determine the sublist of the `candidateAdvisors` list that is applicable to the given class.
`static Method`
`getMostSpecificMethod(Method method, Class<?> targetClass)`
Given a method, which may come from an interface, and a target class used in the current AOP invocation, find the corresponding target method if there is one.
`static Class<?>`
`getTargetClass(Object candidate)`
Determine the target class of the given bean instance which might be an AOP proxy.
`static Object`
`invokeJoinpointUsingReflection(Object target, Method method, Object[] args)`
Invoke the given target via reflection, as part of an AOP method invocation.
`static boolean`
`isAopProxy(Object object)`
Check whether the given object is a JDK dynamic proxy or a CGLIB proxy.
`static boolean`
`isCglibProxy(Object object)`
Check whether the given object is a CGLIB proxy.
`static boolean`
`isEqualsMethod(Method method)`
Determine whether the given method is an "equals" method.
`static boolean`
`isFinalizeMethod(Method method)`
Determine whether the given method is a "finalize" method.
`static boolean`
`isHashCodeMethod(Method method)`
Determine whether the given method is a "hashCode" method.
`static boolean`
`isJdkDynamicProxy(Object object)`
Check whether the given object is a JDK dynamic proxy.
`static boolean`
`isToStringMethod(Method method)`
Determine whether the given method is a "toString" method.
`static Method`
`selectInvocableMethod(Method method, Class<?> targetType)`
Select an invocable method on the target type: either the given method itself if actually exposed on the target type, or otherwise a corresponding method on one of the target type's interfaces or on the target type itself.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### AopUtils

public AopUtils()

## Method Details

### isAopProxy

@Contract("null -> false") public static boolean isAopProxy(@Nullable Object object)
Check whether the given object is a JDK dynamic proxy or a CGLIB proxy.

This method additionally checks if the given object is an instance of `SpringProxy`.

Parameters:
  `object` - the object to check
See Also:
  - `isJdkDynamicProxy(java.lang.Object)`
  - `isCglibProxy(java.lang.Object)`

### isJdkDynamicProxy

@Contract("null -> false") public static boolean isJdkDynamicProxy(@Nullable Object object)
Check whether the given object is a JDK dynamic proxy.

This method goes beyond the implementation of `Proxy.isProxyClass(Class)` by additionally checking if the given object is an instance of `SpringProxy`.

Parameters:
  `object` - the object to check
See Also:
  - `Proxy.isProxyClass(java.lang.Class<?>)`

### isCglibProxy

@Contract("null -> false") public static boolean isCglibProxy(@Nullable Object object)
Check whether the given object is a CGLIB proxy.

This method goes beyond the implementation of `ClassUtils.isCglibProxy(Object)` by additionally checking if the given object is an instance of `SpringProxy`.

Parameters:
  `object` - the object to check
See Also:
  - `ClassUtils.isCglibProxy(Object)`

### getTargetClass

public static Class<?> getTargetClass(Object candidate)
Determine the target class of the given bean instance which might be an AOP proxy.

Returns the target class for an AOP proxy or the plain class otherwise.

Parameters:
  `candidate` - the instance to check (might be an AOP proxy)
Returns:
  the target class (or the plain class of the given object as fallback; never `null`)
See Also:
  - `TargetClassAware.getTargetClass()`
  - `AopProxyUtils.ultimateTargetClass(Object)`

### selectInvocableMethod

public static Method selectInvocableMethod(Method method, @Nullable Class<?> targetType)
Select an invocable method on the target type: either the given method itself if actually exposed on the target type, or otherwise a corresponding method on one of the target type's interfaces or on the target type itself.

Parameters:
  `method` - the method to check
  `targetType` - the target type to search methods on (typically an AOP proxy)
Returns:
  a corresponding invocable method on the target type
Throws:
  `IllegalStateException` - if the given method is not invocable on the given target type (typically due to a proxy mismatch)
Since:
  4.3
See Also:
  - `MethodIntrospector.selectInvocableMethod(Method, Class)`

### isEqualsMethod

public static boolean isEqualsMethod(@Nullable Method method)
Determine whether the given method is an "equals" method.

See Also:
  - `Object.equals(java.lang.Object)`

### isHashCodeMethod

public static boolean isHashCodeMethod(@Nullable Method method)
Determine whether the given method is a "hashCode" method.

See Also:
  - `Object.hashCode()`

### isToStringMethod

public static boolean isToStringMethod(@Nullable Method method)
Determine whether the given method is a "toString" method.

See Also:
  - `Object.toString()`

### isFinalizeMethod

public static boolean isFinalizeMethod(@Nullable Method method)
Determine whether the given method is a "finalize" method.

See Also:
  - `Object.finalize()`

### getMostSpecificMethod

public static Method getMostSpecificMethod(Method method, @Nullable Class<?> targetClass)
Given a method, which may come from an interface, and a target class used in the current AOP invocation, find the corresponding target method if there is one. For example, the method may be `IFoo.bar()` and the target class may be `DefaultFoo`. In this case, the method may be `DefaultFoo.bar()`. This enables attributes on that method to be found.

NOTE: In contrast to `ClassUtils.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)`, this method resolves bridge methods in order to retrieve attributes from the original method definition.

Parameters:
  `method` - the method to be invoked, which may come from an interface
  `targetClass` - the target class for the current invocation (can be `null` or may not even implement the method)
Returns:
  the specific target method, or the original method if the `targetClass` does not implement it
See Also:
  - `ClassUtils.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)`
  - `BridgeMethodResolver.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)`

### canApply

public static boolean canApply(Pointcut pc, Class<?> targetClass)
Can the given pointcut apply at all on the given class?

This is an important test as it can be used to optimize out a pointcut for a class.

Parameters:
  `pc` - the static or dynamic pointcut to check
  `targetClass` - the class to test
Returns:
  whether the pointcut can apply on any method

### canApply

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions)
Can the given pointcut apply at all on the given class?

This is an important test as it can be used to optimize out a pointcut for a class.

Parameters:
  `pc` - the static or dynamic pointcut to check
  `targetClass` - the class to test
  `hasIntroductions` - whether the advisor chain for this bean includes any introductions
Returns:
  whether the pointcut can apply on any method

### canApply

public static boolean canApply(Advisor advisor, Class<?> targetClass)
Can the given advisor apply at all on the given class? This is an important test as it can be used to optimize out an advisor for a class.

Parameters:
  `advisor` - the advisor to check
  `targetClass` - class we're testing
Returns:
  whether the pointcut can apply on any method

### canApply

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions)
Can the given advisor apply at all on the given class?

This is an important test as it can be used to optimize out an advisor for a class. This version also takes into account introductions (for IntroductionAwareMethodMatchers).

Parameters:
  `advisor` - the advisor to check
  `targetClass` - class we're testing
  `hasIntroductions` - whether the advisor chain for this bean includes any introductions
Returns:
  whether the pointcut can apply on any method

### findAdvisorsThatCanApply

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz)
Determine the sublist of the `candidateAdvisors` list that is applicable to the given class.

Parameters:
  `candidateAdvisors` - the Advisors to evaluate
  `clazz` - the target class
Returns:
  sublist of Advisors that can apply to an object of the given class (may be the incoming List as-is)

### invokeJoinpointUsingReflection

@Nullable public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args) throws Throwable
Invoke the given target via reflection, as part of an AOP method invocation.

Parameters:
  `target` - the target object
  `method` - the method to invoke
  `args` - the arguments for the method
Returns:
  the invocation result, if any
Throws:
  `Throwable` - if thrown by the target method
  `AopInvocationException` - in case of a reflection error