An abstract JMS MessageListener adapter providing the necessary infrastructure to extract the payload of a JMS Message.

Base class for BeanPostProcessor implementations that apply a Spring AOP Advisor to specific beans.

org.springframework.web.WebApplicationInitializer to register a DispatcherHandler, wrapping it in a ServletHttpHandlerAdapter, and use Java-based Spring configuration.

org.springframework.web.WebApplicationInitializer to register a DispatcherServlet and use Java-based Spring configuration.

Implementations are required to implement:

• #getRootConfigClasses() -- for "root" application context (non-web infrastructure) configuration.
• #getServletConfigClasses() -- for DispatcherServlet application context (Spring MVC infrastructure) configuration.

If an application context hierarchy is not required, applications may return all configuration via #getRootConfigClasses() and return null from #getServletConfigClasses().

Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.

This class handles annotation parsing and validation functionality. It does not actually generate Spring AOP Advisors, which is deferred to subclasses.

Abstract superclass for Atom Feed views, using the ROME package.

>NOTE: As of Spring 4.1, this is based on the com.rometools variant of ROME, version 1.5. Please upgrade your build dependency.

Application-specific view classes will extend this class. The view will be held in the subclass itself, not in a template. Main entry points are the #buildFeedMetadata and #buildFeedEntries.

Thanks to Jettro Coenradie and Sergio Bossa for the original feed view prototype!

Abstract BeanDefinitionParser implementation providing a number of convenience methods and a template method that subclasses must override to provide the actual parsing logic.

Use this BeanDefinitionParser implementation when you want to parse some arbitrarily complex XML into one or more BeanDefinition. If you just want to parse some XML into a single BeanDefinition, you may wish to consider the simpler convenience extensions of this class, namely AbstractSingleBeanDefinitionParser and AbstractSimpleBeanDefinitionParser.

Abstract base class for bean definition readers which implement the BeanDefinitionReader interface.

Provides common properties like the bean factory to work on and the class loader to use for loading bean classes.

Extension of AbstractAutoProxyCreator which implements BeanFactoryAware, adds exposure of the original target class for each proxied bean (AutoProxyUtils#ORIGINAL_TARGET_CLASS_ATTRIBUTE), and participates in an externally enforced target-class mode for any given bean (AutoProxyUtils#PRESERVE_TARGET_CLASS_ATTRIBUTE). This post-processor is therefore aligned with AbstractAutoProxyCreator.

Convenient superclass for org.springframework.aop.framework.autoproxy.TargetSourceCreator implementations 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 org.springframework.beans.factory.support.AbstractBeanFactory.

Base class for message broker registration classes.

Abstract base class implementing the common CacheManager methods. Useful for 'static' environments where the backing caches do not change.

Type filter that exposes a org.springframework.core.type.ClassMetadata object to subclasses, for class testing purposes.

Abstract base for ClientHttpRequest that makes sure that headers and body are not written multiple times.

Base class for ClientHttpRequest implementations.

Abstract base for ClientHttpResponse.

Convenient base class for WebApplicationInitializer implementations that register a ContextLoaderListener in the servlet context.

The only method required to be implemented by subclasses is #createRootApplicationContext(), which gets invoked from #registerContextLoaderListener(ServletContext).

A base abstract class to resolve method arguments annotated with @CookieValue. Subclasses extract the cookie value from the request.

An @CookieValue is a named value that is resolved from a cookie. It has a required flag and a default value to fall back on when the cookie does not exist.

A WebDataBinder may be invoked to apply type conversion to the resolved cookie value.

Base tag for all data-binding aware JSP form tags.

Provides the common path and id properties. Provides sub-classes with utility methods for accessing the BindStatus of their bound value and also for interacting with the TagWriter.

Abstract implementation of the org.springframework.web.servlet.HandlerMapping interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.

Abstract base class for TestExecutionListener implementations that provide support for marking the ApplicationContext associated with a test as dirty for both test classes and test methods annotated with the DirtiesContext annotation.

The core functionality for this class was extracted from DirtiesContextTestExecutionListener in Spring Framework 4.2.

Base class for org.springframework.web.WebApplicationInitializer implementations that register a DispatcherServlet in the servlet context.

Most applications should consider extending the Spring Java config, sub-class AbstractAnnotationConfigDispatcherServletInitializer.

Abstract base class for JDBC javax.sql.DataSource implementations that operate on a JDBC java.sql.Driver.

Abstract superclass for expression pointcuts, offering location and expression properties.

Abstract base class for Atom and RSS Feed views, using the ROME package.

>NOTE: As of Spring 4.1, this is based on the com.rometools variant of ROME, version 1.5. Please upgrade your build dependency.

Application-specific view classes will typically extend from either AbstractRssFeedView or AbstractAtomFeedView instead of from this class.

Thanks to Jettro Coenradie and Sergio Bossa for the original feed view prototype!

Abstract base class for filename suffix based VersionStrategy implementations, e.g. "static/myresource-version.js"

Abstract base class for org.springframework.web.servlet.HandlerExceptionResolver implementations that support handling exceptions from handlers of type HandlerMethod.

A base class for HandshakeHandler implementations, independent from the Servlet API.

Performs initial validation of the WebSocket handshake request - possibly rejecting it through the appropriate HTTP status code - while also allowing its subclasses to override various parts of the negotiation process (e.g. origin validation, sub-protocol negotiation, extensions negotiation, etc).

If the negotiation succeeds, the actual upgrade is delegated to a server-specific org.springframework.web.socket.server.RequestUpgradeStrategy, which will update the response as necessary and initialize the WebSocket. Currently supported servers are Jetty 9.0-9.3, Tomcat 7.0.47+ and 8.x, Undertow 1.0-1.3, GlassFish 4.1+, WebLogic 12.1.3+.

A base HeaderMapper implementation

Convenient super class for many html tags that render content using the databinding features of the AbstractHtmlElementTag. The only thing sub-tags need to do is override #renderDefaultContent(TagWriter).

Base class for HTTP transport handlers that receive messages via HTTP POST.

Abstract base class for DataFieldMaxValueIncrementer implementations which are based on identity columns in a sequence-like table.

Base implementation for org.springframework.beans.factory.xml.BeanDefinitionDecorator wishing to add an org.aopalliance.intercept.MethodInterceptor to the resulting bean.

This base class controls the creation of the ProxyFactoryBean bean definition and wraps the original as an inner-bean definition for the target property of ProxyFactoryBean.

Chaining is correctly handled, ensuring that only one ProxyFactoryBean definition is created. If a previous org.springframework.beans.factory.xml.BeanDefinitionDecorator already created the org.springframework.aop.framework.ProxyFactoryBean then the interceptor is simply added to the existing definition.

Subclasses have only to create the BeanDefinition to the interceptor that they wish to add.

Abstract implementation of the InterruptibleBatchPreparedStatementSetter interface, combining the check for available values and setting of those into a single callback method #setValuesIfAvailable.

Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a JUnit environment.

Concrete subclasses should typically declare a class-level ContextConfiguration annotation to configure the ApplicationContext or . If your test does not need to load an application context, you may choose to omit the ContextConfiguration declaration and to configure the appropriate org.springframework.test.context.TestExecutionListener manually.

The following org.springframework.test.context.TestExecutionListener are configured by default:

• org.springframework.test.context.web.ServletTestExecutionListener
• org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener
• org.springframework.test.context.support.DependencyInjectionTestExecutionListener
• org.springframework.test.context.support.DirtiesContextTestExecutionListener

This class serves only as a convenience for extension.

• If you do not wish for your test classes to be tied to a Spring-specific class hierarchy, you may configure your own custom test classes by using SpringRunner, ContextConfiguration, TestExecutionListeners, etc.
• If you wish to extend this class and use a runner other than the SpringRunner, as of Spring Framework 4.2 you can use org.springframework.test.context.junit4.rules.SpringClassRule and org.springframework.test.context.junit4.rules.SpringMethodRule and specify your runner of choice via RunWith.

NOTE: As of Spring Framework 4.3, this class requires JUnit 4.12 or higher.

Base class providing support methods for Jackson 2.9 encoding.

Abstract base class for Jackson based and content type independent HttpMessageConverter implementations.

Compatible with Jackson 2.9 and higher, as of Spring 5.0.

Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation).

Subclasses need to implement the #publishEndpoint template methods for actual endpoint exposure.

Base model for a JMS listener endpoint

A convenient base class for a ResponseBodyAdvice to instruct the org.springframework.http.converter.json.MappingJackson2HttpMessageConverter to serialize with JSONP formatting.

Sub-classes must specify the query parameter name(s) to check for the name of the JSONP callback function.

Sub-classes are likely to be annotated with the @ControllerAdvice annotation and auto-detected or otherwise must be registered directly with the RequestMappingHandlerAdapter and ExceptionHandlerExceptionResolver.

org.springframework.aop.TargetSource implementation that will lazily create a user-managed object.

Creation of the lazy target object is controlled by the user by implementing the #createObject() method. This TargetSource will invoke this method the first time the proxy is accessed.

Useful when you need to pass a reference to some dependency to an object but you don't actually want the dependency to be created until it is first used. A typical scenario for this is a connection to a remote resource.

Abstract base class for Publisher implementations that bridge between event-listener read APIs and Reactive Streams.

Specifically a base class for reading from the HTTP request body with Servlet 3.1 non-blocking I/O and Undertow XNIO as well as handling incoming WebSocket messages with standard Java WebSocket (JSR-356), Jetty, and Undertow.

Abstract base class for listener-based server responses, e.g. Servlet 3.1 and Undertow.

An alternative to AbstractListenerWriteProcessor but instead writing a Publisher<Publisher<T>> with flush boundaries enforces after the completion of each nested Publisher.

Abstract base class for Processor implementations that bridge between event-listener write APIs and Reactive Streams.

Specifically a base class for writing to the HTTP response body with Servlet 3.1 non-blocking I/O and Undertow XNIO as well for writing WebSocket messages through the Java WebSocket API (JSR-356), Jetty, and Undertow.

Abstract PreparedStatementCallback implementation that manages a LobCreator. Typically used as inner class, with access to surrounding method arguments.

Delegates to the setValues template method for setting values on the PreparedStatement, using a given LobCreator for BLOB/CLOB arguments.

A usage example with org.springframework.jdbc.core.JdbcTemplate:

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); // reusable object LobHandler lobHandler = new DefaultLobHandler(); // reusable object jdbcTemplate.execute( "INSERT INTO imagedb (image_name, content, description) VALUES (?, ?, ?)", new AbstractLobCreatingPreparedStatementCallback(lobHandler) { protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException { ps.setString(1, name); lobCreator.setBlobAsBinaryStream(ps, 2, contentStream, contentLength); lobCreator.setClobAsString(ps, 3, description); } } );

Abstract ResultSetExtractor implementation that assumes streaming of LOB data. Typically used as inner class, with access to surrounding method arguments.

Delegates to the streamData template method for streaming LOB content to some OutputStream, typically using a LobHandler. Converts an IOException thrown during streaming to a LobRetrievalFailureException.

A usage example with JdbcTemplate:

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); // reusable object final LobHandler lobHandler = new DefaultLobHandler(); // reusable object jdbcTemplate.query( "SELECT content FROM imagedb WHERE image_name=?", new Object[] {name}, new AbstractLobStreamingResultSetExtractor() { public void streamData(ResultSet rs) throws SQLException, IOException { FileCopyUtils.copy(lobHandler.getBlobAsBinaryStream(rs, 1), contentStream); } } );

Abstract base class for LocaleContextResolver implementations. Provides support for a default locale and a default time zone.

Also provides pre-implemented versions of #resolveLocale and #setLocale, delegating to #resolveLocaleContext and #setLocaleContext.

Abstract base class for LocaleResolver implementations. Provides support for a default locale.

Abstract implementation of the Marshaller and Unmarshaller interface. This implementation inspects the given Source or Result, and delegates further handling to overridable template methods.

Provides essential configuration for handling messages with simple messaging protocols such as STOMP.

#clientInboundChannel() and #clientOutboundChannel() deliver messages to and from remote clients to several message handlers such as

• #simpAnnotationMethodMessageHandler()
• #simpleBrokerMessageHandler()
• #stompBrokerRelayMessageHandler()
• #userDestinationMessageHandler()

Subclasses are responsible for the part of the configuration that feed messages to and from the client inbound/outbound channels (e.g. STOMP over WebSocket).

Abstract base class for SmartMessageConverter implementations including support for common properties and a partial implementation of the conversion methods, mainly to check if the converter supports the conversion based on the payload class and MIME type.

Abstract base class for result handlers that handle return values by writing to the response with HttpMessageWriter.

Abstract base class for HandlerMethod-based message handling. Provides most of the logic required to discover handler methods at startup, find a matching handler method at runtime for a given message and invoke it.

Also supports discovering and invoking exception handling methods to process exceptions raised during message handling.

Abstract base class for resolving method arguments from a named value. Message headers, and path variables are examples of named values. Each may have a name, a required flag, and a default value.

Subclasses define how to do the following:

• Obtain named value information for a method parameter
• Resolve names into argument values
• Handle missing argument values when argument values are required
• Optionally handle a resolved value

A default value string can contain ${...} placeholders and Spring Expression Language #{...} expressions. For this to work a ConfigurableBeanFactory must be supplied to the class constructor.

A ConversionService may be used to apply type conversion to the resolved argument value if it doesn't match the method parameter type.

Abstract base class for resolving method arguments from a named value. Request parameters, request headers, and path variables are examples of named values. Each may have a name, a required flag, and a default value.

Subclasses define how to do the following:

• Obtain named value information for a method parameter
• Resolve names into argument values
• Handle missing argument values when argument values are required
• Optionally handle a resolved value

A default value string can contain ${...} placeholders and Spring Expression Language #{...} expressions. For this to work a ConfigurableBeanFactory must be supplied to the class constructor.

A WebDataBinder is created to apply type conversion to the resolved argument value if it doesn't match the method parameter type.

Abstract formatter for Numbers, providing a #getNumberFormat(java.util.Locale) template method.

Abstract superclass for PDF views that operate on an existing document with an AcroForm. Application-specific view classes will extend this class to merge the PDF form with model data.

This view implementation uses Bruno Lowagie's iText package. Known to work with iText 2.1.7 as well as its fork OpenPDF.

Thanks to Bryant Larsen for the suggestion and the original prototype!

Abstract superclass for PDF views. Application-specific view classes will extend this class. The view will be held in the subclass itself, not in a template.

This view implementation uses Bruno Lowagie's iText package. Known to work with iText 2.1.7 as well as its fork OpenPDF.

Note: Internet Explorer requires a ".pdf" extension, as it doesn't always respect the declared content type.

Base class for a org.springframework.web.WebApplicationInitializer that installs a Spring Reactive Web Application on a Servlet container.

Spring configuration is loaded and given to WebHttpHandlerBuilder which scans the context looking for specific beans and creates a reactive HttpHandler. The resulting handler is installed as a Servlet through the ServletHttpHandlerAdapter.

Abstract org.springframework.aop.TargetSource implementation that wraps a refreshable target object. Subclasses can determine whether a refresh is required, and need to provide fresh target objects.

Implements the Refreshable interface in order to allow for explicit control over the refresh status.

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 will be invoked again on deserialization.

A base class for RequestCondition types providing implementations of #equals(Object), #hashCode(), and #toString().

A base class for RequestCondition types providing implementations of #equals(Object), #hashCode(), and #toString().

Abstract superclass for RSS Feed views, using the ROME package.

>NOTE: As of Spring 4.1, this is based on the com.rometools variant of ROME, version 1.5. Please upgrade your build dependency.

Application-specific view classes will extend this class. The view will be held in the subclass itself, not in a template. Main entry points are the #buildFeedMetadata and #buildFeedItems.

Thanks to Jettro Coenradie and Sergio Bossa for the original feed view prototype!

Base class for org.springframework.web.WebApplicationInitializer implementations that register a ServletHttpHandlerAdapter in the servlet context.

Convenient base class for when there exists a one-to-one mapping between attribute names on the element that is to be parsed and the property names on the Class being configured.

Extend this parser class when you want to create a single bean definition from a relatively simple custom XML element. The resulting BeanDefinition will be automatically registered with the relevant org.springframework.beans.factory.support.BeanDefinitionRegistry.

An example will hopefully make the use of this particular parser class immediately clear. Consider the following class definition:

public class SimpleCache implements Cache { public void setName(String name) {...} public void setTimeout(int timeout) {...} public void setEvictionPolicy(EvictionPolicy policy) {...} // remaining class definition elided for clarity... }

Then let us assume the following XML tag has been defined to permit the easy configuration of instances of the above class;

<caching:cache name="..." timeout="..." eviction-policy="..."/>

All that is required of the Java developer tasked with writing the parser to parse the above XML tag into an actual SimpleCache bean definition is the following:

public class SimpleCacheBeanDefinitionParser extends AbstractSimpleBeanDefinitionParser { protected Class getBeanClass(Element element) { return SimpleCache.class; } }

Please note that the AbstractSimpleBeanDefinitionParser is limited to populating the created bean definition with property values. if you want to parse constructor arguments and nested elements from the supplied XML element, then you will have to implement the #postProcess(org.springframework.beans.factory.support.BeanDefinitionBuilder, org.w3c.dom.Element) method and do such parsing yourself, or (more likely) subclass the AbstractSingleBeanDefinitionParser or AbstractBeanDefinitionParser classes directly.

The process of actually registering the SimpleCacheBeanDefinitionParser with the Spring XML parsing infrastructure is described in the Spring Framework reference documentation (in one of the appendices).

For an example of this parser in action (so to speak), do look at the source code for the org.springframework.beans.factory.xml.UtilNamespaceHandler.PropertiesBeanDefinitionParser; the observant (and even not so observant) reader will immediately notice that there is next to no code in the implementation. The PropertiesBeanDefinitionParser populates a org.springframework.beans.factory.config.PropertiesFactoryBean from an XML element that looks like this:

<util:properties location="jdbc.properties"/>

The observant reader will notice that the sole attribute on the <util:properties/> element matches the org.springframework.beans.factory.config.PropertiesFactoryBean#setLocation(org.springframework.core.io.Resource) method name on the PropertiesFactoryBean (the general usage thus illustrated holds true for any number of attributes). All that the PropertiesBeanDefinitionParser needs actually do is supply an implementation of the #getBeanClass(org.w3c.dom.Element) method to return the PropertiesFactoryBean type.

Base class for those BeanDefinitionParser implementations that need to parse and define just a single BeanDefinition.

Extend this parser class when you want to create a single bean definition from an arbitrarily complex XML element. You may wish to consider extending the AbstractSimpleBeanDefinitionParser when you want to create a single bean definition from a relatively simple custom XML element.

The resulting BeanDefinition will be automatically registered with the org.springframework.beans.factory.support.BeanDefinitionRegistry. Your job simply is to parse the custom XML Element into a single BeanDefinition.

Abstract base class for org.springframework.core.codec.Encoder classes that can only deal with a single value.

Convenient superclass for FactoryBean types that produce singleton-scoped proxy objects.

Manages pre- and post-interceptors (references, rather than interceptor names, as in ProxyFactoryBean) and provides consistent interface management.

An base class for SockJS message codec that provides an implementation of #encode(String[]).

An abstract base class for SockJsService implementations that provides SockJS path resolution and handling of static SockJS requests (e.g. "/info", "/iframe.html", etc). Sub-classes must handle session URLs (i.e. transport-specific requests). By default, only same origin requests are allowed. Use #setAllowedOrigins to specify a list of allowed origins (a list containing "*" will allow all origins).

Abstract implementation of the SqlTypeValue interface, for convenient creation of type values that are supposed to be passed into the PreparedStatement.setObject method. The createTypeValue callback method has access to the underlying Connection, if that should be needed to create any database-specific objects.

A usage example from a StoredProcedure (compare this to the plain SqlTypeValue version in the superclass javadoc):

proc.declareParameter(new SqlParameter("myarray", Types.ARRAY, "NUMBERS")); ... Map<String, Object> in = new HashMap<String, Object>(); in.put("myarray", new AbstractSqlTypeValue() { public Object createTypeValue(Connection con, int sqlType, String typeName) throws SQLException { oracle.sql.ArrayDescriptor desc = new oracle.sql.ArrayDescriptor(typeName, con); return new oracle.sql.ARRAY(desc, con, seats); } }); Map out = execute(in); 

A base class for RequestUpgradeStrategy implementations that build on the standard WebSocket API for Java (JSR-356).

Abstract base class for template view resolvers, in particular for FreeMarker views.

Provides a convenient way to specify AbstractTemplateView's exposure flags for request attributes, session attributes, and Spring's macro helpers.

Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a TestNG environment.

Concrete subclasses:

• Typically declare a class-level ContextConfiguration annotation to configure the ApplicationContext resource locations or annotated classes. If your test does not need to load an application context, you may choose to omit the @ContextConfiguration declaration and to configure the appropriate org.springframework.test.context.TestExecutionListener manually.
• Must have constructors which either implicitly or explicitly delegate to super();.

The following org.springframework.test.context.TestExecutionListener are configured by default:

• org.springframework.test.context.web.ServletTestExecutionListener
• org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener
• org.springframework.test.context.support.DependencyInjectionTestExecutionListener
• org.springframework.test.context.support.DirtiesContextTestExecutionListener

Base MethodInterceptor implementation for tracing.

By default, log messages are written to the log for the interceptor class, not the class which is being intercepted. Setting the useDynamicLogger bean property to true causes all log messages to be written to the Log for the target class being intercepted.

Subclasses must implement the invokeUnderTrace method, which is invoked by this class ONLY when a particular invocation SHOULD be traced. Subclasses should write to the Log instance provided.

Abstract Transactional extension of AbstractJUnit4SpringContextTests which adds convenience functionality for JDBC access. Expects a DataSource bean and a PlatformTransactionManager bean to be defined in the Spring ApplicationContext.

This class exposes a JdbcTemplate and provides an easy way to count the number of rows in a table (potentially with a WHERE clause), delete from tables, drop tables, and execute SQL scripts within a transaction.

Concrete subclasses must fulfill the same requirements outlined in AbstractJUnit4SpringContextTests.

The following org.springframework.test.context.TestExecutionListener are configured by default:

• org.springframework.test.context.web.ServletTestExecutionListener
• org.springframework.test.context.support.DependencyInjectionTestExecutionListener
• org.springframework.test.context.support.DirtiesContextTestExecutionListener
• org.springframework.test.context.transaction.TransactionalTestExecutionListener
• org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener

This class serves only as a convenience for extension.

• If you do not wish for your test classes to be tied to a Spring-specific class hierarchy, you may configure your own custom test classes by using SpringRunner, ContextConfiguration, TestExecutionListeners, etc.
• If you wish to extend this class and use a runner other than the SpringRunner, as of Spring Framework 4.2 you can use org.springframework.test.context.junit4.rules.SpringClassRule and org.springframework.test.context.junit4.rules.SpringMethodRule and specify your runner of choice via org.junit.runner.RunWith.

NOTE: As of Spring Framework 4.3, this class requires JUnit 4.12 or higher.

Abstract Transactional extension of AbstractTestNGSpringContextTests which adds convenience functionality for JDBC access. Expects a DataSource bean and a PlatformTransactionManager bean to be defined in the Spring ApplicationContext.

This class exposes a JdbcTemplate and provides an easy way to count the number of rows in a table (potentially with a WHERE clause), delete from tables, drop tables, and execute SQL scripts within a transaction.

Concrete subclasses must fulfill the same requirements outlined in AbstractTestNGSpringContextTests.

The following org.springframework.test.context.TestExecutionListener are configured by default:

• org.springframework.test.context.web.ServletTestExecutionListener
• org.springframework.test.context.support.DependencyInjectionTestExecutionListener
• org.springframework.test.context.support.DirtiesContextTestExecutionListener
• org.springframework.test.context.transaction.TransactionalTestExecutionListener
• org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener

Type filter that is aware of traversing over hierarchy.

This filter is useful when matching needs to be made based on potentially the whole class/interface hierarchy. The algorithm employed uses a succeed-fast strategy: if at any time a match is declared, no further processing is carried out.

A base class for RequestUpgradeStrategy implementations on top of JSR-356 based servers which include Tyrus as their WebSocket engine.

Works with Tyrus 1.11 (WebLogic 12.2.1) and Tyrus 1.12 (GlassFish 4.1.1).

Abstract base class for URL-based views. Provides a consistent way of holding the URL that a View wraps, in the form of a "url" bean property.

Abstract base class for VersionStrategy implementations.

Supports versions as:

• prefix in the request path, like "version/static/myresource.js"
• file name suffix in the request path, like "static/myresource-version.js"

Note: This base class does not provide support for generating the version string.

An abstract base class adapting a WebArgumentResolver to the HandlerMethodArgumentResolver contract.

Note: This class is provided for backwards compatibility. However it is recommended to re-write a WebArgumentResolver as HandlerMethodArgumentResolver. Since #supportsParameter can only be implemented by actually resolving the value and then checking the result is not WebArgumentResolver#UNRESOLVED any exceptions raised must be absorbed and ignored since it's not clear whether the adapter doesn't support the parameter or whether it failed for an internal reason. The HandlerMethodArgumentResolver contract also provides access to model attributes and to WebDataBinderFactory (for type conversion).

Base class for WebSocketHandlerRegistrations that gathers all the configuration options but allows sub-classes to put together the actual HTTP request mappings.

A message that can be handled or sent on a WebSocket connection.

A convenient abstract base class for WebSocketMessageBrokerConfigurer implementations providing empty method implementations for optional methods.

Convenient base class for WebSocketSession implementations that holds common fields and exposes accessors. Also implements the WebSocketMessage factory methods.

An abstract base class for implementations of WebSocketSession.

Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant. Compatible with Apache POI 3.9 and higher.

For working with the workbook in subclasses, see Apache's POI site.

Convenient base class for org.springframework.context.ApplicationContext implementations, drawing configuration from XML documents containing bean definitions understood by an org.springframework.beans.factory.xml.XmlBeanDefinitionReader.

Subclasses just have to implement the #getConfigResources and/or the #getConfigLocations method. Furthermore, they might override the #getResourceByPath hook to interpret relative paths in an environment-specific fashion, and/or #getResourcePatternResolver for extended pattern resolution.

LocaleResolver implementation that simply uses the primary locale specified in the "accept-language" header of the HTTP request (that is, the locale sent by the client browser, normally that of the client's OS).

Note: Does not support setLocale, since the accept header can only be changed through changing the client's locale settings.

JobFactory implementation that supports java.lang.Runnable objects as well as standard Quartz org.quartz.Job instances.

Compatible with Quartz 2.1.4 and higher, as of Spring 4.1.

ParseState entry representing an advice element.

Convenient base class for ImportSelector implementations that select imports based on an AdviceMode value from an annotation (such as the @Enable* annotations).

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.

BeanPostProcessor that registers AdvisorAdapter beans in the BeanFactory with an AdvisorAdapterRegistry (by default the GlobalAdvisorAdapterRegistry).

The only requirement for it to work is that it needs to be defined in application context along with "non-native" Spring AdvisorAdapters that need to be "recognized" by Spring's AOP framework.

org.springframework.beans.factory.parsing.ComponentDefinition that bridges the gap between the advisor bean definition configured by the <aop:advisor> tag and the component definition infrastructure.

ParseState entry representing an advisor.

Interceptor to wrap an org.springframework.aop.AfterReturningAdvice. Used internally by the AOP framework; application developers should not need to use this class directly.

Test annotation which indicates that the annotated void method should be executed after a transaction is ended for a test method configured to run within a transaction via Spring's @Transactional annotation.

As of Spring Framework 4.3, @AfterTransaction may be declared on Java 8 based interface default methods.

@AfterTransaction methods declared in superclasses or as interface default methods will be executed after those of the current test class.

As of Spring Framework 4.0, this annotation may be used as a meta-annotation to create custom composed annotations.

Representation of an alias that has been registered during the parsing process.

Extension of org.springframework.http.converter.FormHttpMessageConverter, adding support for XML and JSON-based parts.

An IdGenerator that uses SecureRandom for the initial seed and Random thereafter, instead of calling UUID#randomUUID() every time as org.springframework.util.JdkIdGenerator does. This provides a better balance between securely random ids and performance.

Extended org.springframework.beans.factory.config.BeanDefinition interface that exposes org.springframework.core.type.AnnotationMetadata about its bean class - without requiring the class to be loaded yet.

Convenient adapter for programmatic registration of annotated bean classes. This is an alternative to ClassPathBeanDefinitionScanner, applying the same resolution of annotations but for explicitly registered classes only.

General utility methods for finding annotations, meta-annotations, and repeatable annotations on AnnotatedElement.

AnnotatedElementUtils defines the public API for Spring's meta-annotation programming model with support for annotation attribute overrides. If you do not need support for annotation attribute overrides, consider using AnnotationUtils instead.

Note that the features of this class are not provided by the JDK's introspection facilities themselves.

Support for meta-annotations with attribute overrides in composed annotations is provided by all variants of the getMergedAnnotationAttributes(), getMergedAnnotation(), getAllMergedAnnotations(), getMergedRepeatableAnnotations(), findMergedAnnotationAttributes(), findMergedAnnotation(), findAllMergedAnnotations(), and findMergedRepeatableAnnotations() methods.

The search algorithms used by methods in this class follow either find or get semantics. Consult the javadocs for each individual method for details on which search algorithm is used.

Get semantics are limited to searching for annotations that are either present on an AnnotatedElement (i.e., declared locally or java.lang.annotation.Inherited) or declared within the annotation hierarchy above the AnnotatedElement.

Find semantics are much more exhaustive, providing get semantics plus support for the following:

• Searching on interfaces, if the annotated element is a class
• Searching on superclasses, if the annotated element is a class
• Resolving bridged methods, if the annotated element is a method
• Searching on methods in interfaces, if the annotated element is a method
• Searching on methods in superclasses, if the annotated element is a method

Methods following get semantics will honor the contract of Java's java.lang.annotation.Inherited annotation except that locally declared annotations (including custom composed annotations) will be favored over inherited annotations. In contrast, methods following find semantics will completely ignore the presence of @Inherited since the find search algorithm manually traverses type and method hierarchies and thereby implicitly supports annotation inheritance without the need for @Inherited.

A WebSocket connection manager that is given a URI, a javax.websocket.ClientEndpoint-annotated endpoint, connects to a WebSocket server through the #start() and #stop() methods. If #setAutoStartup(boolean) is set to true this will be done automatically when the Spring ApplicationContext is refreshed.

Extension of the org.springframework.beans.factory.support.GenericBeanDefinition class, adding support for annotation metadata exposed through the AnnotatedBeanDefinition interface.

This GenericBeanDefinition variant is mainly useful for testing code that expects to operate on an AnnotatedBeanDefinition, for example strategy implementations in Spring's component scanning support (where the default definition class is org.springframework.context.annotation.ScannedGenericBeanDefinition, which also implements the AnnotatedBeanDefinition interface).

Specialization of AsyncExecutionInterceptor that delegates method execution to an Executor based on the Async annotation. Specifically designed to support use of Async#value() executor qualification mechanism introduced in Spring 3.1.2. Supports detecting qualifier metadata via @Async at the method or declaring class level. See #getExecutorQualifier(Method) for details.

AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.

Any AspectJ annotated classes will automatically be recognized, and their advice applied if Spring AOP's proxy-based model is capable of applying it. This covers method execution joinpoints.

If the <aop:include> element is used, only @AspectJ beans with names matched by an include pattern will be considered as defining aspects to use for Spring auto-proxying.

Processing of Spring Advisors follows the rules established in org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator.

org.springframework.beans.factory.support.BeanNameGenerator implementation for bean classes annotated with the org.springframework.stereotype.Component annotation or with another annotation that is itself annotated with org.springframework.stereotype.Component as a meta-annotation. For example, Spring's stereotype annotations (such as org.springframework.stereotype.Repository) are themselves annotated with org.springframework.stereotype.Component.

Also supports Java EE 6's javax.annotation.ManagedBean and JSR-330's javax.inject.Named annotations, if available. Note that Spring component annotations always override such standard annotations.

If the annotation's value doesn't indicate a bean name, an appropriate name will be built based on the short name of the class (with the first letter lower-cased). For example:

com.xyz.FooServiceImpl -> fooServiceImpl

General utility methods for working with annotations in JavaBeans style.

org.springframework.beans.factory.wiring.BeanWiringInfoResolver that uses the Configurable annotation to identify which classes need autowiring. The bean name to look up will be taken from the Configurable annotation if specified; otherwise the default will be the fully-qualified name of the class being configured.

Implementation of the org.springframework.cache.interceptor.CacheOperationSource interface for working with caching metadata in annotation format.

This class reads Spring's Cacheable, CachePut and CacheEvict annotations and exposes corresponding caching operation definition to Spring's cache infrastructure. This class may also serve as base class for a custom CacheOperationSource.

Parser for the <context:annotation-config/> element.

Concrete implementation of AbstractGenericContextLoader that loads bean definitions from annotated classes.

See the Javadoc for org.springframework.test.context.ContextConfiguration for a definition of annotated class.

Note: AnnotationConfigContextLoader supports annotated classes rather than the String-based resource locations defined by the legacy org.springframework.test.context.ContextLoader API. Thus, although AnnotationConfigContextLoader extends AbstractGenericContextLoader, AnnotationConfigContextLoader does not support any String-based methods defined by AbstractContextLoader or AbstractGenericContextLoader. Consequently, AnnotationConfigContextLoader should chiefly be considered a org.springframework.test.context.SmartContextLoader rather than a org.springframework.test.context.ContextLoader.

Utility methods for SmartContextLoader that deal with annotated classes (e.g., Configuration classes).

org.springframework.web.context.WebApplicationContext implementation which accepts annotated classes as input - in particular org.springframework.context.annotation.Configuration-annotated classes, but also plain org.springframework.stereotype.Component classes and JSR-330 compliant classes using javax.inject annotations. Allows for registering classes one by one (specifying class names as config location) as well as for classpath scanning (specifying base packages as config location).

This is essentially the equivalent of org.springframework.context.annotation.AnnotationConfigApplicationContext for a web environment.

To make use of this application context, the "contextClass" context-param for ContextLoader and/or "contextClass" init-param for FrameworkServlet must be set to the fully-qualified name of this class.

As of Spring 3.1, this class may also be directly instantiated and injected into Spring's DispatcherServlet or ContextLoaderListener when using the new org.springframework.web.WebApplicationInitializer code-based alternative to web.xml. See its Javadoc for details and usage examples.

Unlike XmlWebApplicationContext, no default configuration class locations are assumed. Rather, it is a requirement to set the "contextConfigLocation" context-param for ContextLoader and/or "contextConfigLocation" init-param for FrameworkServlet. The param-value may contain both fully-qualified class names and base packages to scan for components. See #loadBeanDefinitions for exact details on how these locations are processed.

As an alternative to setting the "contextConfigLocation" parameter, users may implement an org.springframework.context.ApplicationContextInitializer and set the "contextInitializerClasses" context-param / init-param. In such cases, users should favor the #refresh() and #scan(String...) methods over the #setConfigLocation(String) method, which is primarily for use by ContextLoader.

Note: In case of multiple @Configuration classes, later @Bean definitions will override ones defined in earlier loaded files. This can be leveraged to deliberately override certain bean definitions via an extra Configuration class.

Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from annotated classes.

See the Javadoc for org.springframework.test.context.ContextConfiguration for a definition of annotated class.

Note: AnnotationConfigWebContextLoader supports annotated classes rather than the String-based resource locations defined by the legacy org.springframework.test.context.ContextLoader API. Thus, although AnnotationConfigWebContextLoader extends AbstractGenericWebContextLoader, AnnotationConfigWebContextLoader does not support any String-based methods defined by org.springframework.test.context.support.AbstractContextLoader or AbstractGenericWebContextLoader. Consequently, AnnotationConfigWebContextLoader should chiefly be considered a org.springframework.test.context.SmartContextLoader rather than a org.springframework.test.context.ContextLoader.

Thrown by AnnotationUtils and synthesized annotations if an annotation is improperly configured.

Parser for the 'annotation-driven' element of the 'task' namespace.

A sub-class of AbstractExceptionHandlerMethodResolver that looks for MessageExceptionHandler-annotated methods in a given class. The actual exception types handled are extracted either from the annotation, if present, or from the method signature as a fallback option.

Implementation of the JmxAttributeSource interface that reads annotations and exposes the corresponding attributes.

Simple Pointcut that looks for a specific Java 5 annotation being present on a class or method.

ASM class visitor which looks for the class name and implemented types as well as for the annotations defined on the class, exposing them through the org.springframework.core.type.AnnotationMetadata interface.

A ScopeMetadataResolver implementation that by default checks for the presence of Spring's Scope annotation on the bean class.

The exact type of annotation that is checked for is configurable via #setScopeAnnotationType(Class).

Implementation of the org.springframework.transaction.interceptor.TransactionAttributeSource interface for working with transaction metadata in JDK 1.5+ annotation format.

This class reads Spring's JDK 1.5+ Transactional annotation and exposes corresponding transaction attributes to Spring's transaction infrastructure. Also supports JTA 1.2's javax.transaction.Transactional and EJB3's javax.ejb.TransactionAttribute annotation (if present). This class may also serve as base class for a custom TransactionAttributeSource, or get customized through TransactionAnnotationParser strategies.

Utility class for handling registration of AOP auto-proxy creators.

Only a single auto-proxy creator can be registered yet multiple concrete implementations are available. Therefore this class wraps a simple escalation protocol, allowing classes to request a particular auto-proxy creator and know that class, or a subclass thereof, will eventually be resident in the application context.

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.

Spring's 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 on the invocation. However, this approach should not be used when there is a reasonable alternative, as it makes application code dependent on usage under AOP and the Spring AOP framework in particular.

Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues.

NamespaceHandler for the aop namespace.

Provides a org.springframework.beans.factory.xml.BeanDefinitionParser for the <aop:config> tag. A config tag can include nested pointcut, advisor and aspect tags.

The pointcut tag allows for creation of named AspectJExpressionPointcut beans using a simple syntax:

 <aop:pointcut id="getNameCalls" expression="execution(* *..ITestBean.getName(..))"/> 

Using the advisor tag you can configure an org.springframework.aop.Advisor and have it applied to all relevant beans in you org.springframework.beans.factory.BeanFactory automatically. The advisor tag supports both in-line and referenced org.springframework.aop.Pointcut:

 <aop:advisor id="getAgeAdvisor" pointcut="execution(* *..ITestBean.getAge(..))" advice-ref="getAgeCounter"/> <aop:advisor id="getNameAdvisor" pointcut-ref="getNameCalls" advice-ref="getNameCounter"/>

Utility class for handling registration of auto-proxy creators used internally by the 'aop' namespace tags.

Only a single auto-proxy creator can be registered and multiple tags may wish to register different concrete implementations. As such this class delegates to AopConfigUtils which wraps a simple escalation protocol. Therefore classes may request a particular auto-proxy creator and know that class, or a subclass thereof, will eventually be resident in the application context.

Utility methods for AOP support code.

Mainly for internal use within Spring's AOP support.

See org.springframework.aop.framework.AopProxyUtils for a collection of framework-specific AOP utility methods which depend on internals of Spring's AOP framework implementation.

A ResourceTransformer HTML5 AppCache manifests.

This transformer:

• modifies links to match the public URL paths that should be exposed to clients, using configured ResourceResolver strategies
• appends a comment in the manifest, containing a Hash (e.g. "# Hash: 9de0f09ed7caf84e885f1f0f11c7e326"), thus changing the content of the manifest in order to trigger an appcache reload in the browser.

All files with an ".appcache" file extension (or the extension given to the constructor) will be transformed by this class. The hash is computed using the content of the appcache manifest so that changes in the manifest should invalidate the browser cache. This should also work with changes in referenced resources whose links are also versioned.

A ResourceTransformer implementation that helps handling resources within HTML5 AppCache manifests for HTML5 offline applications.

This transformer:

• modifies links to match the public URL paths that should be exposed to clients, using configured ResourceResolver strategies
• appends a comment in the manifest, containing a Hash (e.g. "# Hash: 9de0f09ed7caf84e885f1f0f11c7e326"), thus changing the content of the manifest in order to trigger an appcache reload in the browser.

All files that have the ".appcache" file extension, or the extension given in the constructor, will be transformed by this class. This hash is computed using the content of the appcache manifest and the content of the linked resources; so changing a resource linked in the manifest or the manifest itself should invalidate the browser cache.

In order to serve manifest files with the proper "text/manifest" content type, it is required to configure it with contentNegotiationConfigurer.mediaType("appcache", MediaType.valueOf("text/manifest") in a WebMvcConfigurer.

Exception thrown during application context initialization.

GenericApplicationListener adapter that delegates the processing of an event to an EventListener annotated method.

Delegates to #processEvent(ApplicationEvent) to give sub-classes a chance to deviate from the default. Unwraps the content of a PayloadApplicationEvent if necessary to allow method declaration to define any arbitrary event type. If a condition is defined, it is evaluated prior to invoking the underlying method.

Convenient superclass for application objects that want to be aware of the application context, e.g. for custom lookup of collaborating beans or for context-specific resource access. It saves the application context reference and provides an initialization callback method. Furthermore, it offers numerous convenience methods for message lookup.

There is no requirement to subclass this class: It just makes things a little easier if you need access to the context, e.g. for access to file resources or to the message source. Note that many application objects do not need to be aware of the application context at all, as they can receive collaborating beans via bean references.

Many framework classes are derived from this class, particularly within the web support.

@ApplicationScope is a specialization of Scope for a component whose lifecycle is bound to the current web application.

Specifically, @ApplicationScope is a composed annotation that acts as a shortcut for @Scope("application") with the default #proxyMode set to TARGET_CLASS.

@ApplicationScope may be used as a meta-annotation to create custom composed annotations.

Subclass of MethodInvoker that tries to convert the given arguments for the actual target method via a TypeConverter.

Supports flexible argument conversions, in particular for invoking a specific overloaded method.

Simple adapter for PreparedStatementSetter that applies a given array of arguments.

The <argument> tag is based on the JSTL fmt:param tag. The purpose is to support arguments inside the message and theme tags.

This tag must be nested under an argument aware tag.

Simple adapter for PreparedStatementSetter that applies given arrays of arguments and JDBC argument types.

org.springframework.beans.factory.parsing.ComponentDefinition that holds an aspect definition, including its nested pointcuts.

ParseState entry representing an aspect.

Superclass for all AOP infrastructure exceptions. Unchecked, as such exceptions are fatal and end user code shouldn't be forced to catch them.

ParameterNameDiscoverer implementation that tries to deduce parameter names for an advice method from the pointcut expression, returning, and throwing clauses. If an unambiguous interpretation is not available, it returns null.

This class interprets arguments in the following way:

1. If the first parameter of the method is of type JoinPoint or ProceedingJoinPoint, it is assumed to be for passing thisJoinPoint to the advice, and the parameter name will be assigned the value "thisJoinPoint".
2. If the first parameter of the method is of type JoinPoint.StaticPart, it is assumed to be for passing "thisJoinPointStaticPart" to the advice, and the parameter name will be assigned the value "thisJoinPointStaticPart".
3. If a throwingName has been set, and there are no unbound arguments of type Throwable+, then an IllegalArgumentException is raised. If there is more than one unbound argument of type Throwable+, then an AmbiguousBindingException is raised. If there is exactly one unbound argument of type Throwable+, then the corresponding parameter name is assigned the value <throwingName>.
4. If there remain unbound arguments, then the pointcut expression is examined. Let a be the number of annotation-based pointcut expressions (@annotation, @this, @target, @args, @within, @withincode) that are used in binding form. Usage in binding form has itself to be deduced: if the expression inside the pointcut is a single string literal that meets Java variable name conventions it is assumed to be a variable name. If a is zero we proceed to the next stage. If a > 1 then an AmbiguousBindingException is raised. If a == 1, and there are no unbound arguments of type Annotation+, then an IllegalArgumentException is raised. if there is exactly one such argument, then the corresponding parameter name is assigned the value from the pointcut expression.
5. If a returningName has been set, and there are no unbound arguments then an IllegalArgumentException is raised. If there is more than one unbound argument then an AmbiguousBindingException is raised. If there is exactly one unbound argument then the corresponding parameter name is assigned the value <returningName>.
6. If there remain unbound arguments, then the pointcut expression is examined once more for this, target, and args pointcut expressions used in the binding form (binding forms are deduced as described for the annotation based pointcuts). If there remains more than one unbound argument of a primitive type (which can only be bound in args) then an AmbiguousBindingException is raised. If there is exactly one argument of a primitive type, then if exactly one args bound variable was found, we assign the corresponding parameter name the variable name. If there were no args bound variables found an IllegalStateException is raised. If there are multiple args bound variables, an AmbiguousBindingException is raised. At this point, if there remains more than one unbound argument we raise an AmbiguousBindingException. If there are no unbound arguments remaining, we are done. If there is exactly one unbound argument remaining, and only one candidate variable name unbound from this, target, or args, it is assigned as the corresponding parameter name. If there are multiple possibilities, an AmbiguousBindingException is raised.

The behavior on raising an IllegalArgumentException or AmbiguousBindingException is configurable to allow this discoverer to be used as part of a chain-of-responsibility. By default the condition will be logged and the getParameterNames(..) method will simply return null. If the raiseExceptions property is set to true, the conditions will be thrown as IllegalArgumentException and AmbiguousBindingException, respectively.

Was that perfectly clear? ;)

Short version: If an unambiguous binding can be deduced, then it is. If the advice requirements cannot possibly be satisfied, then null is returned. By setting the raiseExceptions property to true, descriptive exceptions will be thrown instead of returning null in the case that the parameter names cannot be discovered.

Utility methods for dealing with AspectJ advisors.

@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based asynchronous method execution.

@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management.

Spring org.springframework.aop.Pointcut implementation that uses the AspectJ weaver to evaluate a pointcut expression.

The pointcut expression value is an AspectJ expression. This can reference other pointcuts and use composition and other operations.

Naturally, as this is to be processed by Spring AOP's proxy-based model, only method execution pointcuts are supported.

Spring AOP Advisor that can be used for any AspectJ pointcut expression.

@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management for standard JSR-107 annotations.

AspectJPointcutAdvisor that adapts an AbstractAspectJAdvice to the org.springframework.aop.PointcutAdvisor interface.

AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well Java 5 annotation style).

Utility methods for working with AspectJ proxies.

@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management.

Implementation of AspectJ's IMessageHandler interface that routes AspectJ weaving messages through the same logging system as the regular Spring messages.

Pass the option...

-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler

to the weaver; for example, specifying the following in a "META-INF/aop.xml file:

<weaver options="..."/>

Post-processor that registers AspectJ's org.aspectj.weaver.loadtime.ClassPreProcessorAgentAdapter with the Spring application context's default org.springframework.instrument.classloading.LoadTimeWeaver.

Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut for the per clause.

Uses AspectJ 5 AJType reflection API, enabling us to work with different AspectJ instantiation models such as "singleton", "pertarget" and "perthis".

Assertion utility class that assists in validating arguments.

Useful for identifying programmer errors early and clearly at runtime.

For example, if the contract of a public method states it does not allow null arguments, Assert can be used to validate that contract. Doing this clearly indicates a contract violation when it occurs and protects the class's invariants.

Typically used to validate method arguments rather than configuration properties, to check for cases that are usually programmer errors rather than configuration errors. In contrast to configuration initialization code, there is usually no point in falling back to defaults in such methods.

This class is similar to JUnit's assertion library. If an argument value is deemed invalid, an IllegalArgumentException is thrown (typically). For example:

 Assert.notNull(clazz, "The class must not be null"); Assert.isTrue(i > 0, "The value must be greater than zero");

Mainly for internal use within the framework; consider Apache's Commons Lang for a more comprehensive suite of String utilities.

Represents assignment. An alternative to calling setValue() for an expression is to use an assign.

Example: 'someNumberProperty=42'

Utilities methods for use in the Ast classes.

Advisor that activates asynchronous method execution through the Async annotation. This annotation can be used at the method and type level in implementation classes as well as in service interfaces.

This advisor detects the EJB 3.1 javax.ejb.Asynchronous annotation as well, treating it exactly like Spring's own Async. Furthermore, a custom async annotation type may get specified through the "asyncAnnotationType" property.

Represents the context of a client-side HTTP request execution.

Used to invoke the next interceptor in the interceptor chain, or - if the calling interceptor is last - execute the request itself.

A convenience AsyncConfigurer that implements all methods so that the defaults are used. Provides a backward compatible alternative of implementing AsyncConfigurer directly.

Base class for asynchronous method execution aspects, such as org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect.

Provides support for executor qualification on a method-by-method basis. AsyncExecutionAspectSupport objects must be constructed with a default Executor, but each individual method may further qualify a specific Executor bean to be used when executing it, e.g. through an annotation attribute.

AOP Alliance MethodInterceptor that processes method invocations asynchronously, using a given org.springframework.core.task.AsyncTaskExecutor. Typically used with the org.springframework.scheduling.annotation.Async annotation.

In terms of target method signatures, any parameter types are supported. However, the return type is constrained to either void or java.util.concurrent.Future. In the latter case, the Future handle returned from the proxy will be an actual asynchronous Future that can be used to track the result of the asynchronous method execution. However, since the target method needs to implement the same signature, it will have to return a temporary Future handle that just passes the return value through (like Spring's org.springframework.scheduling.annotation.AsyncResult or EJB 3.1's javax.ejb.AsyncResult).

When the return type is java.util.concurrent.Future, any exception thrown during the execution can be accessed and managed by the caller. With void return type however, such exceptions cannot be transmitted back. In that case an AsyncUncaughtExceptionHandler can be registered to process such exceptions.

As of Spring 3.1.2 the AnnotationAsyncExecutionInterceptor subclass is preferred for use due to its support for executor qualification in conjunction with Spring's @Async annotation.

Extends HandlerInterceptor with a callback method invoked after the start of asynchronous request handling.

When a handler starts an asynchronous request, the DispatcherServlet exits without invoking postHandle and afterCompletion as it normally does for a synchronous request, since the result of request handling (e.g. ModelAndView) is likely not yet ready and will be produced concurrently from another thread. In such scenarios, #afterConcurrentHandlingStarted is invoked instead, allowing implementations to perform tasks such as cleaning up thread-bound attributes before releasing the thread to the Servlet container.

When asynchronous handling completes, the request is dispatched to the container for further processing. At this stage the DispatcherServlet invokes preHandle, postHandle, and afterCompletion. To distinguish between the initial request and the subsequent dispatch after asynchronous handling completes, interceptors can check whether the javax.servlet.DispatcherType of javax.servlet.ServletRequest is "REQUEST" or "ASYNC".

Note that HandlerInterceptor implementations may need to do work when an async request times out or completes with a network error. For such cases the Servlet container does not dispatch and therefore the postHandle and afterCompletion methods will not be invoked. Instead, interceptors can register to track an asynchronous request through the registerCallbackInterceptor and registerDeferredResultInterceptor methods on org.springframework.web.context.request.async.WebAsyncManager. This can be done proactively on every request from preHandle regardless of whether async request processing will start.

A return value handler that supports async types. Such return value types need to be handled with priority so the async value can be "unwrapped".

Note: implementing this contract is not required but it should be implemented when the handler needs to be prioritized ahead of others. For example custom (async) handlers, by default ordered after built-in handlers, should take precedence over @ResponseBody or @ModelAttribute handling, which should occur once the async value is ready. By contrast, built-in (async) handlers are already ordered ahead of sync handlers.

Callback interface for code that operates on an org.springframework.http.client.AsyncClientHttpRequest. Allows to manipulate the request headers, and write to the request body.

Used internally by the AsyncRestTemplate, but also useful for application code.

Exception to be thrown when an async request times out. Alternatively an applications can register a DeferredResultProcessingInterceptor or a CallableProcessingInterceptor to handle the timeout through the MVC Java config or the MVC XML namespace or directly through properties of the RequestMappingHandlerAdapter.

By default the exception will be handled as a 503 error.

A pass-through Future handle that can be used for method signatures which are declared with a Future return type for asynchronous execution.

As of Spring 4.1, this class implements ListenableFuture, not just plain java.util.concurrent.Future, along with the corresponding support in @Async processing.

As of Spring 4.2, this class also supports passing execution exceptions back to the caller.

Handles return values of type WebAsyncTask.

Extends NativeWebRequest with methods for asynchronous request processing.

Implementation of org.springframework.http.converter.HttpMessageConverter that can read and write Atom feeds. Specifically, this converter can handle Feed objects from the ROME project.

>NOTE: As of Spring 4.1, this is based on the com.rometools variant of ROME, version 1.5. Please upgrade your build dependency.

By default, this converter reads and writes the media type (application/atom+xml). This can be overridden through the supportedMediaTypes property.

Simple List wrapper class that allows for elements to be automatically populated as they are requested. This is particularly useful for data binding to List, allowing for elements to be created and added to the List in a "just in time" fashion.

Note: This class is not thread-safe. To create a thread-safe version, use the java.util.Collections#synchronizedList utility methods.

Inspired by LazyList from Commons Collections.

Registers an auto proxy creator against the current BeanDefinitionRegistry as appropriate based on an @Enable* annotation having mode and proxyTargetClass attributes set to the correct values.

Strategy interface for determining whether a specific bean definition qualifies as an autowire candidate for a specific dependency.

Marks a constructor, field, setter method or config method as to be autowired by Spring's dependency injection facilities.

Only one constructor (at max) of any given bean class may carry this annotation, indicating the constructor to autowire when used as a Spring bean. Such a constructor does not have to be public.

Fields are injected right after construction of a bean, before any config methods are invoked. Such a config field does not have to be public.

Config methods may have an arbitrary name and any number of arguments; each of those arguments will be autowired with a matching bean in the Spring container. Bean property setter methods are effectively just a special case of such a general config method. Such config methods do not have to be public.

In the case of a multi-arg constructor or method, the 'required' parameter is applicable to all arguments. Individual parameters may be declared as Java-8-style java.util.Optional or, as of Spring Framework 5.0, also as @Nullable or a not-null parameter type in Kotlin, overriding the base required semantics.

In case of a java.util.Collection or java.util.Map dependency type, the container autowires all beans matching the declared value type. For such purposes, the map keys must be declared as type String which will be resolved to the corresponding bean names. Such a container-provided collection will be ordered, taking into account org.springframework.core.Ordered/org.springframework.core.annotation.Order values of the target components, otherwise following their registration order in the container. Alternatively, a single matching target bean may also be a generally typed Collection or Map itself, getting injected as such.

Note that actual injection is performed through a org.springframework.beans.factory.config.BeanPostProcessor which in turn means that you cannot use @Autowired to inject references into org.springframework.beans.factory.config.BeanPostProcessor or org.springframework.beans.factory.config.BeanFactoryPostProcessor types. Please consult the javadoc for the AutowiredAnnotationBeanPostProcessor class (which, by default, checks for the presence of this annotation).

org.springframework.beans.factory.config.BeanPostProcessor implementation that autowires annotated fields, setter methods and arbitrary config methods. Such members to be injected are detected through a Java 5 annotation: by default, Spring's Autowired and Value annotations.

Also supports JSR-330's javax.inject.Inject annotation, if available, as a direct alternative to Spring's own @Autowired.

Only one constructor (at max) of any given bean class may carry this annotation with the 'required' parameter set to true, indicating the constructor to autowire when used as a Spring bean. If multiple non-required constructors carry the annotation, they will be considered as candidates for autowiring. The constructor with the greatest number of dependencies that can be satisfied by matching beans in the Spring container will be chosen. If none of the candidates can be satisfied, then a default constructor (if present) will be used. An annotated constructor does not have to be public.

Fields are injected right after construction of a bean, before any config methods are invoked. Such a config field does not have to be public.

Config methods may have an arbitrary name and any number of arguments; each of those arguments will be autowired with a matching bean in the Spring container. Bean property setter methods are effectively just a special case of such a general config method. Config methods do not have to be public.

Note: A default AutowiredAnnotationBeanPostProcessor will be registered by the "context:annotation-config" and "context:component-scan" XML tags. Remove or turn off the default annotation configuration there if you intend to specify a custom AutowiredAnnotationBeanPostProcessor bean definition.

NOTE: Annotation injection will be performed before XML injection; thus the latter configuration will override the former for properties wired through both approaches.

In addition to regular injection points as discussed above, this post-processor also handles Spring's Lookup annotation which identifies lookup methods to be replaced by the container at runtime. This is essentially a type-safe version of getBean(Class, args) and getBean(String, args), See Lookup for details.

Exception thrown when SQL specified is invalid. Such exceptions always have a java.sql.SQLException root cause.

It would be possible to have subclasses for no such table, no such column etc. A custom SQLExceptionTranslator could create such more specific exceptions, without affecting code using this class.

A simple utility class for Base64 encoding and decoding.

Adapts to Java 8's java.util.Base64 in a convenience fashion.

ClientHttpRequestInterceptor to apply a BASIC authorization header.

The base interface that all cache operations must implement.

SqlUpdate subclass that performs batch update operations. Encapsulates queuing up records to be updated, and adds them as a single batch once flush is called or the given batch size has been met.

Note that this class is a non-thread-safe object, in contrast to all other JDBC operations objects in this package. You need to create a new instance of it for each use, or call reset before reuse within the same thread.

Generic utility methods for working with JDBC batch statements. Mainly for internal use within the framework.

ComponentDefinition based on a standard BeanDefinition, exposing the given bean definition as well as inner bean definitions and bean references for the given bean.

Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created). Typically subclassed by AspectJ aspects.

Subclasses may also need a custom metadata resolution strategy, in the BeanWiringInfoResolver interface. The default implementation looks for a bean with the same name as the fully-qualified class name. (This is the default name of the bean in a Spring XML file if the 'id' attribute is not used.)

Exception thrown in case of a bean being requested despite bean creation currently not being allowed (for example, during the shutdown phase of a bean factory).

Exception thrown in case of a reference to a bean that's currently in creation. Typically happens when constructor autowiring matches the currently constructed bean.

Programmatic means of constructing org.springframework.beans.factory.config.BeanDefinition using the builder pattern. Intended primarily for use when implementing Spring 2.0 org.springframework.beans.factory.xml.NamespaceHandler.

A simple holder for BeanDefinition property defaults.

SPI for parsing an XML document that contains Spring bean definitions. Used by XmlBeanDefinitionReader for actually parsing a DOM document.

Instantiated per document to parse: implementations can hold state in instance variables during the execution of the registerBeanDefinitions method — for example, global settings that are defined for all bean definitions in the document.

Class implementing functional bean definition Kotlin DSL.

Exception thrown when a bean definition reader encounters an error during the parsing process.

Extension to the standard BeanFactoryPostProcessor SPI, allowing for the registration of further bean definitions before regular BeanFactoryPostProcessor detection kicks in. In particular, BeanDefinitionRegistryPostProcessor may register further bean definitions which in turn define BeanFactoryPostProcessor instances.

Exception thrown when the validation of a bean definition failed.

Visitor class for traversing BeanDefinition objects, in particular the property values and constructor argument values contained in them, resolving bean metadata values.

Used by PropertyPlaceholderConfigurer to parse all String values contained in a BeanDefinition, resolving any placeholders found.

ParseState entry representing a bean definition.

EL property accessor that knows how to traverse the beans and contextual objects of a Spring org.springframework.beans.factory.config.BeanExpressionContext.

Exception that indicates an expression evaluation attempt having failed.

Strategy interface for resolving a value through evaluating it as an expression, if applicable.

A raw org.springframework.beans.factory.BeanFactory does not contain a default implementation of this strategy. However, org.springframework.context.ApplicationContext implementations will provide expression support out of the box.

EL property accessor that knows how to traverse the beans of a Spring org.springframework.beans.factory.BeanFactory.

Convenience methods performing bean lookups related to annotations, for example Spring's Qualifier annotation.

DataSourceLookup implementation based on a Spring BeanFactory.

Will lookup Spring managed beans identified by bean name, expecting them to be of type javax.sql.DataSource.

DestinationResolver implementation based on a Spring BeanFactory.

Will lookup Spring managed beans identified by bean name, expecting them to be of type javax.jms.Destination.

An implementation of DestinationResolver that interprets a destination name as the bean name of a MessageChannel and looks up the bean in the configured BeanFactory.

Refreshable TargetSource that fetches fresh target beans from a BeanFactory.

Can be subclassed to override requiresRefresh() to suppress unnecessary refreshes. By default, a refresh will be performed every time the "refreshCheckDelay" has elapsed.

EL bean resolver that operates against a Spring org.springframework.beans.factory.BeanFactory.

Convenience methods operating on bean factories, in particular on the ListableBeanFactory interface.

Returns bean counts, bean names or bean instances, taking into account the nesting hierarchy of a bean factory (which the methods defined on the ListableBeanFactory interface don't, in contrast to the methods defined on the BeanFactory interface).

Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails. BeansExceptions thrown by bean factory methods themselves should simply be propagated as-is.

Note that afterPropertiesSet() or a custom "init-method" can throw any exception.

Exception thrown when instantiation of a bean failed. Carries the offending bean class.

Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract.

Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name. Whether a bean is a factory is determined by whether it implements the FactoryBean interface.

Auto proxy creator that identifies beans to proxy via a list of names. Checks for direct, "xxx*", and "*xxx" matches.

For configuration details, see the javadoc of the parent class AbstractAutoProxyCreator. Typically, you will specify a list of interceptor names to apply to all identified beans, via the "interceptorNames" property.

A simple implementation of org.springframework.web.servlet.ViewResolver that interprets a view name as a bean name in the current application context, i.e. typically in the XML file of the executing DispatcherServlet.

This resolver can be handy for small applications, keeping all definitions ranging from controllers to views in the same place. For larger applications, XmlViewResolver will be the better choice, as it separates the XML view bean definitions into a dedicated views file.

Note: Neither this ViewResolver nor XmlViewResolver supports internationalization. Consider ResourceBundleViewResolver if you need to apply different view resources per locale.

Note: This ViewResolver implements the Ordered interface in order to allow for flexible participation in ViewResolver chaining. For example, some special views could be defined via this ViewResolver (giving it 0 as "order" value), while all remaining views could be resolved by a UrlBasedViewResolver.

Thrown when a bean doesn't match the expected type.

RowMapper implementation that converts a row into a new instance of the specified mapped target class. The mapped target class must be a top-level class and it must have a default or no-arg constructor.

Column values are mapped based on matching the column name as obtained from result set metadata to public setters for the corresponding properties. The names are matched either directly or by transforming a name separating the parts with underscores to the same name using "camel" case.

Mapping is provided for fields in the target class for many common types, e.g.: String, boolean, Boolean, byte, Byte, short, Short, int, Integer, long, Long, float, Float, double, Double, BigDecimal, java.util.Date, etc.

To facilitate mapping between columns and fields that don't have matching names, try using column aliases in the SQL statement like "select fname as first_name from customer".

For 'null' values read from the database, we will attempt to call the setter, but in the case of Java primitives, this causes a TypeMismatchException. This class can be configured (using the primitivesDefaultedForNullValue property) to trap this exception and use the primitives default value. Be aware that if you use the values from the generated bean to update the database the primitive value will have been set to the primitive's default value instead of null.

Please note that this class is designed to provide convenience rather than high performance. For best performance, consider using a custom RowMapper implementation.

SqlParameterSource implementation that obtains parameter values from bean properties of a given JavaBean object. The names of the bean properties have to match the parameter names.

Uses a Spring BeanWrapper for bean property access underneath.

Represents a bean reference to a type, for example @foo or @'foo.bar'. For a FactoryBean the syntax &foo can be used to access the factory itself.

Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.

Mainly for use within the framework, but to some degree also useful for application classes.

Simple BeanPostProcessor that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).

EntityResolver implementation for the Spring beans DTD, to load the DTD from the Spring class path (or JAR file).

Fetches "spring-beans.dtd" from the class path resource "/org/springframework/beans/factory/xml/spring-beans.dtd", no matter whether specified as some local URL that includes "spring-beans" in the DTD name or as "http://www.springframework.org/dtd/spring-beans-2.0.dtd".

Test annotation which indicates that the annotated void method should be executed before a transaction is started for a test method configured to run within a transaction via Spring's @Transactional annotation.

As of Spring Framework 4.3, @BeforeTransaction may be declared on Java 8 based interface default methods.

@BeforeTransaction methods declared in superclasses or as interface default methods will be executed before those of the current test class.

As of Spring Framework 4.0, this annotation may be used as a meta-annotation to create custom composed annotations.

A convenient base class for WebSocketHandler implementations that process binary messages only.

Text messages are rejected with CloseStatus#NOT_ACCEPTABLE. All other methods have empty implementations.

This <hasBindErrors> tag provides an Errors instance in case of bind errors. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml). Attribute Summary Attribute Required? Runtime Expression? Description htmlEscape false true Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page. name true true The name of the bean in the request that needs to be inspected for errors. If errors are available for this bean, they will be bound under the 'errors' key.

Thrown when binding errors are considered fatal. Implements the BindingResult interface (and its super-interface Errors) to allow for the direct analysis of binding errors.

As of Spring 2.0, this is a special-purpose class. Normally, application code will work with the BindingResult interface, or with a DataBinder that in turn exposes a BindingResult via org.springframework.validation.DataBinder#getBindingResult().

Simple adapter to expose the bind status of a field or object. Set as a variable by FreeMarker macros and other tag libraries.

Obviously, object status representations (i.e. errors at the object level rather than the field level) do not have an expression and a value but only error codes and messages. For simplicity's sake and to be able to use the same tags and macros, the same status class is used for both scenarios.

Subclass of ConcurrentModel that automatically removes the BindingResult object when its corresponding target attribute is replaced through regular Map operations.

This is the class exposed to handler methods by Spring WebFlux, typically consumed through a declaration of the org.springframework.ui.Model interface as a parameter type. There is typically no need to create it within user code. If necessary a handler method can return a regular java.util.Map, likely a java.util.ConcurrentMap, for a pre-determined model.

Subclass of org.springframework.ui.ExtendedModelMap that automatically removes a org.springframework.validation.BindingResult object if the corresponding target attribute gets replaced through regular Map operations.

This is the class exposed to handler methods by Spring MVC, typically consumed through a declaration of the org.springframework.ui.Model interface. There is no need to build it within user code; a plain org.springframework.ui.ModelMap or even a just a regular Map with String keys will be good enough to return a user model.

Convenience methods for looking up BindingResults in a model Map.

Implementations of BodyExtractor that read various bodies, such a reactive streams.

Implementations of BodyInserter that write various bodies, such a reactive streams, server-sent events, resources, etc.

A Comparator for Boolean objects that can sort either true or false first.

Represents the literal values TRUE and FALSE.

Interface to be implemented by any object that wishes to be notified of the BootstrapContext (typically determined by the ResourceAdapterApplicationContext) that it runs in.

@BootstrapWith defines class-level metadata that is used to determine how to bootstrap the Spring TestContext Framework.

This annotation may also be used as a meta-annotation to create custom composed annotations.

Helper for resolving synthetic bridge Methods to the Method being bridged.

Given a synthetic bridge Method returns the Method being bridged. A bridge method may be created by the compiler when extending a parameterized type whose methods have parameterized arguments. During runtime invocation the bridge Method may be invoked and/or used via reflection. When attempting to locate annotations on Method, it is wise to check for bridge Method as appropriate and find the bridged Method.

See The Java Language Specification for more details on the use of bridge methods.

Event raised when a broker's availabilty changes

Callback for browsing the messages in a JMS queue.

To be used with JmsTemplate's callback methods that take a BrowserCallback argument, often implemented as an anonymous inner class or as a lambda expression.

BeanShell-based implementation of Spring's ScriptEvaluator strategy interface.

org.springframework.scripting.ScriptFactory implementation for a BeanShell script.

Typically used in combination with a org.springframework.scripting.support.ScriptFactoryPostProcessor; see the latter's javadoc for a configuration example.

Implementation of HttpMessageConverter that can read and write BufferedImage.

By default, this converter can read all media types that are supported by the registered image readers, and writes using the media type of the first available registered image writer. The latter can be overridden by setting the defaultContentType property.

If the cacheDir property is set, this converter will cache image data.

The #process(ImageReadParam) and #process(ImageWriteParam) template methods allow subclasses to override Image I/O parameters.

Wrapper for a ClientHttpRequestFactory that buffers all outgoing and incoming streams in memory.

Using this wrapper allows for multiple reads of the

An extension of org.springframework.messaging.simp.stomp.StompDecoder that buffers content remaining in the input ByteBuffer after the parent class has read all (complete) STOMP frames from it. The remaining content represents an incomplete STOMP frame. When called repeatedly with additional data, the decode method returns one or more messages or, if there is not enough data still, continues to buffer.

A single instance of this decoder can be invoked repeatedly to read all messages from a single stream (e.g. WebSocket session) as long as decoding does not fail. If there is an exception, StompDecoder instance should not be used any more as its internal state is not guaranteed to be consistent. It is expected that the underlying session is closed at that point.

The <button> tag renders a form field label in an HTML 'button' tag. It is provided for completeness if the application relies on a RequestDataValueProcessor.

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

id

false

true

HTML Standard Attribute

name

false

true

The name attribute for the HTML button tag

value

false

true

The name attribute for the HTML button tag

Decoder for byte arrays.

Encoder for byte arrays.

Implementation of HttpMessageConverter that can read and write byte arrays.

By default, this converter supports all media types (*/*), and writes with a Content-Type of application/octet-stream. This can be overridden by setting the supportedMediaTypes property.

Custom java.beans.PropertyEditor for converting MultipartFile to byte arrays.

Editor for byte arrays. Strings will simply be converted to their corresponding byte representations.

Resource implementation for a given byte array.

Creates a ByteArrayInputStream for the given byte array.

Useful for loading content from any given byte array, without having to resort to a single-use InputStreamResource. Particularly useful for creating mail attachments from local content, where JavaMail needs to be able to read the stream multiple times.

Decoder for ByteBuffers.

Encoder for ByteBuffers.

Base class for caching aspects, such as the CacheInterceptor or an AspectJ aspect.

This enables the underlying Spring caching infrastructure to be used easily to implement an aspect for any aspect system.

Subclasses are responsible for calling methods in this class in the correct order.

Uses the Strategy design pattern. A CacheResolver implementation will resolve the actual cache(s) to use, and a CacheOperationSource is used for determining caching operations.

A cache aspect is serializable if its CacheResolver and CacheOperationSource are serializable.

NamespaceHandler allowing for the configuration of declarative cache management using either XML or using annotations.

This namespace handler is the central piece of functionality in the Spring cache management facilities.

Proxy factory bean for simplified declarative caching handling. This is a convenient alternative to a standard AOP org.springframework.aop.framework.ProxyFactoryBean with a separate CacheInterceptor definition.

This class is designed to facilitate declarative cache demarcation: namely, wrapping a singleton target object with a caching proxy, proxying all the interfaces that the target implements. Exists primarily for third-party framework integration. Users should favor the cache: XML namespace org.springframework.cache.annotation.Cacheable annotation. See the declarative annotation-based caching section of the Spring reference documentation for more information.

Annotation indicating that a method (or all methods on a class) triggers a cache put operation.

In contrast to the Cacheable annotation, this annotation does not cause the advised method to be skipped. Rather, it always causes the method to be invoked and its result to be stored in the associated cache. Note that Java8's Optional return types are automatically handled and its content is stored in the cache if present.

This annotation may be used as a meta-annotation to create custom composed annotations with attribute overrides.

Class describing a cache 'put' operation.

Shared utility class used to evaluate and cache SpEL expressions that are defined on java.lang.reflect.AnnotatedElement.

Internal class that caches JavaBeans java.beans.PropertyDescriptor information for a Java class. Not intended for direct use by application code.

Necessary for own caching of descriptors within the application's ClassLoader, rather than rely on the JDK's system-wide BeanInfo cache (in order to avoid leaks on ClassLoader shutdown).

Information is cached statically, so we don't need to create new objects of this class for every JavaBean we manipulate. Hence, this class implements the factory design pattern, using a private constructor and a static #forClass(Class) factory method to obtain instances.

Note that for caching to work effectively, some preconditions need to be met: Prefer an arrangement where the Spring jars live in the same ClassLoader as the application classes, which allows for clean caching along with the application's lifecycle in any case. For a web application, consider declaring a local org.springframework.web.util.IntrospectorCleanupListener in web.xml in case of a multi-ClassLoader layout, which will allow for effective caching as well.

In case of a non-clean ClassLoader arrangement without a cleanup listener having been set up, this class will fall back to a weak-reference-based caching model that recreates much-requested entries every time the garbage collector removed them. In such a scenario, consider the #IGNORE_BEANINFO_PROPERTY_NAME system property.

Group annotation for multiple cache annotations (of different or the same type).

This annotation may be used as a meta-annotation to create custom composed annotations with attribute overrides.

Selects which implementation of AbstractCachingConfiguration should be used based on the value of EnableCaching#mode on the importing @Configuration class.

Detects the presence of JSR-107 and enables JCache support accordingly.

An implementation of CachingConfigurer with empty methods allowing sub-classes to override only the methods they're interested in.

SingleConnectionFactory subclass that adds javax.jms.Session caching as well javax.jms.MessageProducer caching. This ConnectionFactory also switches the "reconnectOnException" property to "true" by default, allowing for automatic recovery of the underlying Connection.

By default, only one single Session will be cached, with further requested Sessions being created and disposed on demand. Consider raising the "sessionCacheSize" value in case of a high-concurrency environment.

When using the JMS 1.0.2 API, this ConnectionFactory will switch into queue/topic mode according to the JMS API methods used at runtime: createQueueConnection and createTopicConnection will lead to queue/topic mode, respectively; generic createConnection calls will lead to a JMS 1.1 connection which is able to serve both modes.

NOTE: This ConnectionFactory requires explicit closing of all Sessions obtained from its shared Connection. This is the usual recommendation for native JMS access code anyway. However, with this ConnectionFactory, its use is mandatory in order to actually allow for Session reuse.

Note also that MessageConsumers obtained from a cached Session won't get closed until the Session will eventually be removed from the pool. This may lead to semantic side effects in some cases. For a durable subscriber, the logical Session.close() call will also close the subscription. Re-registering a durable consumer for the same subscription on the same Session handle is not supported; close and reobtain a cached Session first.

Extension of the DestinationResolver interface, exposing methods for clearing the cache.

DestinationResolver implementation that proxies a target DestinationResolver, caching its #resolveDestination results. Such caching is particularly useful if the destination resolving process is expensive (e.g. the destination has to be resolved through an external system) and the resolution results are stable anyway.

A ResourceResolver that resolves resources from a Cache or otherwise delegates to the resolver chain and caches the result.

A org.springframework.web.servlet.resource.ResourceResolver that resolves resources from a org.springframework.cache.Cache or otherwise delegates to the resolver chain and saves the result in the cache.

A ResourceTransformer that checks a Cache to see if a previously transformed resource exists in the cache and returns it if found, or otherwise delegates to the resolver chain and caches the result.

A org.springframework.web.servlet.resource.ResourceTransformer that checks a org.springframework.cache.Cache to see if a previously transformed resource exists in the cache and returns it if found, and otherwise delegates to the resolver chain and saves the result in the cache.

Spring org.springframework.cache.Cache adapter implementation on top of a Caffeine com.github.benmanes.caffeine.cache.Cache instance.

Requires Caffeine 2.1 or higher.

CacheManager implementation that lazily builds CaffeineCache instances for each #getCache request. Also supports a 'static' mode where the set of cache names is pre-defined through #setCacheNames, with no dynamic creation of further cache regions at runtime.

The configuration of the underlying cache can be fine-tuned through a Caffeine builder or CaffeineSpec, passed into this CacheManager through #setCaffeine/#setCaffeineSpec. A CaffeineSpec-compliant expression value can also be applied via the "cacheSpecification" bean property.

Requires Caffeine 2.1 or higher.

Class to manage context metadata used for the configuration and execution of the call.

Interface specifying the API to be implemented by a class providing call metadata.

This is intended for internal use by Spring's org.springframework.jdbc.core.simple.SimpleJdbcCall.

Factory used to create a CallMetaDataProvider implementation based on the type of database being used.

Handles return values of type Callable.

Abstract adapter class for the CallableProcessingInterceptor interface, for simplified implementation of individual methods.

Helper class that efficiently creates multiple CallableStatementCreator objects with different parameters based on a SQL statement and a single set of parameter declarations.

Extension of the org.springframework.transaction.PlatformTransactionManager interface, exposing a method for executing a given callback within a transaction.

Implementors of this interface automatically express a preference for callbacks over programmatic getTransaction, commit and rollback calls. Calling code may check whether a given transaction manager implements this interface to choose to prepare a callback instead of explicit transaction demarcation control.

Spring's TransactionTemplate and org.springframework.transaction.interceptor.TransactionInterceptor detect and use this PlatformTransactionManager variant automatically.

Candidate components index loading mechanism for internal use within the framework.

Annotation Processor that writes CandidateComponentsMetadata file for spring components.

Exception thrown on failure to aquire a lock during an update, for example during a "select for update" statement.

Exception thrown when the creating of a CCI Record failed for connector-internal reasons.

Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.

Fatal exception thrown when we can't connect to an EIS using CCI.

Fatal exception thrown when we can't connect to an RDBMS using JDBC.

Exception thrown when the BeanFactory cannot load the specified class of a given bean.

Thrown by ScriptUtils if an SQL script cannot be read.

Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.

Exception thrown by CastorMarshaller whenever it encounters a mapping problem.

Implementation of the Marshaller interface for Castor. By default, Castor does not require any further configuration, though setting target classes, target packages or providing a mapping file can be used to have more control over the behavior of Castor.

If a target class is specified using setTargetClass, the CastorMarshaller can only be used to unmarshal XML that represents that specific class. If you want to unmarshal multiple classes, you have to provide a mapping file using setMappingLocations.

Due to limitations of Castor's API, it is required to set the encoding used for writing to output streams. It defaults to UTF-8.

XStream Converter that supports all classes, but throws exceptions for (un)marshalling.

The main purpose of this class is to register this converter as a catch-all last converter with a normal or higher priority, in addition to converters that explicitly handle the domain classes that should be supported. As a result, default XStream converters with lower priorities and possible security vulnerabilities do not get invoked.

For instance:

 XStreamMarshaller unmarshaller = new XStreamMarshaller(); unmarshaller.getXStream().registerConverter(new MyDomainClassConverter(), XStream.PRIORITY_VERY_HIGH); unmarshaller.getXStream().registerConverter(new CatchAllConverter(), XStream.PRIORITY_NORMAL); MyDomainClass myObject = unmarshaller.unmarshal(source); 

Convenient super class for CCI-based data access objects.

Requires a javax.resource.cci.ConnectionFactory to be set, providing a org.springframework.jca.cci.core.CciTemplate based on it to subclasses through the #getCciTemplate() method.

This base class is mainly intended for CciTemplate usage but can also be used when working with a Connection directly or when using org.springframework.jca.cci.object classes.

org.springframework.transaction.PlatformTransactionManager implementation that manages local transactions for a single CCI ConnectionFactory. Binds a CCI Connection from the specified ConnectionFactory to the thread, potentially allowing for one thread-bound Connection per ConnectionFactory.

Application code is required to retrieve the CCI Connection via ConnectionFactoryUtils#getConnection(ConnectionFactory) instead of a standard Java EE-style ConnectionFactory#getConnection() call. Spring classes such as org.springframework.jca.cci.core.CciTemplate use this strategy implicitly. If not used in combination with this transaction manager, the ConnectionFactoryUtils lookup strategy behaves exactly like the native DataSource lookup; it can thus be used in a portable fashion.

Alternatively, you can allow application code to work with the standard Java EE lookup pattern ConnectionFactory#getConnection(), for example for legacy code that is not aware of Spring at all. In that case, define a TransactionAwareConnectionFactoryProxy for your target ConnectionFactory, which will automatically participate in Spring-managed transactions.

Exception thrown when the connector doesn't support a specific CCI operation.

Default object instantiation strategy for use in BeanFactories.

Uses CGLIB to generate subclasses dynamically if methods need to be overridden by the container to implement Method Injection.

Implementation of the JMS ExceptionListener interface that supports chaining, allowing the addition of multiple ExceptionListener instances in order.

Implementation of PersistenceExceptionTranslator that supports chaining, allowing the addition of PersistenceExceptionTranslator instances in order. Returns non-null on the first (if any) match.

A ChannelInterceptor base class with empty method implementations as a convenience.

Given a write function that accepts a source Publisher<T> to write with and returns Publisher<Void> for the result, this operator helps to defer the invocation of the write function, until we know if the source publisher will begin publishing without an error. If the first emission is an error, the write function is bypassed, and the error is sent directly through the result publisher. Otherwise the write function is invoked.

Editor for char arrays. Strings will simply be converted to their corresponding char representations.

Encode from a CharSequence stream to a bytes stream.

Editor for a Character, to populate a property of type Character or char from a String value.

Note that the JDK does not contain a default java.beans.PropertyEditor for char! org.springframework.beans.BeanWrapperImpl will register this editor by default.

Also supports conversion from a Unicode character sequence; e.g. u0041 ('A').

Servlet Filter that allows one to specify a character encoding for requests. This is useful because current browsers typically do not set a character encoding even if specified in the HTML page or form.

This filter can either apply its encoding if the request does not already specify an encoding, or enforce this filter's encoding in any case ("forceEncoding"="true"). In the latter case, the encoding will also be applied as default response encoding (although this will usually be overridden by a full content type set in the view).

Editor for java.nio.charset.Charset, translating charset String representations into Charset objects and back.

Expects the same syntax as Charset's java.nio.charset.Charset#name(), e.g. UTF-8, ISO-8859-16, etc.

The <checkbox> tag renders an HTML 'input' tag with type 'checkbox'. May be used in one of three different approaches depending on the type of the bound value. Approach One When the bound value is of type Boolean then the 'input(checkbox)' is marked as 'checked' if the bound value is true. The 'value' attribute corresponds to the resolved value of the value property. Approach Two When the bound value is of type Collection then the 'input(checkbox)' is marked as 'checked' if the configured value is present in the bound Collection. Approach Three For any other bound value type, the 'input(checkbox)' is marked as 'checked' if the configured value is equal to the bound value.

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

HTML Optional Attribute

cssErrorClass

false

true

HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

label

false

true

Value to be displayed as part of the tag

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

value

false

true

HTML Optional Attribute

The <checkboxes> tag renders multiple HTML 'input' tags with type 'checkbox'. Intended to be used with a Collection as the #getItems() bound value.

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

HTML Optional Attribute

cssErrorClass

false

true

HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

HTML Optional Attribute

delimiter

false

true

Delimiter to use between each 'input' tag with type 'checkbox'. There is no delimiter by default.

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

element

false

true

Specifies the HTML element that is used to enclose each 'input' tag with type 'checkbox'. Defaults to 'span'.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

itemLabel

false

true

Value to be displayed as part of the 'input' tags with type 'checkbox'

items

true

true

The Collection, Map or array of objects used to generate the 'input' tags with type 'checkbox'

itemValue

false

true

Name of the property mapped to 'value' attribute of the 'input' tags with type 'checkbox'

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

Bean definition for beans which inherit settings from their parent. Child bean definitions have a fixed dependency on a parent bean definition.

A child bean definition will inherit constructor argument values, property values and method overrides from the parent, with the option to add new values. If init method, destroy method and/or static factory method are specified, they will override the corresponding parent settings. The remaining settings will always be taken from the child definition: depends on, autowire mode, dependency check, singleton, lazy init.

NOTE: Since Spring 2.5, the preferred way to register bean definitions programmatically is the GenericBeanDefinition class, which allows to dynamically define parent dependencies through the GenericBeanDefinition#setParentName method. This effectively supersedes the ChildBeanDefinition class for most use cases.

Property editor for an array of Class, to enable the direct population of a Class[] property without having to use a String class name property as bridge.

Also supports "java.lang.String[]"-style array class names, in contrast to the standard Class#forName(String) method.

Property editor for Class, to enable the direct population of a Class property without recourse to having to use a String class name property as bridge.

Also supports "java.lang.String[]"-style array class names, in contrast to the standard Class#forName(String) method.

Static utility methods for composing ClassFilter.

Simple default implementation of the BeanWiringInfoResolver interface, looking for a bean with the same name as the fully-qualified class name. This matches the default name of the bean in a Spring XML file if the bean tag's "id" attribute is not used.

A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory or ApplicationContext).

Candidate classes are detected through configurable type filters. The default filters include classes that are annotated with Spring's org.springframework.stereotype.Component, org.springframework.stereotype.Repository, org.springframework.stereotype.Service, or org.springframework.stereotype.Controller stereotype.

Also supports Java EE 6's javax.annotation.ManagedBean and JSR-330's javax.inject.Named annotations, if available.

Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g. "mypackage/myresource.txt"). Useful for test harnesses as well as for application contexts embedded within JARs.

The config location defaults can be overridden via #getConfigLocations, Config locations can either denote concrete files like "/myfiles/context.xml" or Ant-style patterns like "/myfiles/*-context.xml" (see the org.springframework.util.AntPathMatcher javadoc for pattern details).

Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files. This can be leveraged to deliberately override certain bean definitions via an extra XML file.

This is a simple, one-stop shop convenience ApplicationContext. Consider using the GenericApplicationContext class in combination with an org.springframework.beans.factory.xml.XmlBeanDefinitionReader for more flexible context setup.

ResourceLoader implementation that interprets plain resource paths as relative to a given java.lang.Class.

A ClassVisitor that generates classes in bytecode form. More precisely this visitor generates a byte array conforming to the Java class file format. It can be used alone, to generate a Java class "from scratch", or with one or more ClassReader and adapter class visitor to generate a modified class from one or more existing Java classes.

Exception thrown when we couldn't cleanup after a data access operation, but the actual operation went OK.

For example, this exception or a subclass might be thrown if a JDBC Connection couldn't be closed after it had been used successfully.

Note that data access code might perform resources cleanup in a finally block and therefore log cleanup failure rather than rethrow it, to keep the original data access exception, if any.

Wraps another ClientHttpRequest and delegates all methods to it. Sub-classes can override specific methods selectively.

Intercepts client-side HTTP requests. Implementations of this interface can be registered with the org.springframework.web.client.RestTemplate, as to modify the outgoing ClientHttpRequest and/or the incoming ClientHttpResponse.

The main entry point for interceptors is #intercept(HttpRequest, byte[], ClientHttpRequestExecution).

Wraps another ClientHttpResponse and delegates all methods to it. Sub-classes can override specific methods selectively.

Represents a typed, immutable, client-side HTTP request, as executed by the ExchangeFunction. Instances of this interface can be created via static builder methods.

Note that applications are more likely to perform requests through WebClient rather than using this directly.

Special ObjectInputStream subclass that falls back to a specified codebase to load classes from if not found locally. In contrast to standard RMI conventions for dynamic class download, it is the client that determines the codebase URL here, rather than the "java.rmi.server.codebase" system property on the server.

Uses the JDK's RMIClassLoader to load classes from the specified codebase. The codebase can consist of multiple URLs, separated by spaces. Note that RMIClassLoader requires a SecurityManager to be set, like when using dynamic class download with standard RMI! (See the RMI documentation for details.)

Despite residing in the RMI package, this class is not used for RmiClientInterceptor, which uses the standard RMI infrastructure instead and thus is only able to rely on RMI's standard dynamic class download via "java.rmi.server.codebase". CodebaseAwareObjectInputStream is used by HttpInvokerClientInterceptor (see the "codebaseUrl" property there).

Thanks to Lionel Mestre for suggesting the option and providing a prototype!

General error that indicates a problem while encoding and decoding to and from an Object stream.

Factory for collections that is aware of Java 5, Java 6, and Spring collection types.

Mainly for internal use within the framework.

Miscellaneous collection utility methods. Mainly for internal use within the framework.

RowMapper implementation that creates a java.util.Map for each row, representing all columns as key-value pairs: one entry for each column, with the column name as key.

The Map implementation to use and the key to use for each column in the column Map can be customized through overriding #createColumnMap and #getColumnKey, respectively.

Note: By default, ColumnMapRowMapper will try to build a linked Map with case-insensitive keys, to preserve column order as well as allow any casing to be used for column names. This requires Commons Collections on the classpath (which will be autodetected). Else, the fallback is a standard linked HashMap, which will still preserve column order but requires the application to specify the column names in the same casing as exposed by the driver.

CCI Record implementation for a COMMAREA, holding a byte array.

Abstract base class for PropertySource implementations backed by command line arguments. The parameterized type T represents the underlying source of command line options. This may be as simple as a String array in the case of SimpleCommandLinePropertySource, or specific to a particular API such as JOpt's OptionSet in the case of JOptCommandLinePropertySource. Purpose and General Usage For use in standalone Spring-based applications, i.e. those that are bootstrapped via a traditional main method accepting a String[] of arguments from the command line. In many cases, processing command-line arguments directly within the main method may be sufficient, but in other cases, it may be desirable to inject arguments as values into Spring beans. It is this latter set of cases in which a CommandLinePropertySource becomes useful. A CommandLinePropertySource will typically be added to the Environment of the Spring ApplicationContext, at which point all command line arguments become available through the Environment#getProperty(String) family of methods. For example:

 public static void main(String[] args) { CommandLinePropertySource clps = ...; AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.getEnvironment().getPropertySources().addFirst(clps); ctx.register(AppConfig.class); ctx.refresh(); }

 @Configuration public class AppConfig { @Inject Environment env; @Bean public void DataSource dataSource() { MyVendorDataSource dataSource = new MyVendorDataSource(); dataSource.setHostname(env.getProperty("db.hostname", "localhost")); dataSource.setUsername(env.getRequiredProperty("db.username")); dataSource.setPassword(env.getRequiredProperty("db.password")); // ... return dataSource; } }

As an alternative to injecting the Environment, Spring's @Value annotation may be used to inject these properties, given that a bean has been registered, either directly or through using the <context:property-placeholder> element. For example:

 @Component public class MyComponent { @Value("my.property:defaultVal") private String myProperty; public void getMyProperty() { return this.myProperty; } // ... }

Individual command line arguments are represented as properties through the usual PropertySource#getProperty(String) and PropertySource#containsProperty(String) methods. For example, given the following command line:

--o1=v1 --o2

 CommandLinePropertySource ps = ... assert ps.containsProperty("o1") == true; assert ps.containsProperty("o2") == true; assert ps.containsProperty("o3") == false; assert ps.getProperty("o1").equals("v1"); assert ps.getProperty("o2").equals(""); assert ps.getProperty("o3") == null; 

Note also that while "--" was used in the examples above to denote an option argument, this syntax may vary across individual command line argument libraries. For example, a JOpt- or Commons CLI-based implementation may allow for single dash ("-") "short" option arguments, etc.

Non-option arguments are also supported through this abstraction. Any arguments supplied without an option-style prefix such as "-" or "--" are considered "non-option arguments" and available through the special property. If multiple non-option arguments are specified, the value of this property will be a comma-delimited string containing all of the arguments. This approach ensures a simple and consistent return type (String) for all properties from a CommandLinePropertySource and at the same time lends itself to conversion when used in conjunction with the Spring Environment and its built-in ConversionService. Consider the following example:

--o1=v1 --o2=v2 /path/to/file1 /path/to/file2

 CommandLinePropertySource ps = ... assert ps.containsProperty("o1") == true; assert ps.containsProperty("o2") == true; assert ps.containsProperty("nonOptionArgs") == true; assert ps.getProperty("o1").equals("v1"); assert ps.getProperty("o2").equals("v2"); assert ps.getProperty("nonOptionArgs").equals("/path/to/file1,/path/to/file2"); 

As mentioned above, when used in conjunction with the Spring Environment abstraction, this comma-delimited string may easily be converted to a String array or list:

 Environment env = applicationContext.getEnvironment(); String[] nonOptionArgs = env.getProperty("nonOptionArgs", String[].class); assert nonOptionArgs[0].equals("/path/to/file1"); assert nonOptionArgs[1].equals("/path/to/file2"); 

The name of the special "non-option arguments" property may be customized through the #setNonOptionArgsPropertyName(String) method. Doing so is recommended as it gives proper semantic value to non-option arguments. For example, if filesystem paths are being specified as non-option arguments, it is likely preferable to refer to these as something like "file.locations" than the default of "nonOptionArgs":

 public static void main(String[] args) { CommandLinePropertySource clps = ...; clps.setNonOptionArgsPropertyName("file.locations"); AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.getEnvironment().getPropertySources().addFirst(clps); ctx.register(AppConfig.class); ctx.refresh(); }

@Commit is a test annotation that is used to indicate that a test-managed transaction should be committed after the test method has completed.

Consult the class-level Javadoc for org.springframework.test.context.transaction.TransactionalTestExecutionListener for an explanation of test-managed transactions.

When declared as a class-level annotation, @Commit defines the default commit semantics for all test methods within the test class hierarchy. When declared as a method-level annotation, @Commit defines commit semantics for the specific test method, potentially overriding class-level default commit or rollback semantics.

Warning: @Commit can be used as direct replacement for @Rollback(false); however, it should not be declared alongside @Rollback. Declaring @Commit and @Rollback on the same test method or on the same test class is unsupported and may lead to unpredictable results.

org.springframework.beans.factory.config.BeanPostProcessor implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in the javax.annotation package. These common Java annotations are supported in many Java EE 5 technologies (e.g. JSF 1.2), as well as in Java 6's JAX-WS.

This post-processor includes support for the javax.annotation.PostConstruct and javax.annotation.PreDestroy annotations - as init annotation and destroy annotation, respectively - through inheriting from InitDestroyAnnotationBeanPostProcessor with pre-configured annotation types.

The central element is the javax.annotation.Resource annotation for annotation-driven injection of named beans, by default from the containing Spring BeanFactory, with only mappedName references resolved in JNDI. The "alwaysUseJndiLookup" flag enforces JNDI lookups equivalent to standard Java EE 5 resource injection for name references and default names as well. The target beans can be simple POJOs, with no special requirements other than the type having to match.

The JAX-WS javax.xml.ws.WebServiceRef annotation is supported too, analogous to javax.annotation.Resource but with the capability of creating specific JAX-WS service endpoints. This may either point to an explicitly defined resource by name or operate on a locally specified JAX-WS service class. Finally, this post-processor also supports the EJB 3 javax.ejb.EJB annotation, analogous to javax.annotation.Resource as well, with the capability to specify both a local bean name and a global JNDI name for fallback retrieval. The target beans can be plain POJOs as well as EJB 3 Session Beans in this case.

The common annotations supported by this post-processor are available in Java 6 (JDK 1.6) as well as in Java EE 5/6 (which provides a standalone jar for its common annotations as well, allowing for use in any Java 5 based application).

For default usage, resolving resource names as Spring bean names, simply define the following in your application context:

 <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

 <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"> <property name="alwaysUseJndiLookup" value="true"/> </bean>

NOTE: A default CommonAnnotationBeanPostProcessor will be registered by the "context:annotation-config" and "context:component-scan" XML tags. Remove or turn off the default annotation configuration there if you intend to specify a custom CommonAnnotationBeanPostProcessor bean definition!

NOTE: Annotation injection will be performed before XML injection; thus the latter configuration will override the former for properties wired through both approaches.

java.io.Writer adapter for a Commons Logging Log.

MultipartFile implementation for Apache Commons FileUpload.

org.springframework.aop.TargetSource implementation that holds objects in a configurable Apache Commons2 Pool.

By default, an instance of GenericObjectPool is created. Subclasses may change the type of ObjectPool used by overriding the createObjectPool() method.

Provides many configuration properties mirroring those of the Commons Pool GenericObjectPool class; these properties are passed to the GenericObjectPool during construction. If creating a subclass of this class to change the ObjectPool implementation type, pass in the values of configuration properties that are relevant to your chosen implementation.

The testOnBorrow, testOnReturn and testWhileIdle properties are explicitly not mirrored because the implementation of PoolableObjectFactory used by this class does not implement meaningful validation. All exposed Commons Pool properties use the corresponding Commons Pool defaults.

Compatible with Apache Commons Pool 2.4, as of Spring 4.2.

Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.

Comparator that adapts Comparables to the Comparator interface. Mainly for internal use in other Comparators, when supposed to work on Comparables.

Support for CompletableFuture (and as of 4.3.7 also CompletionStage) as a return value type.

Adapts a CompletableFuture or CompletionStage into a Spring ListenableFuture.

Parser for the <context:component-scan/> element.

Container annotation that aggregates several ComponentScan annotations.

Can be used natively, declaring several nested ComponentScan annotations. Can also be used in conjunction with Java 8's support for repeatable annotations, where ComponentScan can simply be declared several times on the same method, implicitly generating this container annotation.

Convenient class for building up pointcuts. All methods return ComposablePointcut, so we can use a concise idiom like: Pointcut pc = new ComposablePointcut().union(classFilter).intersection(methodMatcher).intersection(pointcut);

Composite CacheManager implementation that iterates over a given collection of delegate CacheManager instances.

Allows NoOpCacheManager to be automatically added to the end of the list for handling cache declarations without a backing store. Otherwise, any custom CacheManager may play that role of the last delegate as well, lazily creating cache regions for any requested name.

Note: Regular CacheManagers that this composite manager delegates to need to return null from #getCache(String) if they are unaware of the specified cache name, allowing for iteration to the next delegate in line. However, most CacheManager implementations fall back to lazy creation of named caches once requested; check out the specific configuration details for a 'static' mode with fixed cache names, if available.

Composite CacheOperationSource implementation that iterates over a given array of CacheOperationSource instances.

Composite DatabasePopulator that delegates to a list of given DatabasePopulator implementations, executing all scripts.

A generic composite servlet Filter that just delegates its behavior to a chain (list) of user-supplied filters, achieving the functionality of a FilterChain, but conveniently using only Filter instances.

This is useful for filters that require dependency injection, and can therefore be set up in a Spring application context. Typically, this composite would be used in conjunction with DelegatingFilterProxy, so that it can be declared in Spring but applied to a servlet context.

Composite iterator that combines multiple other iterators, as registered via #add(Iterator).

This implementation maintains a linked set of iterators which are invoked in sequence until all iterators are exhausted.

Composite PropertySource implementation that iterates over a set of PropertySource instances. Necessary in cases where multiple property sources share the same name, e.g. when multiple values are supplied to @PropertySource.

As of Spring 4.1.2, this class extends EnumerablePropertySource instead of plain PropertySource, exposing #getPropertyNames() based on the accumulated property names from all contained sources (as far as possible).

Implements the RequestCondition contract by delegating to multiple RequestCondition types and using a logical conjunction (' && ') to ensure all conditions match a given request.

When CompositeRequestCondition instances are combined or compared they are expected to (a) contain the same number of conditions and (b) that conditions in the respective index are of the same type. It is acceptable to provide null conditions or no conditions at all to the constructor.

Implements the RequestCondition contract by delegating to multiple RequestCondition types and using a logical conjunction (' && ') to ensure all conditions match a given request.

When CompositeRequestCondition instances are combined or compared they are expected to (a) contain the same number of conditions and (b) that conditions in the respective index are of the same type. It is acceptable to provide null conditions or no conditions at all to the constructor.

Represents a template expression broken into pieces. Each piece will be an Expression but pure text parts to the template will be represented as LiteralExpression objects. An example of a template expression might be:

 "Hello ${getName()}" 

Composite TransactionAttributeSource implementation that iterates over a given array of TransactionAttributeSource instances.

A UriComponentsContributor containing a list of other contributors to delegate and also encapsulating a specific ConversionService to use for formatting method argument values to Strings.

A comparator that chains a sequence of one or more Comparators.

A compound comparator calls each Comparator in sequence until a single Comparator returns a non-zero result, or the comparators are exhausted and zero is returned.

This facilitates in-memory sorting similar to multi-column sorting in SQL. The order of any single Comparator in the list can also be reversed.

Represents a DOT separated expression sequence, such as 'property1.property2.methodOne()'

Interceptor that throttles concurrent access, blocking invocations if a specified concurrency limit is reached.

Can be applied to methods of local services that involve heavy use of system resources, in a scenario where it is more efficient to throttle concurrency for a specific service rather than restricting the entire thread pool (e.g. the web container's thread pool).

The default concurrency limit of this interceptor is 1. Specify the "concurrencyLimit" bean property to change this value.

Adapter that exposes the java.util.concurrent.Executor interface for any Spring org.springframework.core.task.TaskExecutor.

This is less useful as of Spring 3.0, since TaskExecutor itself extends the Executor interface. The adapter is only relevant for hiding the TaskExecutor nature of a given object now, solely exposing the standard Executor interface to a client.

FactoryBean for easy configuration of a ConcurrentMapCache when used within a Spring container. Can be configured through bean properties; uses the assigned Spring bean name as the default cache name.

Useful for testing or simple caching scenarios, typically in combination with org.springframework.cache.support.SimpleCacheManager or dynamically through ConcurrentMapCacheManager.

Adapter that takes a java.util.concurrent.Executor and exposes a Spring org.springframework.core.task.TaskExecutor for it. Also detects an extended java.util.concurrent.ExecutorService, adapting the org.springframework.core.task.AsyncTaskExecutor interface accordingly.

Autodetects a JSR-236 javax.enterprise.concurrent.ManagedExecutorService in order to expose javax.enterprise.concurrent.ManagedTask adapters for it, exposing a long-running hint based on SchedulingAwareRunnable and an identity name based on the given Runnable/Callable's toString(). For JSR-236 style lookup in a Java EE 7 environment, consider using DefaultManagedTaskExecutor.

Note that there is a pre-built ThreadPoolTaskExecutor that allows for defining a java.util.concurrent.ThreadPoolExecutor in bean style, exposing it as a Spring org.springframework.core.task.TaskExecutor directly. This is a convenient alternative to a raw ThreadPoolExecutor definition with a separate definition of the present adapter class.

Wrap a org.springframework.web.socket.WebSocketSession to guarantee only one thread can send messages at a time.

If a send is slow, subsequent attempts to send more messages from other threads will not be able to acquire the flush lock and messages will be buffered instead. At that time, the specified buffer-size limit and send-time limit will be checked and the session will be closed if the limits are exceeded.

Indicates that a component is only eligible for registration when all specified conditions match.

A condition is any state that can be determined programmatically before the bean definition is due to be registered (see Condition for details).

The @Conditional annotation may be used in any of the following ways:

• as a type-level annotation on any class directly or indirectly annotated with @Component, including Configuration classes
• as a meta-annotation, for the purpose of composing custom stereotype annotations
• as a method-level annotation on any Bean method

If a @Configuration class is marked with @Conditional, all of the @Bean methods, Import annotations, and ComponentScan annotations associated with that class will be subject to the conditions.

NOTE: Inheritance of @Conditional annotations is not supported; any conditions from superclasses or from overridden methods will not be considered. In order to enforce these semantics, @Conditional itself is not declared as java.lang.annotation.Inherited; furthermore, any custom composed annotation that is meta-annotated with @Conditional must not be declared as @Inherited.

Allows a Converter, GenericConverter or ConverterFactory to conditionally execute based on attributes of the source and target TypeDescriptor.

Often used to selectively match custom conversion logic based on the presence of a field or class-level characteristic, such as an annotation or method. For example, when converting from a String field to a Date field, an implementation might return true if the target field has also been annotated with @DateTimeFormat.

As another example, when converting from a String field to an Account field, an implementation might return true if the target Account class defines a public static findAccount(String) method.

Spring-configurable FileTypeMap implementation that will read MIME type to file extension mappings from a standard JavaMail MIME type mapping file, using a standard MimetypesFileTypeMap underneath.

The mapping file should be in the following format, as specified by the Java Activation Framework:

 # map text/html to .htm and .html files text/html html htm HTML HTM

By default, the mappings in the mime.types file located in the same package as this class are used, which cover many common file extensions (in contrast to the out-of-the-box mappings in activation.jar). This can be overridden using the mappingLocation property.

Additional mappings can be added via the mappings bean property, as lines that follow the mime.types file format.

Defines common methods for building a MockMvc.

Marker interface for domain object that need DI through aspects.

Convenient WebBindingInitializer for declarative configuration in a Spring application context. Allows for reusing pre-configured initializers with multiple controller/handlers.

BeanFactoryPostProcessor used for bootstrapping processing of Configuration classes.

Registered by default when using <context:annotation-config/> or <context:component-scan/>. Otherwise, may be declared manually as with any other BeanFactoryPostProcessor.

This post processor is Ordered#HIGHEST_PRECEDENCE as it is important that any Bean methods declared in Configuration classes have their respective bean definitions registered before any other BeanFactoryPostProcessor executes.

A Condition that offers more fine-grained control when used with @Configuration. Allows certain Conditions to adapt when they match based on the configuration phase. For example, a condition that checks if a bean has already been registered might choose to only be evaluated during the REGISTER_BEAN ConfigurationPhase.

Helper class for managing a JMS javax.jms.ConnectionFactory, in particular for obtaining transactional JMS resources for a given ConnectionFactory.

Mainly for internal use within the framework. Used by org.springframework.jms.core.JmsTemplate as well as org.springframework.jms.listener.DefaultMessageListenerContainer.

Connection holder, wrapping a CCI Connection.

CciLocalTransactionManager binds instances of this class to the thread, for a given ConnectionFactory.

Note: This is an SPI class, not intended to be used by applications.

Raised when the connection for a STOMP session is lost rather than closed.

Subinterface of java.sql.Connection to be implemented by Connection proxies. Allows access to the underlying target Connection.

This interface can be checked when there is a need to cast to a native JDBC Connection such as Oracle's OracleConnection. Alternatively, all such connections also support JDBC 4.0's Connection#unwrap.

An adapter for a target CCI javax.resource.cci.ConnectionFactory, applying the given ConnectionSpec to every standard getConnection() call, that is, implicitly invoking getConnection(ConnectionSpec) on the target. All other methods simply delegate to the corresponding methods of the target ConnectionFactory.

Can be used to proxy a target JNDI ConnectionFactory that does not have a ConnectionSpec configured. Client code can work with the ConnectionFactory without passing in a ConnectionSpec on every getConnection() call.

In the following example, client code can simply transparently work with the preconfigured "myConnectionFactory", implicitly accessing "myTargetConnectionFactory" with the specified user credentials.

 <bean id="myTargetConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="java:comp/env/cci/mycf"/> </bean> <bean id="myConnectionFactory" class="org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter"> <property name="targetConnectionFactory" ref="myTargetConnectionFactory"/> <property name="connectionSpec"> <bean class="your.resource.adapter.ConnectionSpecImpl"> <property name="username" value="myusername"/> <property name="password" value="mypassword"/> </bean> </property> </bean>

If the "connectionSpec" is empty, this proxy will simply delegate to the standard getConnection() method of the target ConnectionFactory. This can be used to keep a UserCredentialsConnectionFactoryAdapter bean definition just for the option of implicitly passing in a ConnectionSpec if the particular target ConnectionFactory requires it.

FactoryBean that creates a JSR-160 JMXConnectorServer, optionally registers it with the MBeanServer and then starts it.

The JMXConnectorServer can be started in a separate thread by setting the threaded property to true. You can configure this thread to be a daemon thread by setting the daemon property to true.

The JMXConnectorServer is correctly shutdown when an instance of this class is destroyed on shutdown of the containing ApplicationContext.

ParseState entry representing a (possibly indexed) constructor argument.

Intercepts the construction of a new object.

The user should implement the method to modify the original behavior. E.g. the following class implements a singleton interceptor (allows only one unique instance for the intercepted class):

 class DebuggingInterceptor implements ConstructorInterceptor { Object instance=null; Object construct(ConstructorInvocation i) throws Throwable { if(instance==null) { return instance=i.proceed(); } else { throw new Exception("singleton does not allow multiple instance"); } } } 

Represents the invocation of a constructor. Either a constructor on a regular type or construction of an array. When an array is constructed, an initializer can be specified.

Examples: new String('hello world') new int[]{1,2,3,4} new int[3] new int[3]{1,2,3}

javax.servlet.http.HttpServletRequest wrapper that caches all content read from the input stream and reader, and allows this content to be retrieved via a byte array.

Used e.g. by org.springframework.web.filter.AbstractRequestLoggingFilter. Note: As of Spring Framework 5.0, this wrapper is built on the Servlet 3.1 API.

javax.servlet.http.HttpServletResponse wrapper that caches all content written to the output stream and writer, and allows this content to be retrieved via a byte array.

Used e.g. by org.springframework.web.filter.ShallowEtagHeaderFilter. Note: As of Spring Framework 5.0, this wrapper is built on the Servlet 3.1 API.

Represent the Content-Disposition type and parameters as defined in RFC 2183.

Implementation of ViewResolver that resolves a view based on the request file name or Accept header.

The ContentNegotiatingViewResolver does not resolve views itself, but delegates to other ViewResolvers. By default, these other view resolvers are picked up automatically from the application context, though they can also be set explicitly by using the viewResolvers property. Note that in order for this view resolver to work properly, the order property needs to be set to a higher precedence than the others (the default is Ordered#HIGHEST_PRECEDENCE).

This view resolver uses the requested MediaType to select a suitable View for a request. The requested media type is determined through the configured ContentNegotiationManager. Once the requested media type has been determined, this resolver queries each delegate view resolver for a View and determines if the requested media type is compatible with the view's content type). The most compatible view is returned.

Additionally, this view resolver exposes the defaultViews property, allowing you to override the views provided by the view resolvers. Note that these default views are offered as candidates, and still need have the content type requested (via file extension, parameter, or Accept header, described above).

For example, if the request path is /view.html, this view resolver will look for a view that has the text/html content type (based on the html file extension). A request for /view with a text/html request Accept header has the same result.

Central class to determine requested MediaType for a request. This is done by delegating to a list of configured ContentNegotiationStrategy instances.

Also provides methods to look up file extensions for a media type. This is done by delegating to the list of configured MediaTypeFileExtensionResolver instances.

Factory to create a ContentNegotiationManager and configure it with one or more ContentNegotiationStrategy instances.

As of 5.0 you can set the exact strategies to use via #setStrategies(List).

As an alternative you can also rely on the set of defaults described below which can be turned on or off or customized through the methods of this builder:

Factory for response content assertions.

An instance of this class is typically accessed via MockMvcResultMatchers#content.

A VersionStrategy that calculates an Hex MD5 hashes from the content of the resource and appends it to the file name, e.g. "styles/main-e36d2e05253c6c7085a91522ce43a0b4.css".

A VersionStrategy that calculates an Hex MD5 hashes from the content of the resource and appends it to the file name, e.g. "styles/main-e36d2e05253c6c7085a91522ce43a0b4.css".

Complete implementation of the org.springframework.beans.factory.support.AutowireCandidateResolver strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by the Lazy annotation in the context.annotation package.

Collection of utilities for working with ContextCache.

Web application listener that cleans up remaining disposable attributes in the ServletContext, i.e. attributes which implement DisposableBean and haven't been removed before. This is typically used for destroying objects in "application" scope, for which the lifecycle implies destruction at the very end of the web application's shutdown phase.

Event raised when an ApplicationContext gets closed.

HttpServletRequest decorator that makes all Spring beans in a given WebApplicationContext accessible as request attributes, through lazy checking once an attribute gets accessed.

@ContextHierarchy is a class-level annotation that is used to define a hierarchy of org.springframework.context.ApplicationContext for integration tests. Examples

The following JUnit-based examples demonstrate common configuration scenarios for integration tests that require the use of context hierarchies.

ControllerIntegrationTests represents a typical integration testing scenario for a Spring MVC web application by declaring a context hierarchy consisting of two levels, one for the root WebApplicationContext (with TestAppConfig) and one for the dispatcher servlet WebApplicationContext (with WebConfig). The WebApplicationContext that is autowired into the test instance is the one for the child context (i.e., the lowest context in the hierarchy).

 @RunWith(SpringRunner.class) @WebAppConfiguration @ContextHierarchy({ @ContextConfiguration(classes = TestAppConfig.class), @ContextConfiguration(classes = WebConfig.class) }) public class ControllerIntegrationTests { @Autowired private WebApplicationContext wac; // ... }

The following test classes define a context hierarchy within a test class hierarchy. AbstractWebTests declares the configuration for a root WebApplicationContext in a Spring-powered web application. Note, however, that AbstractWebTests does not declare @ContextHierarchy; consequently, subclasses of AbstractWebTests can optionally participate in a context hierarchy or follow the standard semantics for @ContextConfiguration. SoapWebServiceTests and RestWebServiceTests both extend AbstractWebTests and define a context hierarchy via @ContextHierarchy. The result is that three application contexts will be loaded (one for each declaration of @ContextConfiguration, and the application context loaded based on the configuration in AbstractWebTests will be set as the parent context for each of the contexts loaded for the concrete subclasses.

 @RunWith(SpringRunner.class) @WebAppConfiguration @ContextConfiguration("file:src/main/webapp/WEB-INF/applicationContext.xml") public abstract class AbstractWebTests {} @ContextHierarchy(@ContextConfiguration("/spring/soap-ws-config.xml") public class SoapWebServiceTests extends AbstractWebTests {} @ContextHierarchy(@ContextConfiguration("/spring/rest-ws-config.xml") public class RestWebServiceTests extends AbstractWebTests {}

The following classes demonstrate the use of named hierarchy levels in order to merge the configuration for specific levels in a context hierarchy. BaseTests defines two levels in the hierarchy, parent and child. ExtendedTests extends BaseTests and instructs the Spring TestContext Framework to merge the context configuration for the child hierarchy level, simply by ensuring that the names declared via ContextConfiguration#name are both "child". The result is that three application contexts will be loaded: one for "/app-config.xml", one for "/user-config.xml", and one for {"/user-config.xml", "/order-config.xml"}. As with the previous example, the application context loaded from "/app-config.xml" will be set as the parent context for the contexts loaded from "/user-config.xml" and {"/user-config.xml", "/order-config.xml"}.

 @RunWith(SpringRunner.class) @ContextHierarchy({ @ContextConfiguration(name = "parent", locations = "/app-config.xml"), @ContextConfiguration(name = "child", locations = "/user-config.xml") }) public class BaseTests {} @ContextHierarchy( @ContextConfiguration(name = "child", locations = "/order-config.xml") ) public class ExtendedTests extends BaseTests {}

In contrast to the previous example, this example demonstrates how to override the configuration for a given named level in a context hierarchy by setting the ContextConfiguration#inheritLocations flag to false. Consequently, the application context for ExtendedTests will be loaded only from "/test-user-config.xml" and will have its parent set to the context loaded from "/app-config.xml".

 @RunWith(SpringRunner.class) @ContextHierarchy({ @ContextConfiguration(name = "parent", locations = "/app-config.xml"), @ContextConfiguration(name = "child", locations = "/user-config.xml") }) public class BaseTests {} @ContextHierarchy( @ContextConfiguration(name = "child", locations = "/test-user-config.xml", inheritLocations = false) ) public class ExtendedTests extends BaseTests {}

As of Spring Framework 4.0, this annotation may be used as a meta-annotation to create custom composed annotations.

ScheduledTaskRegistrar subclass which redirects the actual scheduling of tasks to the #afterSingletonsInstantiated() callback (as of 4.1.2).

Bootstrap listener to start up and shut down Spring's root WebApplicationContext. Simply delegates to ContextLoader as well as to ContextCleanupListener.

As of Spring 3.1, ContextLoaderListener supports injecting the root web application context via the #ContextLoaderListener(WebApplicationContext) constructor, allowing for programmatic configuration in Servlet 3.0+ environments. See org.springframework.web.WebApplicationInitializer for usage examples.

org.springframework.beans.factory.xml.NamespaceHandler for the 'context' namespace.

HttpHandler delegating requests to one of several HttpHandler's based on simple, prefix-based mappings.

This is intended as a coarse-grained mechanism for delegating requests to one of several applications -- each represented by an HttpHandler, with the application "context path" (the prefix-based mapping) exposed via ServerHttpRequest#getPath().

Event raised when an ApplicationContext gets initialized or refreshed.

Extended interface for a resource that is loaded from an enclosing 'context', e.g. from a javax.servlet.ServletContext but also from plain classpath paths or relative file system paths (specified without an explicit prefix, hence applying relative to the local ResourceLoader's context).

Event raised when an ApplicationContext gets started.

Event raised when an ApplicationContext gets stopped.

Pointcut and method matcher for use in simple cflow-style pointcut. Note that evaluating such pointcuts is 10-15 times slower than evaluating normal pointcuts, but they are useful in some cases.

Specialization of Component for classes that declare ExceptionHandler, InitBinder, or ModelAttribute methods to be shared across multiple @Controller classes.

Classes with @ControllerAdvice can be declared explicitly as Spring beans or auto-detected via classpath scanning. All such beans are sorted via org.springframework.core.annotation.AnnotationAwareOrderComparator, i.e. based on org.springframework.core.annotation.Order and org.springframework.core.Ordered, and applied in that order at runtime. For handling exceptions, an @ExceptionHandler will be picked on the first advice with a matching exception handler method. For model attributes and InitBinder initialization, @ModelAttribute and @InitBinder methods will also follow @ControllerAdvice order.

Note: For @ExceptionHandler methods, a root exception match will be preferred to just matching a cause of the current exception, among the handler methods of a particular advice bean. However, a cause match on a higher-priority advice will still be preferred to a any match (whether root or cause level) on a lower-priority advice bean. As a consequence, please declare your primary root exception mappings on a prioritized advice bean with a corresponding order!

By default the methods in an @ControllerAdvice apply globally to all Controllers. Use selectors #annotations(), #basePackageClasses(), and #basePackages() (or its alias #value()) to define a more narrow subset of targeted Controllers. If multiple selectors are declared, OR logic is applied, meaning selected Controllers should match at least one selector. Note that selector checks are performed at runtime and so adding many selectors may negatively impact performance and add complexity.

Encapsulates information about an ControllerAdvice Spring-managed bean without necessarily requiring it to be instantiated.

The #findAnnotatedBeans(ApplicationContext) method can be used to discover such beans. However, a ControllerAdviceBean may be created from any object, including ones without an @ControllerAdvice.

Exception to be thrown when an actual type conversion attempt fails.

Exception thrown when no suitable editor or converter can be found for a bean property.

Interceptor that places the configured ConversionService in request scope so it's available during request processing. The request attribute name is "org.springframework.core.convert.ConversionService", the value of ConversionService.class.getName().

Mainly for use within JSP tags such as the spring:eval tag.

A factory for common org.springframework.core.convert.ConversionService configurations.

A factory providing convenient access to a ConversionService configured with converters appropriate for most environments. Set the "converters" property to supplement the default converters.

This implementation creates a DefaultConversionService. Subclasses may override #createConversionService() in order to return a GenericConversionService instance of their choosing.

Like all FactoryBean implementations, this class is suitable for use when configuring a Spring application context using Spring <beans> XML. When configuring the container with org.springframework.context.annotation.Configuration classes, simply instantiate, configure and return the appropriate ConversionService object from a method.

Exception to be thrown when a suitable converter could not be found in a given conversion service.

Base class that can be used to implement a standard javax.websocket.Encoder and/or javax.websocket.Decoder. It provides encode and decode method implementations that delegate to a Spring ConversionService.

By default, this class looks up a ConversionService registered in the active ApplicationContext under the name 'webSocketConversionService'. This works fine for both client and server endpoints, in a Servlet container environment. If not running in a Servlet container, subclasses will need to override the #getConversionService() method to provide an alternative lookup strategy.

Subclasses can extend this class and should also implement one or both of javax.websocket.Encoder and javax.websocket.Decoder. For convenience ConvertingEncoderDecoderSupport.BinaryEncoder, ConvertingEncoderDecoderSupport.BinaryDecoder, ConvertingEncoderDecoderSupport.TextEncoder and ConvertingEncoderDecoderSupport.TextDecoder subclasses are provided.

Since JSR-356 only allows Encoder/Decoder to be registered by type, instances of this class are therefore managed by the WebSocket runtime, and do not need to be registered as Spring Beans. They can, however, by injected with Spring-managed dependencies via Autowired.

Converters to convert between the type and String or ByteBuffer should be registered.

Adapter that exposes a java.beans.PropertyEditor for any given org.springframework.core.convert.ConversionService and specific target type.

Helper class for cookie generation, carrying cookie descriptor settings as bean properties and being able to add and remove cookie to/from a given response.

Can serve as base class for components that generate specific cookies, such as CookieLocaleResolver and CookieThemeResolver.

LocaleResolver implementation that uses a cookie sent back to the user in case of a custom setting, with a fallback to the specified default locale or the request's accept-header locale.

This is particularly useful for stateless applications without user sessions. The cookie may optionally contain an associated time zone value as well; alternatively, you may specify a default time zone.

Custom controllers can override the user's locale and time zone by calling #setLocale(Context) on the resolver, e.g. responding to a locale change request. As a more convenient alternative, consider using org.springframework.web.servlet.support.RequestContext#changeLocale.

Factory for response cookie assertions.

An instance of this class is typically accessed via MockMvcResultMatchers#cookie.

ThemeResolver implementation that uses a cookie sent back to the user in case of a custom setting, with a fallback to the default theme. This is particularly useful for stateless applications without user sessions.

Custom controllers can thus override the user's theme by calling setThemeName, e.g. responding to a certain theme change request.

Resolve method arguments annotated with @CookieValue.

An @CookieValue is a named value that is resolved from a cookie. It has a required flag and a default value to fall back on when the cookie does not exist.

Cookie-based WebSessionIdResolver.

org.springframework.beans.factory.xml.BeanDefinitionParser that parses a cors element in order to set the CORS configuration in the various {AbstractHandlerMapping} beans created by AnnotationDrivenBeanDefinitionParser, ResourcesBeanDefinitionParser and ViewControllerBeanDefinitionParser.

javax.servlet.Filter that handles CORS preflight requests and intercepts CORS simple and actual requests thanks to a CorsProcessor implementation (DefaultCorsProcessor by default) in order to add the relevant CORS response headers (like Access-Control-Allow-Origin) using the provided CorsConfigurationSource (for example an UrlBasedCorsConfigurationSource instance.

This is an alternative to Spring MVC Java config and XML namespace CORS configuration, useful for applications depending only on spring-web (not on spring-webmvc) or for security constraints requiring CORS checks to be performed at javax.servlet.Filter level.

This filter could be used in conjunction with DelegatingFilterProxy in order to help with its initialization.

Assists with the creation of a CorsConfiguration instance mapped to a path pattern. By default all origins, headers, and credentials for GET, HEAD, and POST requests are allowed while the max age is set to 30 minutes.

Assists with the creation of a CorsConfiguration instance mapped to a path pattern. By default all origins, headers, and credentials for GET, HEAD, and POST requests are allowed while the max age is set to 30 minutes.

Utility class for CORS request handling based on the CORS W3C recommandation.

Utility class for CORS reactive request handling based on the CORS W3C recommendation.

WebFilter that handles CORS preflight requests and intercepts CORS simple and actual requests thanks to a CorsProcessor implementation (DefaultCorsProcessor by default) in order to add the relevant CORS response headers (like Access-Control-Allow-Origin) using the provided CorsConfigurationSource (for example an UrlBasedCorsConfigurationSource instance.

This is an alternative to Spring WebFlux Java config CORS configuration, mostly useful for applications using the functional API.

Date sequence generator for a Crontab pattern, allowing clients to specify a pattern that the sequence matches.

The pattern is a list of six single space-separated fields: representing second, minute, hour, day, month, weekday. Month and weekday names can be given as the first three letters of the English names.

Example patterns:

• "0 0 * * * *" = the top of every hour of every day.
• "*/10 * * * * *" = every ten seconds.
• "0 0 8-10 * * *" = 8, 9 and 10 o'clock of every day.
• "0 0 6,19 * * *" = 6:00 AM and 7:00 PM every day.
• "0 0/30 8-10 * * *" = 8:00, 8:30, 9:00, 9:30, 10:00 and 10:30 every day.
• "0 0 9-17 * * MON-FRI" = on the hour nine-to-five weekdays
• "0 0 0 25 12 ?" = every Christmas Day at midnight

TriggerTask implementation defining a Runnable to be executed according to a org.springframework.scheduling.support.CronSequenceGenerator.

A Spring FactoryBean for creating a Quartz org.quartz.CronTrigger instance, supporting bean-style usage for trigger configuration.

CronTrigger(Impl) itself is already a JavaBean but lacks sensible defaults. This class uses the Spring bean name as job name, the Quartz default group ("DEFAULT") as job group, the current time as start time, and indefinite repetition, if not specified.

This class will also register the trigger with the job name and group of a given org.quartz.JobDetail. This allows SchedulerFactoryBean to automatically register a trigger for the corresponding JobDetail, instead of registering the JobDetail separately.

Marks the annotated method or type as permitting cross origin requests.

By default all origins and headers are permitted, credentials are not allowed, and the maximum age is set to 1800 seconds (30 minutes). The list of HTTP methods is set to the methods on the @RequestMapping if not explicitly set on @CrossOrigin.

NOTE: @CrossOrigin is processed if an appropriate HandlerMapping-HandlerAdapter pair is configured such as the RequestMappingHandlerMapping-RequestMappingHandlerAdapter pair which are the default in the MVC Java config and the MVC namespace.

A ResourceTransformer implementation that modifies links in a CSS file to match the public URL paths that should be exposed to clients (e.g. with an MD5 content-based hash inserted in the URL).

The implementation looks for links in CSS @import statements and also inside CSS url() functions. All links are then passed through the ResourceResolverChain and resolved relative to the location of the containing CSS file. If successfully resolved, the link is modified, otherwise the original link is preserved.

A ResourceTransformer implementation that modifies links in a CSS file to match the public URL paths that should be exposed to clients (e.g. with an MD5 content-based hash inserted in the URL).

The implementation looks for links in CSS @import statements and also inside CSS url() functions. All links are then passed through the ResourceResolverChain and resolved relative to the location of the containing CSS file. If successfully resolved, the link is modified, otherwise the original link is preserved.

Editor for java.util.Currency, translating currency codes into Currency objects. Exposes the currency code as text representation of a Currency object.

Formatter for JSR-354 javax.money.CurrencyUnit values, from and to currency code Strings.

A org.springframework.beans.factory.config.BeanFactoryPostProcessor implementation that allows for convenient registration of custom autowire qualifier types.

 <bean id="customAutowireConfigurer" class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer"> <property name="customQualifierTypes"> <set> <value>mypackage.MyQualifier</value> </set> </property> </bean>

Property editor for Boolean/boolean properties.

This is not meant to be used as system PropertyEditor but rather as locale-specific Boolean editor within custom controller code, to parse UI-caused boolean strings into boolean properties of beans and check them in the UI form.

In web MVC code, this editor will typically be registered with binder.registerCustomEditor calls.

Property editor for Collections, converting any source Collection to a given target Collection type.

By default registered for Set, SortedSet and List, to automatically convert any given Collection to one of those target types if the type does not match the target property.

Property editor for java.util.Date, supporting a custom java.text.DateFormat.

This is not meant to be used as system PropertyEditor but rather as locale-specific date editor within custom controller code, parsing user-entered number strings into Date properties of beans and rendering them in the UI form.

In web MVC code, this editor will typically be registered with binder.registerCustomEditor.

BeanFactoryPostProcessor implementation that allows for convenient registration of custom PropertyEditor.

In case you want to register PropertyEditor instances, the recommended usage as of Spring 2.0 is to use custom PropertyEditorRegistrar implementations that in turn register any desired editor instances on a given org.springframework.beans.PropertyEditorRegistry. Each PropertyEditorRegistrar can register any number of custom editors.

 <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer"> <property name="propertyEditorRegistrars"> <list> <bean class="mypackage.MyCustomDateEditorRegistrar"/> <bean class="mypackage.MyObjectEditorRegistrar"/> </list> </property> </bean> 

It's perfectly fine to register PropertyEditor classes via the customEditors property. Spring will create fresh instances of them for each editing attempt then:

 <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer"> <property name="customEditors"> <map> <entry key="java.util.Date" value="mypackage.MyCustomDateEditor"/> <entry key="mypackage.MyObject" value="mypackage.MyObjectEditor"/> </map> </property> </bean> 

Note, that you shouldn't register PropertyEditor bean instances via the customEditors property as PropertyEditors are stateful and the instances will then have to be synchronized for every editing attempt. In case you need control over the instantiation process of PropertyEditors, use a PropertyEditorRegistrar to register them.

Also supports "java.lang.String[]"-style array class names and primitive class names (e.g. "boolean"). Delegates to ClassUtils for actual class name resolution.

NOTE: Custom property editors registered with this configurer do not apply to data binding. Custom editors for data binding need to be registered on the org.springframework.validation.DataBinder: Use a common base class or delegate to common PropertyEditorRegistrar implementations to reuse editor registration there.

Property editor for Maps, converting any source Map to a given target Map type.

Property editor for any Number subclass such as Short, Integer, Long, BigInteger, Float, Double, BigDecimal. Can use a given NumberFormat for (locale-specific) parsing and rendering, or alternatively the default decode / valueOf / toString methods.

This is not meant to be used as system PropertyEditor but rather as locale-specific number editor within custom controller code, parsing user-entered number strings into Number properties of beans and rendering them in the UI form.

In web MVC code, this editor will typically be registered with binder.registerCustomEditor calls.

JavaBean for holding custom JDBC error codes translation for a particular database. The "exceptionClass" property defines which exception will be thrown for the list of error codes specified in the errorCodes property.

Registry for registering custom org.springframework.jdbc.support.SQLExceptionTranslator instances for specific databases.

Registry for custom org.springframework.jdbc.support.SQLExceptionTranslator instances associated with specific databases allowing for overriding translation based on values contained in the configuration file named "sql-error-codes.xml".

Simple BeanFactoryPostProcessor implementation that registers custom Scope with the containing ConfigurableBeanFactory.

Will register all of the supplied scopes with the ConfigurableListableBeanFactory that is passed to the #postProcessBeanFactory(ConfigurableListableBeanFactory) method.

This class allows for declarative registration of custom scopes. Alternatively, consider implementing a custom BeanFactoryPostProcessor that calls ConfigurableBeanFactory#registerScope programmatically.

Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the Spring org.springframework.validation.Validator interface.

MethodInterceptor implementation that allows for highly customizable method-level tracing, using placeholders.

Trace messages are written on method entry, and if the method invocation succeeds on method exit. If an invocation results in an exception, then an exception message is written. The contents of these trace messages is fully customizable and special placeholders are available to allow you to include runtime information in your log messages. The placeholders available are:

• $[methodName] - replaced with the name of the method being invoked
• $[targetClassName] - replaced with the name of the class that is the target of the invocation
• $[targetClassShortName] - replaced with the short name of the class that is the target of the invocation
• $[returnValue] - replaced with the value returned by the invocation
• $[argumentTypes] - replaced with a comma-separated list of the short class names of the method arguments
• $[arguments] - replaced with a comma-separated list of the String representation of the method arguments
• $[exception] - replaced with the String representation of any Throwable raised during the invocation
• $[invocationTime] - replaced with the time, in milliseconds, taken by the method invocation

There are restrictions on which placeholders can be used in which messages: see the individual message properties for details on the valid placeholders.

DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2/390 or DB2/400. Thanks to Jens Eickmeyer for the suggestion!

DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2 UDB (for Unix and Windows). Thanks to Mark MacMahon for the suggestion!

Miscellaneous utility methods for DAO implementations. Useful with any data access technology.

Simple pass-through decoder for DataBuffers.

Note that the "decoded" buffers returned by instances of this class should be released after usage by calling org.springframework.core.io.buffer.DataBufferUtils#release(DataBuffer).

Simple pass-through encoder for DataBuffers.

A factory for DataBuffers, allowing for allocation and wrapping of data buffers.

Utility class for working with DataBuffers.

Exception to be thrown by a DataSourceLookup implementation, indicating that the specified DataSource could not be obtained.

org.springframework.transaction.PlatformTransactionManager implementation for a single JDBC javax.sql.DataSource. This class is capable of working in any environment with any JDBC driver, as long as the setup uses a javax.sql.DataSource as its Connection factory mechanism. Binds a JDBC Connection from the specified DataSource to the current thread, potentially allowing for one thread-bound Connection per DataSource.

Note: The DataSource that this transaction manager operates on needs to return independent Connections. The Connections may come from a pool (the typical case), but the DataSource must not return thread-scoped / request-scoped Connections or the like. This transaction manager will associate Connections with thread-bound transactions itself, according to the specified propagation behavior. It assumes that a separate, independent Connection can be obtained even during an ongoing transaction.

Application code is required to retrieve the JDBC Connection via DataSourceUtils#getConnection(DataSource) instead of a standard Java EE-style DataSource#getConnection() call. Spring classes such as org.springframework.jdbc.core.JdbcTemplate use this strategy implicitly. If not used in combination with this transaction manager, the DataSourceUtils lookup strategy behaves exactly like the native DataSource lookup; it can thus be used in a portable fashion.

Alternatively, you can allow application code to work with the standard Java EE-style lookup pattern DataSource#getConnection(), for example for legacy code that is not aware of Spring at all. In that case, define a TransactionAwareDataSourceProxy for your target DataSource, and pass that proxy DataSource to your DAOs, which will automatically participate in Spring-managed transactions when accessing it.

Supports custom isolation levels, and timeouts which get applied as appropriate JDBC statement timeouts. To support the latter, application code must either use org.springframework.jdbc.core.JdbcTemplate, call DataSourceUtils#applyTransactionTimeout for each created JDBC Statement, or go through a TransactionAwareDataSourceProxy which will create timeout-aware JDBC Connections and Statements automatically.

Consider defining a LazyConnectionDataSourceProxy for your target DataSource, pointing both this transaction manager and your DAOs to it. This will lead to optimized handling of "empty" transactions, i.e. of transactions without any JDBC statements executed. A LazyConnectionDataSourceProxy will not fetch an actual JDBC Connection from the target DataSource until a Statement gets executed, lazily applying the specified transaction settings to the target Connection.

This transaction manager supports nested transactions via the JDBC 3.0 java.sql.Savepoint mechanism. The "nestedTransactionAllowed" flag defaults to "true", since nested transactions will work without restrictions on JDBC drivers that support savepoints (such as the Oracle JDBC driver).

This transaction manager can be used as a replacement for the org.springframework.transaction.jta.JtaTransactionManager in the single resource case, as it does not require a container that supports JTA, typically in combination with a locally defined JDBC DataSource (e.g. an Apache Commons DBCP connection pool). Switching between this local strategy and a JTA environment is just a matter of configuration!

As of 4.3.4, this transaction manager triggers flush callbacks on registered transaction synchronizations (if synchronization is generally active), assuming resources operating on the underlying JDBC Connection. This allows for setup analogous to JtaTransactionManager, in particular with respect to lazily registered ORM resources (e.g. a Hibernate Session).

Utility methods for executing a DatabasePopulator.

Bean that checks if a database has already started up. To be referenced via "depends-on" from beans that depend on database startup, like a Hibernate SessionFactory or custom data access objects that access a DataSource directly.

Useful to defer application initialization until a database has started up. Particularly appropriate for waiting on a slowly starting Oracle database.

A formatter for java.util.Date types. Allows the configuration of an explicit date pattern and locale.

Configures basic date formatting for use with Spring, primarily for org.springframework.format.annotation.DateTimeFormat declarations. Applies to fields of type Date, Calendar and long.

Designed for direct instantiation but also exposes the static #addDateConverters(ConverterRegistry) utility method for ad-hoc use against any ConverterRegistry instance.

A context that holds user-specific java.time (JSR-310) settings such as the user's Chronology (calendar system) and time zone. A null property value indicate the user has not specified a setting.

Formats fields annotated with the DateTimeFormat annotation using a DateFormatter.

FactoryBean that creates a Joda-Time DateTimeFormatter. See the DateTimeFormatterFactory for configuration details.

FactoryBean that creates a JSR-310 java.time.format.DateTimeFormatter. See the DateTimeFormatterFactory for configuration details.

Configures the JSR-310 java.time formatting system for use with Spring.

Parses Joda DateTime instances using a DateTimeFormatter.

DB2 specific implementation for the CallMetaDataProvider interface. This class is intended for internal use by the Simple JDBC classes.

AOP Alliance MethodInterceptor that can be introduced in a chain to display verbose information about intercepted invocations to the logger.

Logs full invocation details on method entry and method exit, including invocation arguments and invocation count. This is only intended for debugging purposes; use SimpleTraceInterceptor or CustomizableTraceInterceptor for pure tracing purposes.

HttpMessageReader that wraps and delegates to a Decoder.

Also a HttpMessageReader that pre-resolves decoding hints from the extra information available on the server side such as the request or controller method parameter annotations.

Indicates an issue with decoding the input stream with a focus on content related issues such as a parse failure. As opposed to more general I/O errors, illegal state, or a CodecException such as a configuration issue that a Decoder may choose to raise.

For example in server web application, a DecodingException would translate to a response with a 400 (bad input) status while CodecException would translate to 500 (server error) status.

Base class for JSF NavigationHandler implementations that want to be capable of decorating an original NavigationHandler.

Supports the standard JSF style of decoration (through a constructor argument) as well as an overloaded handleNavigation method with explicit NavigationHandler argument (passing in the original NavigationHandler). Subclasses are forced to implement this overloaded handleNavigation method. Standard JSF invocations will automatically delegate to the overloaded method, with the constructor-injected NavigationHandler as argument.

Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.

Note that this interface should just be implemented if the decorated class is not within the hierarchy of the proxy class to begin with. In particular, a "target-class" proxy such as a Spring AOP CGLIB proxy should not implement it since any lookup on the target class can simply be performed on the proxy class there anyway.

Defined in the core module in order to allow #org.springframework.core.annotation.AnnotationAwareOrderComparator (and potential other candidates without spring-aop dependencies) to use it for introspection purposes, in particular annotation lookups.

Default implementation of the ActiveProfilesResolver strategy that resolves active bean definition profiles based solely on profiles configured declaratively via ActiveProfiles#profiles or ActiveProfiles#value.

Default implementation of the AdvisorAdapterRegistry interface. Supports org.aopalliance.intercept.MethodInterceptor, org.springframework.aop.MethodBeforeAdvice, org.springframework.aop.AfterReturningAdvice, org.springframework.aop.ThrowsAdvice.

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 the advisorBeanNamePrefix property. The separator (.) will also be used in this case.

A simple but definitive way of working out an advice chain for a Method, given an Advised object. Always rebuilds each advice chain; caching can be provided by subclasses.

Default AopProxyFactory implementation, creating either a CGLIB proxy or a JDK dynamic proxy.

Creates a CGLIB proxy if one the following is true for a given AdvisedSupport instance:

• the optimize flag is set
• the proxyTargetClass flag is set
• no proxy 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.

Default implementation of the BeanDefinitionDocumentReader interface that reads bean definitions according to the "spring-beans" DTD and XSD format (Spring's default XML bean definition format).

The structure, elements, and attribute names of the required XML document are hard-coded in this class. (Of course a transform could be run if necessary to produce this format). <beans> does not need to be the root element of the XML document: this class will parse all bean definition elements in the XML file, regardless of the actual root element.

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.

Specifying the name of an advice bean instead of the advice object itself (if running within a BeanFactory) increases loose coupling at initialization time, in order to not initialize the advice object until the pointcut actually matches.

Default implementation of the BeanNameGenerator interface, delegating to BeanDefinitionReaderUtils#generateBeanName(BeanDefinition, BeanDefinitionRegistry).

Default BindingErrorProcessor implementation.

Uses the "required" error code and the field name to resolve message codes for a missing field error.

Creates a FieldError for each PropertyAccessException given, using the PropertyAccessException's error code ("typeMismatch", "methodInvocation") for resolving message codes.

Default implementation of the BootstrapContext interface.

Default implementation of the CacheAwareContextLoaderDelegate interface.

To use a static DefaultContextCache, invoke the #DefaultCacheAwareContextLoaderDelegate() constructor; otherwise, invoke the #DefaultCacheAwareContextLoaderDelegate(ContextCache) and provide a custom ContextCache implementation.

Default implementation of ClientCodecConfigurer.

A default ContentTypeResolver that checks the MessageHeaders#CONTENT_TYPE header or falls back to a default value.

The header value is expected to be a org.springframework.util.MimeType or a String that can be parsed into a MimeType.

Default implementation of the ContextCache API.

Uses a synchronized Map configured with a maximum size and a least recently used (LRU) eviction policy to cache ApplicationContext instances.

The maximum size may be supplied as a constructor argument or set via a system property or Spring property named spring.test.context.cache.maxSize.

The default implementation of CorsProcessor, as defined by the CORS W3C recommendation.

Note that when input CorsConfiguration is null, this implementation does not reject simple or actual requests outright but simply avoid adding CORS headers to the response. CORS processing is also skipped if the response already contains CORS headers, or if the request is detected as a same-origin one.

The default implementation of CorsProcessor, as defined by the CORS W3C recommendation.

Note that when input CorsConfiguration is null, this implementation does not reject simple or actual requests outright but simply avoid adding CORS headers to the response. CORS processing is also skipped if the response already contains CORS headers, or if the request is detected as a same-origin one.

Create a WebRequestDataBinder instance and initialize it with a WebBindingInitializer.

Default implementation of the DataBufferFactory interface. Allows for specification of the default initial capacity at construction time, as well as whether heap-based or direct buffers are to be preferred.

Spring's default DocumentLoader implementation.

Simply loads Document using the standard JAXP-configured XML parser. If you want to change the DocumentBuilder that is used to load documents, then one strategy is to define a corresponding Java system property when starting your JVM. For example, to use the Oracle DocumentBuilder, you might start your application like as follows:

java -Djavax.xml.parsers.DocumentBuilderFactory=oracle.xml.jaxp.JXDocumentBuilderFactory MyMainClass

Default EventListenerFactory implementation that supports the regular EventListener annotation.

Used as "catch-all" implementation by default.

A specialization of FormattingConversionService configured by default with converters and formatters appropriate for most applications.

Designed for direct instantiation but also exposes the static #addDefaultFormatters utility method for ad hoc use against any FormatterRegistry instance, just as DefaultConversionService exposes its own addDefaultConverters method.

Automatically registers formatters for JSR-354 Money & Currency, JSR-310 Date-Time and/or Joda-Time, depending on the presence of the corresponding API on the classpath.

Simple org.springframework.aop.IntroductionAdvisor implementation that by default applies to any class.

The default JCacheOperationSource implementation delegating default operations to configurable services with sensible defaults when not present.

A JmsListenerContainerFactory implementation to build a JCA-based JmsMessageEndpointManager.

Default implementation of the JmsActivationSpecFactory interface. Supports the standard JMS properties as defined by the JCA 1.5 specification, as well as Spring's extended "maxConcurrency" and "prefetchSize" settings through autodetection of well-known vendor-specific provider properties.

An ActivationSpec factory is effectively dependent on the concrete JMS provider, e.g. on ActiveMQ. This default implementation simply guesses the ActivationSpec class name from the provider's class name ("ActiveMQResourceAdapter" -> "ActiveMQActivationSpec" in the same package, or "ActivationSpecImpl" in the same package as the ResourceAdapter class), and populates the ActivationSpec properties as suggested by the JCA 1.5 specification (Appendix B). Specify the 'activationSpecClass' property explicitly if these default naming rules do not apply.

Note: ActiveMQ, JORAM and WebSphere are supported in terms of extended settings (through the detection of their bean property naming conventions). The default ActivationSpec class detection rules may apply to other JMS providers as well.

Thanks to Agim Emruli and Laurie Chan for pointing out WebSphere MQ settings and contributing corresponding tests!

A JmsListenerContainerFactory implementation to build a regular DefaultMessageListenerContainer.

This should be the default for most users and a good transition paths for those that are used to build such container definition manually.

Default implementation of the JpaDialect interface. Used as default dialect by JpaTransactionManager.

Simply begins a standard JPA transaction in #beginTransaction and performs standard exception translation through EntityManagerFactoryUtils.

NOTE: Spring's JPA support requires JPA 2.1 or higher, as of Spring 5.0.

Default implementation of the LifecycleProcessor strategy.

JNDI-based variant of CustomizableThreadFactory, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment, falling back to the local CustomizableThreadFactory setup if not found.

This is a convenient way to use managed threads when running in a Java EE 7 environment, simply using regular local threads otherwise - without conditional setup (i.e. without profiles).

Note: This class is not strictly JSR-236 based; it can work with any regular java.util.concurrent.ThreadFactory that can be found in JNDI. Therefore, the default JNDI name "java:comp/DefaultManagedThreadFactory" can be customized through the "jndiName" bean property.

JNDI-based variant of ConcurrentTaskExecutor, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7 environment.

Note: This class is not strictly JSR-236 based; it can work with any regular java.util.concurrent.Executor that can be found in JNDI. The actual adapting to javax.enterprise.concurrent.ManagedExecutorService happens in the base class ConcurrentTaskExecutor itself.

JNDI-based variant of ConcurrentTaskScheduler, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment.

Note: This class is not strictly JSR-236 based; it can work with any regular java.util.concurrent.ScheduledExecutorService that can be found in JNDI. The actual adapting to javax.enterprise.concurrent.ManagedScheduledExecutorService happens in the base class ConcurrentTaskScheduler itself.

Default implementation of the MessageCodesResolver interface.

Will create two message codes for an object error, in the following order (when using the prefixed formatter):

• 1.: code + "." + object name
• 2.: code

Will create four message codes for a field specification, in the following order:

• 1.: code + "." + object name + "." + field
• 2.: code + "." + field
• 3.: code + "." + field type
• 4.: code

For example, in case of code "typeMismatch", object name "user", field "age":

• 1. try "typeMismatch.user.age"
• 2. try "typeMismatch.age"
• 3. try "typeMismatch.int"
• 4. try "typeMismatch"

This resolution algorithm thus can be leveraged for example to show specific messages for binding errors like "required" and "typeMismatch":

• at the object + field level ("age" field, but only on "user");
• at the field level (all "age" fields, no matter which object name);
• or at the general level (all fields, on any object).

In case of array, List or java.util.Map properties, both codes for specific elements and for the whole collection are generated. Assuming a field "name" of an array "groups" in object "user":

• 1. try "typeMismatch.user.groups[0].name"
• 2. try "typeMismatch.user.groups.name"
• 3. try "typeMismatch.groups[0].name"
• 4. try "typeMismatch.groups.name"
• 5. try "typeMismatch.name"
• 6. try "typeMismatch.java.lang.String"
• 7. try "typeMismatch"

By default the errorCodes will be placed at the beginning of constructed message strings. The messageCodeFormatter property can be used to specify an alternative concatenation MessageCodeFormatter.

In order to group all codes into a specific category within your resource bundles, e.g. "validation.typeMismatch.name" instead of the default "typeMismatch.name", consider specifying a prefix to be applied.

Default implementation of the MessageSourceResolvable interface. Offers an easy way to store all the necessary values needed to resolve a message via a org.springframework.context.MessageSource.

A concrete implementation of AbstractMockMvcBuilder that provides the WebApplicationContext supplied to it as a constructor argument.

In addition, if the ServletContext in the supplied WebApplicationContext does not contain an entry for the WebApplicationContext#ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE key, the root WebApplicationContext will be detected and stored in the ServletContext under the ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE key.

Default implementation of the org.springframework.web.multipart.MultipartHttpServletRequest interface. Provides management of pre-generated parameter values.

Used by org.springframework.web.multipart.commons.CommonsMultipartResolver.

Default implementation of the NamespaceHandlerResolver interface. Resolves namespace URIs to implementation classes based on the mappings contained in mapping file.

By default, this implementation looks for the mapping file at META-INF/spring.handlers, but this can be changed using the #DefaultNamespaceHandlerResolver(ClassLoader, String) constructor.

Convenient Pointcut-driven Advisor implementation.

This is the most commonly used Advisor implementation. It can be used with any pointcut and advice type, except for introductions. There is normally no need to subclass this class, or to implement custom Advisors.

The default implementation for PropertySourceFactory, wrapping every resource in a ResourcePropertySource.

Default implementation of the RemoteInvocationExecutor interface. Simply delegates to RemoteInvocation's invoke method.

Default implementation of the RemoteInvocationFactory interface. Simply creates a new standard RemoteInvocation object.

Default implementation of RequestExpectation that simply delegates to the request matchers and the response creator it contains.

RequestToViewNameTranslator that simply transforms the URI of the incoming request into a view name.

Can be explicitly defined as the viewNameTranslator bean in a org.springframework.web.servlet.DispatcherServlet context. Otherwise, a plain default instance will be used.

The default transformation simply strips leading and trailing slashes as well as the file extension of the URI, and returns the result as the view name with the configured prefix and a suffix added as appropriate.

The stripping of the leading slash and file extension can be disabled using the stripLeadingSlash and stripExtension properties, respectively.

Find below some examples of request to view name translation.

• http://localhost:8080/gamecast/display.html » display
• http://localhost:8080/gamecast/displayShoppingCart.html » displayShoppingCart
• http://localhost:8080/gamecast/admin/index.html » admin/index

Default implementation of the ScopedObject interface.

Simply delegates the calls to the underlying ConfigurableBeanFactory (ConfigurableBeanFactory#getBean(String)/ ConfigurableBeanFactory#destroyScopedBean(String)).

Default implementation of ServerCodecConfigurer.

An HttpRequestHandler for serving static files using the Servlet container's "default" Servlet.

This handler is intended to be used with a "/*" mapping when the org.springframework.web.servlet.DispatcherServlet is mapped to "/", thus overriding the Servlet container's default handling of static resources. The mapping to this handler should generally be ordered as the last in the chain so that it will only execute when no other more specific mappings (i.e., to controllers) can be matched.

Requests are handled by forwarding through the RequestDispatcher obtained via the name specified through the "defaultServletName" property. In most cases, the defaultServletName does not need to be set explicitly, as the handler checks at initialization time for the presence of the default Servlet of well-known containers such as Tomcat, Jetty, Resin, WebLogic and WebSphere. However, when running in a container where the default Servlet's name is not known, or where it has been customized via server configuration, the defaultServletName will need to be set explicitly.

Default implementation of the SessionAttributeStore interface, storing the attributes in the WebRequest session (i.e. HttpSession or PortletSession).

Default implementation of ConnectionHandlingStompSession.

Default implementation of the TestContext interface.

Default implementation of the TestContextBootstrapper SPI.

Uses DelegatingSmartContextLoader as the default ContextLoader.

Spring's default toString() styler.

This class is used by ToStringCreator to style toString() output in a consistent manner according to Spring conventions.

Default implementation of the TransactionDefinition interface, offering bean-style configuration and sensible default values (PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).

Base class for both TransactionTemplate and org.springframework.transaction.interceptor.DefaultTransactionAttribute.

Default implementation of UriBuilderFactory providing options to pre-configure all UriBuilder instances with common properties such as a base URI, encoding mode, and default URI variables.

Uses UriComponentsBuilder for URI building.

Default implementation of UriTemplateHandler based on the use of UriComponentsBuilder for expanding and encoding variables.

There are also several properties to customize how URI template handling is performed, including a baseUrl to be used as a prefix for all URI templates and a couple of encoding related options — parsePath and strictEncoding respectively.

Converts objects to String form, generally for debugging purposes, using Spring's toString styling conventions.

Uses the reflective visitor pattern underneath the hood to nicely encapsulate styling algorithms for each type of styled object.

Default implementation of WebFilterChain.

A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.

Implementations can also extend the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation to indicate a precedence against other DeferredImportSelectors.

Handler for return values of type DeferredResult, ListenableFuture, and CompletionStage.

Abstract adapter class for the DeferredResultProcessingInterceptor interface for simplified implementation of individual methods.

Convenient implementation of the org.springframework.aop.IntroductionInterceptor interface.

This differs from DelegatingIntroductionInterceptor in that a single instance of this class can be used to advise multiple target objects, and each target object will have its own delegate (whereas DelegatingIntroductionInterceptor shares the same delegate, and hence the same state across all targets).

The suppressInterface method can be used to suppress interfaces implemented by the delegate class but which should not be introduced to the owning AOP proxy.

An instance of this class is serializable if the delegates are.

Note: There are some implementation similarities between this class and DelegatingIntroductionInterceptor that suggest a possible refactoring to extract a common ancestor class in the future.

javax.jms.ConnectionFactory implementation that delegates all calls to a given target javax.jms.ConnectionFactory, adapting specific create(Queue/Topic)Connection calls to the target ConnectionFactory if necessary (e.g. when running JMS 1.0.2 API based code against a generic JMS 1.1 ConnectionFactory, such as ActiveMQ's PooledConnectionFactory).

This class allows for being subclassed, with subclasses overriding only those methods (such as #createConnection()) that should not simply delegate to the target ConnectionFactory.

Can also be defined as-is, wrapping a specific target ConnectionFactory, using the "shouldStopConnections" flag to indicate whether Connections obtained from the target factory are supposed to be stopped before closed. The latter may be necessary for some connection pools that simply return released connections to the pool, not stopping them while they sit in the pool.

Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface. Supports a "targetBeanName" filter init-param in web.xml, specifying the name of the target bean in the Spring application context.

web.xml will usually contain a DelegatingFilterProxy definition, with the specified filter-name corresponding to a bean name in Spring's root application context. All calls to the filter proxy will then be delegated to that bean in the Spring context, which is required to implement the standard Servlet Filter interface.

This approach is particularly useful for Filter implementation with complex setup needs, allowing to apply the full Spring bean definition machinery to Filter instances. Alternatively, consider standard Filter setup in combination with looking up service beans from the Spring root application context.

NOTE: The lifecycle methods defined by the Servlet Filter interface will by default not be delegated to the target bean, relying on the Spring application context to manage the lifecycle of that bean. Specifying the "targetFilterLifecycle" filter init-param as "true" will enforce invocation of the Filter.init and Filter.destroy lifecycle methods on the target bean, letting the servlet container manage the filter lifecycle.

As of Spring 3.1, DelegatingFilterProxy has been updated to optionally accept constructor parameters when using Servlet 3.0's instance-based filter registration methods, usually in conjunction with Spring 3.1's org.springframework.web.WebApplicationInitializer SPI. These constructors allow for providing the delegate Filter bean directly, or providing the application context and bean name to fetch, avoiding the need to look up the application context from the ServletContext.

This class was originally inspired by Spring Security's FilterToBeanProxy class, written by Ben Alex.

Convenient implementation of the org.springframework.aop.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 should not be introduced to the owning AOP proxy.

An instance of this class is serializable if the delegate is.

Simple Quartz org.quartz.Job adapter that delegates to a given java.lang.Runnable instance.

Typically used in combination with property injection on the Runnable instance, receiving parameters from the Quartz JobDataMap that way instead of via the JobExecutionContext.

Empty MessageSource that delegates all calls to the parent MessageSource. If no parent is available, it simply won't resolve any message.

Used as placeholder by AbstractApplicationContext, if the context doesn't define its own MessageSource. Not intended for direct use in applications.

JSF NavigationHandler implementation that delegates to a NavigationHandler bean obtained from the Spring root WebApplicationContext.

Configure this handler proxy in your faces-config.xml file as follows:

 <application> ... <navigation-handler> org.springframework.web.jsf.DelegatingNavigationHandlerProxy </navigation-handler> ... </application>

 <bean name="jsfNavigationHandler" class="mypackage.MyNavigationHandler"> <property name="myProperty" ref="myOtherBean"/> </bean>

For decorating the original NavigationHandler, make sure that your target bean extends Spring's DecoratingNavigationHandler class. This allows to pass in the original handler as method argument, which this proxy automatically detects. Note that a DecoratingNavigationHandler subclass will still work as standard JSF NavigationHandler as well!

This proxy may be subclassed to change the bean name used to search for the navigation handler, change the strategy used to obtain the target handler, or change the strategy used to access the ApplicationContext (normally obtained via FacesContextUtils#getWebApplicationContext(FacesContext)).

JSF PhaseListener implementation that delegates to one or more Spring-managed PhaseListener beans coming from the Spring root WebApplicationContext.

Configure this listener multicaster in your faces-config.xml file as follows:

 <application> ... <phase-listener> org.springframework.web.jsf.DelegatingPhaseListenerMulticaster </phase-listener> ... </application>

Note: This multicaster's getPhaseId() method will always return ANY_PHASE. The phase id exposed by the target listener beans will be ignored; all events will be propagated to all listeners.

This multicaster may be subclassed to change the strategy used to obtain the listener beans, or to change the strategy used to access the ApplicationContext (normally obtained via FacesContextUtils#getWebApplicationContext(FacesContext)).

Delegating implementation of javax.servlet.ServletInputStream.

Used by MockHttpServletRequest; typically not directly used for testing application controllers.

Delegating implementation of javax.servlet.ServletOutputStream.

Used by MockHttpServletResponse; typically not directly used for testing application controllers.

DelegatingSmartContextLoader is a concrete implementation of AbstractDelegatingSmartContextLoader that delegates to a GenericXmlContextLoader (or a GenericGroovyXmlContextLoader if Groovy is present in the classpath) and an AnnotationConfigContextLoader.

Empty ThemeSource that delegates all calls to the parent ThemeSource. If no parent is available, it simply won't resolve any theme.

Used as placeholder by UiApplicationContextUtils, if a context doesn't define its own ThemeSource. Not intended for direct use in applications.

Simple TimerListener adapter that delegates to a given Runnable.

TransactionDefinition implementation that delegates all calls to a given target TransactionDefinition instance. Abstract because it is meant to be subclassed, with subclasses overriding specific methods that are not supposed to simply delegate to the target instance.

Implementation of WebConnection that allows delegating to various WebConnection implementations.

For example, if you host your JavaScript on the domain code.jquery.com, you might want to use the following.

 WebClient webClient = new WebClient(); MockMvc mockMvc = ... MockMvcWebConnection mockConnection = new MockMvcWebConnection(mockMvc, webClient); WebRequestMatcher cdnMatcher = new UrlRegexRequestMatcher(".*?//code.jquery.com/.*"); WebConnection httpConnection = new HttpWebConnection(webClient); WebConnection webConnection = new DelegatingWebConnection(mockConnection, new DelegateWebConnection(cdnMatcher, httpConnection)); webClient.setWebConnection(webConnection); WebClient webClient = new WebClient(); webClient.setWebConnection(webConnection); 

A variation of WebSocketConfigurationSupport that detects implementations of WebSocketConfigurer in Spring configuration and invokes them in order to configure WebSocket request handling.

A WebSocketMessageBrokerConfigurationSupport extension that detects beans of type WebSocketMessageBrokerConfigurer and delegates to all of them allowing callback style customization of the configuration provided in WebSocketMessageBrokerConfigurationSupport.

This class is typically imported via EnableWebSocketMessageBroker.

Simple Work adapter that delegates to a given Runnable.

Simple Work adapter that delegates to a given Runnable.

Annotation for mapping HTTP DELETE requests onto specific handler methods.

Specifically, @DeleteMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.DELETE).

Beans on which the current bean depends. Any beans specified are guaranteed to be created by the container before this bean. Used infrequently in cases where a bean does not explicitly depend on another through properties or constructor arguments, but rather depends on the side effects of another bean's initialization.

May be used on any class directly or indirectly annotated with org.springframework.stereotype.Component or on methods annotated with Bean.

Using DependsOn at the class level has no effect unless component-scanning is being used. If a DependsOn-annotated class is declared via XML, DependsOn annotation metadata is ignored, and <bean depends-on="..."/> is respected instead.

Bean factory post processor that logs a warning for Deprecated beans.

Derby specific implementation for the CallMetaDataProvider interface. This class is intended for internal use by the Simple JDBC classes.

DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table with the equivalent of an auto-increment column. Note: If you use this class, your Derby key column should NOT be defined as an IDENTITY column, as the sequence table does the job.

The sequence is kept in a table. There should be one sequence table per table that needs an auto-generated key.

Derby requires an additional column to be used for the insert since it is impossible to insert a null into the identity column and have the value generated. This is solved by providing the name of a dummy column that also must be created in the sequence table.

Example:

create table tab (id int not null primary key, text varchar(100)); create table tab_sequence (value int generated always as identity, dummy char(1)); insert into tab_sequence (dummy) values(null);

Thanks to Endre Stolsvik for the suggestion!

The Derby specific implementation of the org.springframework.jdbc.core.metadata.TableMetaDataProvider. Overrides the Derby metadata info regarding retrieving generated keys. It seems to work OK so not sure why they claim it's not supported.

Adds a textual description to bean definitions derived from org.springframework.stereotype.Component or Bean.

A Converter that delegates to a org.springframework.core.serializer.Deserializer to convert data in a byte array to an object.

A MessageCondition for matching the destination of a Message against one or more destination patterns using a PathMatcher.

Thrown by a DestinationResolver when it cannot resolve a destination name.

Thrown by a DestinationResolver when it cannot resolve a destination.

A java.security.Principal can also implement this contract when getName() isn't globally unique and therefore not suited for use with "user" destinations.

Annotation that indicates a method parameter should be bound to a template variable in a destination template string. Supported on message handling methods such as MessageMapping.

A @DestinationVariable template variable is always required.

Resolves method parameters annotated with org.springframework.messaging.handler.annotation.DestinationVariable.

Subinterface of BeanPostProcessor that adds a before-destruction callback.

The typical usage will be to invoke custom destruction callbacks on specific bean types, matching corresponding initialization callbacks.

Adapter that implements the Servlet HttpSessionBindingListener interface, wrapping a session destruction callback.

Miscellaneous methods for calculating digests.

Mainly for internal use within the framework; consider Apache Commons Codec for a more comprehensive suite of digest utilities.

ConfigurablePropertyAccessor implementation that directly accesses instance fields. Allows for direct binding to fields instead of going through JavaBean setters.

As of Spring 4.2, the vast majority of the BeanWrapper features have been merged to AbstractPropertyAccessor, which means that property traversal as well as collections and map access is now supported here as well.

A DirectFieldAccessor's default for the "extractOldValueForEditor" setting is "true", since a field can always be read without side effects.

Special implementation of the Errors and BindingResult interfaces, supporting registration and evaluation of binding errors on value objects. Performs direct field access instead of going through JavaBean getters.

Since Spring 4.1 this implementation is able to traverse nested fields.

Test annotation which indicates that the org.springframework.context.ApplicationContext associated with a test is dirty and should therefore be closed and removed from the context cache.

Use this annotation if a test has modified the context — for example, by modifying the state of a singleton bean, modifying the state of an embedded database, etc. Subsequent tests that request the same context will be supplied a new context.

@DirtiesContext may be used as a class-level and method-level annotation within the same class or class hierarchy. In such scenarios, the ApplicationContext will be marked as dirty before or after any such annotated method as well as before or after the current test class, depending on the configured #methodMode and #classMode.

As of Spring Framework 4.0, this annotation may be used as a meta-annotation to create custom composed annotations.

• Before current test class: when declared at the class level with class mode set to BEFORE_CLASS
• Before each test method in current test class: when declared at the class level with class mode set to BEFORE_EACH_TEST_METHOD
• Before current test method: when declared at the method level with method mode set to BEFORE_METHOD
• After current test method: when declared at the method level with method mode set to AFTER_METHOD
• After each test method in current test class: when declared at the class level with class mode set to AFTER_EACH_TEST_METHOD
• After current test class: when declared at the class level with class mode set to AFTER_CLASS

BEFORE_* modes are supported by the org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener; AFTER_* modes are supported by the org.springframework.test.context.support.DirtiesContextTestExecutionListener.

@DisabledIf is used to signal that the annotated test class or test method is disabled and should not be executed if the supplied #expression evaluates to true.

When applied at the class level, all test methods within that class are automatically disabled as well.

For basic examples, see the Javadoc for #expression.

This annotation may be used as a meta-annotation to create custom composed annotations. For example, a custom @DisabledOnMac annotation can be created as follows.

 @Target({ ElementType.TYPE, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @DisabledIf( expression = "#{systemProperties['os.name'].toLowerCase().contains('mac')}", reason = "Disabled on Mac OS" ) public @interface DisabledOnMac {} 

ServletWebRequest subclass that is aware of org.springframework.web.servlet.DispatcherServlet's request context, such as the Locale determined by the configured org.springframework.web.servlet.LocaleResolver.

Simple JavaBean that holds the defaults specified at the <beans> level in a standard Spring XML bean definition document: default-lazy-init, default-autowire, etc.

Convenience methods for working with the DOM API, in particular for working with DOM Nodes and DOM Elements.

Simple implementation of the standard JDBC javax.sql.DataSource interface, configuring the plain old JDBC java.sql.DriverManager via bean properties, and returning a new java.sql.Connection from every getConnection call.

NOTE: This class is not an actual connection pool; it does not actually pool Connections. It just serves as simple replacement for a full-blown connection pool, implementing the same standard interface, but creating new Connections on every call.

Useful for test or standalone environments outside of a Java EE container, either as a DataSource bean in a corresponding ApplicationContext or in conjunction with a simple JNDI environment. Pool-assuming Connection.close() calls will simply close the Connection, so any DataSource-aware persistence code should work.

NOTE: Within special class loading environments such as OSGi, this class is effectively superseded by SimpleDriverDataSource due to general class loading issues with the JDBC DriverManager that be resolved through direct Driver usage (which is exactly what SimpleDriverDataSource does).

In a Java EE container, it is recommended to use a JNDI DataSource provided by the container. Such a DataSource can be exposed as a DataSource bean in a Spring ApplicationContext via org.springframework.jndi.JndiObjectFactoryBean, for seamless switching to and from a local DataSource bean like this class. For tests, you can then either set up a mock JNDI environment through Spring's org.springframework.mock.jndi.SimpleNamingContextBuilder, or switch the bean definition to a local DataSource (which is simpler and thus recommended).

If you need a "real" connection pool outside of a Java EE container, consider Apache Commons DBCP or C3P0. Commons DBCP's BasicDataSource and C3P0's ComboPooledDataSource are full connection pool beans, supporting the same basic properties as this class plus specific settings (such as minimal/maximal pool size etc).

Exception thrown when an attempt to insert or update data results in violation of an primary key or unique constraint. Note that this is not necessarily a purely relational concept; unique primary keys are required by most database types.

Convenient superclass when we want to force subclasses to implement MethodMatcher interface, but subclasses will want to be pointcuts. The getClassFilter() method can be overriden to customize ClassFilter behaviour as well.

org.springframework.orm.jpa.JpaVendorAdapter implementation for Eclipse Persistence Services (EclipseLink). Developed and tested against EclipseLink 2.4.

Exposes EclipseLink's persistence provider and EntityManager extension interface, and adapts AbstractJpaVendorAdapter's common configuration settings. No support for the detection of annotated packages (through org.springframework.orm.jpa.persistenceunit.SmartPersistenceUnitInfo#getManagedPackages()) since EclipseLink doesn't use package-level metadata.

Cache implementation on top of an Ehcache instance.

CacheManager backed by an EhCache net.sf.ehcache.CacheManager.

FactoryBean that creates a named EhCache net.sf.ehcache.Cache instance (or a decorator that implements the net.sf.ehcache.Ehcache interface), representing a cache region within an EhCache net.sf.ehcache.CacheManager.

If the specified named cache is not configured in the cache configuration descriptor, this FactoryBean will construct an instance of a Cache with the provided name and the specified cache properties and add it to the CacheManager for later retrieval. If some or all properties are not set at configuration time, this FactoryBean will use defaults.

Note: If the named Cache instance is found, the properties will be ignored and the Cache instance will be retrieved from the CacheManager.

Note: As of Spring 5.0, Spring's EhCache support requires EhCache 2.10 or higher.

FactoryBean that exposes an EhCache net.sf.ehcache.CacheManager instance (independent or shared), configured from a specified config location.

If no config location is specified, a CacheManager will be configured from "ehcache.xml" in the root of the class path (that is, default EhCache initialization - as defined in the EhCache docs - will apply).

Setting up a separate EhCacheManagerFactoryBean is also advisable when using EhCacheFactoryBean, as it provides a (by default) independent CacheManager instance and cares for proper shutdown of the CacheManager. EhCacheManagerFactoryBean is also necessary for loading EhCache configuration from a non-default config location.

Note: As of Spring 5.0, Spring's EhCache support requires EhCache 2.10 or higher.

Convenient builder methods for EhCache 2.5+ CacheManager setup, providing easy programmatic bootstrapping from a Spring-provided resource. This is primarily intended for use within @Bean methods in a Spring configuration class.

These methods are a simple alternative to custom CacheManager setup code. For any advanced purposes, consider using #parseConfiguration, customizing the configuration object, and then calling the CacheManager#CacheManager(Configuration) constructor.

Base class for EIS operation objects that work with the CCI API. Encapsulates a CCI ConnectionFactory and a CCI InteractionSpec.

Works with a CciTemplate instance underneath. EIS operation objects are an alternative to working with a CciTemplate directly.

Strategy implementation for parsing EJB3's javax.ejb.TransactionAttribute annotation.

Exception that gets thrown when an EJB stub cannot be accessed properly.

Represents the elvis operator ?:. For an expression "a?:b" if a is not null, the value of the expression is "a", if a is null then the value of the expression is "b".

EmbeddedDatabase serves as a handle to an embedded database instance.

An EmbeddedDatabase is also a DataSource and adds a #shutdown operation so that the embedded database instance can be shut down gracefully.

A builder that provides a convenient API for constructing an embedded database. Usage Example

 EmbeddedDatabase db = new EmbeddedDatabaseBuilder() .generateUniqueName(true) .setType(H2) .setScriptEncoding("UTF-8") .ignoreFailedDrops(true) .addScript("schema.sql") .addScripts("user_data.sql", "country_data.sql") .build(); // perform actions against the db (EmbeddedDatabase extends javax.sql.DataSource) db.shutdown(); 

EmbeddedDatabaseConfigurer encapsulates the configuration required to create, connect to, and shut down a specific type of embedded database such as HSQL, H2, or Derby.

Factory for creating an EmbeddedDatabase instance.

Callers are guaranteed that the returned database has been fully initialized and populated.

The factory can be configured as follows:

• Call #generateUniqueDatabaseName to set a unique, random name for the database.
• Call #setDatabaseName to set an explicit name for the database.
• Call #setDatabaseType to set the database type if you wish to use one of the supported types.
• Call #setDatabaseConfigurer to configure support for a custom embedded database type.
• Call #setDatabasePopulator to change the algorithm used to populate the database.
• Call #setDataSourceFactory to change the type of DataSource used to connect to the database.

After configuring the factory, call #getDatabase() to obtain a reference to the EmbeddedDatabase instance.

A subclass of EmbeddedDatabaseFactory that implements FactoryBean for registration as a Spring bean. Returns the actual DataSource that provides connectivity to the embedded database to Spring.

The target DataSource is returned instead of an EmbeddedDatabase proxy since the FactoryBean will manage the initialization and destruction lifecycle of the embedded database instance.

Implements DisposableBean to shutdown the embedded database when the managing Spring container is being closed.

Convenient base class for components with a need for embedded value resolution (i.e. org.springframework.context.EmbeddedValueResolverAware consumers).

StringValueResolver adapter for resolving placeholders and expressions against a ConfigurableBeanFactory.

Note that this adapter resolves expressions as well, in contrast to the ConfigurableBeanFactory#resolveEmbeddedValue method. The BeanExpressionContext used is for the plain bean factory, with no scope specified for any contextual objects to access.

Interface to be implemented by any object that wishes to be notified of a StringValueResolver for the resolution of embedded definition values.

This is an alternative to a full ConfigurableBeanFactory dependency via the ApplicationContextAware/BeanFactoryAware interfaces.

Empty implementation of the ReaderEventListener interface, providing no-op implementations of all callback methods.

Data access exception thrown when a result was expected to have at least one row (or element) but zero rows (or elements) were actually returned.

A simple empty implementation of the SqlParameterSource interface.

Canonical TargetSource when there is no target (or just the target class known), and behavior is supplied by interfaces and advisors only.

Enables support for handling components marked with AspectJ's @Aspect annotation, similar to functionality found in Spring's <aop:aspectj-autoproxy> XML element. To be used on @Configuration classes as follows:

 @Configuration @EnableAspectJAutoProxy public class AppConfig { @Bean public FooService fooService() { return new FooService(); } @Bean public MyAspect myAspect() { return new MyAspect(); } }

 public class FooService { // various methods }

 @Aspect public class MyAspect { @Before("execution(* FooService+.*(..))") public void advice() { // advise FooService methods as appropriate } }

Users can control the type of proxy that gets created for FooService using the #proxyTargetClass() attribute. The following enables CGLIB-style 'subclass' proxies as opposed to the default interface-based JDK proxy approach.

 @Configuration @EnableAspectJAutoProxy(proxyTargetClass=true) public class AppConfig { // ... }

Note that @Aspect beans may be component-scanned like any other. Simply mark the aspect with both @Aspect and @Component:

 package com.foo; @Component public class FooService { ... } @Aspect @Component public class MyAspect { ... }

 @Configuration @ComponentScan("com.foo") @EnableAspectJAutoProxy public class AppConfig { // no explicit @Bean definitions required }

Enables Spring's asynchronous method execution capability, similar to functionality found in Spring's <task:*> XML namespace.

To be used together with @Configuration classes as follows, enabling annotation-driven async processing for an entire Spring application context:

 @Configuration @EnableAsync public class AppConfig { }

 @Configuration public class AnotherAppConfig { @Bean public MyAsyncBean asyncBean() { return new MyAsyncBean(); } }

By default, Spring will be searching for an associated thread pool definition: either a unique org.springframework.core.task.TaskExecutor bean in the context, or an java.util.concurrent.Executor bean named "taskExecutor" otherwise. If neither of the two is resolvable, a org.springframework.core.task.SimpleAsyncTaskExecutor will be used to process async method invocations. Besides, annotated methods having a void return type cannot transmit any exception back to the caller. By default, such uncaught exceptions are only logged.

To customize all this, implement AsyncConfigurer and provide:

• your own java.util.concurrent.Executor through the getAsyncExecutor() method, and
• your own org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler through the getAsyncUncaughtExceptionHandler() method.

 @Configuration @EnableAsync public class AppConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(7); executor.setMaxPoolSize(42); executor.setQueueCapacity(11); executor.setThreadNamePrefix("MyExecutor-"); executor.initialize(); return executor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return MyAsyncUncaughtExceptionHandler(); } }

If only one item needs to be customized, null can be returned to keep the default settings. Consider also extending from AsyncConfigurerSupport when possible.

Note: In the above example the ThreadPoolTaskExecutor is not a fully managed Spring bean. Add the @Bean annotation to the getAsyncExecutor() method if you want a fully managed bean. In such circumstances it is no longer necessary to manually call the executor.initialize() method as this will be invoked automatically when the bean is initialized.

For reference, the example above can be compared to the following Spring XML configuration:

<beans> <task:annotation-driven executor="myExecutor" exception-handler="exceptionHandler"/> <task:executor id="myExecutor" pool-size="7-42" queue-capacity="11"/> <bean id="asyncBean" class="com.foo.MyAsyncBean"/> <bean id="exceptionHandler" class="com.foo.MyAsyncUncaughtExceptionHandler"/> </beans> 

The #mode attribute controls how advice is applied: If the mode is AdviceMode#PROXY (the default), then the other attributes control the behavior of the proxying. Please note that proxy mode allows for interception of calls through the proxy only; local calls within the same class cannot get intercepted that way.

Note that if the #mode is set to AdviceMode#ASPECTJ, then the value of the #proxyTargetClass attribute will be ignored. Note also that in this case the spring-aspects module JAR must be present on the classpath, with compile-time weaving or load-time weaving applying the aspect to the affected classes. There is no proxy involved in such a scenario; local calls will be intercepted as well.

Enable JMS listener annotated endpoints that are created under the cover by a org.springframework.jms.config.JmsListenerContainerFactory. To be used on org.springframework.context.annotation.Configuration classes as follows:

 @Configuration @EnableJms public class AppConfig { @Bean public DefaultJmsListenerContainerFactory myJmsListenerContainerFactory() { DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory(); factory.setConnectionFactory(connectionFactory()); factory.setDestinationResolver(destinationResolver()); factory.setConcurrency("5"); return factory; } // other @Bean definitions }

@EnableJms enables detection of JmsListener annotations on any Spring-managed bean in the container. For example, given a class MyService:

 package com.acme.foo; public class MyService { @JmsListener(containerFactory = "myJmsListenerContainerFactory", destination="myQueue") public void process(String msg) { // process incoming message } }

the following configuration would ensure that every time a javax.jms.Message is received on the javax.jms.Destination named "myQueue", MyService.process() is called with the content of the message:

 @Configuration @EnableJms public class AppConfig { @Bean public MyService myService() { return new MyService(); } // JMS infrastructure setup }

 @Configuration @EnableJms @ComponentScan(basePackages="com.acme.foo") public class AppConfig { }

Annotated methods can use flexible signature; in particular, it is possible to use the org.springframework.messaging.Message abstraction and related annotations, see JmsListener Javadoc for more details. For instance, the following would inject the content of the message and a custom "myCounter" JMS header:

 @JmsListener(containerFactory = "myJmsListenerContainerFactory", destination="myQueue") public void process(String msg, @Header("myCounter") int counter) { // process incoming message }

When more control is desired, a @Configuration class may implement JmsListenerConfigurer. This allows access to the underlying org.springframework.jms.config.JmsListenerEndpointRegistrar instance. The following example demonstrates how to specify an explicit default JmsListenerContainerFactory

 @Configuration @EnableJms public class AppConfig implements JmsListenerConfigurer { @Override public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) { registrar.setContainerFactory(myJmsListenerContainerFactory()); } @Bean public JmsListenerContainerFactory myJmsListenerContainerFactory() { // factory settings } @Bean public MyService myService() { return new MyService(); } }

<beans> <jms:annotation-driven container-factory="myJmsListenerContainerFactory"/> <bean id="myJmsListenerContainerFactory" class="org.springframework.jms.config.DefaultJmsListenerContainerFactory"> // factory settings </bean> <bean id="myService" class="com.acme.foo.MyService"/> </beans> 

 @Configuration @EnableJms public class AppConfig implements JmsListenerConfigurer { @Override public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) { registrar.setEndpointRegistry(myJmsListenerEndpointRegistry()); registrar.setMessageHandlerMethodFactory(myJmsHandlerMethodFactory); } @Bean public JmsListenerEndpointRegistry myJmsListenerEndpointRegistry() { // registry configuration } @Bean public JmsHandlerMethodFactory myJmsHandlerMethodFactory() { DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory(); factory.setValidator(new MyValidator()); return factory; } @Bean public MyService myService() { return new MyService(); } }

<beans> <jms:annotation-driven registry="myJmsListenerEndpointRegistry" handler-method-factory="myJmsHandlerMethodFactory"/&gt; <bean id="myJmsListenerEndpointRegistry" class="org.springframework.jms.config.JmsListenerEndpointRegistry"> // registry configuration </bean> <bean id="myJmsHandlerMethodFactory" class="org.springframework.messaging.handler.support.DefaultJmsHandlerMethodFactory"> <property name="validator" ref="myValidator"/> </bean> <bean id="myService" class="com.acme.foo.MyService"/> </beans> 

 @Configuration @EnableJms public class AppConfig implements JmsListenerConfigurer { @Override public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) { SimpleJmsListenerEndpoint myEndpoint = new SimpleJmsListenerEndpoint(); // ... configure the endpoint registrar.registerEndpoint(endpoint, anotherJmsListenerContainerFactory()); } @Bean public MyService myService() { return new MyService(); } @Bean public JmsListenerContainerFactory anotherJmsListenerContainerFactory() { // ... } // JMS infrastructure setup }

Activates a Spring LoadTimeWeaver for this application context, available as a bean with the name "loadTimeWeaver", similar to the <context:load-time-weaver> element in Spring XML.

To be used on @org.springframework.context.annotation.Configuration classes; the simplest possible example of which follows:

 @Configuration @EnableLoadTimeWeaving public class AppConfig { // application-specific @Bean definitions ... }

<beans> <context:load-time-weaver/> <!-- application-specific <bean> definitions --> </beans> 

To customize the weaver used, the @Configuration class annotated with @EnableLoadTimeWeaving may also implement the LoadTimeWeavingConfigurer interface and return a custom LoadTimeWeaver instance through the #getLoadTimeWeaver method:

 @Configuration @EnableLoadTimeWeaving public class AppConfig implements LoadTimeWeavingConfigurer { @Override public LoadTimeWeaver getLoadTimeWeaver() { MyLoadTimeWeaver ltw = new MyLoadTimeWeaver(); ltw.addClassTransformer(myClassFileTransformer); // ... return ltw; } }

The example above can be compared to the following Spring XML configuration:

<beans> <context:load-time-weaver weaverClass="com.acme.MyLoadTimeWeaver"/> </beans> 

The code example differs from the XML example in that it actually instantiates the MyLoadTimeWeaver type, meaning that it can also configure the instance, e.g. calling the #addClassTransformer method. This demonstrates how the code-based configuration approach is more flexible through direct programmatic access.

 @Configuration @EnableLoadTimeWeaving(aspectjWeaving=ENABLED) public class AppConfig { }

The example above can be compared to the following Spring XML configuration:

<beans> <context:load-time-weaver aspectj-weaving="on"/> </beans> 

The two examples are equivalent with one significant exception: in the XML case, the functionality of <context:spring-configured> is implicitly enabled when aspectj-weaving is "on". This does not occur when using @EnableLoadTimeWeaving(aspectjWeaving=ENABLED). Instead you must explicitly add @EnableSpringConfigured (included in the spring-aspects module)

Enables default exporting of all standard MBeans from the Spring context, as well as well all @ManagedResource annotated beans.

The resulting org.springframework.jmx.export.MBeanExporter bean is defined under the name "mbeanExporter". Alternatively, consider defining a custom AnnotationMBeanExporter bean explicitly.

This annotation is modeled after and functionally equivalent to Spring XML's <context:mbean-export/> element.

Enables Spring's scheduled task execution capability, similar to functionality found in Spring's <task:*> XML namespace. To be used on @Configuration classes as follows:

 @Configuration @EnableScheduling public class AppConfig { // various @Bean definitions }

 package com.myco.tasks; public class MyTask { @Scheduled(fixedRate=1000) public void work() { // task execution logic } }

 @Configuration @EnableScheduling public class AppConfig { @Bean public MyTask task() { return new MyTask(); } }

 @Configuration @EnableScheduling @ComponentScan(basePackages="com.myco.tasks") public class AppConfig { }

 @Configuration @EnableScheduling public class AppConfig { @Scheduled(fixedRate=1000) public void work() { // task execution logic } }

By default, will be searching for an associated scheduler definition: either a unique org.springframework.scheduling.TaskScheduler bean in the context, or a TaskScheduler bean named "taskScheduler" otherwise; the same lookup will also be performed for a java.util.concurrent.ScheduledExecutorService bean. If neither of the two is resolvable, a local single-threaded default scheduler will be created and used within the registrar.

When more control is desired, a @Configuration class may implement SchedulingConfigurer. This allows access to the underlying ScheduledTaskRegistrar instance. For example, the following example demonstrates how to customize the Executor used to execute scheduled tasks:

 @Configuration @EnableScheduling public class AppConfig implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar.setScheduler(taskExecutor()); } @Bean(destroyMethod="shutdown") public Executor taskExecutor() { return Executors.newScheduledThreadPool(100); } }

Note in the example above the use of @Bean(destroyMethod="shutdown"). This ensures that the task executor is properly shut down when the Spring application context itself is closed.

Implementing SchedulingConfigurer also allows for fine-grained control over task registration via the ScheduledTaskRegistrar. For example, the following configures the execution of a particular bean method per a custom Trigger implementation:

 @Configuration @EnableScheduling public class AppConfig implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar.setScheduler(taskScheduler()); taskRegistrar.addTriggerTask( new Runnable() { public void run() { myTask().work(); } }, new CustomTrigger() ); } @Bean(destroyMethod="shutdown") public Executor taskScheduler() { return Executors.newScheduledThreadPool(42); } @Bean public MyTask myTask() { return new MyTask(); } }

For reference, the example above can be compared to the following Spring XML configuration:

<beans> <task:annotation-driven scheduler="taskScheduler"/> <task:scheduler id="taskScheduler" pool-size="42"/> <task:scheduled-tasks scheduler="taskScheduler"> <task:scheduled ref="myTask" method="work" fixed-rate="1000"/> </task:scheduled-tasks> <bean id="myTask" class="com.foo.MyTask"/> </beans> 

Signals the current application context to apply dependency injection to non-managed classes that are instantiated outside of the Spring bean factory (typically classes annotated with the org.springframework.beans.factory.annotation.Configurable annotation).

Similar to functionality found in Spring's <context:spring-configured> XML element. Often used in conjunction with org.springframework.context.annotation.EnableLoadTimeWeaving.

Enables Spring's annotation-driven transaction management capability, similar to the support found in Spring's <tx:*> XML namespace. To be used on org.springframework.context.annotation.Configuration classes as follows:

 @Configuration @EnableTransactionManagement public class AppConfig { @Bean public FooRepository fooRepository() { // configure and return a class having @Transactional methods return new JdbcFooRepository(dataSource()); } @Bean public DataSource dataSource() { // configure and return the necessary JDBC DataSource } @Bean public PlatformTransactionManager txManager() { return new DataSourceTransactionManager(dataSource()); } }

For reference, the example above can be compared to the following Spring XML configuration:

<beans> <tx:annotation-driven/> <bean id="fooRepository" class="com.foo.JdbcFooRepository"> <constructor-arg ref="dataSource"/> </bean> <bean id="dataSource" class="com.vendor.VendorDataSource"/> <bean id="transactionManager" class="org.sfwk...DataSourceTransactionManager"> <constructor-arg ref="dataSource"/> </bean> </beans> 

A minor difference between the two examples lies in the naming of the PlatformTransactionManager bean: In the @Bean case, the name is "txManager" (per the name of the method); in the XML case, the name is "transactionManager". The <tx:annotation-driven/> is hard-wired to look for a bean named "transactionManager" by default, however @EnableTransactionManagement is more flexible; it will fall back to a by-type lookup for any PlatformTransactionManager bean in the container. Thus the name can be "txManager", "transactionManager", or "tm": it simply does not matter.

For those that wish to establish a more direct relationship between @EnableTransactionManagement and the exact transaction manager bean to be used, the TransactionManagementConfigurer callback interface may be implemented - notice the implements clause and the @Override-annotated method below:

 @Configuration @EnableTransactionManagement public class AppConfig implements TransactionManagementConfigurer { @Bean public FooRepository fooRepository() { // configure and return a class having @Transactional methods return new JdbcFooRepository(dataSource()); } @Bean public DataSource dataSource() { // configure and return the necessary JDBC DataSource } @Bean public PlatformTransactionManager txManager() { return new DataSourceTransactionManager(dataSource()); } @Override public PlatformTransactionManager annotationDrivenTransactionManager() { return txManager(); } }

The #mode attribute controls how advice is applied: If the mode is AdviceMode#PROXY (the default), then the other attributes control the behavior of the proxying. Please note that proxy mode allows for interception of calls through the proxy only; local calls within the same class cannot get intercepted that way.

Note that if the #mode is set to AdviceMode#ASPECTJ, then the value of the #proxyTargetClass attribute will be ignored. Note also that in this case the spring-aspects module JAR must be present on the classpath, with compile-time weaving or load-time weaving applying the aspect to the affected classes. There is no proxy involved in such a scenario; local calls will be intercepted as well.

Adding this annotation to an @Configuration class imports the Spring Web Reactive configuration from WebFluxConfigurationSupport, e.g.:

 @Configuration @EnableWebFlux @ComponentScan(basePackageClasses = MyConfiguration.class) public class MyConfiguration { } 

To customize the imported configuration implement WebFluxConfigurer and override individual methods as shown below:

 @Configuration @EnableWebFlux @ComponentScan(basePackageClasses = MyConfiguration.class) public class MyConfiguration implements WebFluxConfigurer { @Override public void addFormatters(FormatterRegistry formatterRegistry) { formatterRegistry.addConverter(new MyConverter()); } @Override public void configureMessageWriters(List<HttpMessageWriter<?>> messageWriters) { messageWriters.add(new MyHttpMessageWriter()); } } 

Note: only one @Configuration class may have the @EnableWebFlux annotation to import the Spring WebFlux configuration. There can however be multiple @Configuration classes implementing WebFluxConfigurer in order to customize the provided configuration.

If WebFluxConfigurer does not expose some more advanced setting that needs to be configured consider removing the @EnableWebFlux annotation and extending directly from WebFluxConfigurationSupport or DelegatingWebFluxConfiguration if you still want to allow WebFluxConfigurer instances to customize the configuration.

Adding this annotation to an @Configuration class imports the Spring MVC configuration from WebMvcConfigurationSupport, e.g.:

 @Configuration @EnableWebMvc @ComponentScan(basePackageClasses = MyConfiguration.class) public class MyConfiguration { } 

To customize the imported configuration, implement the interface WebMvcConfigurer and override individual methods, e.g.:

 @Configuration @EnableWebMvc @ComponentScan(basePackageClasses = MyConfiguration.class) public class MyConfiguration implements WebMvcConfigurer { @Override public void addFormatters(FormatterRegistry formatterRegistry) { formatterRegistry.addConverter(new MyConverter()); } @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { converters.add(new MyHttpMessageConverter()); } } 

Note: only one @Configuration class may have the @EnableWebMvc annotation to import the Spring Web MVC configuration. There can however be multiple @Configuration classes implementing WebMvcConfigurer in order to customize the provided configuration.

If WebMvcConfigurer does not expose some more advanced setting that needs to be configured consider removing the @EnableWebMvc annotation and extending directly from WebMvcConfigurationSupport or DelegatingWebMvcConfiguration, e.g.:

 @Configuration @ComponentScan(basePackageClasses = { MyConfiguration.class }) public class MyConfiguration extends WebMvcConfigurationSupport { @Override public void addFormatters(FormatterRegistry formatterRegistry) { formatterRegistry.addConverter(new MyConverter()); } @Bean public RequestMappingHandlerAdapter requestMappingHandlerAdapter() { // Create or delegate to "super" to create and // customize properties of RequestMappingHandlerAdapter } } 

Add this annotation to an @Configuration class to configure processing WebSocket requests:

 @Configuration @EnableWebSocket public class MyWebSocketConfig { } 

Customize the imported configuration by implementing the WebSocketConfigurer interface:

 @Configuration @EnableWebSocket public class MyConfiguration implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(echoWebSocketHandler(), "/echo").withSockJS(); } @Bean public WebSocketHandler echoWebSocketHandler() { return new EchoWebSocketHandler(); } } 

Add this annotation to an @Configuration class to enable broker-backed messaging over WebSocket using a higher-level messaging sub-protocol.

 @Configuration @EnableWebSocketMessageBroker public class MyWebSocketConfig { } 

Customize the imported configuration by implementing the WebSocketMessageBrokerConfigurer interface or more likely extend the convenient base class AbstractWebSocketMessageBrokerConfigurer:

 @Configuration @EnableWebSocketMessageBroker public class MyConfiguration extends AbstractWebSocketMessageBrokerConfigurer { @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/portfolio").withSockJS(); } @Bean public void configureMessageBroker(MessageBrokerRegistry registry) { registry.enableStompBrokerRelay("/queue/", "/topic/"); registry.setApplicationDestinationPrefixes("/app/"); } } 

@EnabledIf is used to signal that the annotated test class or test method is enabled and should be executed if the supplied #expression evaluates to true.

When applied at the class level, all test methods within that class are automatically enabled by default as well.

For basic examples, see the Javadoc for #expression.

This annotation may be used as a meta-annotation to create custom composed annotations. For example, a custom @EnabledOnMac annotation can be created as follows.

 @Target({ ElementType.TYPE, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @EnabledIf( expression = "#{systemProperties['os.name'].toLowerCase().contains('mac')}", reason = "Enabled on Mac OS" ) public @interface EnabledOnMac {} 

Indicates an issue with encoding the input Object stream with a focus on not being able to encode Objects. As opposed to a more general I/O errors or a CodecException such as a configuration issue that an Encoder may also choose to raise.

A WebSocket connection manager that is given a URI, an Endpoint, connects to a WebSocket server through the #start() and #stop() methods. If #setAutoStartup(boolean) is set to true this will be done automatically when the Spring ApplicationContext is refreshed.

Base class for any class that needs to access a JPA EntityManagerFactory, usually in order to obtain a JPA EntityManager. Defines common properties.

Holder wrapping a JPA EntityManager. JpaTransactionManager binds instances of this class to the thread, for a given EntityManagerFactory.

Note: This is an SPI class, not intended to be used by applications.

Subinterface of javax.persistence.EntityManager to be implemented by EntityManager proxies. Allows access to the underlying target EntityManager.

This interface is mainly intended for framework usage. Application code should prefer the use of the javax.persistence.EntityManager#getDelegate() method to access native functionality of the underlying resource.

Entity-specific subtype of ServerResponse that exposes entity data.

Read-only EL property accessor that knows how to retrieve keys of a Spring Environment instance.

A GenericMessage with a Throwable payload.

The payload is typically a org.springframework.messaging.MessagingException with the message at the point of failure in its failedMessage property. An optional originalMessage may be provided, which represents the message that existed at the point in the stack where the error message is created.

Consider some code that starts with a message, invokes some process that performs transformation on that message and then fails for some reason, throwing the exception. The exception is caught and an error message produced that contains both the original message, and the transformed message that failed.

Resolves Errors method arguments.

An Errors method argument is expected to appear immediately after the model attribute in the method signature. It is resolved by expecting the last two attributes added to the model to be the model attribute and its BindingResult.

Resolve Errors or BindingResult method arguments. An Errors argument is expected to appear immediately after the model attribute in the method signature.

The <errors> tag renders field errors in an HTML 'span' tag. Displays errors for either an object or a particular field.

This tag supports three main usage patterns:

1. Field only - set 'path' to the field name (or path)
2. Object errors only - omit 'path'
3. All errors - set 'path' to '*'

cssClass

false

true

HTML Optional Attribute

cssStyle

false

true

HTML Optional Attribute

delimiter

false

true

Delimiter for displaying multiple error messages. Defaults to the br tag.

dir

false

true

HTML Standard Attribute

element

false

true

Specifies the HTML element that is used to render the enclosing errors.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

false

true

Path to errors object for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

The <escapeBody> tag is used to escape its enclosed body content, applying HTML escaping and/or JavaScript escaping.

Provides a "htmlEscape" property for explicitly specifying whether to apply HTML escaping. If not set, a page-level default (e.g. from the HtmlEscapeTag) or an application-wide default (the "defaultHtmlEscape" context-param in web.xml) is used.

Provides a "javaScriptEscape" property for specifying whether to apply JavaScript escaping. Can be combined with HTML escaping or used standalone.

Errors wrapper that adds automatic HTML escaping to the wrapped instance, for convenient usage in HTML views. Can be retrieved easily via RequestContext's getErrors method.

Note that BindTag does not use this class to avoid unnecessary creation of ObjectError instances. It just escapes the messages and values that get copied into the respective BindStatus instance.

The <eval> tag evaluates a Spring expression (SpEL) and either prints the result or assigns it to a variable. Supports the standard JSP evaluation context consisting of implicit variables and scoped attributes. Attribute Summary Attribute Required? Runtime Expression? Description expression true true The expression to evaluate. htmlEscape false true Set HTML escaping for this tag, as a boolean value. Overrides the default HTML escaping setting for the current page. javaScriptEscape false true Set JavaScript escaping for this tag, as a boolean value. Default is false. scope false true The scope for the var. 'application', 'session', 'request' and 'page' scopes are supported. Defaults to page scope. This attribute has no effect unless the var attribute is also defined. var false true The name of the variable to export the evaluation result to. If not specified the evaluation result is converted to a String and written as output.

Represent an exception that occurs during expression evaluation.

Annotation that marks a method as a listener for application events.

If an annotated method supports a single event type, the method may declare a single parameter that reflects the event type to listen to. If an annotated method supports multiple event types, this annotation may refer to one or more supported event types using the classes attribute. See the #classes javadoc for further details.

Events can be ApplicationEvent instances as well as arbitrary objects.

Processing of @EventListener annotations is performed via the internal EventListenerMethodProcessor bean which gets registered automatically when using Java config or manually via the <context:annotation-config/> or <context:component-scan/> element when using XML config.

Annotated methods may have a non-void return type. When they do, the result of the method invocation is sent as a new event. If the return type is either an array or a collection, each element is sent as a new individual event.

It is also possible to define the order in which listeners for a certain event are to be invoked. To do so, add Spring's common org.springframework.core.annotation.Order annotation alongside this event listener annotation.

While it is possible for an event listener to declare that it throws arbitrary exception types, any checked exceptions thrown from an event listener will be wrapped in an java.lang.reflect.UndeclaredThrowableException since the event publisher can only handle runtime exceptions.

Register EventListener annotated method as individual ApplicationListener instances.

MethodInterceptor that publishes an ApplicationEvent to all ApplicationListeners registered with an ApplicationEventPublisher after each successful method invocation.

Note that this interceptor is only capable of publishing stateless events configured via the "applicationEventClass" property.

A TransportHandler for sending messages via Server-Sent events: http://dev.w3.org/html5/eventsource/.

Comparator capable of sorting exceptions based on their depth from the thrown exception type.

Annotation for handling exceptions in specific handler classes and/or handler methods.

Handler methods which are annotated with this annotation are allowed to have very flexible signatures. They may have parameters of the following types, in arbitrary order:

• An exception argument: declared as a general Exception or as a more specific exception. This also serves as a mapping hint if the annotation itself does not narrow the exception types through its #value().
• Request and/or response objects (typically from the Servlet API). You may choose any specific request/response type, e.g. javax.servlet.ServletRequest / javax.servlet.http.HttpServletRequest.
• Session object: typically javax.servlet.http.HttpSession. An argument of this type will enforce the presence of a corresponding session. As a consequence, such an argument will never be null. Note that session access may not be thread-safe, in particular in a Servlet environment: Consider switching the "synchronizeOnSession" flag to "true" if multiple requests are allowed to access a session concurrently.
• org.springframework.web.context.request.WebRequest or org.springframework.web.context.request.NativeWebRequest. Allows for generic request parameter access as well as request/session attribute access, without ties to the native Servlet API.
• java.util.Locale for the current request locale (determined by the most specific locale resolver available, i.e. the configured org.springframework.web.servlet.LocaleResolver in a Servlet environment).
• java.io.InputStream / java.io.Reader for access to the request's content. This will be the raw InputStream/Reader as exposed by the Servlet API.
• java.io.OutputStream / java.io.Writer for generating the response's content. This will be the raw OutputStream/Writer as exposed by the Servlet API.
• org.springframework.ui.Model as an alternative to returning a model map from the handler method. Note that the provided model is not pre-populated with regular model attributes and therefore always empty, as a convenience for preparing the model for an exception-specific view.

The following return types are supported for handler methods:

• A ModelAndView object (from Servlet MVC).
• A org.springframework.ui.Model object, with the view name implicitly determined through a org.springframework.web.servlet.RequestToViewNameTranslator.
• A java.util.Map object for exposing a model, with the view name implicitly determined through a org.springframework.web.servlet.RequestToViewNameTranslator.
• A org.springframework.web.servlet.View object.
• A String value which is interpreted as view name.
• ResponseBody annotated methods (Servlet-only) to set the response content. The return value will be converted to the response stream using org.springframework.http.converter.HttpMessageConverter.
• An org.springframework.http.HttpEntity or org.springframework.http.ResponseEntity object (Servlet-only) to set response headers and content. The ResponseEntity body will be converted and written to the response stream using org.springframework.http.converter.HttpMessageConverter.
• void if the method handles the response itself (by writing the response content directly, declaring an argument of type javax.servlet.ServletResponse / javax.servlet.http.HttpServletResponse for that purpose) or if the view name is supposed to be implicitly determined through a org.springframework.web.servlet.RequestToViewNameTranslator (not declaring a response argument in the handler method signature).

In Servlet environments, you can combine the ExceptionHandler annotation with ResponseStatus, to define the response status for the HTTP response.

Discovers ExceptionHandler methods in a given class, including all of its superclasses, and helps to resolve a given Exception to the exception types supported by a given Method.

WebHandler decorator that invokes one or more WebExceptionHandlers after the delegate WebHandler.

An InstanceFilter implementation that handles exception types. A type will match against a given candidate if it is assignable to that candidate.

An exception handling WebSocketHandlerDecorator. Traps all Throwable instances that escape from the decorated handler and closes the session with CloseStatus#SERVER_ERROR.

Implementations of ExchangeFilterFunction that provide various useful request filter operations, such as basic authentication, error handling, etc.

Exposes request-response exchange functionality, such as to create an ExchangeFunction given a ClientHttpConnector.

Container for request and response details for exchanges performed through WebTestClient.

Note that a decoded response body is not exposed at this level since the body may not have been decoded and consumed yet. Sub-types EntityExchangeResult and FluxExchangeResult provide access to a decoded response entity and a decoded (but not consumed) response body respectively.

Parser for the 'executor' element of the 'task' namespace.

An extension of ChannelInterceptor with callbacks to intercept the asynchronous sending of a org.springframework.messaging.Message to a specific subscriber through an java.util.concurrent.Executor. Supported on org.springframework.messaging.MessageChannel implementations that can be configured with an Executor.

Adapter that takes a Spring org.springframework.core.task.TaskExecutor) and exposes a full java.util.concurrent.ExecutorService for it.

This is primarily for adapting to client components that communicate via the java.util.concurrent.ExecutorService API. It can also be used as common ground between a local Spring TaskExecutor backend and a JNDI-located ManagedExecutorService in a Java EE 6 environment.

NOTE: This ExecutorService adapter does not support the lifecycle methods in the java.util.concurrent.ExecutorService API ("shutdown()" etc), similar to a server-wide ManagedExecutorService in a Java EE 6 environment. The lifecycle is always up to the backend pool, with this adapter acting as an access-only proxy for that target pool.

A SubscribableChannel that sends messages to each of its subscribers.

Simple extension of the JndiTemplate class that always returns a given object.

Very useful for testing. Effectively a mock object.

Implementation of BackOff that increases the back off period for each retry attempt. When the interval has reached the max interval, it is no longer increased. Stops retrying once the max elapsed time has been reached.

Example: The default interval is {@value #DEFAULT_INITIAL_INTERVAL} ms, the default multiplier is {@value #DEFAULT_MULTIPLIER}, and the default max interval is {@value #DEFAULT_MAX_INTERVAL}. For 10 attempts the sequence will be as follows:

 request# back off 1 2000 2 3000 3 4500 4 6750 5 10125 6 15187 7 22780 8 30000 9 30000 10 30000 

Note that the default max elapsed time is Long#MAX_VALUE. Use #setMaxElapsedTime(long) to limit the maximum length of time that an instance should accumulate before returning BackOffExecution#STOP.

Convenient methods for creating advisors that may be used when autoproxying beans created with the Spring IoC container, binding the bean name to the current invocation. May support a bean() pointcut designator with AspectJ.

Typically used in Spring auto-proxying, where the bean name is known at proxy creation time.

Interceptor that exposes the current org.aopalliance.intercept.MethodInvocation as a thread-local object. We occasionally need to do this; for example, when a pointcut (e.g. an AspectJ expression pointcut) needs to know the full 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 API. Target objects should be plain POJOs as far as possible.

If used, this interceptor will normally be the first in the interceptor chain.

This exception wraps (as cause) a checked exception thrown by some method that SpEL invokes. It differs from a SpelEvaluationException because this indicates the occurrence of a checked exception that the invoked method was defined to throw. SpelEvaluationExceptions are for handling (and wrapping) unexpected exceptions.

Interface to be implemented by pointcuts that use String expressions.

Common utility functions that may be used by any Expression Language provider.

Resolves method arguments annotated with @Value.

An @Value does not have a name but gets resolved from the default value string, which may contain ${...} placeholder or Spring Expression Language #{...} expressions.

A WebDataBinder may be invoked to apply type conversion to resolved argument value.

Resolves method arguments annotated with @Value.

An @Value does not have a name but gets resolved from the default value string, which may contain ${...} placeholder or Spring Expression Language #{...} expressions.

BeanInfoFactory implementation that evaluates whether bean classes have "non-standard" JavaBeans setter methods and are thus candidates for introspection by Spring's (package-visible) ExtendedBeanInfo implementation.

Ordered at Ordered#LOWEST_PRECEDENCE to allow other user-defined BeanInfoFactory types to take precedence.

Delegate for creating a variety of javax.persistence.EntityManager proxies that follow the JPA spec's semantics for "extended" EntityManagers.

Supports several different variants of "extended" EntityManagers: in particular, an "application-managed extended EntityManager", as defined by javax.persistence.EntityManagerFactory#createEntityManager(), as well as a "container-managed extended EntityManager", as defined by javax.persistence.PersistenceContextType#EXTENDED.

The original difference between "application-managed" and "container-managed" was the need for explicit joining of an externally managed transaction through the EntityManager#joinTransaction() method in the "application" case versus the automatic joining on each user-level EntityManager operation in the "container" case. As of JPA 2.1, both join modes are available with both kinds of EntityManagers, so the difference between "application-" and "container-managed" is now primarily in the join mode default and in the restricted lifecycle of a container-managed EntityManager (i.e. tied to the object that it is injected into).

Subclass of ServletRequestDataBinder that adds URI template variables to the values used for data binding.

Implementation of ResponseErrorHandler that uses HttpMessageConverters to convert HTTP error responses to RestClientException.

To use this error handler, you must specify a status mapping and/or a series mapping. If either of these mappings has a match for the status code of a given ClientHttpResponse, #hasError(ClientHttpResponse) will return true and #handleError(ClientHttpResponse) will attempt to use the configured message converters to convert the response into the mapped subclass of RestClientException. Note that the status mapping takes precedence over series mapping.

If there is no match, this error handler will default to the behavior of DefaultResponseErrorHandler. Note that you can override this default behavior by specifying a series mapping from HttpStatus.Series#CLIENT_ERROR and/or HttpStatus.Series#SERVER_ERROR to null.

WebRequest adapter for a JSF javax.faces.context.FacesContext.

Requires JSF 2.0 or higher, as of Spring 4.0.

Exception to be thrown from a FactoryBean's getObject() method if the bean is not fully initialized yet, for example because it is involved in a circular reference.

Note: A circular reference with a FactoryBean cannot be solved by eagerly caching singleton instances like with normal beans. The reason is that every FactoryBean needs to be fully initialized before it can return the created bean, while only specific normal beans need to be initialized - that is, if a collaborating bean actually invokes them on initialization instead of just storing the reference.

Simple ProblemReporter implementation that exhibits fail-fast behavior when errors are encountered.

The first error encountered results in a BeanDefinitionParsingException being thrown.

Warnings are written to the log for this class.

A speedy alternative to java.io.ByteArrayOutputStream. Note that this variant does not extend ByteArrayOutputStream, unlike its sibling ResizableByteArrayOutputStream.

Unlike java.io.ByteArrayOutputStream, this implementation is backed by a java.util.LinkedList of byte[] instead of 1 constantly resizing byte[]. It does not copy buffers when it gets expanded.

The initial buffer is only created when the stream is first written. There is also no copying of the internal buffer if its contents is extracted with the #writeTo(OutputStream) method.

Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field.

FactoryBean which retrieves a static or non-static field value.

Typically used for retrieving public static final constants. Usage example:

// standard definition for exposing a static field, specifying the "staticField" property <bean id="myField" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"> <property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE"/> </bean> // convenience version that specifies a static field pattern as bean name <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>

If you are using Spring 2.0, you can also use the following style of configuration for public static fields.

<util:constant static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>

Simple utility methods for file and stream copying. All copy methods use a block size of 4096 bytes, and close all affected streams when done. A variation of the copy methods from this class that leave streams open can be found in StreamUtils.

Mainly for use within the framework, but also useful for application code.

Editor for java.io.File, to directly populate a File property from a Spring resource location.

Supports Spring-style URL notation: any fully qualified standard URL ("file:", "http:", etc) and Spring's special "classpath:" pseudo-URL.

NOTE: The behavior of this editor has changed in Spring 2.0. Previously, it created a File instance directly from a filename. As of Spring 2.0, it takes a standard Spring resource location as input; this is consistent with URLEditor and InputStreamEditor now.

NOTE: In Spring 2.5 the following modification was made. If a file name is specified without a URL prefix or without an absolute path then we try to locate the file using standard ResourceLoader semantics. If the file was not found, then a File instance is created assuming the file name refers to a relative file location.

Specialization of Part for a file upload.

ResourceLoader implementation that resolves plain paths as file system resources rather than as class path resources (the latter is DefaultResourceLoader's default strategy).

NOTE: Plain paths will always be interpreted as relative to the current VM working directory, even if they start with a slash. (This is consistent with the semantics in a Servlet container.) Use an explicit "file:" prefix to enforce an absolute file path.

org.springframework.context.support.FileSystemXmlApplicationContext is a full-fledged ApplicationContext implementation that provides the same resource path resolution strategy.

Utility methods for working with the file system.

Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g. "mydir/myfile.txt"). Useful for test harnesses as well as for standalone environments.

NOTE: Plain paths will always be interpreted as relative to the current VM working directory, even if they start with a slash. (This is consistent with the semantics in a Servlet container.) Use an explicit "file:" prefix to enforce an absolute file path.

The config location defaults can be overridden via #getConfigLocations, Config locations can either denote concrete files like "/myfiles/context.xml" or Ant-style patterns like "/myfiles/*-context.xml" (see the org.springframework.util.AntPathMatcher javadoc for pattern details).

Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files. This can be leveraged to deliberately override certain bean definitions via an extra XML file.

This is a simple, one-stop shop convenience ApplicationContext. Consider using the GenericApplicationContext class in combination with an org.springframework.beans.factory.xml.XmlBeanDefinitionReader for more flexible context setup.

Subclass of UrlResource which assumes file resolution, to the degree of implementing the WritableResource interface for it.

This is the class resolved by DefaultResourceLoader for a "file:..." URL location, allowing a downcast to WritableResource for it.

Alternatively, for direct construction from a java.io.File handle, consider using FileSystemResource. For an NIO java.nio.file.Path, consider using PathResource instead.

Enumeration of the type filters that may be used in conjunction with ComponentScan.

WebHandler decorator that invokes a chain of WebFilters before the delegate WebHandler.

A simple BackOff implementation that provides a fixed interval between two attempts and a maximum number of retries.

A ContentNegotiationStrategy that returns a fixed content type.

Resolver that always resolves to a fixed list of media types. This can be used as the "last in line" strategy providing a fallback for when the client has not requested any media types.

A simple strategy for making reconnect attempts at a fixed interval.

LocaleContextResolver implementation that always returns a fixed default locale and optionally time zone. Default is the current JVM's default locale.

Note: Does not support setLocale(Context), as the fixed locale and time zone cannot be changed.

org.springframework.web.servlet.LocaleResolver implementation that always returns a fixed default locale and optionally time zone. Default is the current JVM's default locale.

Note: Does not support setLocale(Context), as the fixed locale and time zone cannot be changed.

org.springframework.web.servlet.ThemeResolver implementation that simply uses a fixed theme. The fixed name can be defined via the "defaultThemeName" property; out of the box, it is "theme".

Note: Does not support setThemeName, as the fixed theme cannot be changed.

A VersionStrategy that relies on a fixed version applied as a request path prefix, e.g. reduced SHA, version name, release date, etc.

This is useful for example when ContentVersionStrategy cannot be used such as when using JavaScript module loaders which are in charge of loading the JavaScript resources and need to know their relative paths.

A VersionStrategy that relies on a fixed version applied as a request path prefix, e.g. reduced SHA, version name, release date, etc.

This is useful for example when ContentVersionStrategy cannot be used such as when using JavaScript module loaders which are in charge of loading the JavaScript resources and need to know their relative paths.

Factory for "output" flash attribute assertions.

An instance of this class is typically accessed via MockMvcResultMatchers#flash.

Expression language AST node that represents a float literal.

A Spring FactoryBean that builds and exposes a preconfigured ForkJoinPool.

For details on the ForkJoinPool API and its use with RecursiveActions, see the JDK 7 javadoc.

jsr166.jar, containing java.util.concurrent updates for Java 6, can be obtained from the concurrency interest website.

Specialization of Part for a form field.

Implementation of an HttpMessageReader to read HTML form data, i.e. request body with media type "application/x-www-form-urlencoded".

Utility methods (formatters, etc) used during parsing and evaluation.

Adapter that bridges between Formatter and PropertyEditor.

Registers Converter and Formatter with a FormattingConversionService through the FormatterRegistry SPI.

A org.springframework.core.convert.ConversionService implementation designed to be configured as a FormatterRegistry.

A factory providing convenient access to a FormattingConversionService configured with converters and formatters for common types such as numbers and datetimes.

Additional converters and formatters can be registered declaratively through #setConverters(Set) and #setFormatters(Set). Another option is to register converters and formatters in code by implementing the FormatterRegistrar interface. You can then configure provide the set of registrars to use through #setFormatterRegistrars(Set).

A good example for registering converters and formatters in code is JodaTimeFormatterRegistrar, which registers a number of date-related formatters and converters. For a more detailed list of cases see #setFormatterRegistrars(Set)

Like all FactoryBean implementations, this class is suitable for use when configuring a Spring application context using Spring <beans> XML. When configuring the container with org.springframework.context.annotation.Configuration classes, simply instantiate, configure and return the appropriate FormattingConversionService object from a org.springframework.context.annotation.Bean method.

Extract values from "Forwarded" and "X-Forwarded-*" headers in order to wrap and override the following from the request and response: getServerName(), getServerPort(), getScheme(), isSecure(), and sendRedirect(String). In effect the wrapped request and response reflect the client-originated protocol and address.

Note: This filter can also be used in a removeOnly mode where "Forwarded" and "X-Forwarded-*" headers are only eliminated without being used.

Extract values from "Forwarded" and "X-Forwarded-*" headers in order to change and override ServerHttpRequest#getURI(). In effect the request URI will reflect the client-originated protocol and address.

Note: This filter can also be used in a removeOnly mode where "Forwarded" and "X-Forwarded-*" headers are only eliminated without being used.

Factory that configures a FreeMarker Configuration. Can be used standalone, but typically you will either use FreeMarkerConfigurationFactoryBean for preparing a Configuration as bean reference, or FreeMarkerConfigurer for web views.

The optional "configLocation" property sets the location of a FreeMarker properties file, within the current application. FreeMarker properties can be overridden via "freemarkerSettings". All of these properties will be set by calling FreeMarker's Configuration.setSettings() method and are subject to constraints set by FreeMarker.

The "freemarkerVariables" property can be used to specify a Map of shared variables that will be applied to the Configuration via the setAllSharedVariables() method. Like setSettings(), these entries are subject to FreeMarker constraints.

The simplest way to use this class is to specify a "templateLoaderPath"; FreeMarker does not need any further configuration then.

Note: Spring's FreeMarker support requires FreeMarker 2.3 or higher.

Factory bean that creates a FreeMarker Configuration and provides it as bean reference. This bean is intended for any kind of usage of FreeMarker in application code, e.g. for generating email content. For web views, FreeMarkerConfigurer is used to set up a FreeMarkerConfigurationFactory. The simplest way to use this class is to specify just a "templateLoaderPath"; you do not need any further configuration then. For example, in a web application context:

 <bean id="freemarkerConfiguration" class="org.springframework.ui.freemarker.FreeMarkerConfigurationFactoryBean"> <property name="templateLoaderPath" value="/WEB-INF/freemarker/"/> </bean>

Note: Spring's FreeMarker support requires FreeMarker 2.3 or higher.

JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties. The simplest way to use this class is to specify just a "templateLoaderPath"; you do not need any further configuration then.

 <bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer"> <property name="templateLoaderPath"><value>/WEB-INF/freemarker/</value></property> </bean>

Note that you can also refer to a preconfigured FreeMarker Configuration instance, for example one set up by FreeMarkerConfigurationFactoryBean, via the "configuration" property. This allows to share a FreeMarker Configuration for web and email usage, for example.

This configurer registers a template loader for this package, allowing to reference the "spring.ftl" macro library (contained in this package and thus in spring.jar) like this:

 <#import "/spring.ftl" as spring/> <@spring.bind "person.age"/> age is ${spring.status.value}

Parse the MVC namespace element and register FreeMarkerConfigurer bean

A View implementation that uses the FreeMarker template engine.

Depends on a single FreeMarkerConfig object such as FreeMarkerConfigurer being accessible in the application context. Alternatively set the FreeMarker configuration can be set directly on this class via #setConfiguration.

The url property is the location of the FreeMarker template relative to the FreeMarkerConfigurer's templateLoaderPath.

Note: Spring's FreeMarker support requires FreeMarker 2.3 or higher.

A ViewResolver for resolving FreeMarkerView instances, i.e. FreeMarker templates and custom subclasses of it.

The view class for all views generated by this resolver can be specified via the "viewClass" property. See UrlBasedViewResolver for details.

Convenience subclass of org.springframework.web.servlet.view.UrlBasedViewResolver that supports FreeMarkerView (i.e. FreeMarker templates) and custom subclasses of it.

The view class for all views generated by this resolver can be specified via the "viewClass" property. See UrlBasedViewResolver's javadoc for details.

Note: When chaining ViewResolvers, a FreeMarkerViewResolver will check for the existence of the specified template resources and only return a non-null View object if the template was actually found.

A function reference is of the form "#someFunction(a,b,c)". Functions may be defined in the context prior to the expression being evaluated or within the expression itself using a lambda function definition. For example: Lambda function definition in an expression: "(#max = {|x,y|$x>$y?$x:$y};max(2,3))" Calling context defined function: "#isEven(37)". Functions may also be static java methods, registered in the context prior to invocation of the expression.

Functions are very simplistic, the arguments are not part of the definition (right now), so the names must be unique.

Abstract class that adapts a Future parameterized over S into a Future parameterized over T. All methods are delegated to the adaptee, where #get() and #get(long, TimeUnit) call #adapt(Object) on the adaptee's result.

Default implementation of the KeyHolder interface, to be used for holding auto-generated keys (as potentially returned by JDBC insert statements).

Create an instance of this class for each insert operation, and pass it to the corresponding org.springframework.jdbc.core.JdbcTemplate or {org.springframework.jdbc.object.SqlUpdate} methods.

GenericApplicationListener adapter that determines supported event types through introspecting the generically declared type of the target listener.

GenericBeanDefinition is a one-stop shop for standard bean definition purposes. Like any bean definition, it allows for specifying a class plus optionally constructor argument values and property values. Additionally, deriving from a parent bean definition can be flexibly configured through the "parentName" property.

In general, use this GenericBeanDefinition class for the purpose of registering user-visible bean definitions (which a post-processor might operate on, potentially even reconfiguring the parent name). Use RootBeanDefinition / ChildBeanDefinition where parent/child relationships happen to be pre-determined.

An org.springframework.context.ApplicationContext implementation that extends GenericApplicationContext and implements GroovyObject such that beans can be retrieved with the dot de-reference syntax instead of using #getBean.

Consider this as the equivalent of GenericXmlApplicationContext for Groovy bean definitions, or even an upgrade thereof since it seamlessly understands XML bean definition files as well. The main difference is that, within a Groovy script, the context can be used with an inline bean definition closure as follows:

 import org.hibernate.SessionFactory import org.apache.commons.dbcp.BasicDataSource def context = new GenericGroovyApplicationContext() context.reader.beans { dataSource(BasicDataSource) { // <--- invokeMethod driverClassName = "org.hsqldb.jdbcDriver" url = "jdbc:hsqldb:mem:grailsDB" username = "sa" // <-- setProperty password = "" settings = [mynew:"setting"] } sessionFactory(SessionFactory) { dataSource = dataSource // <-- getProperty for retrieving references } myService(MyService) { nestedBean = { AnotherBean bean -> // <-- setProperty with closure for nested bean dataSource = dataSource } } } context.refresh() 

Alternatively, load a Groovy bean definition script like the following from an external resource (e.g. an "applicationContext.groovy" file):

 import org.hibernate.SessionFactory import org.apache.commons.dbcp.BasicDataSource beans { dataSource(BasicDataSource) { driverClassName = "org.hsqldb.jdbcDriver" url = "jdbc:hsqldb:mem:grailsDB" username = "sa" password = "" settings = [mynew:"setting"] } sessionFactory(SessionFactory) { dataSource = dataSource } myService(MyService) { nestedBean = { AnotherBean bean -> dataSource = dataSource } } } 

With the following Java code creating the GenericGroovyApplicationContext (potentially using Ant-style '*'/'**' location patterns):

 GenericGroovyApplicationContext context = new GenericGroovyApplicationContext(); context.load("org/myapp/applicationContext.groovy"); context.refresh(); 

Or even more concise, provided that no extra configuration is needed:

 ApplicationContext context = new GenericGroovyApplicationContext("org/myapp/applicationContext.groovy"); 

This application context also understands XML bean definition files, allowing for seamless mixing and matching with Groovy bean definition files. ".xml" files will be parsed as XML content; all other kinds of resources will be parsed as Groovy scripts.

Concrete implementation of AbstractGenericContextLoader that reads bean definitions from Groovy scripts and XML configuration files.

Default resource locations are detected using the suffixes "-context.xml" and "Context.groovy".

Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from Groovy scripts and XML configuration files.

Default resource locations are detected using the suffixes "-context.xml" and "Context.groovy".

An extension of the SimpleMessageConverter that uses a ConversionService to convert the payload of the message to the requested type.

Return null if the conversion service cannot convert from the payload type to the requested type.

Generic implementation of the JCA 1.7 javax.resource.spi.endpoint.MessageEndpointFactory interface, providing transaction management capabilities for any kind of message listener object (e.g. javax.jms.MessageListener objects or javax.resource.cci.MessageListener objects.

Uses AOP proxies for concrete endpoint instances, simply wrapping the specified message listener object and exposing all of its implemented interfaces on the endpoint instance.

Typically used with Spring's GenericMessageEndpointManager, but not tied to it. As a consequence, this endpoint factory could also be used with programmatic endpoint management on a native javax.resource.spi.ResourceAdapter instance.

A messaging template that resolves destinations names to MessageChannel's to send and receive messages from.

Concrete implementation of AbstractGenericContextLoader that reads bean definitions from Java Properties resources.

A concrete variant of SqlQuery which can be configured with a RowMapper.

Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.

This implementation does not provide a typed method for invocation so executions must use one of the generic StoredProcedure#execute(java.util.Map) or StoredProcedure#execute(org.springframework.jdbc.core.ParameterMapper) methods.

Basic AutowireCandidateResolver that performs a full generic type match with the candidate's type if the dependency is declared as a generic type (e.g. Repository<Customer>).

This is the base class for org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver, providing an implementation all non-annotation-based resolution steps at this level.

Helper class for resolving generic types against type variables.

Mainly intended for usage within the framework, resolving method parameter types even when they are declared generically.

Subinterface of Unmarshaller that has support for Java 5 generics.

Convenient application context with built-in XML support. This is a flexible alternative to ClassPathXmlApplicationContext and FileSystemXmlApplicationContext, to be configured via setters, with an eventual #refresh() call activating the context.

In case of multiple configuration files, bean definitions in later files will override those defined in earlier files. This can be leveraged to intentionally override certain bean definitions via an extra configuration file appended to the list.

Annotation for mapping HTTP GET requests onto specific handler methods.

Specifically, @GetMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.GET).

LoadTimeWeaver implementation for GlassFish's org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader.

As of Spring Framework 5.0, this weaver supports GlassFish 4+.

A WebSocket RequestUpgradeStrategy for Oracle's GlassFish 4.1 and higher.

Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.

A Groovy-based reader for Spring bean definitions: like a Groovy builder, but more of a DSL for Spring configuration.

This bean definition reader also understands XML bean definition files, allowing for seamless mixing and matching with Groovy bean definition files.

Typically applied to a org.springframework.beans.factory.support.DefaultListableBeanFactory or a org.springframework.context.support.GenericApplicationContext, but can be used against any BeanDefinitionRegistry implementation.

 import org.hibernate.SessionFactory import org.apache.commons.dbcp.BasicDataSource def reader = new GroovyBeanDefinitionReader(myApplicationContext) reader.beans { dataSource(BasicDataSource) { // <--- invokeMethod driverClassName = "org.hsqldb.jdbcDriver" url = "jdbc:hsqldb:mem:grailsDB" username = "sa" // <-- setProperty password = "" settings = [mynew:"setting"] } sessionFactory(SessionFactory) { dataSource = dataSource // <-- getProperty for retrieving references } myService(MyService) { nestedBean = { AnotherBean bean -> // <-- setProperty with closure for nested bean dataSource = dataSource } } }

You can also load resources containing beans defined in a Groovy script using either the #loadBeanDefinitions(Resource...) or #loadBeanDefinitions(String...) method, with a script looking similar to the following.

 import org.hibernate.SessionFactory import org.apache.commons.dbcp.BasicDataSource beans { dataSource(BasicDataSource) { driverClassName = "org.hsqldb.jdbcDriver" url = "jdbc:hsqldb:mem:grailsDB" username = "sa" password = "" settings = [mynew:"setting"] } sessionFactory(SessionFactory) { dataSource = dataSource } myService(MyService) { nestedBean = { AnotherBean bean -> dataSource = dataSource } } }

Interface to be implemented by objects that configure and manage a Groovy MarkupTemplateEngine for automatic lookup in a web environment. Detected and used by GroovyMarkupView.

An extension of Groovy's groovy.text.markup.TemplateConfiguration and an implementation of Spring MVC's GroovyMarkupConfig for creating a MarkupTemplateEngine for use in a web application. The most basic way to configure this class is to set the "resourceLoaderPath". For example:

 // Add the following to an @Configuration class @Bean public GroovyMarkupConfig groovyMarkupConfigurer() { GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer(); configurer.setResourceLoaderPath("classpath:/WEB-INF/groovymarkup/"); return configurer; } 

• a parent ClassLoader for loading Groovy templates with their references
• the default configuration in the base class TemplateConfiguration
• a groovy.text.markup.TemplateResolver for resolving template files

This bean must be included in the application context of any application using the Spring MVC GroovyMarkupView for rendering. It exists purely for the purpose of configuring Groovy's Markup templates. It is not meant to be referenced by application components directly. It implements GroovyMarkupConfig to be found by GroovyMarkupView without depending on a bean name. Each DispatcherServlet can define its own GroovyMarkupConfigurer if desired.

Note that resource caching is enabled by default in MarkupTemplateEngine. Use the #setCacheTemplates(boolean) to configure that as necessary.

Spring's Groovy Markup template support requires Groovy 2.3.1 or higher.

Parse the MVC namespace element and register a GroovyConfigurer bean

An AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.

Spring's Groovy Markup Template support requires Groovy 2.3.1 and higher.

Convenience subclass of @link AbstractTemplateViewResolver} that supports GroovyMarkupView (i.e. Groovy XML/XHTML markup templates) and custom subclasses of it.

The view class for all views created by this resolver can be specified via the #setViewClass(Class) property.

Note: When chaining ViewResolvers this resolver will check for the existence of the specified template resources and only return a non-null View object if a template is actually found.

Groovy-based implementation of Spring's ScriptEvaluator strategy interface.

org.springframework.scripting.ScriptFactory implementation for a Groovy script.

Typically used in combination with a org.springframework.scripting.support.ScriptFactoryPostProcessor; see the latter's javadoc for a configuration example.

Note: Spring 4.0 supports Groovy 1.8 and higher.

org.springframework.web.context.WebApplicationContext implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by an org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader. This is essentially the equivalent of org.springframework.context.support.GenericGroovyApplicationContext for a web environment.

By default, the configuration will be taken from "/WEB-INF/applicationContext.groovy" for the root context, and "/WEB-INF/test-servlet.groovy" for a context with the namespace "test-servlet" (like for a DispatcherServlet instance with the servlet-name "test").

The config location defaults can be overridden via the "contextConfigLocation" context-param of org.springframework.web.context.ContextLoader and servlet init-param of org.springframework.web.servlet.FrameworkServlet. Config locations can either denote concrete files like "/WEB-INF/context.groovy" or Ant-style patterns like "/WEB-INF/*-context.groovy" (see org.springframework.util.PathMatcher javadoc for pattern details). Note that ".xml" files will be parsed as XML content; all other kinds of resources will be parsed as Groovy scripts.

Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files. This can be leveraged to deliberately override certain bean definitions via an extra Groovy script.

For a WebApplicationContext that reads in a different bean definition format, create an analogous subclass of AbstractRefreshableWebApplicationContext. Such a context implementation can be specified as "contextClass" context-param for ContextLoader or "contextClass" init-param for FrameworkServlet.

A simple utility class for obtaining a Google Gson 2.x GsonBuilder which Base64-encodes byte[] properties when reading and writing JSON.

Implementation of org.springframework.http.converter.HttpMessageConverter that can read and write JSON using the Google Gson library.

This converter can be used to bind to typed beans or untyped HashMaps. By default, it supports application/json and application/*+json with UTF-8 character set.

Tested against Gson 2.6; compatible with Gson 2.0 and higher.

A ResourceResolver that delegates to the chain to locate a resource and then attempts to find a variation with the ".gz" extension.

The resolver gets involved only if the "Accept-Encoding" request header contains the value "gzip" indicating the client accepts gzipped responses.

A ResourceResolver that delegates to the chain to locate a resource and then attempts to find a variation with the ".gz" extension.

The resolver gets involved only if the "Accept-Encoding" request header contains the value "gzip" indicating the client accepts gzipped responses.

DataFieldMaxValueIncrementer that retrieves the next value of a given H2 Database sequence.

SAP HANA specific implementation for the CallMetaDataProvider interface. This class is intended for internal use by the Simple JDBC classes.

Contract that decouples the DispatcherHandler from the details of invoking a handler and makes it possible to support any handler type.

A HandlerExceptionResolver that delegates to a list of other HandlerExceptionResolvers.

Strategy interface for resolving method parameters into argument values in the context of a given Message.

Strategy interface for resolving method parameters into argument values in the context of a given request.

Strategy to resolve the argument value for a method parameter in the context of the current HTTP request.

Base class for HandlerMethodArgumentResolver implementations with access to a ReactiveAdapterRegistry and methods to check for method parameter support.

A HandlerMethodReturnValueHandler that wraps and delegates to others.

Handles method return values by delegating to a list of registered HandlerMethodReturnValueHandlers. Previously resolved return types are cached for faster lookups.

Process the HandlerResult, usually returned by an HandlerAdapter.

Base class for org.springframework.web.reactive.HandlerResultHandler with support for content negotiation and access to a ReactiveAdapter registry.

Factory for assertions on the selected handler or handler method.

An instance of this class is typically accessed via MockMvcResultMatchers#handler.

Note: Expectations that assert the controller method used to process the request work only for requests processed with RequestMappingHandlerMapping and RequestMappingHandlerAdapter which is used by default with the Spring MVC Java config and XML namespace.

Thrown when handshake processing failed to complete due to an internal, unrecoverable error. This implies a server error (HTTP status code 500) as opposed to a failure in the handshake negotiation.

By contrast, when handshake negotiation fails, the response status code will be 200 and the response headers and body will have been updated to reflect the cause for the failure. A HandshakeHandler implementation will have protected methods to customize updates to the response in those cases.

A helper class that assists with invoking a list of handshake interceptors.

WebSocketService implementation that handles a WebSocket HTTP handshake request by delegating to a RequestUpgradeStrategy which is either auto-detected (no-arg constructor) from the classpath but can also be explicitly configured.

A ContentNegotiationStrategy that checks the 'Accept' request header.

Resolver that looks at the 'Accept' header of the request.

Resolves method parameters annotated with Header.

Factory for response header assertions.

An instance of this class is available via MockMvcResultMatchers#header.

Request and response header-based WebSessionIdResolver.

Annotation which indicates that a method parameter should be bound to the headers of a message. The annotated parameter must be assignable to java.util.Map with String keys and Object values.

Resolves the following method parameters:

• Parameters assignable to Map annotated with Headers
• Parameters of type MessageHeaders
• Parameters assignable to MessageHeaderAccessor

org.aopalliance.intercept.MethodInterceptor for accessing a Hessian service. Supports authentication via username and password. The service URL must be an HTTP URL exposing a Hessian service.

Hessian is a slim, binary RPC protocol. For information on Hessian, see the Hessian website Note: As of Spring 4.0, this client requires Hessian 4.0 or above.

Note: There is no requirement for services accessed with this proxy factory to have been exported using Spring's HessianServiceExporter, as there is no special handling involved. As a consequence, you can also access services that have been exported using Caucho's com.caucho.hessian.server.HessianServlet.

General stream-based protocol exporter for a Hessian endpoint.

Hessian is a slim, binary RPC protocol. For information on Hessian, see the Hessian website. Note: As of Spring 4.0, this exporter requires Hessian 4.0 or above.

FactoryBean for Hessian proxies. Exposes the proxied service for use as a bean reference, using the specified service interface.

Hessian is a slim, binary RPC protocol. For information on Hessian, see the Hessian website Note: As of Spring 4.0, this proxy factory requires Hessian 4.0 or above.

The service URL must be an HTTP URL exposing a Hessian service. For details, see the HessianClientInterceptor javadoc.

Servlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.

Note: Spring also provides an alternative version of this exporter, for Sun's JRE 1.6 HTTP server: SimpleHessianServiceExporter.

Hessian is a slim, binary RPC protocol. For information on Hessian, see the Hessian website. Note: As of Spring 4.0, this exporter requires Hessian 4.0 or above.

Hessian services exported with this class can be accessed by any Hessian client, as there isn't any special handling involved.

Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.

Callback interface for Hibernate code. To be used with HibernateTemplate's execution methods, often as anonymous classes within a method implementation. A typical implementation will call Session.load/find/update to perform some operations on persistent objects.

Convenient super class for Hibernate-based data access objects.

Requires a SessionFactory to be set, providing a org.springframework.orm.hibernate5.HibernateTemplate based on it to subclasses through the #getHibernateTemplate() method. Can alternatively be initialized directly with a HibernateTemplate, in order to reuse the latter's settings such as the SessionFactory, exception translator, flush mode, etc.

This class will create its own HibernateTemplate instance if a SessionFactory is passed in. The "allowCreate" flag on that HibernateTemplate will be "true" by default. A custom HibernateTemplate instance can be used through overriding #createHibernateTemplate.

NOTE: Hibernate access code can also be coded in plain Hibernate style. Hence, for newly started projects, consider adopting the standard Hibernate style of coding data access objects instead, based on SessionFactory#getCurrentSession(). This HibernateTemplate primarily exists as a migration helper for Hibernate 3 based data access code, to benefit from bug fixes in Hibernate 5.x.

Hibernate-specific subclass of UncategorizedDataAccessException, for JDBC exceptions that Hibernate wrapped.

org.springframework.orm.jpa.JpaDialect implementation for Hibernate EntityManager. Developed against Hibernate 5.0/5.1/5.2.

Simple FactoryBean that exposes the underlying SessionFactory behind a Hibernate-backed JPA EntityManagerFactory.

Primarily available for resolving a SessionFactory by JPA persistence unit name via the "persistenceUnitName" bean property.

Note that, for straightforward cases, you could also simply declare a factory method:

 <bean id="sessionFactory" factory-bean="entityManagerFactory" factory-method="getSessionFactory"/> 

And as of JPA 2.1, EntityManagerFactory#unwrap provides a nice approach as well, in particular within configuration class arrangements:

 @Bean public SessionFactory sessionFactory(@Qualifier("entityManagerFactory") EntityManagerFactory emf) { return emf.unwrap(SessionFactory.class); } 

org.springframework.orm.jpa.JpaVendorAdapter implementation for Hibernate EntityManager. Developed and tested against Hibernate 5.0, 5.1 and 5.2; backwards-compatible with Hibernate 4.3 at runtime on a best-effort basis.

Exposes Hibernate's persistence provider and EntityManager extension interface, and adapts AbstractJpaVendorAdapter's common configuration settings. Also supports the detection of annotated packages (through org.springframework.orm.jpa.persistenceunit.SmartPersistenceUnitInfo#getManagedPackages()), e.g. containing Hibernate org.hibernate.annotations.FilterDef annotations, along with Spring-driven entity scanning which requires no persistence.xml (org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean#setPackagesToScan).

Hibernate-specific subclass of ObjectRetrievalFailureException. Converts Hibernate's UnresolvableObjectException and WrongClassException.

Hibernate-specific subclass of ObjectOptimisticLockingFailureException. Converts Hibernate's StaleObjectStateException, StaleStateException and OptimisticEntityLockException.

Hibernate-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid HQL query syntax.

Hibernate-specific subclass of UncategorizedDataAccessException, for Hibernate system errors that do not match any concrete org.springframework.dao exceptions.

org.springframework.transaction.PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread-bound Session per factory. SessionFactory.getCurrentSession() is required for Hibernate access code that needs to support this transaction handling mechanism, with the SessionFactory being configured with SpringSessionContext.

Supports custom isolation levels, and timeouts that get applied as Hibernate transaction timeouts.

This transaction manager is appropriate for applications that use a single Hibernate SessionFactory for transactional data access, but it also supports direct DataSource access within a transaction (i.e. plain JDBC code working with the same DataSource). This allows for mixing services which access Hibernate and services which use plain JDBC (without being aware of Hibernate)! Application code needs to stick to the same simple Connection lookup pattern as with org.springframework.jdbc.datasource.DataSourceTransactionManager (i.e. org.springframework.jdbc.datasource.DataSourceUtils#getConnection or going through a org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy).

Note: To be able to register a DataSource's Connection for plain JDBC code, this instance needs to be aware of the DataSource (#setDataSource). The given DataSource should obviously match the one used by the given SessionFactory.

JTA (usually through org.springframework.transaction.jta.JtaTransactionManager) is necessary for accessing multiple transactional resources within the same transaction. The DataSource that Hibernate uses needs to be JTA-enabled in such a scenario (see container setup).

This transaction manager supports nested transactions via JDBC 3.0 Savepoints. The #setNestedTransactionAllowed "nestedTransactionAllowed"} flag defaults to "false", though, as nested transactions will just apply to the JDBC Connection, not to the Hibernate Session and its cached entity objects and related context. You can manually set the flag to "true" if you want to use nested transactions for JDBC access code which participates in Hibernate transactions (provided that your JDBC driver supports Savepoints). Note that Hibernate itself does not support nested transactions! Hence, do not expect Hibernate access code to semantically participate in a nested transaction.

javax.servlet.Filter that converts posted method parameters into HTTP methods, retrievable via HttpServletRequest#getMethod(). Since browsers currently only support GET and POST, a common technique - used by the Prototype library, for instance - is to use a normal POST with an additional hidden form field (_method) to pass the "real" HTTP method along. This filter reads that parameter and changes the HttpServletRequestWrapper#getMethod() return value accordingly.

The name of the request parameter defaults to _method, but can be adapted via the methodParam property.

NOTE: This filter needs to run after multipart processing in case of a multipart POST request, due to its inherent need for checking a POST body parameter. So typically, put a Spring org.springframework.web.multipart.support.MultipartFilter before this HiddenHttpMethodFilter in your web.xml filter chain.

Reactive WebFilter that converts posted method parameters into HTTP methods, retrievable via ServerHttpRequest#getMethod(). Since browsers currently only support GET and POST, a common technique is to use a normal POST with an additional hidden form field (_method) to pass the "real" HTTP method along. This filter reads that parameter and changes the ServerHttpRequest#getMethod() return value using ServerWebExchange#mutate().

The name of the request parameter defaults to _method, but can be adapted via the methodParamName property.

The <hidden> tag renders an HTML 'input' tag with type 'hidden' using the bound value.

Example (binding to 'name' property of form backing object):

 <form:hidden path="name"/> 

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

path

true

true

Path to property for data binding

A WebRequestMatcher that allows matching on the host and optionally the port of WebRequest#getUrl().

For example, the following would match any request to the host "code.jquery.com" without regard for the port.

WebRequestMatcher cdnMatcher = new HostMatcher("code.jquery.com");

Multiple hosts can also be passed in. For example, the following would match any request to the host "code.jquery.com" or the host "cdn.com" without regard for the port.

WebRequestMatcher cdnMatcher = new HostMatcher("code.jquery.com", "cdn.com");

Alternatively, one can also specify the port. For example, the following would match any request to the host "code.jquery.com" with the port of 80.

WebRequestMatcher cdnMatcher = new HostMatcher("code.jquery.com:80");

The above cdnMatcher would match "http://code.jquery.com/jquery.js" which has a default port of 80 and "http://code.jquery.com:80/jquery.js". However, it would not match "https://code.jquery.com/jquery.js" which has a default port of 443.

org.springframework.aop.TargetSource implementation that caches a local target object, but allows the target to be swapped while the application is running.

If configuring an object of this class in a Spring IoC container, use constructor injection.

This TargetSource is serializable if the target is at the time of serialization.

DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column. Note: If you use this class, your HSQL key column should NOT be auto-increment, as the sequence table does the job.

The sequence is kept in a table. There should be one sequence table per table that needs an auto-generated key.

Example:

create table tab (id int not null primary key, text varchar(100)); create table tab_sequence (value identity); insert into tab_sequence values(0);

NOTE: HSQL now supports sequences and you should consider using them instead: HsqlSequenceMaxValueIncrementer

DataFieldMaxValueIncrementer that retrieves the next value of a given HSQL sequence. Thanks to Guillaume Bilodeau for the suggestion!

NOTE: This is an alternative to using a regular table to support generating unique keys that was necessary in previous versions of HSQL.

The HSQL specific implementation of TableMetaDataProvider. Supports a feature for retrieving generated keys without the JDBC 3.0 getGeneratedKeys support.

The <htmlEscape> tag sets default HTML escape value for the current page. The actual value can be overridden by escaping-aware tags. The default is "false".

Note: You can also set a "defaultHtmlEscape" web.xml context-param. A page-level setting overrides a context-param.

An HTTP TransportHandler that uses a famous browser document.domain technique: http://stackoverflow.com/questions/1481251/what-does-document-domain-document-domain-do

Utility class for HTML escaping. Escapes and unescapes based on the W3C HTML 4.01 recommendation, handling character entity references.

Reference: http://www.w3.org/TR/html4/charset.html

For a comprehensive set of String escaping utilities, consider Apache Commons Lang and its StringEscapeUtils class. We are not using that class here to avoid a runtime dependency on Commons Lang just for HTML escaping. Furthermore, Spring's HTML escaping is more flexible and 100% HTML 4.0 compliant.

Exception thrown when an HTTP 4xx is received.

Asynchronous extension of the HttpComponentsClientHttpRequestFactory. Uses Apache HttpComponents HttpAsyncClient 4.0 to create requests.

org.springframework.remoting.httpinvoker.HttpInvokerRequestExecutor implementation that uses Apache HttpComponents HttpClient to execute POST requests.

Allows to use a pre-configured org.apache.http.client.HttpClient instance, potentially with authentication, HTTP connection pooling, etc. Also designed for easy subclassing, providing specific template methods.

As of Spring 4.1, this request executor requires Apache HttpComponents 4.3 or higher.

Resolves method arguments of type HttpEntity or RequestEntity by reading the body of the request through a compatible HttpMessageReader.

Resolves HttpEntity and RequestEntity method argument values and also handles HttpEntity and ResponseEntity return values.

An HttpEntity return type has a specific purpose. Therefore this handler should be configured ahead of handlers that support any return value type annotated with @ModelAttribute or @ResponseBody to ensure they don't take over.

Connector that handles requests by invoking an HttpHandler rather than making actual requests to a network socket.

Internally the connector uses and adapts MockClientHttpRequest and MockClientHttpResponse to MockServerHttpRequest and MockServerHttpResponse.

ServerHttpResponse decorator for HTTP HEAD requests.

Handles HttpHeaders return values.

FactoryBean for HTTP invoker proxies. Exposes the proxied service for use as a bean reference, using the specified service interface.

The service URL must be an HTTP URL exposing an HTTP invoker service. Optionally, a codebase URL can be specified for on-demand dynamic code download from a remote location. For details, see HttpInvokerClientInterceptor docs.

Serializes remote invocation objects and deserializes remote invocation result objects. Uses Java serialization just like RMI, but provides the same ease of setup as Caucho's HTTP-based Hessian protocol.

HTTP invoker is the recommended protocol for Java-to-Java remoting. It is more powerful and more extensible than Hessian, at the expense of being tied to Java. Nevertheless, it is as easy to set up as Hessian, which is its main advantage compared to RMI.

WARNING: Be aware of vulnerabilities due to unsafe Java deserialization: Manipulated input streams could lead to unwanted code execution on the server during the deserialization step. As a consequence, do not expose HTTP invoker endpoints to untrusted clients but rather just between your own services. In general, we strongly recommend any other message format (e.g. JSON) instead.

Strategy interface for actual execution of an HTTP invoker request. Used by HttpInvokerClientInterceptor and its subclass HttpInvokerProxyFactoryBean.

Two implementations are provided out of the box:

• SimpleHttpInvokerRequestExecutor: Uses JDK facilities to execute POST requests, without support for HTTP authentication or advanced configuration options.
• HttpComponentsHttpInvokerRequestExecutor: Uses Apache's Commons HttpClient to execute POST requests, allowing to use a preconfigured HttpClient instance (potentially with authentication, HTTP connection pooling, etc).

Exception thrown when the request handler cannot generate a response that is acceptable by the client.

Exception thrown when a client POSTs, PUTs, or PATCHes content of a type not supported by request handler.

Thrown by HttpMessageConverter implementations when a conversion attempt fails.

Response extractor that uses the given HttpMessageConverter to convert the response into a type T.

Extension of Encoder exposing extra methods relevant in the context of HTTP request or response body encoding.

Thrown by HttpMessageConverter implementations when the HttpMessageConverter#read method fails.

Thrown by HttpMessageConverter implementations when the HttpMessageConverter#write method fails.

View that writes model attribute(s) with an HttpMessageWriter.

javax.servlet.Filter that makes form encoded data available through the ServletRequest.getParameter*() family of methods during HTTP PUT or PATCH requests.

The Servlet spec requires form data to be available for HTTP POST but not for HTTP PUT or PATCH requests. This filter intercepts HTTP PUT and PATCH requests where content type is 'application/x-www-form-urlencoded', reads form encoded content from the body of the request, and wraps the ServletRequest in order to make the form data available as request parameters just like it is for HTTP POST requests.

Represents an HTTP (byte) range for use with the HTTP "Range" header.

Simple HttpServlet that delegates to an HttpRequestHandler bean defined in Spring's root web application context. The target bean name must match the HttpRequestHandlerServlet servlet-name as defined in web.xml.

This can for example be used to expose a single Spring remote exporter, such as org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter or org.springframework.remoting.caucho.HessianServiceExporter, per HttpRequestHandlerServlet definition. This is a minimal alternative to defining remote exporters as beans in a DispatcherServlet context (with advanced mapping and interception facilities being available there).

Exception thrown when a request handler does not support a specific request method.

Provides a convenient implementation of the HttpRequest interface that can be overridden to adapt the request.

These methods default to calling through to the wrapped request object.

Extended interface for a Resource to be written to an HTTP response.

Extended interface for a Resource to be written to an HTTP response.

Exception thrown when an HTTP 5xx is received.

An interceptor to copy information from the HTTP session to the "handshake attributes" map to made available viaWebSocketSession#getAttributes().

Copies a subset or all HTTP session attributes and/or the HTTP session id under the key #HTTP_SESSION_ID_ATTR_NAME.

Servlet HttpSessionListener that automatically exposes the session mutex when an HttpSession gets created. To be registered as a listener in web.xml.

The session mutex is guaranteed to be the same object during the entire lifetime of the session, available under the key defined by the SESSION_MUTEX_ATTRIBUTE constant. It serves as a safe reference to synchronize on for locking on the current session.

In many cases, the HttpSession reference itself is a safe mutex as well, since it will always be the same object reference for the same active logical session. However, this is not guaranteed across different servlet containers; the only 100% safe way is a session mutex.

Exception thrown when an HTTP request handler requires a pre-existing session.

Default adapter of WebHandler to the HttpHandler contract.

By default creates and configures a DefaultServerWebExchange and then invokes the target WebHandler.

A org.springframework.messaging.support.MessageHeaderInitializer to customize the strategy for ID and TIMESTAMP message header generation.

An implementation of the ObjectNamingStrategy interface that creates a name based on the identity of a given instance.

The resulting ObjectName will be in the form package:class=class name,hashCode=identity hash (in hex)

Test annotation to indicate whether a test is enabled or disabled for a specific testing profile.

In the context of this annotation, the term profile refers to a Java system property by default; however, the semantics can be changed by implementing a custom ProfileValueSource. If the configured ProfileValueSource returns a matching #value for the declared #name, the test will be enabled. Otherwise, the test will be disabled and effectively ignored.

@IfProfileValue can be applied at the class level, the method level, or both. Class-level usage of @IfProfileValue takes precedence over method-level usage for any methods within that class or its subclasses. Specifically, a test is enabled if it is enabled both at the class level and at the method level; the absence of @IfProfileValue means the test is implicitly enabled. This is analogous to the semantics of JUnit's org.junit.Ignore annotation, except that the presence of @Ignore always disables a test.

 @IfProfileValue(name = "java.vendor", value = "Oracle Corporation") public void testSomething() { // ... }

You can alternatively configure @IfProfileValue with OR semantics for multiple #values. The following test will be enabled if a ProfileValueSource has been appropriately configured for the "test-groups" profile with a value of either unit-tests or integration-tests. This functionality is similar to TestNG's support for test groups and JUnit's experimental support for test categories.

 @IfProfileValue(name = "test-groups", values = { "unit-tests", "integration-tests" }) public void testWhichRunsForUnitOrIntegrationTestGroups() { // ... }

Although the @IfProfileValue and org.springframework.context.annotation.Profile annotations both involve profiles, they are not directly related. @Profile involves bean definition profiles configured in the org.springframework.core.env.Environment; whereas, @IfProfileValue is used to enable or disable tests.

As of Spring Framework 4.0, this annotation may be used as a meta-annotation to create custom composed annotations.

Runtime exception mirroring the JMS IllegalStateException.

Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies.

A simpler interceptor that calls MessageHeaderAccessor#setImmutable() on the headers of messages passed through the preSend method.

When configured as the last interceptor in a chain, it allows the component sending the message to leave headers mutable for interceptors to modify prior to the message actually being sent and exposed to concurrent access.

Representation of an import that has been processed during the parsing process.

Indicates one or more resources containing bean definitions to import.

Like Import, this annotation provides functionality similar to the <import/> element in Spring XML. It is typically used when designing Configuration classes to be bootstrapped by an AnnotationConfigApplicationContext, but where some XML functionality such as namespaces is still necessary.

By default, arguments to the #value attribute will be processed using a org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader if ending in ".groovy"; otherwise, an org.springframework.beans.factory.xml.XmlBeanDefinitionReader will be used to parse Spring <beans/> XML files. Optionally, the #reader attribute may be declared, allowing the user to choose a custom BeanDefinitionReader implementation.

Simple Map-based storage for WebSession instances.

Data access exception thrown when a result set did not have the correct column count, for example when expecting a single column but getting 0 or more than 1 columns.

Indicate that the annotated element represents a stereotype for the index.

The CandidateComponentsIndex is an alternative to classpath scanning that uses a metadata file generated at compilation time. The index allows retrieving the candidate components (i.e. fully qualified name) based on a stereotype. This annotation instructs the generator to index the element on which the annotated element is present or if it implements or extends from the annotated element. The stereotype is the fully qualified name of the annotated element.

Consider the default Component annotation that is meta-annotated with this annotation. If a component is annotated with Component, an entry for that component will be added to the index using the org.springframework.stereotype.Component stereotype.

This annotation is also honored on meta-annotations. Consider this custom annotation:

 package com.example; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Indexed @Service public @interface PrivilegedService { ... } 

It is also possible to index all implementations of a certain interface or all the subclasses of a given class by adding @Indexed on it. Consider this base interface:

 package com.example; @Indexed public interface AdminService { ... } 

 package com.example.foo; import com.example.AdminService; public class ConfigurationAdminService implements AdminService { ... } 

An Indexer can index into some proceeding structure to access a particular piece of it. Supported structures are: strings / collections (lists/sets) / arrays.

Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.

Interface to be implemented by transparent resource proxies that need to be considered as equal to the underlying resource, for example for consistent lookup key comparisons. Note that this interface does imply such special semantics and does not constitute a general-purpose mixin!

Such wrappers will automatically be unwrapped for key comparisons in org.springframework.transaction.support.TransactionSynchronizationManager.

Only fully transparent proxies, e.g. for redirection or service lookups, are supposed to implement this interface. Proxies that decorate the target object with new behavior, such as AOP proxies, do not qualify here!

Annotation that identifies methods which initialize the org.springframework.web.bind.WebDataBinder which will be used for populating command and form object arguments of annotated handler methods.

Such init-binder methods support all arguments that RequestMapping supports, except for command/form objects and corresponding validation result objects. Init-binder methods must not have a return value; they are usually declared as void.

Typical arguments are org.springframework.web.bind.WebDataBinder in combination with org.springframework.web.context.request.WebRequest or java.util.Locale, allowing to register context-specific editors.

Adds initialization to a WebDataBinder via @InitBinder methods.

org.springframework.beans.factory.config.BeanPostProcessor implementation that invokes annotated init and destroy methods. Allows for an annotation alternative to Spring's org.springframework.beans.factory.InitializingBean and org.springframework.beans.factory.DisposableBean callback interfaces.

The actual annotation types that this post-processor checks for can be configured through the "initAnnotationType" and "destroyAnnotationType" properties. Any custom annotation can be used, since there are no required annotation attributes.

Init and destroy annotations may be applied to methods of any visibility: public, package-protected, protected, or private. Multiple such methods may be annotated, but it is recommended to only annotate one single init method and destroy method, respectively.

Spring's org.springframework.context.annotation.CommonAnnotationBeanPostProcessor supports the JSR-250 javax.annotation.PostConstruct and javax.annotation.PreDestroy annotations out of the box, as init annotation and destroy annotation, respectively. Furthermore, it also supports the javax.annotation.Resource annotation for annotation-driven injection of named beans.