| Home >> All >> org >> springframework >> aop >> [ framework Javadoc ] |
• org.springframework.aop.framework: Javadoc index of package org.springframework.aop.framework.
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.framework.adapter
• org.springframework.aop.framework.autoproxy.metadata
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 ...
• 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"> ...
• 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 ...
• 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 ...
• 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 ...
• 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.
• 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.
• AdvisedSupport: Superclass for AOP proxy configuration managers. These are not themselves AOP proxies, but subclasses of this class are normally factories from which AOP proxy instances are obtained directly. This class frees subclasses of the housekeeping of Advices and Advisors, but doesn't actually implement proxy creation methods, which are provided by subclasses. This class is serializable; subclasses need not be. This class is used to hold snapshots of proxies.
• AdvisorAdapter: Interface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types. Implementing objects can create AOP Alliance Interceptors from custom advice types, enabling these advice types to be used in the Spring AOP framework, which uses interception under the covers. There is no need for most Spring users to implement this interface; do so only if you need to introduce more Advisor or Advice types to Spring.
• ProxyConfig: Convenience superclass for configuration used in creating proxies, to ensure that all proxy creators have consistent properties. Note that it is no longer possible to configure subclasses to expose the MethodInvocation. Interceptors should normally manage their own ThreadLocals if they need to make resources available to advised objects. If it's absolutely necessary to expose the MethodInvocation, use an interceptor to do so.
• ReflectiveMethodInvocation: Spring's implementation of AOP Alliance MethodInvocation interface. Invokes the target object using reflection. Subclasses can override the invokeJoinpoint() method to change this behavior, so this is also a useful base class for more specialized MethodInvocation implementations. It's possible to clone an invocation, to invoke proceed repeatedly (once per clone), using the invocableClone method.
• DefaultAopProxyFactory: Simple implementation of AopProxyFactory, either creating a CGLIB proxy or a JDK dynamic proxy. Creates a CGLIB proxy if one the following is true: the "optimize" flag is set the "proxyTargetClass" flag is set no interfaces have been specified In general, specify "proxyTargetClass" to enforce a CGLIB proxy, or specify one or more interfaces to use a JDK dynamic proxy.
• AbstractBeanFactoryBasedTargetSourceCreator: Convenient superclass for TargetSourceCreators that require creating multiple instances of a prototype bean. Uses an internal BeanFactory to manage the target instances, copying the original bean definition to this internal factory. This is necessary because the original BeanFactory will just contain the proxy instance created through auto-proxying. Requires running in an AbstractBeanFactory.
• AdvisorAdapterRegistrationManager: BeanPostProcessor implementation that "registers" instances of any non-default AdvisorAdapters with GlobalAdvisorAdapterRegistry. The only requirement for it to work is that it needs to be defined in application context along with any arbitrary "non-native" Spring AdvisorAdapters that need to be "recognized" by Spring's AOP framework.
• TargetSourceCreator: Implementations can create special target sources, such as pooling target sources, for particular beans. For example, they may base their choice on attributes, such as a pooling attribute, on the target class. AbstractAutoProxyCreator can support a number of TargetSourceCreators, which will be applied in order.
• Advised: Interface to be implemented by classes that hold the configuration of a factory of AOP proxies. This configuration includes the Interceptors and other advice, and Advisors, and the proxied interfaces. Any AOP proxy obtained from Spring can be cast to this interface to allow manipulation of its AOP advice.
• InterceptorAndDynamicMethodMatcher: Internal framework class. This class is required because if we put an Interceptor that implements InterceptionAdvice in the interceptor list passed to MethodInvocationImpl, it may be mistaken for an advice that requires dynamic method matching.
• HashMapCachingAdvisorChainFactory: AdvisorChainFactory implementation that caches by method. Uses IdentityHashMap on JDK >= 1.4 or Commons Collections 3.x' IdentityMap (if available), which skip expensive Method.hashCode() calls. Falls back to standard HashMap on plain JDK 1.3.
• AdvisorChainFactoryUtils: Utility methods for use by AdviceChainFactory implementations. The calculateInterceptorsAndDynamicInterceptionAdvice method is the definitive way of working out an advice chain for a Method, given an Advised object.
| Home | Contact Us | Privacy Policy | Terms of Service |