The Spring Framework

## 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.ClassFilter
`TRUE`

Fields inherited from interface org.springframework.core.Ordered
`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

Constructor Summary
`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 intf)` Create a DefaultIntroductionAdvisor for the given advice.

Method Summary
`void` `addInterface(Class intf)` 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()` Return the order value of this object, with a higher value meaning greater in terms of sorting.
`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?

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,
                                      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 intf)

  Create a DefaultIntroductionAdvisor for the given advice.

  Parameters:
    `advice` - the Advice to apply
    `intf` - the interface to introduce

Method Detail

### addInterface

    public void addInterface(Class intf)

  Add the specified interface to the list of interfaces to introduce.

  Parameters:
    `intf` - 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`
  Return the order value of this object, with a higher value meaning greater in terms of sorting.

  Normally starting with 0 or 1, with `Ordered.LOWEST_PRECEDENCE` indicating greatest. Same order values will result in arbitrary positions for the affected objects.

  Higher value can be interpreted as lower priority, consequently the first object has highest priority (somewhat analogous to Servlet "load-on-startup" values).

  Note that order values below 0 are reserved for framework purposes. Application-specified values should always be 0 or greater, with only framework components (internal or third-party) supposed to use lower values.

  Specified by:
    `getOrder` in interface `Ordered`
  Returns:
    the order value
  See Also:
    `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(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`

The Spring Framework

Copyright © 2002-2008 The Spring Framework.