| Home >> All >> org >> springframework >> [ aop Javadoc ] |
• org.springframework.aop: Javadoc index of package org.springframework.aop.
Package Samples:
• org.springframework.aop.framework.autoproxy.target: Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
• org.springframework.aop.framework.autoproxy: Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
• org.springframework.aop.target: Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
• org.springframework.aop.framework.adapter
• org.springframework.aop.framework.autoproxy.metadata
• org.springframework.aop.framework
• org.springframework.aop.interceptor
• org.springframework.aop.support
Classes:
• ProxyFactoryBean: FactoryBean implementation for use to source AOP proxies from a Spring BeanFactory. Interceptors and Advisors are identified by a list of bean names in the current bean factory. These beans should be of type Interceptor or Advisor. The last entry in the list can be the name of any bean in the factory. If it's neither an Interceptor nor an Advisor, a new SingletonTargetSource is added to wrap it. If it;s a TargetSource, it is used as this proxy factory's TargetSource. It's normally preferred to use the "targetSource" property to set the TargetSource. It is not possible to use both the targetSource ...
• AbstractAutoProxyCreator: BeanPostProcessor implementation that wraps a group of beans with AOP proxies that delegate to the given interceptors before invoking the bean itself. This class distinguishes between "common" interceptors: shared for all proxies it creates, and "specific" interceptors: unique per bean instance. There need not be any common interceptors. If there are, they are set using the interceptorNames property. As with ProxyFactoryBean, interceptors names in the current factory are used rather than bean references to allow correct handling of prototype advisors and interceptors: for example, to support stateful ...
• MethodMatcher: Part of a Pointcut. Checks whether the target method is eligible for advice. A MethodMatcher may be evaluated statically or at runtime (dynamically). Static matching involves method and (possibly) method attributes. Dynamic matching also makes arguments for a particular call available, and any effects of running previous advice applying to the joinpoint. If an implementation returns false in its isRuntime() method, evaluation can be performed statically, and the result will be the same for all invocations of this method, whatever their arguments. If the isRuntime() method returns false, the 3-arg ...
• LazyInitTargetSourceCreator: TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init". This will lead to a proxy created for each of those beans, allowing to fetch a reference to such a bean without actually initialized the target bean instance. To be registered as custom TargetSourceCreator for an auto-proxy creator, in combination with custom interceptors for specific beans or for the creation of lazy-init proxies only. For example, as autodetected infrastructure bean in an XML application context definition: <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> ...
• LazyInitTargetSource: TargetSource that lazily accesses a singleton from a BeanFactory. Useful when a proxy reference is needed on initialization but the actual target object should not be initialized until first use. The target bean must me marked as "lazy-init" too, else it would get instantiated by the BeanFactory on startup. For example: <bean id="serviceTarget" class="example.MyService" lazy-init="true"> ... </bean> <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="targetSource"> <bean class="org.springframework.aop.target.LazyInitTargetSource"> ...
• AbstractAdvisorAutoProxyCreator: Abstract BeanPostProcessor implementation that creates AOP proxies. This class is completely generic; it contains no special code to handle any particular aspects, such as pooling aspects. Subclasses must implement the abstract findCandidateAdvisors() method to return a list of Advisors applying to any object. Subclasses can also override the inherited shouldSkip method to exclude certain objects from auto-proxying, but they must be careful to invoke the base shouldSkip method, which tries to avoid circular reference problems and infinite loops. Advisors or advices requiring ordering should implement ...
• AopContext: Class containing static methods used to obtain information about the current AOP invocation. The currentProxy() method is usable if the AOP framework is configured to expose the current proxy (not the default). It returns the AOP proxy in use. Target objects or advice can use this to make advised calls, in the same way as getEJBObject() can be used in EJBs. They can also use it to find advice configuration. The AOP framework does not expose proxies by default, as there is a performance cost in doing so. The functionality in this class might be used by a target object that needed access to resources ...
• AbstractPoolingTargetSource: Abstract superclass for pooling TargetSources that maintains a pool of target instances, acquiring and releasing a target object from the pool for each method invocation. This class is independent of pooling technology. Subclasses must implement the getTarget() and releaseTarget() methods to work with their chosen pool. The newPrototypeInstance() method inherited from AbstractPrototypeBasedTargetSource can be used to create objects to put in the pool. Subclasses must also implement some of the monitoring methods from the PoolingConfig interface. This class provides the getPoolingConfigMixin() method ...
• Cglib2AopProxy: CGLIB2-based AopProxy implementation for the Spring AOP framework. Requires CGLIB2 on the class path. Objects of this type should be obtained through proxy factories, configured by an AdvisedSupport object. This class is internal to the Spring AOP framework and need not be used directly by client code. DefaultAopProxyFactory will automatically create CGLIB2-based proxies if necessary, for example in case of proxying a target class. See DefaultAopProxyFactory's javadoc for details. Proxies created using this class are thread-safe if the underlying (target) class is thread-safe. Built and tested ...
• AopProxyFactory: Interface to be implemented by objects that can create AOP proxies based on AdvisedSupport objects. Proxies should observe the following contract: They should implement all interfaces that the configuration indicates should be proxied. They should implement the Advised interface. They should implement the equals method to compare proxied interfaces, advice, and target. They should be serializable if all advisors and target are serializable. They should be thread-safe if advisors and target are thread-safe. Proxies may or may not allow advice changes to be made. If they do not permit advice changes ...
• DelegatingIntroductionInterceptor: Convenient implementation of the IntroductionInterceptor interface. Subclasses merely need to extend this class and implement the interfaces to be introduced themselves. In this case the delegate is the subclass instance itself. Alternatively a separate delegate may implement the interface, and be set via the delegate bean property. Delegates or subclasses may implement any number of interfaces. All interfaces except IntroductionInterceptor are picked up from the subclass or delegate by default. The suppressInterface method can be used to suppress interfaces implemented by the delegate but which ...
• RegexpMethodPointcutAdvisor: Convenient class for regexp method pointcuts that hold an Advice, making them an Advisor. Configure this class using the "pattern" and "patterns" pass-through properties. These are analogous to the pattern and patterns properties of AbstractRegexpMethodPointcut. Can delegate to any AbstractRegexpMethodPointcut subclass, like Perl5RegexpMethodPointcut or JdkRegexpMethodPointcut. To choose a specific one, either override createPointcut or set the "perl5" flag accordingly. By default, JdkRegexpMethodPointcut will be used on JDK 1.4+, falling back to Perl5RegexpMethodPointcut on JDK 1.3 (requiring ...
• JdkDynamicAopProxy: InvocationHandler implementation for the Spring AOP framework, based on J2SE 1.3+ dynamic proxies. Creates a J2SE proxy, implementing the interfaces exposed by the proxy. Dynamic proxies cannot be used to proxy methods defined in classes, rather than interface. Objects of this type should be obtained through proxy factories, configured by an AdvisedSupport class. This class is internal to the Spring framework and need not be used directly by client code. Proxies created using this class will be threadsafe if the underlying (target) class is threadsafe. Proxies are serializable so long as all Advisors ...
• DefaultAdvisorAutoProxyCreator: BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory. This class is completely generic; it contains no special code to handle any particular aspects, such as pooling aspects. It's possible to filter out advisors - for example, to use multiple post processors of this type in the same factory - by setting the usePrefix property to true, in which case only advisors beginning with the DefaultAdvisorAutoProxyCreator's bean name followed by a dot (like "aapc.") will be used. This default prefix can be changed from the bean name by setting ...
• AbstractRegexpMethodPointcut: Abstract base regular expression pointcut bean. JavaBean properties are: pattern: regular expression for the fully-qualified method names to match. The exact regexp syntax will depend on the subclass (e.g. Perl5 regular expressions) patterns: alternative property taking a String array of patterns. The result will be the union of these patterns. Note: the regular expressions must be a match. For example, .*get.* will match com.mycom.Foo.getBar(). get.* will not. This base class is serializable. Subclasses should declare all fields transient - the initPatternRepresentation method in this class will ...
• JdkRegexpMethodPointcut: Java 1.4 regular expression pointcut. JavaBean properties are: pattern: Java 1.4 regular expression for the fully-qualified method names to match patterns: alternative property taking a String array of patterns. The result will be the union of these patterns. Note: the regular expressions must be a match. For example, .*get.* will match com.mycom.Foo.getBar(). get.* will not. Requires JDK 1.4+, as it builds on the java.util.regex package. As alternative on JDK 1.3 or for Perl5-style regular expression parsing, consider Perl5RegexpMethodPointcut.
• DynamicIntroductionAdvice: Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor. This is a fundamental AOP concept called introduction . Introductions are often mixins , enabling the building of composite objects that can achieve many of the goals of multiple inheritance in Java. Compared to IntroductionInfo, this interface allows an advice to implement a range of interfaces that is not necessarily known in advance. Thus an IntroductionAdvisor can be used to specify which interfaces will be exposed in an advised object.
• Perl5RegexpMethodPointcut: Perl5-style regular expression pointcut. JavaBean properties are: pattern: Perl5 regular expression for the fully-qualified method names to match patterns: alternative property taking a String array of patterns. The result will be the union of these patterns. Note: the regular expressions must be a match. For example, .*get.* will match com.mycom.Foo.getBar(). get.* will not. Currently uses the Jakarta ORO regular expression library. Does not require JDK 1.4+, in contrast to JdkRegexpMethodPointcut.
• ThreadLocalTargetSource: Alternative to an object pool. This TargetSource uses a threading model in which every thread has its own copy of the target. There's no contention for targets. Target object creation is kept to a minimum on the running server. Application code is written as to a normal pool; callers can't assume they will be dealing with the same instance in invocations in different threads. However, state can be relied on during the operations of a single thread: for example, if one caller makes repeated calls on the AOP proxy. Cleanup is performed in the destroy() method from DisposableBean.
• Advisor: Base interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut). This interface is not for use by Spring users, but to allow for commonality in support for different types of advice. Spring AOP is based around around advice delivered via method interception , compliant with the AOP Alliance interception API. The Advisor interface allows support for different types of advice, such as before and after advice, which need not be implemented using interception.
• ThrowsAdviceInterceptor: Interceptor to wrap an after throwing advice. The signatures on handler methods on the throwsAdvice constructor argument must be of form: void afterThrowing([Method], [args], [target], ThrowableSubclass); Only the last argument is required. This is a framework class that need not be used directly by Spring users. You can, however, use this class to wrap Spring ThrowsAdvice implementations for use in other AOP frameworks supporting the AOP Alliance interfaces.
• AfterReturningAdviceInterceptor: Interceptor to wrap a MethodAfterReturningAdvice. In future we may also offer a more efficient alternative solution in cases where there is no interception advice and therefore no need to create a MethodInvocation object. Used internally by the AOP framework: Application developers should not need to use this class directly. You can also use this class to wrap Spring AfterReturningAdvice implementations for use in other AOP frameworks supporting the AOP Alliance interfaces.
• TargetSource: A TargetSource is used to obtain the current "target" of an AOP invocation, which will be invoked via reflection if no around advice chooses to end the interceptor chain itself. If a TargetSource is "static", it will always return the same target, allowing optimizations in the AOP framework. Dynamic target sources can support pooling, hot swapping, etc. Application developers don't usually need to work with TargetSources directly: This is an AOP framework interface.
• ExposeInvocationInterceptor: Interceptor that exposes the current MethodInvocation. We occasionally need to do this--for example, when a pointcut or target object needs to know the Invocation context. Don't use this interceptor unless this is really necessary. Target objects should not normally know about Spring AOP, as this creates a dependency on Spring. Target objects should be plain POJOs as far as possible. If used, this interceptor will normally be the first in the interceptor chain.
• MethodBeforeAdviceInterceptor: Interceptor to wrap a MethodBeforeAdvice. In future we may also offer a more efficient alternative solution in cases where there is no interception advice and therefore no need to create a MethodInvocation object. Used internally by the AOP framework: application developers should not need to use this class directly. You can use this class to wrap Spring MethodBeforeAdvice implementations for use in other AOP frameworks supporting the AOP Alliance interfaces.
| Home | Contact Us | Privacy Policy | Terms of Service |