Outline for Spring Framework Reference Documentation
A huge hunk of specification.
I had planned to cut/paste, add notes, etc. but the thing overwhelms me ... whatever the subject is, it's probably in there somewhere.
From http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/
I. Overview of Spring Framework
- Getting Started with Spring
- 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
- 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
- New Features and Enhancements in Spring Framework 4.1
4.1. JMS Improvements 4.2. Caching Improvements 4.3. Web Improvements 4.4. WebSocket STOMP Messaging Improvements 4.5. Testing Improvements
III. Core Technologies
5. The IoC container
5.1. Introduction to the Spring IoC container and beans 5.2. Container overview
5.2.1. Configuration metadata 5.2.2. Instantiating a container
Composing XML-based configuration metadata
5.2.3. Using the container
5.3. Bean overview
5.3.1. Naming beans
Aliasing a bean outside the bean definition
5.3.2. Instantiating beans
Instantiation with a constructor Instantiation with a static factory method Instantiation using an instance factory method
5.4. Dependencies
5.4.1. Dependency injection
Constructor-based dependency injection Setter-based dependency injection Dependency resolution process Examples of dependency injection
5.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
5.4.3. Using depends-on 5.4.4. Lazy-initialized beans 5.4.5. Autowiring collaborators
Limitations and disadvantages of autowiring Excluding a bean from autowiring
5.4.6. Method injection
Lookup method injection Arbitrary method replacement
5.5. Bean scopes
5.5.1. The singleton scope 5.5.2. The prototype scope 5.5.3. Singleton beans with prototype-bean dependencies 5.5.4. Request, session, and global session scopes
Initial web configuration Request scope Session scope Global session scope Application scope Scoped beans as dependencies
5.5.5. Custom scopes
Creating a custom scope Using a custom scope
5.6. Customizing the nature of a bean
5.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
5.6.2. ApplicationContextAware? and BeanNameAware? 5.6.3. Other Aware interfaces
5.7. Bean definition inheritance 5.8. Container Extension Points
5.8.1. Customizing beans using a BeanPostProcessor?
Example: Hello World, BeanPostProcessor?-style Example: The RequiredAnnotationBeanPostProcessor?
5.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor?
Example: the Class name substitution PropertyPlaceholderConfigurer? Example: the PropertyOverrideConfigurer?
5.8.3. Customizing instantiation logic with a FactoryBean?
5.9. Annotation-based container configuration
5.9.1. @Required 5.9.2. @Autowired 5.9.3. Fine-tuning annotation-based autowiring with qualifiers 5.9.4. Using generics as autowiring qualifiers 5.9.5. CustomAutowireConfigurer? 5.9.6. @Resource 5.9.7. @PostConstruct? and @PreDestroy?
5.10. Classpath scanning and managed components
5.10.1. @Component and further stereotype annotations 5.10.2. Meta-annotations 5.10.3. Automatically detecting classes and registering bean definitions 5.10.4. Using filters to customize scanning 5.10.5. Defining bean metadata within components 5.10.6. Naming autodetected components 5.10.7. Providing a scope for autodetected components 5.10.8. Providing qualifier metadata with annotations
5.11. Using JSR 330 Standard Annotations
5.11.1. Dependency Injection with @Inject and @Named 5.11.2. @Named: a standard equivalent to the @Component annotation 5.11.3. Limitations of the standard approach
5.12. Java-based container configuration
5.12.1. Basic concepts: @Bean and @Configuration 5.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?
5.12.3. Using the @Bean annotation
Declaring a bean Receiving lifecycle callbacks Specifying bean scope Customizing bean naming Bean aliasing Bean description
5.12.4. Using the @Configuration annotation
Injecting inter-bean dependencies Lookup method injection Further information about how Java-based configuration works internally
5.12.5. Composing Java-based configurations
Using the @Import annotation Conditionally including @Configuration classes or @Beans Combining Java and XML configuration
5.13. Environment abstraction
5.13.1. Bean definition profiles
@Profile
5.13.2. XML Bean definition profiles
Enabling a profile Default profile
5.13.3. PropertySource? Abstraction 5.13.4. @PropertySource? 5.13.5. Placeholder resolution in statements
5.14. Registering a LoadTimeWeaver? 5.15. Additional Capabilities of the ApplicationContext?
5.15.1. Internationalization using MessageSource? 5.15.2. Standard and Custom Events 5.15.3. Convenient access to low-level resources 5.15.4. Convenient ApplicationContext? instantiation for web applications 5.15.5. Deploying a Spring ApplicationContext? as a Java EE RAR file
5.16. The BeanFactory?
5.16.1. BeanFactory? or ApplicationContext?? 5.16.2. Glue code and the evil singleton
6. Resources
6.1. Introduction 6.2. The Resource interface 6.3. Built-in Resource implementations
6.3.1. UrlResource? 6.3.2. ClassPathResource? 6.3.3. FileSystemResource? 6.3.4. ServletContextResource? 6.3.5. InputStreamResource? 6.3.6. ByteArrayResource?
6.4. The ResourceLoader? 6.5. The ResourceLoaderAware? interface 6.6. Resources as dependencies 6.7. Application contexts and Resource paths
6.7.1. Constructing application contexts
Constructing ClassPathXmlApplicationContext? instances - shortcuts
6.7.2. Wildcards in application context constructor resource paths
Ant-style Patterns The Classpath*: portability classpath*: prefix Other notes relating to wildcards
6.7.3. FileSystemResource? caveats
7. Validation, Data Binding, and Type Conversion
7.1. Introduction 7.2. Validation using Spring’s Validator interface 7.3. Resolving codes to error messages 7.4. Bean manipulation and the BeanWrapper?
7.4.1. Setting and getting basic and nested properties 7.4.2. Built-in PropertyEditor? implementations
Registering additional custom PropertyEditors?
7.5. Spring Type Conversion
7.5.1. Converter SPI 7.5.2. ConverterFactory? 7.5.3. GenericConverter?
7.5.4. ConversionService? API 7.5.5. Configuring a ConversionService? 7.5.6. Using a ConversionService? programmatically
7.6. Spring Field Formatting
7.6.1. Formatter SPI 7.6.2. Annotation-driven Formatting
Format Annotation API
7.6.3. FormatterRegistry? SPI 7.6.4. FormatterRegistrar? SPI 7.6.5. Configuring Formatting in Spring MVC
7.7. Configuring a global date & time format 7.8. Spring Validation
7.8.1. Overview of the JSR-303 Bean Validation API 7.8.2. Configuring a Bean Validation Provider
Injecting a Validator Configuring Custom Constraints Spring-driven Method Validation Additional Configuration Options
7.8.3. Configuring a DataBinder? 7.8.4. Spring MVC 3 Validation
Triggering @Controller Input Validation Configuring a Validator for use by Spring MVC Configuring a JSR-303/JSR-349 Validator for use by Spring MVC
8. Spring Expression Language (SpEL)
8.1. Introduction 8.2. Feature Overview 8.3. Expression Evaluation using Spring’s Expression Interface
8.3.1. The EvaluationContext? interface
Type Conversion
8.3.2. Parser configuration 8.3.3. SpEL compilation
Compiler configuration Compiler limitations
8.4. Expression support for defining bean definitions
8.4.1. XML based configuration 8.4.2. Annotation-based configuration
8.5. Language Reference
8.5.1. Literal expressions 8.5.2. Properties, Arrays, Lists, Maps, Indexers 8.5.3. Inline lists 8.5.4. Inline Maps 8.5.5. Array construction 8.5.6. Methods 8.5.7. Operators
Relational operators Logical operators Mathematical operators
8.5.8. Assignment 8.5.9. Types 8.5.10. Constructors 8.5.11. Variables
The #this and #root variables
8.5.12. Functions 8.5.13. Bean references 8.5.14. Ternary Operator (If-Then-Else) 8.5.15. The Elvis Operator 8.5.16. Safe Navigation operator 8.5.17. Collection Selection 8.5.18. Collection Projection 8.5.19. Expression templating
8.6. Classes used in the examples
9. Aspect Oriented Programming with Spring
9.1. Introduction
9.1.1. AOP concepts 9.1.2. Spring AOP capabilities and goals 9.1.3. AOP Proxies
9.2. @AspectJ support
9.2.1. Enabling @AspectJ Support
Enabling @AspectJ Support with Java configuration Enabling @AspectJ Support with XML configuration
9.2.2. Declaring an aspect 9.2.3. Declaring a pointcut
Supported Pointcut Designators Combining pointcut expressions Sharing common pointcut definitions Examples Writing good pointcuts
9.2.4. Declaring advice
Before advice After returning advice After throwing advice After (finally) advice Around advice Advice parameters Advice ordering
9.2.5. Introductions 9.2.6. Aspect instantiation models 9.2.7. Example
9.3. Schema-based AOP support
9.3.1. Declaring an aspect 9.3.2. Declaring a pointcut 9.3.3. Declaring advice
Before advice After returning advice After throwing advice After (finally) advice Around advice Advice parameters Advice ordering
9.3.4. Introductions 9.3.5. Aspect instantiation models 9.3.6. Advisors 9.3.7. Example
9.4. Choosing which AOP declaration style to use
9.4.1. Spring AOP or full AspectJ? 9.4.2. @AspectJ or XML for Spring AOP?
9.5. Mixing aspect types 9.6. Proxying mechanisms
9.6.1. Understanding AOP proxies
9.7. Programmatic creation of @AspectJ Proxies 9.8. Using AspectJ with Spring applications
9.8.1. Using AspectJ to dependency inject domain objects with Spring
Unit testing @Configurable objects Working with multiple application contexts
9.8.2. Other Spring aspects for AspectJ 9.8.3. Configuring AspectJ aspects using Spring IoC 9.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
9.9. Further Resources
10. Spring AOP APIs
10.1. Introduction 10.2. Pointcut API in Spring
10.2.1. Concepts 10.2.2. Operations on pointcuts 10.2.3. AspectJ expression pointcuts 10.2.4. Convenience pointcut implementations
Static pointcuts Dynamic pointcuts
10.2.5. Pointcut superclasses 10.2.6. Custom pointcuts
10.3. Advice API in Spring
10.3.1. Advice lifecycles 10.3.2. Advice types in Spring
Interception around advice Before advice Throws advice After Returning advice Introduction advice
10.4. Advisor API in Spring 10.5. Using the ProxyFactoryBean? to create AOP proxies
10.5.1. Basics 10.5.2. JavaBean? properties 10.5.3. JDK- and CGLIB-based proxies 10.5.4. Proxying interfaces 10.5.5. Proxying classes 10.5.6. Using global advisors
10.6. Concise proxy definitions 10.7. Creating AOP proxies programmatically with the ProxyFactory? 10.8. Manipulating advised objects 10.9. Using the "auto-proxy" facility
10.9.1. Autoproxy bean definitions
BeanNameAutoProxyCreator? DefaultAdvisorAutoProxyCreator? AbstractAdvisorAutoProxyCreator?
10.9.2. Using metadata-driven auto-proxying
10.10. Using TargetSources?
10.10.1. Hot swappable target sources 10.10.2. Pooling target sources 10.10.3. Prototype target sources 10.10.4. ThreadLocal? target sources
10.11. Defining new Advice types 10.12. Further resources
11. Testing
11.1. Introduction to Spring Testing 11.2. Unit Testing
11.2.1. Mock Objects
Environment JNDI Servlet API Portlet API
11.2.2. Unit Testing support Classes
General utilities Spring MVC
11.3. Integration Testing
11.3.1. Overview 11.3.2. Goals of Integration Testing
Context management and caching Dependency Injection of test fixtures Transaction management Support classes for integration testing
11.3.3. JDBC Testing Support 11.3.4. Annotations
Spring Testing Annotations Standard Annotation Support Spring JUnit Testing Annotations Meta-Annotation Support for Testing
11.3.5. Spring TestContext? Framework
Key abstractions TestExecutionListener? configuration Context management Dependency injection of test fixtures Testing request and session scoped beans Transaction management Executing SQL scripts TestContext? Framework support classes
11.3.6. Spring MVC Test Framework
Server-Side Tests Client-Side REST Tests
11.3.7. PetClinic? Example
11.4. Further Resources
IV. Data Access
12. Transaction Management
12.1. Introduction to Spring Framework transaction management 12.2. Advantages of the Spring Framework’s transaction support model
12.2.1. Global transactions 12.2.2. Local transactions 12.2.3. Spring Framework’s consistent programming model
12.3. Understanding the Spring Framework transaction abstraction 12.4. Synchronizing resources with transactions
12.4.1. High-level synchronization approach 12.4.2. Low-level synchronization approach 12.4.3. TransactionAwareDataSourceProxy?
12.5. Declarative transaction management
12.5.1. Understanding the Spring Framework’s declarative transaction implementation 12.5.2. Example of declarative transaction implementation 12.5.3. Rolling back a declarative transaction 12.5.4. Configuring different transactional semantics for different beans 12.5.5. <tx:advice/> settings 12.5.6. Using @Transactional
@Transactional settings Multiple Transaction Managers with @Transactional Custom shortcut annotations
12.5.7. Transaction propagation
Required RequiresNew? Nested
12.5.8. Advising transactional operations 12.5.9. Using @Transactional with AspectJ
12.6. Programmatic transaction management
12.6.1. Using the TransactionTemplate?
Specifying transaction settings
12.6.2. Using the PlatformTransactionManager?
12.7. Choosing between programmatic and declarative transaction management 12.8. Application server-specific integration
12.8.1. IBM WebSphere? 12.8.2. Oracle WebLogic? Server
12.9. Solutions to common problems
12.9.1. Use of the wrong transaction manager for a specific DataSource?
12.10. Further Resources
13. DAO support
13.1. Introduction 13.2. Consistent exception hierarchy 13.3. Annotations used for configuring DAO or Repository classes
14. Data access with JDBC
14.1. Introduction to Spring Framework JDBC
14.1.1. Choosing an approach for JDBC database access 14.1.2. Package hierarchy
14.2. Using the JDBC core classes to control basic JDBC processing and error handling
14.2.1. JdbcTemplate?
Examples of JdbcTemplate? class usage JdbcTemplate? best practices
14.2.2. NamedParameterJdbcTemplate? 14.2.3. SQLExceptionTranslator 14.2.4. Executing statements 14.2.5. Running queries 14.2.6. Updating the database 14.2.7. Retrieving auto-generated keys
14.3. Controlling database connections
14.3.1. DataSource? 14.3.2. DataSourceUtils? 14.3.3. SmartDataSource? 14.3.4. AbstractDataSource? 14.3.5. SingleConnectionDataSource? 14.3.6. DriverManagerDataSource? 14.3.7. TransactionAwareDataSourceProxy? 14.3.8. DataSourceTransactionManager? 14.3.9. NativeJdbcExtractor?
14.4. JDBC batch operations
14.4.1. Basic batch operations with the JdbcTemplate? 14.4.2. Batch operations with a List of objects 14.4.3. Batch operations with multiple batches
14.5. Simplifying JDBC operations with the SimpleJdbc? classes
14.5.1. Inserting data using SimpleJdbcInsert? 14.5.2. Retrieving auto-generated keys using SimpleJdbcInsert? 14.5.3. Specifying columns for a SimpleJdbcInsert? 14.5.4. Using SqlParameterSource? to provide parameter values 14.5.5. Calling a stored procedure with SimpleJdbcCall? 14.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall? 14.5.7. How to define SqlParameters? 14.5.8. Calling a stored function using SimpleJdbcCall? 14.5.9. Returning ResultSet?/REF Cursor from a SimpleJdbcCall?
14.6. Modeling JDBC operations as Java objects
14.6.1. SqlQuery? 14.6.2. MappingSqlQuery? 14.6.3. SqlUpdate? 14.6.4. StoredProcedure?
14.7. Common problems with parameter and data value handling
14.7.1. Providing SQL type information for parameters 14.7.2. Handling BLOB and CLOB objects 14.7.3. Passing in lists of values for IN clause 14.7.4. Handling complex types for stored procedure calls
14.8. Embedded database support
14.8.1. Why use an embedded database? 14.8.2. Creating an embedded database instance using Spring XML 14.8.3. Creating an embedded database instance programmatically 14.8.4. Extending the embedded database support 14.8.5. Using HSQL 14.8.6. Using H2 14.8.7. Using Derby 14.8.8. Testing data access logic with an embedded database
14.9. Initializing a DataSource?
14.9.1. Initializing a database instance using Spring XML
Initialization of Other Components that Depend on the Database
15. Object Relational Mapping (ORM) Data Access
15.1. Introduction to ORM with Spring 15.2. General ORM integration considerations
15.2.1. Resource and transaction management 15.2.2. Exception translation
15.3. Hibernate
15.3.1. SessionFactory? setup in a Spring container 15.3.2. Implementing DAOs based on plain Hibernate 3 API 15.3.3. Declarative transaction demarcation 15.3.4. Programmatic transaction demarcation 15.3.5. Transaction management strategies 15.3.6. Comparing container-managed and locally defined resources 15.3.7. Spurious application server warnings with Hibernate
15.4. JDO
15.4.1. PersistenceManagerFactory? setup 15.4.2. Implementing DAOs based on the plain JDO API 15.4.3. Transaction management 15.4.4. JdoDialect?
15.5. JPA
15.5.1. Three options for JPA setup in a Spring environment
LocalEntityManagerFactoryBean? Obtaining an EntityManagerFactory? from JNDI LocalContainerEntityManagerFactoryBean? Dealing with multiple persistence units
15.5.2. Implementing DAOs based on plain JPA 15.5.3. Transaction Management 15.5.4. JpaDialect?
16. Marshalling XML using O/X Mappers
16.1. Introduction
16.1.1. Ease of configuration 16.1.2. Consistent Interfaces 16.1.3. Consistent Exception Hierarchy
16.2. Marshaller and Unmarshaller
16.2.1. Marshaller 16.2.2. Unmarshaller 16.2.3. XmlMappingException?
16.3. Using Marshaller and Unmarshaller 16.4. XML Schema-based Configuration 16.5. JAXB
16.5.1. Jaxb2Marshaller
XML Schema-based Configuration
16.6. Castor
16.6.1. CastorMarshaller? 16.6.2. Mapping
XML Schema-based Configuration
16.7. XMLBeans
16.7.1. XmlBeansMarshaller?
XML Schema-based Configuration
16.8. JiBX
16.8.1. JibxMarshaller?
XML Schema-based Configuration
16.9. XStream
16.9.1. XStreamMarshaller
V. The Web
17. Web MVC framework
17.1. Introduction to Spring Web MVC framework
17.1.1. Features of Spring Web MVC 17.1.2. Pluggability of other MVC implementations
17.2. The DispatcherServlet?
17.2.1. Special Bean Types In the WebApplicationContext? 17.2.2. Default DispatcherServlet? Configuration 17.2.3. DispatcherServlet? Processing Sequence
17.3. Implementing Controllers
17.3.1. Defining a controller with @Controller 17.3.2. Mapping Requests With @RequestMapping?
@Controller's 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 Path Pattern Matching By Suffix Matrix Variables Consumable Media Types Producible Media Types Request Parameters and Header Values
17.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 Specifying redirect and flash 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 Support for the Last-Modified Response Header To Facilitate Content Caching Advising controllers with the @ControllerAdvice? annotation Jackson Serialization View Support Jackson JSONP Support
17.3.4. Asynchronous Request Processing
Exception Handling for Async Requests Intercepting Async Requests Configuration for Async Request Processing
17.3.5. Testing Controllers
17.4. Handler mappings
17.4.1. Intercepting requests with a HandlerInterceptor?
17.5. Resolving views
17.5.1. Resolving views with the ViewResolver? interface 17.5.2. Chaining ViewResolvers? 17.5.3. Redirecting to views
RedirectView? The redirect: prefix The forward: prefix
17.5.4. ContentNegotiatingViewResolver?
17.6. Using flash attributes 17.7. Building URIs
17.7.1. Building URIs to Controllers and methods 17.7.2. Building URIs to Controllers and methods from views
17.8. Using locales
17.8.1. Obtaining Time Zone Information 17.8.2. AcceptHeaderLocaleResolver? 17.8.3. CookieLocaleResolver? 17.8.4. SessionLocaleResolver? 17.8.5. LocaleChangeInterceptor?
17.9. Using themes
17.9.1. Overview of themes 17.9.2. Defining themes 17.9.3. Theme resolvers
17.10. Spring’s multipart (file upload) support
17.10.1. Introduction 17.10.2. Using a MultipartResolver? with Commons FileUpload? 17.10.3. Using a MultipartResolver? with Servlet 3.0 17.10.4. Handling a file upload in a form 17.10.5. Handling a file upload request from programmatic clients
17.11. Handling exceptions
17.11.1. HandlerExceptionResolver? 17.11.2. @ExceptionHandler? 17.11.3. Handling Standard Spring MVC Exceptions 17.11.4. Annotating Business Exceptions With @ResponseStatus? 17.11.5. Customizing the Default Servlet Container Error Page
17.12. Web Security 17.13. Convention over configuration support
17.13.1. The Controller ControllerClassNameHandlerMapping? 17.13.2. The Model ModelMap? (ModelAndView?) 17.13.3. The View - RequestToViewNameTranslator?
17.14. ETag support 17.15. Code-based Servlet container initialization 17.16. Configuring Spring MVC
17.16.1. Enabling the MVC Java Config or the MVC XML Namespace 17.16.2. Customizing the Provided Configuration 17.16.3. Interceptors 17.16.4. Content Negotiation 17.16.5. View Controllers 17.16.6. View Resolvers 17.16.7. Serving of Resources 17.16.8. Falling Back On the "Default" Servlet To Serve Resources 17.16.9. Path Matching 17.16.10. Advanced Customizations with MVC Java Config 17.16.11. Advanced Customizations with the MVC Namespace
18. View technologies
18.1. Introduction 18.2. JSP & JSTL
18.2.1. View resolvers 18.2.2. Plain-old JSPs versus JSTL 18.2.3. Additional tags facilitating development 18.2.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
18.3. Tiles
18.3.1. Dependencies 18.3.2. How to integrate Tiles
UrlBasedViewResolver? ResourceBundleViewResolver? SimpleSpringPreparerFactory? and SpringBeanPreparerFactory?
18.4. Velocity & FreeMarker?
18.4.1. Dependencies 18.4.2. Context configuration 18.4.3. Creating templates 18.4.4. Advanced configuration
velocity.properties FreeMarker?
18.4.5. Bind support and form handling
The bind macros Simple binding Form input generation macros HTML escaping and XHTML compliance
18.5. XSLT
18.5.1. My First Words
Bean definitions Standard MVC controller code Convert the model data to XML Defining the view properties Document transformation
18.5.2. Summary
18.6. Document views (PDF/Excel)
18.6.1. Introduction 18.6.2. Configuration and setup
Document view definitions Controller code Subclassing for Excel views Subclassing for PDF views
18.7. JasperReports?
18.7.1. Dependencies 18.7.2. Configuration
Configuring the ViewResolver? Configuring the Views About Report Files Using JasperReportsMultiFormatView?
18.7.3. Populating the ModelAndView? 18.7.4. Working with Sub-Reports
Configuring Sub-Report Files Configuring Sub-Report Data Sources
18.7.5. Configuring Exporter Parameters
18.8. Feed Views 18.9. XML Marshalling View 18.10. JSON Mapping View 18.11. XML Mapping View
19. Integrating with other web frameworks
19.1. Introduction 19.2. Common configuration 19.3. JavaServer? Faces 1.2
19.3.1. SpringBeanFacesELResolver (JSF 1.2+) 19.3.2. FacesContextUtils?
19.4. Apache Struts 2.x 19.5. Tapestry 5.x 19.6. Further Resources
20. Portlet MVC Framework
20.1. Introduction
20.1.1. Controllers - The C in MVC 20.1.2. Views - The V in MVC 20.1.3. Web-scoped beans
20.2. The DispatcherPortlet? 20.3. The ViewRendererServlet? 20.4. Controllers
20.4.1. AbstractController? and PortletContentGenerator? 20.4.2. Other simple controllers 20.4.3. Command Controllers 20.4.4. PortletWrappingController?
20.5. Handler mappings
20.5.1. PortletModeHandlerMapping? 20.5.2. ParameterHandlerMapping? 20.5.3. PortletModeParameterHandlerMapping? 20.5.4. Adding HandlerInterceptors? 20.5.5. HandlerInterceptorAdapter? 20.5.6. ParameterMappingInterceptor?
20.6. Views and resolving them 20.7. Multipart (file upload) support
20.7.1. Using the PortletMultipartResolver? 20.7.2. Handling a file upload in a form
20.8. Handling exceptions 20.9. Annotation-based controller configuration
20.9.1. Setting up the dispatcher for annotation support 20.9.2. Defining a controller with @Controller 20.9.3. Mapping requests with @RequestMapping? 20.9.4. Supported handler method arguments 20.9.5. Binding request parameters to method parameters with @RequestParam? 20.9.6. Providing a link to data from the model with @ModelAttribute? 20.9.7. Specifying attributes to store in a Session with @SessionAttributes? 20.9.8. Customizing WebDataBinder? initialization
Customizing data binding with @InitBinder? Configuring a custom WebBindingInitializer?
20.10. Portlet application deployment
21. WebSocket Support
21.1. Introduction
21.1.1. WebSocket Fallback Options 21.1.2. A Messaging Architecture 21.1.3. Sub-Protocol Support in WebSocket 21.1.4. Should I Use WebSocket?
21.2. WebSocket API
21.2.1. Create and Configure a WebSocketHandler? 21.2.2. Customizing the WebSocket Handshake 21.2.3. WebSocketHandler? Decoration 21.2.4. Deployment Considerations 21.2.5. Configuring the WebSocket Engine 21.2.6. Configuring allowed origins
21.3. SockJS Fallback Options
21.3.1. Overview of SockJS 21.3.2. Enable SockJS 21.3.3. HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame 21.3.4. Heartbeat Messages 21.3.5. Servlet 3 Async Requests 21.3.6. CORS Headers for SockJS 21.3.7. SockJS Client
21.4. STOMP Over WebSocket Messaging Architecture
21.4.1. Overview of STOMP 21.4.2. Enable STOMP over WebSocket 21.4.3. Flow of Messages 21.4.4. Annotation Message Handling 21.4.5. Sending Messages 21.4.6. Simple Broker 21.4.7. Full-Featured Broker 21.4.8. Connections To Full-Featured Broker 21.4.9. Using Dot as Separator in @MessageMapping? Destinations 21.4.10. Authentication 21.4.11. User Destinations 21.4.12. Listening To ApplicationContext? Events and Intercepting Messages 21.4.13. WebSocket Scope 21.4.14. Configuration and Performance 21.4.15. Runtime Monitoring 21.4.16. Testing Annotated Controller Methods
VI. Integration
22. Remoting and web services using Spring
22.1. Introduction 22.2. Exposing services using RMI
22.2.1. Exporting the service using the RmiServiceExporter? 22.2.2. Linking in the service at the client
22.3. Using Hessian or Burlap to remotely call services via HTTP
22.3.1. Wiring up the DispatcherServlet? for Hessian and co. 22.3.2. Exposing your beans by using the HessianServiceExporter? 22.3.3. Linking in the service on the client 22.3.4. Using Burlap 22.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
22.4. Exposing services using HTTP invokers
22.4.1. Exposing the service object 22.4.2. Linking in the service at the client
22.5. Web services
22.5.1. Exposing servlet-based web services using JAX-WS 22.5.2. Exporting standalone web services using JAX-WS 22.5.3. Exporting web services using the JAX-WS RI’s Spring support 22.5.4. Accessing web services using JAX-WS
22.6. JMS
22.6.1. Server-side configuration 22.6.2. Client-side configuration
22.7. AMQP 22.8. Auto-detection is not implemented for remote interfaces 22.9. Considerations when choosing a technology 22.10. Accessing RESTful services on the Client
22.10.1. RestTemplate?
Working with the URI Dealing with request and response headers Jackson JSON Views support
22.10.2. HTTP Message Conversion
StringHttpMessageConverter? FormHttpMessageConverter? ByteArrayHttpMessageConverter? MarshallingHttpMessageConverter? MappingJackson2HttpMessageConverter MappingJackson2XmlHttpMessageConverter SourceHttpMessageConverter? BufferedImageHttpMessageConverter?
22.10.3. Async RestTemplate?
23. Enterprise JavaBeans? (EJB) integration
23.1. Introduction 23.2. Accessing EJBs
23.2.1. Concepts 23.2.2. Accessing local SLSBs 23.2.3. Accessing remote SLSBs 23.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
23.3. Using Spring’s EJB implementation support classes
23.3.1. EJB 3 injection interceptor
24. JMS (Java Message Service)
24.1. Introduction 24.2. Using Spring JMS
24.2.1. JmsTemplate? 24.2.2. Connections
Caching Messaging Resources SingleConnectionFactory? CachingConnectionFactory?
24.2.3. Destination Management 24.2.4. Message Listener Containers
SimpleMessageListenerContainer? DefaultMessageListenerContainer?
24.2.5. Transaction management
24.3. Sending a Message
24.3.1. Using Message Converters 24.3.2. SessionCallback? and ProducerCallback?
24.4. Receiving a message
24.4.1. Synchronous Reception 24.4.2. Asynchronous Reception - Message-Driven POJOs 24.4.3. the SessionAwareMessageListener? interface 24.4.4. the MessageListenerAdapter? 24.4.5. Processing messages within transactions
24.5. Support for JCA Message Endpoints 24.6. Annotation-driven listener endpoints
24.6.1. Enable listener endpoint annotations 24.6.2. Programmatic endpoints registration 24.6.3. Annotated endpoint method signature 24.6.4. Reply management
24.7. JMS Namespace Support
25. JMX
25.1. Introduction 25.2. Exporting your beans to JMX
25.2.1. Creating an MBeanServer 25.2.2. Reusing an existing MBeanServer 25.2.3. Lazy-initialized MBeans 25.2.4. Automatic registration of MBeans 25.2.5. Controlling the registration behavior
25.3. Controlling the management interface of your beans
25.3.1. the MBeanInfoAssembler Interface 25.3.2. Using Source-Level Metadata (Java annotations) 25.3.3. Source-Level Metadata Types 25.3.4. the AutodetectCapableMBeanInfoAssembler interface 25.3.5. Defining management interfaces using Java interfaces 25.3.6. Using MethodNameBasedMBeanInfoAssembler
25.4. Controlling the ObjectNames? for your beans
25.4.1. Reading ObjectNames? from Properties 25.4.2. Using the MetadataNamingStrategy? 25.4.3. Configuring annotation based MBean export
25.5. JSR-160 Connectors
25.5.1. Server-side Connectors 25.5.2. Client-side Connectors 25.5.3. JMX over Burlap/Hessian?/SOAP
25.6. Accessing MBeans via Proxies 25.7. Notifications
25.7.1. Registering Listeners for Notifications 25.7.2. Publishing Notifications
25.8. Further Resources
26. JCA CCI
26.1. Introduction 26.2. Configuring CCI
26.2.1. Connector configuration 26.2.2. ConnectionFactory? configuration in Spring 26.2.3. Configuring CCI connections 26.2.4. Using a single CCI connection
26.3. Using Spring’s CCI access support
26.3.1. Record conversion 26.3.2. the CciTemplate? 26.3.3. DAO support 26.3.4. Automatic output record generation 26.3.5. Summary 26.3.6. Using a CCI Connection and Interaction directly 26.3.7. Example for CciTemplate? usage
26.4. Modeling CCI access as operation objects
26.4.1. MappingRecordOperation? 26.4.2. MappingCommAreaOperation? 26.4.3. Automatic output record generation 26.4.4. Summary 26.4.5. Example for MappingRecordOperation? usage 26.4.6. Example for MappingCommAreaOperation? usage
26.5. Transactions
27. Email
27.1. Introduction 27.2. Usage
27.2.1. Basic MailSender? and SimpleMailMessage? usage 27.2.2. Using the JavaMailSender? and the MimeMessagePreparator?
27.3. Using the JavaMail? MimeMessageHelper?
27.3.1. Sending attachments and inline resources
Attachments Inline resources
27.3.2. Creating email content using a templating library
A Velocity-based example
28. Task Execution and Scheduling
28.1. Introduction 28.2. The Spring TaskExecutor? abstraction
28.2.1. TaskExecutor? types 28.2.2. Using a TaskExecutor?
28.3. The Spring TaskScheduler? abstraction
28.3.1. the Trigger interface 28.3.2. Trigger implementations 28.3.3. TaskScheduler? implementations
28.4. Annotation Support for Scheduling and Asynchronous Execution
28.4.1. Enable scheduling annotations 28.4.2. The @Scheduled Annotation 28.4.3. The @Async Annotation 28.4.4. Executor qualification with @Async 28.4.5. Exception management with @Async
28.5. The Task Namespace
28.5.1. The scheduler element 28.5.2. The executor element 28.5.3. The scheduled-tasks element
28.6. Using the Quartz Scheduler
28.6.1. Using the JobDetailFactoryBean? 28.6.2. Using the MethodInvokingJobDetailFactoryBean? 28.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean?
29. Dynamic language support
29.1. Introduction 29.2. A first example 29.3. Defining beans that are backed by dynamic languages
29.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
29.3.2. JRuby beans 29.3.3. Groovy beans
Customizing Groovy objects via a callback
29.3.4. BeanShell? beans
29.4. Scenarios
29.4.1. Scripted Spring MVC Controllers 29.4.2. Scripted Validators
29.5. Bits and bobs
29.5.1. AOP - advising scripted beans 29.5.2. Scoping
29.6. Further Resources
30. Cache Abstraction
30.1. Introduction 30.2. Understanding the cache abstraction 30.3. Declarative annotation-based caching
30.3.1. @Cacheable annotation
Default Key Generation Custom Key Generation Declaration Default Cache Resolution Custom cache resolution Conditional caching Available caching SpEL evaluation context
30.3.2. @CachePut? annotation 30.3.3. @CacheEvict? annotation 30.3.4. @Caching annotation 30.3.5. @CacheConfig? annotation 30.3.6. Enable caching annotations 30.3.7. Using custom annotations
30.4. JCache (JSR-107) annotations
30.4.1. Features summary 30.4.2. Enabling JSR-107 support
30.5. Declarative XML-based caching 30.6. Configuring the cache storage
30.6.1. JDK ConcurrentMap?-based Cache 30.6.2. EhCache?-based Cache 30.6.3. Guava Cache 30.6.4. GemFire?-based Cache 30.6.5. JSR-107 Cache 30.6.6. Dealing with caches without a backing store
30.7. Plugging-in different back-end caches 30.8. How can I set the TTL/TTI/Eviction policy/XXX feature?
VII. Appendices
31. Migrating to Spring Framework 4.0
32. Classic Spring Usage
32.1. Classic ORM usage
32.1.1. Hibernate
the HibernateTemplate? Implementing Spring-based DAOs without callbacks
32.1.2. JDO
32.1.3. JPA
32.2. Classic Spring MVC 32.3. JMS Usage
32.3.1. JmsTemplate? 32.3.2. Asynchronous Message Reception 32.3.3. Connections 32.3.4. Transaction Management
33. Classic Spring AOP Usage
33.1. Pointcut API in Spring
33.1.1. Concepts 33.1.2. Operations on pointcuts 33.1.3. AspectJ expression pointcuts 33.1.4. Convenience pointcut implementations
Static pointcuts Dynamic pointcuts
33.1.5. Pointcut superclasses 33.1.6. Custom pointcuts
33.2. Advice API in Spring
33.2.1. Advice lifecycles 33.2.2. Advice types in Spring
Interception around advice Before advice Throws advice After Returning advice Introduction advice
33.3. Advisor API in Spring 33.4. Using the ProxyFactoryBean? to create AOP proxies
33.4.1. Basics 33.4.2. JavaBean? properties 33.4.3. JDK- and CGLIB-based proxies 33.4.4. Proxying interfaces 33.4.5. Proxying classes 33.4.6. Using global advisors
33.5. Concise proxy definitions 33.6. Creating AOP proxies programmatically with the ProxyFactory? 33.7. Manipulating advised objects 33.8. Using the "autoproxy" facility
33.8.1. Autoproxy bean definitions
BeanNameAutoProxyCreator? DefaultAdvisorAutoProxyCreator? AbstractAdvisorAutoProxyCreator?
33.8.2. Using metadata-driven auto-proxying
33.9. Using TargetSources?
33.9.1. Hot swappable target sources 33.9.2. Pooling target sources 33.9.3. Prototype target sources 33.9.4. ThreadLocal? target sources
33.10. Defining new Advice types 33.11. Further resources
34. XML Schema-based configuration
34.1. Introduction 34.2. XML Schema-based configuration
34.2.1. Referencing the schemas 34.2.2. the util schema
<util:constant/> <util:property-path/> <util:properties/> <util:list/> <util:map/> <util:set/>
34.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/>
34.2.4. the lang schema 34.2.5. the jms schema 34.2.6. the tx (transaction) schema 34.2.7. the aop schema 34.2.8. the context schema
<property-placeholder/> <annotation-config/> <component-scan/> <load-time-weaver/> <spring-configured/> <mbean-export/>
34.2.9. the tool schema 34.2.10. the jdbc schema 34.2.11. the cache schema 34.2.12. the beans schema
35. Extensible XML authoring
35.1. Introduction 35.2. Authoring the schema 35.3. Coding a NamespaceHandler? 35.4. BeanDefinitionParser? 35.5. Registering the handler and the schema
35.5.1. META-INF/spring.handlers 35.5.2. META-INF/spring.schemas
35.6. Using a custom extension in your Spring XML configuration 35.7. Meatier examples
35.7.1. Nesting custom tags within custom tags 35.7.2. Custom attributes on normal elements
35.8. Further Resources
36. spring.tld
36.1. Introduction 36.2. the bind tag 36.3. the escapeBody tag 36.4. the hasBindErrors tag 36.5. the htmlEscape tag 36.6. the message tag 36.7. the nestedPath tag 36.8. the theme tag 36.9. the transform tag 36.10. the url tag 36.11. the eval tag
37. spring-form.tld
37.1. Introduction 37.2. the checkbox tag 37.3. the checkboxes tag 37.4. the errors tag 37.5. the form tag 37.6. the hidden tag 37.7. the input tag 37.8. the label tag 37.9. the option tag 37.10. the options tag 37.11. the password tag 37.12. the radiobutton tag 37.13. the radiobuttons tag 37.14. the select tag 37.15. the textarea tag
