org.springframework.aop.support

## Class DefaultIntroductionAdvisor

- java.lang.Object
- - org.springframework.aop.support.DefaultIntroductionAdvisor

- All Implemented Interfaces:
    Serializable, Advisor, ClassFilter, IntroductionAdvisor, IntroductionInfo, Ordered

      public class DefaultIntroductionAdvisor
      extends Object
      implements IntroductionAdvisor, ClassFilter, Ordered, Serializable

  Simple `IntroductionAdvisor` implementation that by default applies to any class.
  Since:
    11.11.2003
  Author:
    Rod Johnson, Juergen Hoeller
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.aop.Advisor

      `EMPTY_ADVICE`

    - ### Fields inherited from interface org.springframework.aop.ClassFilter

      `TRUE`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DefaultIntroductionAdvisor(Advice advice)` Create a DefaultIntroductionAdvisor for the given advice.
    `DefaultIntroductionAdvisor(Advice advice, IntroductionInfo introductionInfo)` Create a DefaultIntroductionAdvisor for the given advice.
    `DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> ifc)` Create a DefaultIntroductionAdvisor for the given advice.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addInterface(Class<?> ifc)` Add the specified interface to the list of interfaces to introduce.
    `boolean` | `equals(Object other)`
    `Advice` | `getAdvice()` Return the advice part of this aspect.
    `ClassFilter` | `getClassFilter()` Return the filter determining which target classes this introduction should apply to.
    `Class<?>[]` | `getInterfaces()` Return the additional interfaces introduced by this Advisor or Advice.
    `int` | `getOrder()` Get the order value of this object.
    `int` | `hashCode()`
    `boolean` | `isPerInstance()` Return whether this advice is associated with a particular instance (for example, creating a mixin) or shared with all instances of the advised class obtained from the same Spring bean factory.
    `boolean` | `matches(Class<?> clazz)` Should the pointcut apply to the given interface or target class?
    `void` | `setOrder(int order)`
    `String` | `toString()`
    `void` | `validateInterfaces()` Can the advised interfaces be implemented by the introduction advice? Invoked before adding an IntroductionAdvisor.

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### DefaultIntroductionAdvisor

          public DefaultIntroductionAdvisor(Advice advice)

      Create a DefaultIntroductionAdvisor for the given advice.
      Parameters:
        `advice` - the Advice to apply (may implement the `IntroductionInfo` interface)
      See Also:
        `addInterface(java.lang.Class<?>)`

    - #### DefaultIntroductionAdvisor

          public DefaultIntroductionAdvisor(Advice advice,
                                            @Nullable
                                            IntroductionInfo introductionInfo)

      Create a DefaultIntroductionAdvisor for the given advice.
      Parameters:
        `advice` - the Advice to apply
        `introductionInfo` - the IntroductionInfo that describes the interface to introduce (may be `null`)

    - #### DefaultIntroductionAdvisor

          public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice,
                                            Class<?> ifc)

      Create a DefaultIntroductionAdvisor for the given advice.
      Parameters:
        `advice` - the Advice to apply
        `ifc` - the interface to introduce

  - ### Method Detail

    - #### addInterface

          public void addInterface(Class<?> ifc)

      Add the specified interface to the list of interfaces to introduce.
      Parameters:
        `ifc` - the interface to introduce

    - #### getInterfaces

          public Class<?>[] getInterfaces()

      Description copied from interface: `IntroductionInfo`
      Return the additional interfaces introduced by this Advisor or Advice.
      Specified by:
        `getInterfaces` in interface `IntroductionInfo`
      Returns:
        the introduced interfaces

    - #### validateInterfaces

          public void validateInterfaces()
                                  throws IllegalArgumentException

      Description copied from interface: `IntroductionAdvisor`
      Can the advised interfaces be implemented by the introduction advice? Invoked before adding an IntroductionAdvisor.
      Specified by:
        `validateInterfaces` in interface `IntroductionAdvisor`
      Throws:
        `IllegalArgumentException` - if the advised interfaces can't be implemented by the introduction advice

    - #### setOrder

          public void setOrder(int order)

    - #### 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`

    - #### getAdvice

          public Advice getAdvice()

      Description copied from interface: `Advisor`
      Return the advice part of this aspect. An advice may be an interceptor, a before advice, a throws advice, etc.
      Specified by:
        `getAdvice` in interface `Advisor`
      Returns:
        the advice that should apply if the pointcut matches
      See Also:
        `MethodInterceptor`, `BeforeAdvice`, `ThrowsAdvice`, `AfterReturningAdvice`

    - #### isPerInstance

          public boolean isPerInstance()

      Description copied from interface: `Advisor`
      Return whether this advice is associated with a particular instance (for example, creating a mixin) or shared with all instances of the advised class obtained from the same Spring bean factory.

      Note that this method is not currently used by the framework. Typical Advisor implementations always return `true`. Use singleton/prototype bean definitions or appropriate programmatic proxy creation to ensure that Advisors have the correct lifecycle model.

      Specified by:
        `isPerInstance` in interface `Advisor`
      Returns:
        whether this advice is associated with a particular target instance

    - #### getClassFilter

          public ClassFilter getClassFilter()

      Description copied from interface: `IntroductionAdvisor`
      Return the filter determining which target classes this introduction should apply to.

      This represents the class part of a pointcut. Note that method matching doesn't make sense to introductions.

      Specified by:
        `getClassFilter` in interface `IntroductionAdvisor`
      Returns:
        the class filter

    - #### matches

          public boolean matches(Class<?> clazz)

      Description copied from interface: `ClassFilter`
      Should the pointcut apply to the given interface or target class?
      Specified by:
        `matches` in interface `ClassFilter`
      Parameters:
        `clazz` - the candidate target class
      Returns:
        whether the advice should apply to the given target class

    - #### equals

          public boolean equals(@Nullable
                                Object other)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`