Spring框架文檔與API（4.3.6版本）

http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/

Table of Contents

I. Overview of Spring Framework

1. Getting Started with Spring

2. Introduction to the Spring Framework

2.1. Dependency Injection and Inversion of Control

2.2. Modules

2.2.1. Core Container

2.2.2. AOP and Instrumentation

2.2.3. Messaging

2.2.4. Data Access/Integration

2.2.5. Web

2.2.6. Test

2.3. Usage scenarios

2.3.1. Dependency Management and Naming Conventions

Spring Dependencies and Depending on Spring

Maven Dependency Management

Maven "Bill Of Materials" Dependency

Gradle Dependency Management

Ivy Dependency Management

Distribution Zip Files

2.3.2. Logging

Not Using Commons Logging

Using SLF4J

Using Log4j

II. What’s New in Spring Framework 4.x

3. New Features and Enhancements in Spring Framework 4.0

3.1. Improved Getting Started Experience

3.2. Removed Deprecated Packages and Methods

3.3. Java 8 (as well as 6 and 7)

3.4. Java EE 6 and 7

3.5. Groovy Bean Definition DSL

3.6. Core Container Improvements

3.7. General Web Improvements

3.8. WebSocket, SockJS, and STOMP Messaging

3.9. Testing Improvements

4. New Features and Enhancements in Spring Framework 4.1

4.1. JMS Improvements

4.2. Caching Improvements

4.3. Web Improvements

4.4. WebSocket Messaging Improvements

4.5. Testing Improvements

5. New Features and Enhancements in Spring Framework 4.2

5.1. Core Container Improvements

5.2. Data Access Improvements

5.3. JMS Improvements

5.4. Web Improvements

5.5. WebSocket Messaging Improvements

5.6. Testing Improvements

6. New Features and Enhancements in Spring Framework 4.3

6.1. Core Container Improvements

6.2. Data Access Improvements

6.3. Caching Improvements

6.4. JMS Improvements

6.5. Web Improvements

6.6. WebSocket Messaging Improvements

6.7. Testing Improvements

6.8. Support for new library and server generations

III. Core Technologies

7. The IoC container

7.1. Introduction to the Spring IoC container and beans

7.2. Container overview

7.2.1. Configuration metadata

7.2.2. Instantiating a container

Composing XML-based configuration metadata

The Groovy Bean Definition DSL

7.2.3. Using the container

7.3. Bean overview

7.3.1. Naming beans

Aliasing a bean outside the bean definition

7.3.2. Instantiating beans

Instantiation with a constructor

Instantiation with a static factory method

Instantiation using an instance factory method

7.4. Dependencies

7.4.1. Dependency Injection

Constructor-based dependency injection

Setter-based dependency injection

Dependency resolution process

Examples of dependency injection

7.4.2. Dependencies and configuration in detail

Straight values (primitives, Strings, and so on)

References to other beans (collaborators)

Inner beans

Collections

Null and empty string values

XML shortcut with the p-namespace

XML shortcut with the c-namespace

Compound property names

7.4.3. Using depends-on

7.4.4. Lazy-initialized beans

7.4.5. Autowiring collaborators

Limitations and disadvantages of autowiring

Excluding a bean from autowiring

7.4.6. Method injection

Lookup method injection

Arbitrary method replacement

7.5. Bean scopes

7.5.1. The singleton scope

7.5.2. The prototype scope

7.5.3. Singleton beans with prototype-bean dependencies

7.5.4. Request, session, global session, application, and WebSocket scopes

Initial web configuration

Request scope

Session scope

Global session scope

Application scope

Scoped beans as dependencies

7.5.5. Custom scopes

Creating a custom scope

Using a custom scope

7.6. Customizing the nature of a bean

7.6.1. Lifecycle callbacks

Initialization callbacks

Destruction callbacks

Default initialization and destroy methods

Combining lifecycle mechanisms

Startup and shutdown callbacks

Shutting down the Spring IoC container gracefully in non-web applications

7.6.2. ApplicationContextAware and BeanNameAware

7.6.3. Other Aware interfaces

7.7. Bean definition inheritance

7.8. Container Extension Points

7.8.1. Customizing beans using a BeanPostProcessor

Example: Hello World, BeanPostProcessor-style

Example: The RequiredAnnotationBeanPostProcessor

7.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor

Example: the Class name substitution PropertyPlaceholderConfigurer

Example: the PropertyOverrideConfigurer

7.8.3. Customizing instantiation logic with a FactoryBean

7.9. Annotation-based container configuration

7.9.1. @Required

7.9.2. @Autowired

7.9.3. Fine-tuning annotation-based autowiring with @Primary

7.9.4. Fine-tuning annotation-based autowiring with qualifiers

7.9.5. Using generics as autowiring qualifiers

7.9.6. CustomAutowireConfigurer

7.9.7. @Resource

7.9.8. @PostConstruct and @PreDestroy

7.10. Classpath scanning and managed components

7.10.1. @Component and further stereotype annotations

7.10.2. Meta-annotations

7.10.3. Automatically detecting classes and registering bean definitions

7.10.4. Using filters to customize scanning

7.10.5. Defining bean metadata within components

7.10.6. Naming autodetected components

7.10.7. Providing a scope for autodetected components

7.10.8. Providing qualifier metadata with annotations

7.11. Using JSR 330 Standard Annotations

7.11.1. Dependency Injection with @Inject and @Named

7.11.2. @Named and @ManagedBean: standard equivalents to the @Component annotation

7.11.3. Limitations of JSR-330 standard annotations

7.12. Java-based container configuration

7.12.1. Basic concepts: @Bean and @Configuration

7.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext

Simple construction

Building the container programmatically using register(Class<?>…​)

Enabling component scanning with scan(String…​)

Support for web applications with AnnotationConfigWebApplicationContext

7.12.3. Using the @Bean annotation

Declaring a bean

Bean dependencies

Receiving lifecycle callbacks

Specifying bean scope

Customizing bean naming

Bean aliasing

Bean description

7.12.4. Using the @Configuration annotation

Injecting inter-bean dependencies

Lookup method injection

Further information about how Java-based configuration works internally

7.12.5. Composing Java-based configurations

Using the @Import annotation

Conditionally include @Configuration classes or @Bean methods

Combining Java and XML configuration

7.13. Environment abstraction

7.13.1. Bean definition profiles

@Profile

7.13.2. XML bean definition profiles

Activating a profile

Default profile

7.13.3. PropertySource abstraction

7.13.4. @PropertySource

7.13.5. Placeholder resolution in statements

7.14. Registering a LoadTimeWeaver

7.15. Additional Capabilities of the ApplicationContext

7.15.1. Internationalization using MessageSource

7.15.2. Standard and Custom Events

Annotation-based Event Listeners

Asynchronous Listeners

Ordering Listeners

Generic Events

7.15.3. Convenient access to low-level resources

7.15.4. Convenient ApplicationContext instantiation for web applications

7.15.5. Deploying a Spring ApplicationContext as a Java EE RAR file

7.16. The BeanFactory

7.16.1. BeanFactory or ApplicationContext?

7.16.2. Glue code and the evil singleton

8. Resources

8.1. Introduction

8.2. The Resource interface

8.3. Built-in Resource implementations

8.3.1. UrlResource

8.3.2. ClassPathResource

8.3.3. FileSystemResource

8.3.4. ServletContextResource

8.3.5. InputStreamResource

8.3.6. ByteArrayResource

8.4. The ResourceLoader

8.5. The ResourceLoaderAware interface

8.6. Resources as dependencies

8.7. Application contexts and Resource paths

8.7.1. Constructing application contexts

Constructing ClassPathXmlApplicationContext instances - shortcuts

8.7.2. Wildcards in application context constructor resource paths

Ant-style Patterns

The Classpath*: portability classpath*: prefix

Other notes relating to wildcards

8.7.3. FileSystemResource caveats

9. Validation, Data Binding, and Type Conversion

9.1. Introduction

9.2. Validation using Spring’s Validator interface

9.3. Resolving codes to error messages

9.4. Bean manipulation and the BeanWrapper

9.4.1. Setting and getting basic and nested properties

9.4.2. Built-in PropertyEditor implementations

Registering additional custom PropertyEditors

9.5. Spring Type Conversion

9.5.1. Converter SPI

9.5.2. ConverterFactory

9.5.3. GenericConverter

ConditionalGenericConverter

9.5.4. ConversionService API

9.5.5. Configuring a ConversionService

9.5.6. Using a ConversionService programmatically

9.6. Spring Field Formatting

9.6.1. Formatter SPI

9.6.2. Annotation-driven Formatting

Format Annotation API

9.6.3. FormatterRegistry SPI

9.6.4. FormatterRegistrar SPI

9.6.5. Configuring Formatting in Spring MVC

9.7. Configuring a global date & time format

9.8. Spring Validation

9.8.1. Overview of the JSR-303 Bean Validation API

9.8.2. Configuring a Bean Validation Provider

Injecting a Validator

Configuring Custom Constraints

Spring-driven Method Validation

Additional Configuration Options

9.8.3. Configuring a DataBinder

9.8.4. Spring MVC 3 Validation

10. Spring Expression Language (SpEL)

10.1. Introduction

10.2. Feature Overview

10.3. Expression Evaluation using Spring’s Expression Interface

10.3.1. The EvaluationContext interface

Type Conversion

10.3.2. Parser configuration

10.3.3. SpEL compilation

Compiler configuration

Compiler limitations

10.4. Expression support for defining bean definitions

10.4.1. XML based configuration

10.4.2. Annotation-based configuration

10.5. Language Reference

10.5.1. Literal expressions

10.5.2. Properties, Arrays, Lists, Maps, Indexers

10.5.3. Inline lists

10.5.4. Inline Maps

10.5.5. Array construction

10.5.6. Methods

10.5.7. Operators

Relational operators

Logical operators

Mathematical operators

10.5.8. Assignment

10.5.9. Types

10.5.10. Constructors

10.5.11. Variables

The #this and #root variables

10.5.12. Functions

10.5.13. Bean references

10.5.14. Ternary Operator (If-Then-Else)

10.5.15. The Elvis Operator

10.5.16. Safe Navigation operator

10.5.17. Collection Selection

10.5.18. Collection Projection

10.5.19. Expression templating

10.6. Classes used in the examples

11. Aspect Oriented Programming with Spring

11.1. Introduction

11.1.1. AOP concepts

11.1.2. Spring AOP capabilities and goals

11.1.3. AOP Proxies

11.2. @AspectJ support

11.2.1. Enabling @AspectJ Support

Enabling @AspectJ Support with Java configuration

Enabling @AspectJ Support with XML configuration

11.2.2. Declaring an aspect

11.2.3. Declaring a pointcut

Supported Pointcut Designators

Combining pointcut expressions

Sharing common pointcut definitions

Examples

Writing good pointcuts

11.2.4. Declaring advice

Before advice

After returning advice

After throwing advice

After (finally) advice

Around advice

Advice parameters

Advice ordering

11.2.5. Introductions

11.2.6. Aspect instantiation models

11.2.7. Example

11.3. Schema-based AOP support

11.3.1. Declaring an aspect

11.3.2. Declaring a pointcut

11.3.3. Declaring advice

Before advice

After returning advice

After throwing advice

After (finally) advice

Around advice

Advice parameters

Advice ordering

11.3.4. Introductions

11.3.5. Aspect instantiation models

11.3.6. Advisors

11.3.7. Example

11.4. Choosing which AOP declaration style to use

11.4.1. Spring AOP or full AspectJ?

11.4.2. @AspectJ or XML for Spring AOP?

11.5. Mixing aspect types

11.6. Proxying mechanisms

11.6.1. Understanding AOP proxies

11.7. Programmatic creation of @AspectJ Proxies

11.8. Using AspectJ with Spring applications

11.8.1. Using AspectJ to dependency inject domain objects with Spring

Unit testing @Configurable objects

Working with multiple application contexts

11.8.2. Other Spring aspects for AspectJ

11.8.3. Configuring AspectJ aspects using Spring IoC

11.8.4. Load-time weaving with AspectJ in the Spring Framework

A first example

Aspects

'META-INF/aop.xml'

Required libraries (JARS)

Spring configuration

Environment-specific configuration

11.9. Further Resources

12. Spring AOP APIs

12.1. Introduction

12.2. Pointcut API in Spring

12.2.1. Concepts

12.2.2. Operations on pointcuts

12.2.3. AspectJ expression pointcuts

12.2.4. Convenience pointcut implementations

Static pointcuts

Dynamic pointcuts

12.2.5. Pointcut superclasses

12.2.6. Custom pointcuts

12.3. Advice API in Spring

12.3.1. Advice lifecycles

12.3.2. Advice types in Spring

Interception around advice

Before advice

Throws advice

After Returning advice

Introduction advice

12.4. Advisor API in Spring

12.5. Using the ProxyFactoryBean to create AOP proxies

12.5.1. Basics

12.5.2. JavaBean properties

12.5.3. JDK- and CGLIB-based proxies

12.5.4. Proxying interfaces

12.5.5. Proxying classes

12.5.6. Using 'global' advisors

12.6. Concise proxy definitions

12.7. Creating AOP proxies programmatically with the ProxyFactory

12.8. Manipulating advised objects

12.9. Using the "auto-proxy" facility

12.9.1. Autoproxy bean definitions

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

AbstractAdvisorAutoProxyCreator

12.9.2. Using metadata-driven auto-proxying

12.10. Using TargetSources

12.10.1. Hot swappable target sources

12.10.2. Pooling target sources

12.10.3. Prototype target sources

12.10.4. ThreadLocal target sources

12.11. Defining new Advice types

12.12. Further resources

IV. Testing

13. Introduction to Spring Testing

14. Unit Testing

14.1. Mock Objects

14.1.1. Environment

14.1.2. JNDI

14.1.3. Servlet API

14.1.4. Portlet API

14.2. Unit Testing support Classes

14.2.1. General testing utilities

14.2.2. Spring MVC

15. Integration Testing

15.1. Overview

15.2. Goals of Integration Testing

15.2.1. Context management and caching

15.2.2. Dependency Injection of test fixtures

15.2.3. Transaction management

15.2.4. Support classes for integration testing

15.3. JDBC Testing Support

15.4. Annotations

15.4.1. Spring Testing Annotations

@BootstrapWith

@ContextConfiguration

@WebAppConfiguration

@ContextHierarchy

@ActiveProfiles

@TestPropertySource

@DirtiesContext

@TestExecutionListeners

@Commit

@Rollback

@BeforeTransaction

@AfterTransaction

@Sql

@SqlConfig

@SqlGroup

15.4.2. Standard Annotation Support

15.4.3. Spring JUnit 4 Testing Annotations

@IfProfileValue

@ProfileValueSourceConfiguration

@Timed

@Repeat

15.4.4. Meta-Annotation Support for Testing

15.5. Spring TestContext Framework

15.5.1. Key abstractions

TestContext

TestContextManager

TestExecutionListener

Context Loaders

15.5.2. Bootstrapping the TestContext framework

15.5.3. TestExecutionListener configuration

Registering custom TestExecutionListeners

Automatic discovery of default TestExecutionListeners

Ordering TestExecutionListeners

Merging TestExecutionListeners

15.5.4. Context management

Context configuration with XML resources

Context configuration with Groovy scripts

Context configuration with annotated classes

Mixing XML, Groovy scripts, and annotated classes

Context configuration with context initializers

Context configuration inheritance

Context configuration with environment profiles

Context configuration with test property sources

Loading a WebApplicationContext

Context caching

Context hierarchies

15.5.5. Dependency injection of test fixtures

15.5.6. Testing request and session scoped beans

15.5.7. Transaction management

Test-managed transactions

Enabling and disabling transactions

Transaction rollback and commit behavior

Programmatic transaction management

Executing code outside of a transaction

Configuring a transaction manager

Demonstration of all transaction-related annotations

15.5.8. Executing SQL scripts

Executing SQL scripts programmatically

Executing SQL scripts declaratively with @Sql

15.5.9. TestContext Framework support classes

Spring JUnit 4 Runner

Spring JUnit 4 Rules

JUnit 4 support classes

TestNG support classes

15.6. Spring MVC Test Framework

15.6.1. Server-Side Tests

Static Imports

Setup Options

Performing Requests

Defining Expectations

Filter Registrations

Differences between Out-of-Container and End-to-End Integration Tests

Further Server-Side Test Examples

15.6.2. HtmlUnit Integration

Why HtmlUnit Integration?

MockMvc and HtmlUnit

MockMvc and WebDriver

MockMvc and Geb

15.6.3. Client-Side REST Tests

Static Imports

Further Examples of Client-side REST Tests

15.7. PetClinic Example

16. Further Resources

V. Data Access

17. Transaction Management

17.1. Introduction to Spring Framework transaction management

17.2. Advantages of the Spring Framework’s transaction support model

17.2.1. Global transactions

17.2.2. Local transactions

17.2.3. Spring Framework’s consistent programming model

17.3. Understanding the Spring Framework transaction abstraction

17.4. Synchronizing resources with transactions

17.4.1. High-level synchronization approach

17.4.2. Low-level synchronization approach

17.4.3. TransactionAwareDataSourceProxy

17.5. Declarative transaction management

17.5.1. Understanding the Spring Framework’s declarative transaction implementation

17.5.2. Example of declarative transaction implementation

17.5.3. Rolling back a declarative transaction

17.5.4. Configuring different transactional semantics for different beans

17.5.5. <tx:advice/> settings

17.5.6. Using @Transactional

@Transactional settings

Multiple Transaction Managers with @Transactional

Custom shortcut annotations

17.5.7. Transaction propagation

Required

RequiresNew

Nested

17.5.8. Advising transactional operations

17.5.9. Using @Transactional with AspectJ

17.6. Programmatic transaction management

17.6.1. Using the TransactionTemplate

Specifying transaction settings

17.6.2. Using the PlatformTransactionManager

17.7. Choosing between programmatic and declarative transaction management

17.8. Transaction bound event

17.9. Application server-specific integration

17.9.1. IBM WebSphere

17.9.2. Oracle WebLogic Server

17.10. Solutions to common problems

17.10.1. Use of the wrong transaction manager for a specific DataSource

17.11. Further Resources

18. DAO support

18.1. Introduction

18.2. Consistent exception hierarchy

18.3. Annotations used for configuring DAO or Repository classes

19. Data access with JDBC

19.1. Introduction to Spring Framework JDBC

19.1.1. Choosing an approach for JDBC database access

19.1.2. Package hierarchy

19.2. Using the JDBC core classes to control basic JDBC processing and error handling

19.2.1. JdbcTemplate

Examples of JdbcTemplate class usage

JdbcTemplate best practices

19.2.2. NamedParameterJdbcTemplate

19.2.3. SQLExceptionTranslator

19.2.4. Executing statements

19.2.5. Running queries

19.2.6. Updating the database

19.2.7. Retrieving auto-generated keys

19.3. Controlling database connections

19.3.1. DataSource

19.3.2. DataSourceUtils

19.3.3. SmartDataSource

19.3.4. AbstractDataSource

19.3.5. SingleConnectionDataSource

19.3.6. DriverManagerDataSource

19.3.7. TransactionAwareDataSourceProxy

19.3.8. DataSourceTransactionManager

19.3.9. NativeJdbcExtractor

19.4. JDBC batch operations

19.4.1. Basic batch operations with the JdbcTemplate

19.4.2. Batch operations with a List of objects

19.4.3. Batch operations with multiple batches

19.5. Simplifying JDBC operations with the SimpleJdbc classes

19.5.1. Inserting data using SimpleJdbcInsert

19.5.2. Retrieving auto-generated keys using SimpleJdbcInsert

19.5.3. Specifying columns for a SimpleJdbcInsert

19.5.4. Using SqlParameterSource to provide parameter values

19.5.5. Calling a stored procedure with SimpleJdbcCall

19.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall

19.5.7. How to define SqlParameters

19.5.8. Calling a stored function using SimpleJdbcCall

19.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall

19.6. Modeling JDBC operations as Java objects

19.6.1. SqlQuery

19.6.2. MappingSqlQuery

19.6.3. SqlUpdate

19.6.4. StoredProcedure

19.7. Common problems with parameter and data value handling

19.7.1. Providing SQL type information for parameters

19.7.2. Handling BLOB and CLOB objects

19.7.3. Passing in lists of values for IN clause

19.7.4. Handling complex types for stored procedure calls

19.8. Embedded database support

19.8.1. Why use an embedded database?

19.8.2. Creating an embedded database using Spring XML

19.8.3. Creating an embedded database programmatically

19.8.4. Selecting the embedded database type

Using HSQL

Using H2

Using Derby

19.8.5. Testing data access logic with an embedded database

19.8.6. Generating unique names for embedded databases

19.8.7. Extending the embedded database support

19.9. Initializing a DataSource

19.9.1. Initializing a database using Spring XML

Initialization of other components that depend on the database

20. Object Relational Mapping (ORM) Data Access

20.1. Introduction to ORM with Spring

20.2. General ORM integration considerations

20.2.1. Resource and transaction management

20.2.2. Exception translation

20.3. Hibernate

20.3.1. SessionFactory setup in a Spring container

20.3.2. Implementing DAOs based on plain Hibernate API

20.3.3. Declarative transaction demarcation

20.3.4. Programmatic transaction demarcation

20.3.5. Transaction management strategies

20.3.6. Comparing container-managed and locally defined resources

20.3.7. Spurious application server warnings with Hibernate

20.4. JDO

20.4.1. PersistenceManagerFactory setup

20.4.2. Implementing DAOs based on the plain JDO API

20.4.3. Transaction management

20.4.4. JdoDialect

20.5. JPA

20.5.1. Three options for JPA setup in a Spring environment

LocalEntityManagerFactoryBean

Obtaining an EntityManagerFactory from JNDI

LocalContainerEntityManagerFactoryBean

Dealing with multiple persistence units

20.5.2. Implementing DAOs based on JPA: EntityManagerFactory and EntityManager

20.5.3. Spring-driven JPA transactions

20.5.4. JpaDialect and JpaVendorAdapter

20.5.5. Setting up JPA with JTA transaction management

21. Marshalling XML using O/X Mappers

21.1. Introduction

21.1.1. Ease of configuration

21.1.2. Consistent Interfaces

21.1.3. Consistent Exception Hierarchy

21.2. Marshaller and Unmarshaller

21.2.1. Marshaller

21.2.2. Unmarshaller

21.2.3. XmlMappingException

21.3. Using Marshaller and Unmarshaller

21.4. XML Schema-based Configuration

21.5. JAXB

21.5.1. Jaxb2Marshaller

XML Schema-based Configuration

21.6. Castor

21.6.1. CastorMarshaller

21.6.2. Mapping

XML Schema-based Configuration

21.7. XMLBeans

21.7.1. XmlBeansMarshaller

XML Schema-based Configuration

21.8. JiBX

21.8.1. JibxMarshaller

XML Schema-based Configuration

21.9. XStream

21.9.1. XStreamMarshaller

VI. The Web

22. Web MVC framework

22.1. Introduction to Spring Web MVC framework

22.1.1. Features of Spring Web MVC

22.1.2. Pluggability of other MVC implementations

22.2. The DispatcherServlet

22.2.1. Special Bean Types In the WebApplicationContext

22.2.2. Default DispatcherServlet Configuration

22.2.3. DispatcherServlet Processing Sequence

22.3. Implementing Controllers

22.3.1. Defining a controller with @Controller

22.3.2. Mapping Requests With @RequestMapping

Composed @RequestMapping Variants

@Controller and AOP Proxying

New Support Classes for @RequestMapping methods in Spring MVC 3.1

URI Template Patterns

URI Template Patterns with Regular Expressions

Path Patterns

Path Pattern Comparison

Path Patterns with Placeholders

Suffix Pattern Matching

Suffix Pattern Matching and RFD

Matrix Variables

Consumable Media Types

Producible Media Types

Request Parameters and Header Values

HTTP HEAD and HTTP OPTIONS

22.3.3. Defining @RequestMapping handler methods

Supported method argument types

Supported method return types

Binding request parameters to method parameters with @RequestParam

Mapping the request body with the @RequestBody annotation

Mapping the response body with the @ResponseBody annotation

Creating REST Controllers with the @RestController annotation

Using HttpEntity

Using @ModelAttribute on a method

Using @ModelAttribute on a method argument

Using @SessionAttributes to store model attributes in the HTTP session between requests

Using @SessionAttribute to access pre-existing global session attributes

Using @RequestAttribute to access request attributes

Working with "application/x-www-form-urlencoded" data

Mapping cookie values with the @CookieValue annotation

Mapping request header attributes with the @RequestHeader annotation

Method Parameters And Type Conversion

Customizing WebDataBinder initialization

Advising controllers with @ControllerAdvice and @RestControllerAdvice

Jackson Serialization View Support

Jackson JSONP Support

22.3.4. Asynchronous Request Processing

Exception Handling for Async Requests

Intercepting Async Requests

HTTP Streaming

HTTP Streaming With Server-Sent Events

HTTP Streaming Directly To The OutputStream

Configuring Asynchronous Request Processing

22.3.5. Testing Controllers

22.4. Handler mappings

22.4.1. Intercepting requests with a HandlerInterceptor

22.5. Resolving views

22.5.1. Resolving views with the ViewResolver interface

22.5.2. Chaining ViewResolvers

22.5.3. Redirecting to Views

RedirectView

The redirect: prefix

The forward: prefix

22.5.4. ContentNegotiatingViewResolver

22.6. Using flash attributes

22.7. Building URIs

22.7.1. Building URIs to Controllers and methods

22.7.2. Building URIs to Controllers and methods from views

22.8. Using locales

22.8.1. Obtaining Time Zone Information

22.8.2. AcceptHeaderLocaleResolver

22.8.3. CookieLocaleResolver

22.8.4. SessionLocaleResolver

22.8.5. LocaleChangeInterceptor

22.9. Using themes

22.9.1. Overview of themes

22.9.2. Defining themes

22.9.3. Theme resolvers

22.10. Spring’s multipart (file upload) support

22.10.1. Introduction

22.10.2. Using a MultipartResolver with Commons FileUpload

22.10.3. Using a MultipartResolver with Servlet 3.0

22.10.4. Handling a file upload in a form

22.10.5. Handling a file upload request from programmatic clients

22.11. Handling exceptions

22.11.1. HandlerExceptionResolver

22.11.2. @ExceptionHandler

22.11.3. Handling Standard Spring MVC Exceptions

22.11.4. Annotating Business Exceptions With @ResponseStatus

22.11.5. Customizing the Default Servlet Container Error Page

22.12. Web Security

22.13. Convention over configuration support

22.13.1. The Controller ControllerClassNameHandlerMapping

22.13.2. The Model ModelMap (ModelAndView)

22.13.3. The View - RequestToViewNameTranslator

22.14. HTTP caching support

22.14.1. Cache-Control HTTP header

22.14.2. HTTP caching support for static resources

22.14.3. Support for the Cache-Control, ETag and Last-Modified response headers in Controllers

22.14.4. Shallow ETag support

22.15. Code-based Servlet container initialization

22.16. Configuring Spring MVC

22.16.1. Enabling the MVC Java Config or the MVC XML Namespace

22.16.2. Customizing the Provided Configuration

22.16.3. Conversion and Formatting

22.16.4. Validation

22.16.5. Interceptors

22.16.6. Content Negotiation

22.16.7. View Controllers

22.16.8. View Resolvers

22.16.9. Serving of Resources

22.16.10. Falling Back On the "Default" Servlet To Serve Resources

22.16.11. Path Matching

22.16.12. Message Converters

22.16.13. Advanced Customizations with MVC Java Config

22.16.14. Advanced Customizations with the MVC Namespace

23. View technologies

23.1. Introduction

23.2. Thymeleaf

23.3. Groovy Markup Templates

23.3.1. Configuration

23.3.2. Example

23.4. Velocity & FreeMarker

23.4.1. Dependencies

23.4.2. Context configuration

23.4.3. Creating templates

23.4.4. Advanced configuration

velocity.properties

FreeMarker

23.4.5. Bind support and form handling

The bind macros

Simple binding

Form input generation macros

HTML escaping and XHTML compliance

23.5. JSP & JSTL

23.5.1. View resolvers

23.5.2. 'Plain-old' JSPs versus JSTL

23.5.3. Additional tags facilitating development

23.5.4. Using Spring’s form tag library

Configuration

The form tag

The input tag

The checkbox tag

The checkboxes tag

The radiobutton tag

The radiobuttons tag

The password tag

The select tag

The option tag

The options tag

The textarea tag

The hidden tag

The errors tag

HTTP Method Conversion

HTML5 Tags

23.6. Script templates

23.6.1. Dependencies

23.6.2. How to integrate script based templating

23.7. XML Marshalling View

23.8. Tiles

23.8.1. Dependencies

23.8.2. How to integrate Tiles

UrlBasedViewResolver

ResourceBundleViewResolver

SimpleSpringPreparerFactory and SpringBeanPreparerFactory

23.9. XSLT

23.9.1. My First Words

Bean definitions

Standard MVC controller code

Document transformation

23.10. Document views (PDF/Excel)

23.10.1. Introduction

23.10.2. Configuration and setup

Document view definitions

Controller code

Subclassing for Excel views

Subclassing for PDF views

23.11. JasperReports

23.11.1. Dependencies

23.11.2. Configuration

Configuring the ViewResolver

Configuring the Views

About Report Files

Using JasperReportsMultiFormatView

23.11.3. Populating the ModelAndView

23.11.4. Working with Sub-Reports

Configuring Sub-Report Files

Configuring Sub-Report Data Sources

23.11.5. Configuring Exporter Parameters

23.12. Feed Views

23.13. JSON Mapping View

23.14. XML Mapping View

24. Integrating with other web frameworks

24.1. Introduction

24.2. Common configuration

24.3. JavaServer Faces 1.2

24.3.1. SpringBeanFacesELResolver (JSF 1.2+)

24.3.2. FacesContextUtils

24.4. Apache Struts 2.x

24.5. Tapestry 5.x

24.6. Further Resources

25. Portlet MVC Framework

25.1. Introduction

25.1.1. Controllers - The C in MVC

25.1.2. Views - The V in MVC

25.1.3. Web-scoped beans

25.2. The DispatcherPortlet

25.3. The ViewRendererServlet

25.4. Controllers

25.4.1. AbstractController and PortletContentGenerator

25.4.2. Other simple controllers

25.4.3. Command Controllers

25.4.4. PortletWrappingController

25.5. Handler mappings

25.5.1. PortletModeHandlerMapping

25.5.2. ParameterHandlerMapping

25.5.3. PortletModeParameterHandlerMapping

25.5.4. Adding HandlerInterceptors

25.5.5. HandlerInterceptorAdapter

25.5.6. ParameterMappingInterceptor

25.6. Views and resolving them

25.7. Multipart (file upload) support

25.7.1. Using the PortletMultipartResolver

25.7.2. Handling a file upload in a form

25.8. Handling exceptions

25.9. Annotation-based controller configuration

25.9.1. Setting up the dispatcher for annotation support

25.9.2. Defining a controller with @Controller

25.9.3. Mapping requests with @RequestMapping

25.9.4. Supported handler method arguments

25.9.5. Binding request parameters to method parameters with @RequestParam

25.9.6. Providing a link to data from the model with @ModelAttribute

25.9.7. Specifying attributes to store in a Session with @SessionAttributes

25.9.8. Customizing WebDataBinder initialization

Customizing data binding with @InitBinder

Configuring a custom WebBindingInitializer

25.10. Portlet application deployment

26. WebSocket Support

26.1. Introduction

26.1.1. WebSocket Fallback Options

26.1.2. A Messaging Architecture

26.1.3. Sub-Protocol Support in WebSocket

26.1.4. Should I Use WebSocket?

26.2. WebSocket API

26.2.1. Create and Configure a WebSocketHandler

26.2.2. Customizing the WebSocket Handshake

26.2.3. WebSocketHandler Decoration

26.2.4. Deployment Considerations

26.2.5. Configuring the WebSocket Engine

26.2.6. Configuring allowed origins

26.3. SockJS Fallback Options

26.3.1. Overview of SockJS

26.3.2. Enable SockJS

26.3.3. HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame

26.3.4. Heartbeat Messages

26.3.5. Servlet 3 Async Requests

26.3.6. CORS Headers for SockJS

26.3.7. SockJS Client

26.4. STOMP Over WebSocket Messaging Architecture

26.4.1. Overview of STOMP

26.4.2. Enable STOMP over WebSocket

26.4.3. Flow of Messages

26.4.4. Annotation Message Handling

26.4.5. Sending Messages

26.4.6. Simple Broker

26.4.7. Full-Featured Broker

26.4.8. Connections To Full-Featured Broker

26.4.9. Using Dot as Separator in @MessageMapping Destinations

26.4.10. Authentication

26.4.11. Token-based Authentication

26.4.12. User Destinations

26.4.13. Listening To ApplicationContext Events and Intercepting Messages

26.4.14. STOMP Client

26.4.15. WebSocket Scope

26.4.16. Configuration and Performance

26.4.17. Runtime Monitoring

26.4.18. Testing Annotated Controller Methods

27. CORS Support

27.1. Introduction

27.2. Controller method CORS configuration

27.3. Global CORS configuration

27.3.1. JavaConfig

27.3.2. XML namespace

27.4. Advanced Customization

27.5. Filter based CORS support

VII. Integration

28. Remoting and web services using Spring

28.1. Introduction

28.2. Exposing services using RMI

28.2.1. Exporting the service using the RmiServiceExporter

28.2.2. Linking in the service at the client

28.3. Using Hessian or Burlap to remotely call services via HTTP

28.3.1. Wiring up the DispatcherServlet for Hessian and co.

28.3.2. Exposing your beans by using the HessianServiceExporter

28.3.3. Linking in the service on the client

28.3.4. Using Burlap

28.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap

28.4. Exposing services using HTTP invokers

28.4.1. Exposing the service object

28.4.2. Linking in the service at the client

28.5. Web services

28.5.1. Exposing servlet-based web services using JAX-WS

28.5.2. Exporting standalone web services using JAX-WS

28.5.3. Exporting web services using the JAX-WS RI’s Spring support

28.5.4. Accessing web services using JAX-WS

28.6. JMS

28.6.1. Server-side configuration

28.6.2. Client-side configuration

28.7. AMQP

28.8. Auto-detection is not implemented for remote interfaces

28.9. Considerations when choosing a technology

28.10. Accessing RESTful services on the Client

28.10.1. RestTemplate

Working with the URI

Dealing with request and response headers

Jackson JSON Views support

28.10.2. HTTP Message Conversion

StringHttpMessageConverter

FormHttpMessageConverter

ByteArrayHttpMessageConverter

MarshallingHttpMessageConverter

MappingJackson2HttpMessageConverter

MappingJackson2XmlHttpMessageConverter

SourceHttpMessageConverter

BufferedImageHttpMessageConverter

28.10.3. Async RestTemplate

29. Enterprise JavaBeans (EJB) integration

29.1. Introduction

29.2. Accessing EJBs

29.2.1. Concepts

29.2.2. Accessing local SLSBs

29.2.3. Accessing remote SLSBs

29.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs

29.3. Using Spring’s EJB implementation support classes

29.3.1. EJB 3 injection interceptor

30. JMS (Java Message Service)

30.1. Introduction

30.2. Using Spring JMS

30.2.1. JmsTemplate

30.2.2. Connections

Caching Messaging Resources

SingleConnectionFactory

CachingConnectionFactory

30.2.3. Destination Management

30.2.4. Message Listener Containers

SimpleMessageListenerContainer

DefaultMessageListenerContainer

30.2.5. Transaction management

30.3. Sending a Message

30.3.1. Using Message Converters

30.3.2. SessionCallback and ProducerCallback

30.4. Receiving a message

30.4.1. Synchronous Reception

30.4.2. Asynchronous Reception - Message-Driven POJOs

30.4.3. the SessionAwareMessageListener interface

30.4.4. the MessageListenerAdapter

30.4.5. Processing messages within transactions

30.5. Support for JCA Message Endpoints

30.6. Annotation-driven listener endpoints

30.6.1. Enable listener endpoint annotations

30.6.2. Programmatic endpoints registration

30.6.3. Annotated endpoint method signature

30.6.4. Response management

30.7. JMS namespace support

31. JMX

31.1. Introduction

31.2. Exporting your beans to JMX

31.2.1. Creating an MBeanServer

31.2.2. Reusing an existing MBeanServer

31.2.3. Lazy-initialized MBeans

31.2.4. Automatic registration of MBeans

31.2.5. Controlling the registration behavior

31.3. Controlling the management interface of your beans

31.3.1. the MBeanInfoAssembler Interface

31.3.2. Using Source-Level Metadata (Java annotations)

31.3.3. Source-Level Metadata Types

31.3.4. the AutodetectCapableMBeanInfoAssembler interface

31.3.5. Defining management interfaces using Java interfaces

31.3.6. Using MethodNameBasedMBeanInfoAssembler

31.4. Controlling the ObjectNames for your beans

31.4.1. Reading ObjectNames from Properties

31.4.2. Using the MetadataNamingStrategy

31.4.3. Configuring annotation based MBean export

31.5. JSR-160 Connectors

31.5.1. Server-side Connectors

31.5.2. Client-side Connectors

31.5.3. JMX over Burlap/Hessian/SOAP

31.6. Accessing MBeans via Proxies

31.7. Notifications

31.7.1. Registering Listeners for Notifications

31.7.2. Publishing Notifications

31.8. Further Resources

32. JCA CCI

32.1. Introduction

32.2. Configuring CCI

32.2.1. Connector configuration

32.2.2. ConnectionFactory configuration in Spring

32.2.3. Configuring CCI connections

32.2.4. Using a single CCI connection

32.3. Using Spring’s CCI access support

32.3.1. Record conversion

32.3.2. the CciTemplate

32.3.3. DAO support

32.3.4. Automatic output record generation

32.3.5. Summary

32.3.6. Using a CCI Connection and Interaction directly

32.3.7. Example for CciTemplate usage

32.4. Modeling CCI access as operation objects

32.4.1. MappingRecordOperation

32.4.2. MappingCommAreaOperation

32.4.3. Automatic output record generation

32.4.4. Summary

32.4.5. Example for MappingRecordOperation usage

32.4.6. Example for MappingCommAreaOperation usage

32.5. Transactions

33. Email

33.1. Introduction

33.2. Usage

33.2.1. Basic MailSender and SimpleMailMessage usage

33.2.2. Using the JavaMailSender and the MimeMessagePreparator

33.3. Using the JavaMail MimeMessageHelper

33.3.1. Sending attachments and inline resources

Attachments

Inline resources

33.3.2. Creating email content using a templating library

A Velocity-based example

34. Task Execution and Scheduling

34.1. Introduction

34.2. The Spring TaskExecutor abstraction

34.2.1. TaskExecutor types

34.2.2. Using a TaskExecutor

34.3. The Spring TaskScheduler abstraction

34.3.1. the Trigger interface

34.3.2. Trigger implementations

34.3.3. TaskScheduler implementations

34.4. Annotation Support for Scheduling and Asynchronous Execution

34.4.1. Enable scheduling annotations

34.4.2. The @Scheduled annotation

34.4.3. The @Async annotation

34.4.4. Executor qualification with @Async

34.4.5. Exception management with @Async

34.5. The task namespace

34.5.1. The 'scheduler' element

34.5.2. The 'executor' element

34.5.3. The 'scheduled-tasks' element

34.6. Using the Quartz Scheduler

34.6.1. Using the JobDetailFactoryBean

34.6.2. Using the MethodInvokingJobDetailFactoryBean

34.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean

35. Dynamic language support

35.1. Introduction

35.2. A first example

35.3. Defining beans that are backed by dynamic languages

35.3.1. Common concepts

The <lang:language/> element

Refreshable beans

Inline dynamic language source files

Understanding Constructor Injection in the context of dynamic-language-backed beans

35.3.2. JRuby beans

35.3.3. Groovy beans

Customizing Groovy objects via a callback

35.3.4. BeanShell beans

35.4. Scenarios

35.4.1. Scripted Spring MVC Controllers

35.4.2. Scripted Validators

35.5. Bits and bobs

35.5.1. AOP - advising scripted beans

35.5.2. Scoping

35.6. Further Resources

36. Cache Abstraction

36.1. Introduction

36.2. Understanding the cache abstraction

36.3. Declarative annotation-based caching

36.3.1. @Cacheable annotation

Default Key Generation

Custom Key Generation Declaration

Default Cache Resolution

Custom cache resolution

Synchronized caching

Conditional caching

Available caching SpEL evaluation context

36.3.2. @CachePut annotation

36.3.3. @CacheEvict annotation

36.3.4. @Caching annotation

36.3.5. @CacheConfig annotation

36.3.6. Enable caching annotations

36.3.7. Using custom annotations

36.4. JCache (JSR-107) annotations

36.4.1. Features summary

36.4.2. Enabling JSR-107 support

36.5. Declarative XML-based caching

36.6. Configuring the cache storage

36.6.1. JDK ConcurrentMap-based Cache

36.6.2. Ehcache-based Cache

36.6.3. Caffeine Cache

36.6.4. Guava Cache

36.6.5. GemFire-based Cache

36.6.6. JSR-107 Cache

36.6.7. Dealing with caches without a backing store

36.7. Plugging-in different back-end caches

36.8. How can I set the TTL/TTI/Eviction policy/XXX feature?

VIII. Appendices

37. Migrating to Spring Framework 4.x

38. Spring Annotation Programming Model

39. Classic Spring Usage

39.1. Classic ORM usage

39.1.1. Hibernate

The HibernateTemplate

Implementing Spring-based DAOs without callbacks

39.2. JMS Usage

39.2.1. JmsTemplate

39.2.2. Asynchronous Message Reception

39.2.3. Connections

39.2.4. Transaction Management

40. Classic Spring AOP Usage

40.1. Pointcut API in Spring

40.1.1. Concepts

40.1.2. Operations on pointcuts

40.1.3. AspectJ expression pointcuts

40.1.4. Convenience pointcut implementations

Static pointcuts

Dynamic pointcuts

40.1.5. Pointcut superclasses

40.1.6. Custom pointcuts

40.2. Advice API in Spring

40.2.1. Advice lifecycles

40.2.2. Advice types in Spring

Interception around advice

Before advice

Throws advice

After Returning advice

Introduction advice

40.3. Advisor API in Spring

40.4. Using the ProxyFactoryBean to create AOP proxies

40.4.1. Basics

40.4.2. JavaBean properties

40.4.3. JDK- and CGLIB-based proxies

40.4.4. Proxying interfaces

40.4.5. Proxying classes

40.4.6. Using 'global' advisors

40.5. Concise proxy definitions

40.6. Creating AOP proxies programmatically with the ProxyFactory

40.7. Manipulating advised objects

40.8. Using the "autoproxy" facility

40.8.1. Autoproxy bean definitions

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

AbstractAdvisorAutoProxyCreator

40.8.2. Using metadata-driven auto-proxying

40.9. Using TargetSources

40.9.1. Hot swappable target sources

40.9.2. Pooling target sources

40.9.3. Prototype target sources

40.9.4. ThreadLocal target sources

40.10. Defining new Advice types

40.11. Further resources

41. XML Schema-based configuration

41.1. Introduction

41.2. XML Schema-based configuration

41.2.1. Referencing the schemas

41.2.2. the util schema

<util:constant/>

<util:property-path/>

<util:properties/>

<util:list/>

<util:map/>

<util:set/>

41.2.3. the jee schema

<jee:jndi-lookup/> (simple)

<jee:jndi-lookup/> (with single JNDI environment setting)

<jee:jndi-lookup/> (with multiple JNDI environment settings)

<jee:jndi-lookup/> (complex)

<jee:local-slsb/> (simple)

<jee:local-slsb/> (complex)

<jee:remote-slsb/>

41.2.4. the lang schema

41.2.5. the jms schema

41.2.6. the tx (transaction) schema

41.2.7. the aop schema

41.2.8. the context schema

<property-placeholder/>

<annotation-config/>

<component-scan/>

<load-time-weaver/>

<spring-configured/>

<mbean-export/>

41.2.9. the tool schema

41.2.10. the jdbc schema

41.2.11. the cache schema

41.2.12. the beans schema

42. Extensible XML authoring

42.1. Introduction

42.2. Authoring the schema

42.3. Coding a NamespaceHandler

42.4. BeanDefinitionParser

42.5. Registering the handler and the schema

42.5.1. 'META-INF/spring.handlers'

42.5.2. 'META-INF/spring.schemas'

42.6. Using a custom extension in your Spring XML configuration

42.7. Meatier examples

42.7.1. Nesting custom tags within custom tags

42.7.2. Custom attributes on 'normal' elements

42.8. Further Resources

43. spring JSP Tag Library

43.1. Introduction

43.2. The argument tag

43.3. The bind tag

43.4. The escapeBody tag

43.5. The eval tag

43.6. The hasBindErrors tag

43.7. The htmlEscape tag

43.8. The message tag

43.9. The nestedPath tag

43.10. The param tag

43.11. The theme tag

43.12. The transform tag

43.13. The url tag

44. spring-form JSP Tag Library

44.1. Introduction

44.2. The button tag

44.3. The checkbox tag

44.4. The checkboxes tag

44.5. The errors tag

44.6. The form tag

44.7. The hidden tag

44.8. The input tag

44.9. The label tag

44.10. The option tag

44.11. The options tag

44.12. The password tag

44.13. The radiobutton tag

44.14. The radiobuttons tag

44.15. The select tag

44.16. The textarea tag

http://docs.spring.io/spring/docs/current/javadoc-api/