## Uses of Interface
org.springframework.core.Ordered

Packages that use Ordered
org.springframework.aop.aspectj: AspectJ integration package.
org.springframework.aop.aspectj.annotation: Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
org.springframework.aop.aspectj.autoproxy: Base classes enabling auto-proxying based on AspectJ.
org.springframework.aop.config: Support package for declarative AOP configuration, with XML schema being the primary configuration format.
org.springframework.aop.framework.autoproxy: 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.support: Convenience classes for using Spring's AOP API.
org.springframework.beans.factory.annotation: Support package for annotation-driven bean configuration.
org.springframework.beans.factory.config: SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.context.annotation: Annotation support for context configuration, including classpath scanning for autowire candidates.
org.springframework.context.weaving: Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
org.springframework.core: Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.dao.annotation: Annotation support for DAOs.
org.springframework.jdbc.support.lob: Provides a stategy interface for Large OBject handling, with implementations for various databases.
org.springframework.orm.jpa.support: Classes supporting the `org.springframework.orm.jpa` package.
org.springframework.scripting.support: Support classes for Spring's scripting package.
org.springframework.transaction.interceptor: AOP-based solution for declarative transaction demarcation.
org.springframework.transaction.support: Support classes for the org.springframework.transaction package.
org.springframework.web.context.support: Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.portlet.handler: Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.portlet.mvc.annotation: Support package for annotation-based Portlet MVC controllers.
org.springframework.web.servlet.handler: Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.handler.metadata: This package enables automatic web controller targeting.
org.springframework.web.servlet.mvc.support: Support package for MVC controllers.
org.springframework.web.servlet.view: Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.view.freemarker: Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.jasperreports: Support classes for the integration of JasperReports as Spring web view technology.
org.springframework.web.servlet.view.velocity: Support classes for the integration of Velocity as Spring web view technology.
org.springframework.web.servlet.view.xslt: Support classes for XSLT, providing a View implementation for XSLT stylesheets.

Uses of Ordered in org.springframework.aop.aspectj

Subinterfaces of Ordered in org.springframework.aop.aspectj
`interface` `AspectInstanceFactory` Interface implemented to provide an instance of an AspectJ aspect.
`interface` `AspectJPrecedenceInformation` Interface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules.

Classes in org.springframework.aop.aspectj that implement Ordered
`class` `AbstractAspectJAdvice` Base class for AOP Alliance `Advice` classes wrapping an AspectJ aspect or an AspectJ-annotated advice method.
`class` `AspectJAfterAdvice` Spring AOP advice wrapping an AspectJ after advice method.
`class` `AspectJAfterReturningAdvice` Spring AOP advice wrapping an AspectJ after-returning advice method.
`class` `AspectJAfterThrowingAdvice` Spring AOP advice wrapping an AspectJ after-throwing advice method.
`class` `AspectJAroundAdvice` Spring AOP around advice (MethodInterceptor) that wraps an AspectJ advice method.
`class` `AspectJExpressionPointcutAdvisor` Spring AOP Advisor that can be used for any AspectJ pointcut expression.
`class` `AspectJMethodBeforeAdvice` Spring AOP advice that wraps an AspectJ before method.
`class` `AspectJPointcutAdvisor` AspectJPointcutAdvisor that adapts an `AbstractAspectJAdvice` to the `PointcutAdvisor` interface.
`class` `SimpleAspectInstanceFactory` Implementation of `AspectInstanceFactory` that creates a new instance of the specified aspect class for every `SimpleAspectInstanceFactory.getAspectInstance()` call.
`class` `SingletonAspectInstanceFactory` Implementation of `AspectInstanceFactory` that is backed by a specified singleton object, returning the same instance for every `SingletonAspectInstanceFactory.getAspectInstance()` call.

Uses of Ordered in org.springframework.aop.aspectj.annotation

Subinterfaces of Ordered in org.springframework.aop.aspectj.annotation
`interface` `MetadataAwareAspectInstanceFactory` Subinterface of `AspectInstanceFactory` that returns `AspectMetadata` associated with AspectJ-annotated classes.

Classes in org.springframework.aop.aspectj.annotation that implement Ordered
`class` `AnnotationAwareAspectJAutoProxyCreator` `AspectJAwareAdvisorAutoProxyCreator` subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.
`class` `BeanFactoryAspectInstanceFactory` AspectInstanceFactory backed by a Spring `BeanFactory`.
`class` `LazySingletonAspectInstanceFactoryDecorator` Decorator to cause a MetadataAwareAspectInstanceFactory to instantiate only once.
`class` `PrototypeAspectInstanceFactory` AspectInstanceFactory backed by a BeanFactory-provided prototype, enforcing prototype semantics.
`protected static class` `ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor` Synthetic advisor that instantiates the aspect.
`class` `SimpleMetadataAwareAspectInstanceFactory` Implementation of `MetadataAwareAspectInstanceFactory` that creates a new instance of the specified aspect class for every `SimpleAspectInstanceFactory.getAspectInstance()` call.
`class` `SingletonMetadataAwareAspectInstanceFactory` Implementation of `MetadataAwareAspectInstanceFactory` that is backed by a specified singleton object, returning the same instance for every `SingletonAspectInstanceFactory.getAspectInstance()` call.

Uses of Ordered in org.springframework.aop.aspectj.autoproxy

Classes in org.springframework.aop.aspectj.autoproxy that implement Ordered
`class` `AspectJAwareAdvisorAutoProxyCreator` `AbstractAdvisorAutoProxyCreator` subclass that exposes AspectJ's invocation context and understands AspectJ's rules for advice precedence when multiple pieces of advice come from the same aspect.

Uses of Ordered in org.springframework.aop.config

Classes in org.springframework.aop.config that implement Ordered
`class` `SimpleBeanFactoryAwareAspectInstanceFactory` Implementation of `AspectInstanceFactory` that locates the aspect from the `BeanFactory` using a configured bean name.

Uses of Ordered in org.springframework.aop.framework.autoproxy

Classes in org.springframework.aop.framework.autoproxy that implement Ordered
`class` `AbstractAdvisorAutoProxyCreator` Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
`class` `AbstractAutoProxyCreator` `BeanPostProcessor` implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
`class` `BeanNameAutoProxyCreator` Auto proxy creator that identifies beans to proxy via a list of names.
`class` `DefaultAdvisorAutoProxyCreator` BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory.
`class` `InfrastructureAdvisorAutoProxyCreator` Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.

Uses of Ordered in org.springframework.aop.support

Classes in org.springframework.aop.support that implement Ordered
`class` `AbstractBeanFactoryPointcutAdvisor` Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.
`class` `AbstractGenericPointcutAdvisor` Abstract generic PointcutAdvisor that allows for any Advice to be configured.
`class` `AbstractPointcutAdvisor` Abstract base class for `PointcutAdvisor` implementations.
`class` `DefaultBeanFactoryPointcutAdvisor` Concrete BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in the BeanFactory, as well as the Pointcut to be configured through a bean property.
`class` `DefaultIntroductionAdvisor` Simple `IntroductionAdvisor` implementation that by default applies to any class.
`class` `DefaultPointcutAdvisor` Convenient Pointcut-driven Advisor implementation.
`class` `NameMatchMethodPointcutAdvisor` Convenient class for name-match method pointcuts that hold an Advice, making them an Advisor.
`class` `RegexpMethodPointcutAdvisor` Convenient class for regexp method pointcuts that hold an Advice, making them an `Advisor`.
`class` `StaticMethodMatcherPointcutAdvisor` Convenient base class for Advisors that are also static pointcuts.

Uses of Ordered in org.springframework.beans.factory.annotation

Classes in org.springframework.beans.factory.annotation that implement Ordered
`class` `AutowiredAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that autowires annotated fields, setter methods and arbitrary config methods.
`class` `CustomAutowireConfigurer` A `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom autowire qualifier types.
`class` `InitDestroyAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that invokes annotated init and destroy methods.
`class` `RequiredAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that enforces required JavaBean properties to have been configured.

Uses of Ordered in org.springframework.beans.factory.config

Classes in org.springframework.beans.factory.config that implement Ordered
`class` `CustomEditorConfigurer` `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom `property editors`.
`class` `CustomScopeConfigurer` Simple `BeanFactoryPostProcessor` implementation that registers custom `Scope(s)` with the containing `ConfigurableBeanFactory`.
`class` `PreferencesPlaceholderConfigurer` Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API (`java.util.prefs`).
`class` `PropertyOverrideConfigurer` Property resource configurer that overrides bean property values in an application context definition.
`class` `PropertyPlaceholderConfigurer` A property resource configurer that resolves placeholders in bean property values of context definitions.
`class` `PropertyResourceConfigurer` Allows for configuration of individual bean property values from a property resource, i.e. a properties file.

Uses of Ordered in org.springframework.context.annotation

Classes in org.springframework.context.annotation that implement Ordered
`class` `CommonAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in the `javax.annotation` package.

Uses of Ordered in org.springframework.context.weaving

Classes in org.springframework.context.weaving that implement Ordered
`class` `AspectJWeavingEnabler` Post-processor that registers AspectJ's `ClassPreProcessorAgentAdapter` with the Spring application context's default `LoadTimeWeaver`.

Uses of Ordered in org.springframework.core

Subinterfaces of Ordered in org.springframework.core
`interface` `PriorityOrdered` Extension of the `Ordered` interface, expressing a 'priority' ordering: Order values expressed by PriorityOrdered objects always apply before order values of 'plain' Ordered values.

Uses of Ordered in org.springframework.dao.annotation

Classes in org.springframework.dao.annotation that implement Ordered
`class` `PersistenceExceptionTranslationAdvisor` Spring AOP exception translation aspect for use at Repository or DAO layer level.
`class` `PersistenceExceptionTranslationPostProcessor` Bean post-processor that automatically applies persistence exception translation to any bean that carries the `Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

Uses of Ordered in org.springframework.jdbc.support.lob

Classes in org.springframework.jdbc.support.lob that implement Ordered
`class` `SpringLobCreatorSynchronization` Callback for resource cleanup at the end of a Spring transaction.

Uses of Ordered in org.springframework.orm.jpa.support

Classes in org.springframework.orm.jpa.support that implement Ordered
`class` `PersistenceAnnotationBeanPostProcessor` BeanPostProcessor that processes `PersistenceUnit` and `PersistenceContext` annotations, for injection of the corresponding JPA resources `EntityManagerFactory` and `EntityManager`.

Uses of Ordered in org.springframework.scripting.support

Classes in org.springframework.scripting.support that implement Ordered
`class` `ScriptFactoryPostProcessor` `BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.

Uses of Ordered in org.springframework.transaction.interceptor

Classes in org.springframework.transaction.interceptor that implement Ordered
`class` `BeanFactoryTransactionAttributeSourceAdvisor` Advisor driven by a `TransactionAttributeSource`, used to include a transaction advice bean for methods that are transactional.
`class` `TransactionAttributeSourceAdvisor` Advisor driven by a `TransactionAttributeSource`, used to include a `TransactionInterceptor` only for methods that are transactional.

Uses of Ordered in org.springframework.transaction.support

Classes in org.springframework.transaction.support that implement Ordered
`class` `TransactionSynchronizationAdapter` Simple `TransactionSynchronization` adapter containing empty method implementations, for easier overriding of single methods.

Uses of Ordered in org.springframework.web.context.support

Classes in org.springframework.web.context.support that implement Ordered
`class` `ServletContextPropertyPlaceholderConfigurer` Subclass of PropertyPlaceholderConfigurer that resolves placeholders as ServletContext init parameters (that is, `web.xml` context-param entries).

Uses of Ordered in org.springframework.web.portlet.handler

Classes in org.springframework.web.portlet.handler that implement Ordered
`class` `AbstractHandlerMapping` Abstract base class for `HandlerMapping` implementations.
`class` `AbstractMapBasedHandlerMapping` Abstract base class for `HandlerMapping` implementations that rely on a map which caches handler objects per lookup key.
`class` `ParameterHandlerMapping` Implementation of the `HandlerMapping` to map from a request parameter to request handler beans.
`class` `PortletModeHandlerMapping` Implementation of the `HandlerMapping` interface to map from the current PortletMode to request handler beans.
`class` `PortletModeParameterHandlerMapping` Implementation of the `HandlerMapping` interface to map from the current PortletMode and a request parameter to request handler beans.
`class` `SimpleMappingExceptionResolver` `HandlerExceptionResolver` implementation that allows for mapping exception class names to view names, either for a set of given handlers or for all handlers in the DispatcherPortlet.

Uses of Ordered in org.springframework.web.portlet.mvc.annotation

Classes in org.springframework.web.portlet.mvc.annotation that implement Ordered
`class` `DefaultAnnotationHandlerMapping` Implementation of the `HandlerMapping` interface that maps handlers based on portlet modes expressed through the `RequestMapping` annotation at the type or method level.

Uses of Ordered in org.springframework.web.servlet.handler

Classes in org.springframework.web.servlet.handler that implement Ordered
`class` `AbstractDetectingUrlHandlerMapping` Abstract implementation of the `HandlerMapping` interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.
`class` `AbstractUrlHandlerMapping` Abstract base class for URL-mapped `HandlerMapping` implementations.
`class` `BeanNameUrlHandlerMapping` Implementation of the `HandlerMapping` interface that map from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.
`class` `SimpleUrlHandlerMapping` Implementation of the `HandlerMapping` interface to map from URLs to request handler beans.

Uses of Ordered in org.springframework.web.servlet.handler.metadata

Classes in org.springframework.web.servlet.handler.metadata that implement Ordered
`class` `AbstractPathMapHandlerMapping` Deprecated. as of Spring 2.5, in favor of annotation-based request mapping. To be removed in Spring 3.0.
`class` `CommonsPathMapHandlerMapping` Deprecated. as of Spring 2.5, in favor of annotation-based request mapping. To be removed in Spring 3.0.

Uses of Ordered in org.springframework.web.servlet.mvc.support

Classes in org.springframework.web.servlet.mvc.support that implement Ordered
`class` `AbstractControllerUrlHandlerMapping` Base class for `HandlerMapping` implementations that derive URL paths according to conventions for specific controller types.
`class` `ControllerBeanNameHandlerMapping` Implementation of `HandlerMapping` that follows a simple convention for generating URL path mappings from the bean names of registered `Controller` and `ThrowawayController` beans as well as `@Controller` annotated beans.
`class` `ControllerClassNameHandlerMapping` Implementation of `HandlerMapping` that follows a simple convention for generating URL path mappings from the class names of registered `Controller` and `ThrowawayController` beans as well as `@Controller` annotated beans.

Uses of Ordered in org.springframework.web.servlet.view

Classes in org.springframework.web.servlet.view that implement Ordered
`class` `AbstractTemplateViewResolver` Abstract base class for template view resolvers, in particular for Velocity and FreeMarker views.
`class` `BeanNameViewResolver` Simple implementation of ViewResolver that interprets a view name as bean name in the current application context, i.e. in the XML file of the executing DispatcherServlet.
`class` `InternalResourceViewResolver` Convenient subclass of `UrlBasedViewResolver` that supports `InternalResourceView` (i.e.
`class` `ResourceBundleViewResolver` `ViewResolver` implementation that uses bean definitions in a `ResourceBundle`, specified by the bundle basename.
`class` `UrlBasedViewResolver` Simple implementation of the `ViewResolver` interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definition.
`class` `XmlViewResolver` Implementation of ViewResolver that uses bean definitions in an XML file, specified by resource location.

Uses of Ordered in org.springframework.web.servlet.view.freemarker

Classes in org.springframework.web.servlet.view.freemarker that implement Ordered
`class` `FreeMarkerViewResolver` Convenience subclass of UrlBasedViewResolver that supports FreeMarkerView (i.e.

Uses of Ordered in org.springframework.web.servlet.view.jasperreports

Classes in org.springframework.web.servlet.view.jasperreports that implement Ordered
`class` `JasperReportsViewResolver` `ViewResolver` implementation that resolves instances of `AbstractJasperReportsView` by translating the supplied view name into the URL of the report file.

Uses of Ordered in org.springframework.web.servlet.view.velocity

Classes in org.springframework.web.servlet.view.velocity that implement Ordered
`class` `VelocityLayoutViewResolver` Convenience subclass of VelocityViewResolver, adding support for VelocityLayoutView and its properties.
`class` `VelocityViewResolver` Convenience subclass of UrlBasedViewResolver that supports VelocityView (that is Velocity templates) and custom subclasses of it.

Uses of Ordered in org.springframework.web.servlet.view.xslt

Classes in org.springframework.web.servlet.view.xslt that implement Ordered
`class` `XsltViewResolver` `ViewResolver` implementation that resolves instances of `XsltView` by translating the supplied view name into the URL of the XSLT stylesheet.

Copyright © 2002-2008 The Spring Framework.