Not Using Commons Logging ................................................................... 12
Using SLF4J ............................................................................................ 13
Using Log4J ............................................................................................. 14
II. What’s New in Spring Framework 4.x .................................................................................... 16
3. New Features and Enhancements in Spring Framework 4.0 ............................................ 17
3.1. Improved Getting Started Experience .................................................................. 17
3.2. Removed Deprecated Packages and Methods .................................................... 17
3.3. Java 8 (as well as 6 and 7) ............................................................................... 17
3.4. Java EE 6 and 7 ............................................................................................... 18
3.5. Groovy Bean Definition DSL .............................................................................. 18
3.6. Core Container Improvements ............................................................................ 19
3.7. General Web Improvements ............................................................................... 19
3.8. WebSocket, SockJS, and STOMP Messaging ..................................................... 19
3.9. Testing Improvements ........................................................................................ 20
III. Core Technologies .............................................................................................................. 21
4. The IoC container ........................................................................................................ 22
4.1. Introduction to the Spring IoC container and beans .............................................. 22
4.2. Container overview ............................................................................................ 22
Configuration metadata ..................................................................................... 23
Instantiating a container .................................................................................... 24
Composing XML-based configuration metadata .......................................... 25
Using the container .......................................................................................... 26
4.3. Bean overview ................................................................................................... 27
Naming beans .................................................................................................. 28
Aliasing a bean outside the bean definition ................................................ 28
Instantiating beans ........................................................................................... 29
Instantiation with a constructor .................................................................. 29
Instantiation with a static factory method .................................................... 30
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation iii
Instantiation using an instance factory method ........................................... 30
4.4. Dependencies ................................................................................................... 32
Dependency injection ....................................................................................... 32
Constructor-based dependency injection .................................................... 32
Setter-based dependency injection ............................................................ 34
Dependency resolution process ................................................................. 35
Examples of dependency injection ............................................................. 36
Dependencies and configuration in detail ........................................................... 38
Straight values (primitives, Strings, and so on) ........................................... 38
References to other beans (collaborators) .................................................. 40
Inner beans .............................................................................................. 41
Collections ............................................................................................... 41
Null and empty string values ..................................................................... 44
XML shortcut with the p-namespace .......................................................... 44
XML shortcut with the c-namespace .......................................................... 46
Compound property names ....................................................................... 46
Using depends-on ............................................................................................ 47
Lazy-initialized beans ....................................................................................... 47
Autowiring collaborators .................................................................................... 48
Limitations and disadvantages of autowiring ............................................... 49
Excluding a bean from autowiring .............................................................. 50
Method injection ............................................................................................... 50
Lookup method injection ........................................................................... 51
Arbitrary method replacement ................................................................... 53
4.5. Bean scopes ..................................................................................................... 54
The singleton scope ......................................................................................... 55
The prototype scope ......................................................................................... 55
Singleton beans with prototype-bean dependencies ............................................ 56
Request, session, and global session scopes .................................................... 56
Initial web configuration ............................................................................ 57
Request scope ......................................................................................... 58
Session scope .......................................................................................... 58
Global session scope ............................................................................... 58
Scoped beans as dependencies ................................................................ 58
Custom scopes ................................................................................................ 60
Creating a custom scope .......................................................................... 60
Using a custom scope .............................................................................. 61
4.6. Customizing the nature of a bean ....................................................................... 62
Lifecycle callbacks ............................................................................................ 62
Initialization callbacks ............................................................................... 63
Destruction callbacks ................................................................................ 64
Default initialization and destroy methods .................................................. 64
Combining lifecycle mechanisms ............................................................... 66
Startup and shutdown callbacks ................................................................ 66
Shutting down the Spring IoC container gracefully in non-web applications
................................................................................................................. 68
ApplicationContextAware and BeanNameAware ................................................. 68
Other Aware interfaces ..................................................................................... 69
4.7. Bean definition inheritance ................................................................................. 71
4.8. Container Extension Points ................................................................................ 72
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation iv
Customizing beans using a BeanPostProcessor ................................................. 72
Example: Hello World, BeanPostProcessor-style ........................................ 74
Example: The RequiredAnnotationBeanPostProcessor ............................... 75
Customizing configuration metadata with a BeanFactoryPostProcessor ................ 75
Example: the Class name substitution PropertyPlaceholderConfigurer .......... 76
Example: the PropertyOverrideConfigurer .................................................. 77
Customizing instantiation logic with a FactoryBean ............................................. 78
4.9. Annotation-based container configuration ............................................................ 79
@Required ....................................................................................................... 80
@Autowired ..................................................................................................... 80
Fine-tuning annotation-based autowiring with qualifiers ....................................... 83
Using generics as autowiring qualifiers .............................................................. 89
CustomAutowireConfigurer ................................................................................ 90
@Resource ...................................................................................................... 90
@PostConstruct and @PreDestroy .................................................................... 92
4.10. Classpath scanning and managed components ................................................. 92
@Component and further stereotype annotations ............................................... 93
Meta-annotations .............................................................................................. 93
Automatically detecting classes and registering bean definitions .......................... 94
Using filters to customize scanning ................................................................... 95
Defining bean metadata within components ....................................................... 96
Naming autodetected components ..................................................................... 97
Providing a scope for autodetected components ................................................ 98
Providing qualifier metadata with annotations ..................................................... 99
4.11. Using JSR 330 Standard Annotations ............................................................... 99
Dependency Injection with @Inject and @Named ............................................. 100
@Named: a standard equivalent to the @Component annotation ....................... 100
Limitations of the standard approach ............................................................... 101
4.12. Java-based container configuration ................................................................. 102
Basic concepts: @Bean and @Configuration ................................................... 102
Instantiating the Spring container using AnnotationConfigApplicationContext ....... 103
Simple construction ................................................................................ 103
Building the container programmatically using register(Class<?>…) ........... 104
Enabling component scanning with scan(String…) .................................... 104
Support for web applications with AnnotationConfigWebApplicationContext
............................................................................................................... 105
Using the @Bean annotation .......................................................................... 106
Declaring a bean .................................................................................... 107
Receiving lifecycle callbacks ................................................................... 107
Specifying bean scope ............................................................................ 108
Customizing bean naming ....................................................................... 109
Bean aliasing ......................................................................................... 109
Bean description ..................................................................................... 110
Using the @Configuration annotation ............................................................... 110
Injecting inter-bean dependencies ............................................................ 110
Lookup method injection ......................................................................... 111
Further information about how Java-based configuration works internally .... 111
Composing Java-based configurations ............................................................. 112
Using the @Import annotation ................................................................. 112
Conditionally including @Configuration classes or @Beans ....................... 116
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation v
Combining Java and XML configuration ................................................... 117
4.13. Bean definition profiles and environment abstraction ........................................ 120
4.14. PropertySource Abstraction ............................................................................ 120
4.15. Registering a LoadTimeWeaver ...................................................................... 120
4.16. Additional Capabilities of the ApplicationContext .............................................. 120
Internationalization using MessageSource ........................................................ 121
Standard and Custom Events .......................................................................... 124
Convenient access to low-level resources ........................................................ 127
Convenient ApplicationContext instantiation for web applications ....................... 128
Deploying a Spring ApplicationContext as a J2EE RAR file ............................... 128
4.17. The BeanFactory ........................................................................................... 129
BeanFactory or ApplicationContext? ................................................................ 129
Glue code and the evil singleton ..................................................................... 131
5. Resources .................................................................................................................. 132
5.1. Introduction ..................................................................................................... 132
5.2. The Resource interface .................................................................................... 132
5.3. Built-in Resource implementations .................................................................... 133
UrlResource ................................................................................................... 133
ClassPathResource ........................................................................................ 133
FileSystemResource ....................................................................................... 134
ServletContextResource .................................................................................. 134
InputStreamResource ..................................................................................... 134
ByteArrayResource ......................................................................................... 134
5.4. The ResourceLoader ....................................................................................... 134
5.5. The ResourceLoaderAware interface ................................................................ 135
5.6. Resources as dependencies ............................................................................. 136
5.7. Application contexts and Resource paths .......................................................... 137
Constructing application contexts ..................................................................... 137
Constructing ClassPathXmlApplicationContext instances - shortcuts .......... 137
Wildcards in application context constructor resource paths ............................... 138
Ant-style Patterns ................................................................................... 138
The Classpath*: portability classpath*: prefix ............................................ 139
Other notes relating to wildcards ............................................................. 139
FileSystemResource caveats .......................................................................... 140
6. Validation, Data Binding, and Type Conversion ............................................................ 141
6.1. Introduction ..................................................................................................... 141
6.2. Validation using Spring’s Validator interface ...................................................... 141
6.3. Resolving codes to error messages .................................................................. 143
6.4. Bean manipulation and the BeanWrapper ......................................................... 144
Setting and getting basic and nested properties ............................................... 144
Built-in PropertyEditor implementations ............................................................ 146
Registering additional custom PropertyEditors .......................................... 149
6.5. Spring Type Conversion ................................................................................... 151
Converter SPI ................................................................................................ 151
ConverterFactory ............................................................................................ 152
GenericConverter ........................................................................................... 153
ConditionalGenericConverter ................................................................... 154
ConversionService API ................................................................................... 154
Configuring a ConversionService ..................................................................... 154
Using a ConversionService programmatically ................................................... 155
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation vi
6.6. Spring Field Formatting .................................................................................... 155
Formatter SPI ................................................................................................. 156
Annotation-driven Formatting ........................................................................... 157
Format Annotation API ............................................................................ 158
FormatterRegistry SPI ..................................................................................... 159
FormatterRegistrar SPI ................................................................................... 159
Configuring Formatting in Spring MVC ............................................................. 159
6.7. Configuring a global date & time format ............................................................ 161
6.8. Spring Validation ............................................................................................. 163
Overview of the JSR-303 Bean Validation API ................................................. 163
Configuring a Bean Validation Provider ............................................................ 164
Injecting a Validator ................................................................................ 164
Configuring Custom Constraints .............................................................. 164
Additional Configuration Options .............................................................. 165
Configuring a DataBinder ................................................................................ 165
Spring MVC 3 Validation ................................................................................. 166
Triggering @Controller Input Validation .................................................... 166
Configuring a Validator for use by Spring MVC ......................................... 166
Configuring a JSR-303/JSR-349 Validator for use by Spring MVC .............. 167
7. Spring Expression Language (SpEL) ........................................................................... 168
7.1. Introduction ..................................................................................................... 168
7.2. Feature Overview ............................................................................................ 168
7.3. Expression Evaluation using Spring’s Expression Interface ................................. 169
The EvaluationContext interface ...................................................................... 171
Type Conversion .................................................................................... 171
7.4. Expression support for defining bean definitions ................................................ 172
XML based configuration ................................................................................ 172
Annotation-based configuration ........................................................................ 173
7.5. Language Reference ........................................................................................ 174
Literal expressions .......................................................................................... 174
Properties, Arrays, Lists, Maps, Indexers ......................................................... 174
Inline lists ....................................................................................................... 175
Array construction ........................................................................................... 175
Methods ......................................................................................................... 176
Operators ....................................................................................................... 176
Relational operators ................................................................................ 176
Logical operators .................................................................................... 177
Mathematical operators ........................................................................... 177
Assignment .................................................................................................... 178
Types ............................................................................................................. 178
Constructors ................................................................................................... 179
Variables ........................................................................................................ 179
The #this and #root variables .................................................................. 179
Functions ....................................................................................................... 180
Bean references ............................................................................................. 180
Ternary Operator (If-Then-Else) ....................................................................... 180
The Elvis Operator ......................................................................................... 181
Safe Navigation operator ................................................................................ 181
Collection Selection ........................................................................................ 182
Collection Projection ....................................................................................... 182
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation vii
Expression templating ..................................................................................... 183
7.6. Classes used in the examples .......................................................................... 183
8. Aspect Oriented Programming with Spring ................................................................... 187
8.1. Introduction ..................................................................................................... 187
AOP concepts ................................................................................................ 187
Spring AOP capabilities and goals ................................................................... 189
AOP Proxies .................................................................................................. 190
8.2. @AspectJ support ........................................................................................... 190
Enabling @AspectJ Support ............................................................................ 190
Enabling @AspectJ Support with Java configuration ................................. 190
Enabling @AspectJ Support with XML configuration ................................. 191
Declaring an aspect ........................................................................................ 191
Declaring a pointcut ........................................................................................ 192
Supported Pointcut Designators .............................................................. 192
Combining pointcut expressions .............................................................. 194
Sharing common pointcut definitions ........................................................ 194
Examples ............................................................................................... 196
Writing good pointcuts ............................................................................ 198
Declaring advice ............................................................................................. 199
Before advice ......................................................................................... 199
After returning advice .............................................................................. 200
After throwing advice .............................................................................. 200
After (finally) advice ................................................................................ 201
Around advice ........................................................................................ 202
Advice parameters .................................................................................. 203
Advice ordering ...................................................................................... 206
Introductions ................................................................................................... 206
Aspect instantiation models ............................................................................. 207
Example ......................................................................................................... 208
8.3. Schema-based AOP support ............................................................................ 209
Declaring an aspect ........................................................................................ 210
Declaring a pointcut ........................................................................................ 210
Declaring advice ............................................................................................. 212
Before advice ......................................................................................... 212
After returning advice .............................................................................. 212
After throwing advice .............................................................................. 213
After (finally) advice ................................................................................ 214
Around advice ........................................................................................ 214
Advice parameters .................................................................................. 215
Advice ordering ...................................................................................... 216
Introductions ................................................................................................... 217
Aspect instantiation models ............................................................................. 217
Advisors ......................................................................................................... 217
Example ......................................................................................................... 218
8.4. Choosing which AOP declaration style to use .................................................... 220
Spring AOP or full AspectJ? ........................................................................... 220
@AspectJ or XML for Spring AOP? ................................................................. 221
8.5. Mixing aspect types ......................................................................................... 222
8.6. Proxying mechanisms ...................................................................................... 222
Understanding AOP proxies ............................................................................ 223
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation viii
8.7. Programmatic creation of @AspectJ Proxies ..................................................... 225
8.8. Using AspectJ with Spring applications ............................................................. 225
Using AspectJ to dependency inject domain objects with Spring ........................ 226
Unit testing @Configurable objects .......................................................... 228
Working with multiple application contexts ................................................ 228
Other Spring aspects for AspectJ .................................................................... 229
Configuring AspectJ aspects using Spring IoC ................................................. 229
Load-time weaving with AspectJ in the Spring Framework ................................. 230
A first example ....................................................................................... 231
Aspects .................................................................................................. 234
' META-INF/aop.xml' ............................................................................... 234
Required libraries (JARS) ........................................................................ 234
Spring configuration ................................................................................ 235
Environment-specific configuration ........................................................... 237
8.9. Further Resources ........................................................................................... 239
9. Spring AOP APIs ....................................................................................................... 240
9.1. Introduction ..................................................................................................... 240
9.2. Pointcut API in Spring ...................................................................................... 240
Concepts ........................................................................................................ 240
Operations on pointcuts .................................................................................. 241
AspectJ expression pointcuts .......................................................................... 241
Convenience pointcut implementations ............................................................ 241
Static pointcuts ....................................................................................... 241
Dynamic pointcuts .................................................................................. 242
Pointcut superclasses ..................................................................................... 243
Custom pointcuts ............................................................................................ 243
9.3. Advice API in Spring ........................................................................................ 243
Advice lifecycles ............................................................................................. 243
Advice types in Spring .................................................................................... 244
Interception around advice ...................................................................... 244
Before advice ......................................................................................... 244
Throws advice ........................................................................................ 245
After Returning advice ............................................................................ 246
Introduction advice .................................................................................. 247
9.4. Advisor API in Spring ....................................................................................... 249
9.5. Using the ProxyFactoryBean to create AOP proxies ........................................... 250
Basics ............................................................................................................ 250
JavaBean properties ....................................................................................... 250
JDK- and CGLIB-based proxies ...................................................................... 251
Proxying interfaces ......................................................................................... 252
Proxying classes ............................................................................................ 254
Using global advisors ...................................................................................... 255
9.6. Concise proxy definitions ................................................................................. 255
9.7. Creating AOP proxies programmatically with the ProxyFactory ............................ 256
9.8. Manipulating advised objects ............................................................................ 257
9.9. Using the "auto-proxy" facility ........................................................................... 258
Autoproxy bean definitions .............................................................................. 258
BeanNameAutoProxyCreator ................................................................... 259
DefaultAdvisorAutoProxyCreator .............................................................. 259
AbstractAdvisorAutoProxyCreator ............................................................ 260
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation ix
Using metadata-driven auto-proxying ............................................................... 260
9.10. Using TargetSources ...................................................................................... 262
Hot swappable target sources ......................................................................... 263
Pooling target sources .................................................................................... 263
Prototype target sources ................................................................................. 265
ThreadLocal target sources ............................................................................. 265
9.11. Defining new Advice types ............................................................................. 265
9.12. Further resources ........................................................................................... 266
10. Testing ..................................................................................................................... 267
10.1. Introduction to Spring Testing ......................................................................... 267
10.2. Unit Testing ................................................................................................... 267
Mock Objects ................................................................................................. 267
Environment ........................................................................................... 267
JNDI ...................................................................................................... 267
Servlet API ............................................................................................. 267
Portlet API ............................................................................................. 268
Unit Testing support Classes .......................................................................... 268
General utilities ...................................................................................... 268
Spring MVC ........................................................................................... 268
10.3. Integration Testing ......................................................................................... 268
Overview ........................................................................................................ 268
Goals of Integration Testing ............................................................................ 269
Context management and caching ........................................................... 269
Dependency Injection of test fixtures ....................................................... 269
Transaction management ........................................................................ 270
Support classes for integration testing ..................................................... 270
JDBC Testing Support .................................................................................... 271
Annotations .................................................................................................... 271
Spring Testing Annotations ..................................................................... 271
Standard Annotation Support .................................................................. 276
Spring JUnit Testing Annotations ............................................................. 277
Meta-Annotation Support for Testing ........................................................ 278
Spring TestContext Framework ....................................................................... 279
Key abstractions ..................................................................................... 280
Context management .............................................................................. 281
Dependency injection of test fixtures ........................................................ 297
Testing request and session scoped beans .............................................. 299
Transaction management ........................................................................ 301
TestContext Framework support classes .................................................. 304
Spring MVC Test Framework .......................................................................... 306
Server-Side Tests ................................................................................... 306
Client-Side REST Tests .......................................................................... 312
PetClinic Example .......................................................................................... 313
10.4. Further Resources ......................................................................................... 314
IV. Data Access ..................................................................................................................... 316
11. Transaction Management .......................................................................................... 317
11.1. Introduction to Spring Framework transaction management .............................. 317
11.2. Advantages of the Spring Framework’s transaction support model ..................... 317
Global transactions ......................................................................................... 317
Local transactions ........................................................................................... 318
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation x
Spring Framework’s consistent programming model ......................................... 318
11.3. Understanding the Spring Framework transaction abstraction ............................ 319
11.4. Synchronizing resources with transactions ....................................................... 323
High-level synchronization approach ................................................................ 323
Low-level synchronization approach ................................................................. 323
TransactionAwareDataSourceProxy ................................................................. 324
11.5. Declarative transaction management ............................................................... 324
Understanding the Spring Framework’s declarative transaction implementation ... 325
Example of declarative transaction implementation ........................................... 326
Rolling back a declarative transaction .............................................................. 330
Configuring different transactional semantics for different beans ........................ 331
<tx:advice/> settings ....................................................................................... 333
Using @Transactional ..................................................................................... 335
@Transactional settings .......................................................................... 339
Multiple Transaction Managers with @Transactional ................................. 340
Custom shortcut annotations ................................................................... 341
Transaction propagation .................................................................................. 341
Required ................................................................................................ 342
RequiresNew .......................................................................................... 342
Nested ................................................................................................... 343
Advising transactional operations ..................................................................... 343
Using @Transactional with AspectJ ................................................................. 346
11.6. Programmatic transaction management ........................................................... 347
Using the TransactionTemplate ....................................................................... 347
Specifying transaction settings ................................................................ 349
Using the PlatformTransactionManager ............................................................ 349
11.7. Choosing between programmatic and declarative transaction management ........ 350
11.8. Application server-specific integration .............................................................. 350
IBM WebSphere ............................................................................................. 351
Oracle WebLogic Server ................................................................................. 351
11.9. Solutions to common problems ....................................................................... 351
Use of the wrong transaction manager for a specific DataSource ....................... 351
11.10. Further Resources ....................................................................................... 351
12. DAO support ............................................................................................................ 352
12.1. Introduction .................................................................................................... 352
12.2. Consistent exception hierarchy ....................................................................... 352
12.3. Annotations used for configuring DAO or Repository classes ............................ 353
13. Data access with JDBC ............................................................................................ 355
13.1. Introduction to Spring Framework JDBC .......................................................... 355
Choosing an approach for JDBC database access ........................................... 355
Package hierarchy .......................................................................................... 356
13.2. Using the JDBC core classes to control basic JDBC processing and error
handling ................................................................................................................. 357
JdbcTemplate ................................................................................................. 357
Examples of JdbcTemplate class usage ................................................... 357
JdbcTemplate best practices ................................................................... 359
NamedParameterJdbcTemplate ....................................................................... 361
SQLExceptionTranslator .................................................................................. 363
Executing statements ...................................................................................... 365
Running queries ............................................................................................. 365
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation xi
Updating the database .................................................................................... 366
Retrieving auto-generated keys ....................................................................... 367
13.3. Controlling database connections .................................................................... 367
DataSource .................................................................................................... 367
DataSourceUtils .............................................................................................. 369
SmartDataSource ........................................................................................... 369
AbstractDataSource ........................................................................................ 369
SingleConnectionDataSource .......................................................................... 369
DriverManagerDataSource .............................................................................. 369
TransactionAwareDataSourceProxy ................................................................. 370
DataSourceTransactionManager ...................................................................... 370
NativeJdbcExtractor ........................................................................................ 370
13.4. JDBC batch operations .................................................................................. 371
Basic batch operations with the JdbcTemplate ................................................. 371
Batch operations with a List of objects ............................................................. 372
Batch operations with multiple batches ............................................................ 373
13.5. Simplifying JDBC operations with the SimpleJdbc classes ................................ 374
Inserting data using SimpleJdbcInsert .............................................................. 374
Retrieving auto-generated keys using SimpleJdbcInsert .................................... 375
Specifying columns for a SimpleJdbcInsert ...................................................... 376
Using SqlParameterSource to provide parameter values ................................... 376
Calling a stored procedure with SimpleJdbcCall ............................................... 377
Explicitly declaring parameters to use for a SimpleJdbcCall ............................... 379
How to define SqlParameters .......................................................................... 380
Calling a stored function using SimpleJdbcCall ................................................. 381
Returning ResultSet/REF Cursor from a SimpleJdbcCall ................................... 381
13.6. Modeling JDBC operations as Java objects ..................................................... 382
SqlQuery ........................................................................................................ 383
MappingSqlQuery ........................................................................................... 383
SqlUpdate ...................................................................................................... 384
StoredProcedure ............................................................................................. 385
13.7. Common problems with parameter and data value handling .............................. 388
Providing SQL type information for parameters ................................................. 389
Handling BLOB and CLOB objects .................................................................. 389
Passing in lists of values for IN clause ............................................................ 390
Handling complex types for stored procedure calls ........................................... 391
13.8. Embedded database support .......................................................................... 392
Why use an embedded database? .................................................................. 392
Creating an embedded database instance using Spring XML ............................ 392
Creating an embedded database instance programmatically .............................. 392
Extending the embedded database support ...................................................... 393
Using HSQL ................................................................................................... 393
Using H2 ........................................................................................................ 393
Using Derby ................................................................................................... 393
Testing data access logic with an embedded database ..................................... 393
13.9. Initializing a DataSource ................................................................................. 394
Initializing a database instance using Spring XML ............................................. 394
Initialization of Other Components that Depend on the Database ............... 395
14. Object Relational Mapping (ORM) Data Access .......................................................... 397
14.1. Introduction to ORM with Spring ..................................................................... 397
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation xii
14.2. General ORM integration considerations ......................................................... 398
Resource and transaction management ........................................................... 398
Exception translation ....................................................................................... 399
14.3. Hibernate ....................................................................................................... 399
SessionFactory setup in a Spring container ...................................................... 400
Implementing DAOs based on plain Hibernate 3 API ........................................ 400
Declarative transaction demarcation ................................................................ 402
Programmatic transaction demarcation ............................................................ 404
Transaction management strategies ................................................................ 405
Comparing container-managed and locally defined resources ............................ 407
Spurious application server warnings with Hibernate ......................................... 408
14.4. JDO .............................................................................................................. 409
PersistenceManagerFactory setup ................................................................... 409
Implementing DAOs based on the plain JDO API ............................................. 410
Transaction management ................................................................................ 412
JdoDialect ...................................................................................................... 413
14.5. JPA ............................................................................................................... 414
Three options for JPA setup in a Spring environment ........................................ 414
LocalEntityManagerFactoryBean .............................................................. 414
Obtaining an EntityManagerFactory from JNDI ......................................... 415
LocalContainerEntityManagerFactoryBean ............................................... 415
Dealing with multiple persistence units ..................................................... 417
Implementing DAOs based on plain JPA .......................................................... 418
Transaction Management ................................................................................ 420
JpaDialect ...................................................................................................... 421
15. Marshalling XML using O/X Mappers ......................................................................... 423
15.1. Introduction .................................................................................................... 423
Ease of configuration ...................................................................................... 423
Consistent Interfaces ...................................................................................... 423
Consistent Exception Hierarchy ....................................................................... 423
15.2. Marshaller and Unmarshaller .......................................................................... 423
Marshaller ...................................................................................................... 423
Unmarshaller .................................................................................................. 424
XmlMappingException ..................................................................................... 425
15.3. Using Marshaller and Unmarshaller ................................................................. 425
15.4. XML Schema-based Configuration .................................................................. 427
15.5. JAXB ............................................................................................................. 427
Jaxb2Marshaller ............................................................................................. 428
XML Schema-based Configuration ........................................................... 428
15.6. Castor ........................................................................................................... 429
CastorMarshaller ............................................................................................ 429
Mapping ......................................................................................................... 429
XML Schema-based Configuration ........................................................... 429
15.7. XMLBeans ..................................................................................................... 430
XmlBeansMarshaller ....................................................................................... 430
XML Schema-based Configuration ........................................................... 430
15.8. JiBX .............................................................................................................. 431
JibxMarshaller ................................................................................................ 431
XML Schema-based Configuration ........................................................... 431
15.9. XStream ........................................................................................................ 432
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation xiii
XStreamMarshaller ......................................................................................... 432
V. The Web ........................................................................................................................... 434
16. Web MVC framework ................................................................................................ 435
16.1. Introduction to Spring Web MVC framework .................................................... 435
Features of Spring Web MVC ......................................................................... 436
Pluggability of other MVC implementations ...................................................... 437
16.2. The DispatcherServlet .................................................................................... 437
Special Bean Types In the WebApplicationContext ........................................... 440
Default DispatcherServlet Configuration ........................................................... 441
DispatcherServlet Processing Sequence .......................................................... 441
16.3. Implementing Controllers ................................................................................ 443
Defining a controller with @Controller .............................................................. 443
Mapping Requests With Using @RequestMapping ........................................... 444
New Support Classes for @RequestMapping methods in Spring MVC 3.1 .. 446
URI Template Patterns ........................................................................... 447
URI Template Patterns with Regular Expressions ..................................... 448
Path Patterns ......................................................................................... 449
Patterns with Placeholders ...................................................................... 449
Matrix Variables ...................................................................................... 449
Consumable Media Types ....................................................................... 450
Producible Media Types .......................................................................... 451
Request Parameters and Header Values ................................................. 451
Defining @RequestMapping handler methods .................................................. 452
Supported method argument types .......................................................... 452
Supported method return types ............................................................... 454
Binding request parameters to method parameters with @RequestParam ... 455
Mapping the request body with the @RequestBody annotation .................. 456
Mapping the response body with the @ResponseBody annotation ............. 457
Creating REST Controllers with the @RestController annotation ................ 457
Using HttpEntity ...................................................................................... 457
Using @ModelAttribute on a method ....................................................... 458
Using @ModelAttribute on a method argument ......................................... 459
Using @SessionAttributes to store model attributes in the HTTP session
between requests ................................................................................... 461
Specifying redirect and flash attributes ..................................................... 461
Working with "application/x-www-form-urlencoded" data ............................ 462
Mapping cookie values with the @CookieValue annotation ........................ 462
Mapping request header attributes with the @RequestHeader annotation ... 463
Method Parameters And Type Conversion ............................................... 463
Customizing WebDataBinder initialization ................................................. 464
Support for the Last-Modified Response Header To Facilitate Content
Caching ................................................................................................. 465
Assisting Controllers with the @ControllerAdvice annotation ...................... 465
Asynchronous Request Processing .................................................................. 466
Exception Handling for Async Requests ................................................... 467
Intercepting Async Requests ................................................................... 467
Configuration for Async Request Processing ............................................ 468
Testing Controllers ......................................................................................... 469
16.4. Handler mappings .......................................................................................... 469
Intercepting requests with a HandlerInterceptor ................................................ 469
Spring Framework
4.0.0.RELEASE
Spring Framework
Reference Documentation xiv
16.5. Resolving views ............................................................................................. 471
Resolving views with the ViewResolver interface .............................................. 471
Chaining ViewResolvers ................................................................................. 473
Redirecting to views ....................................................................................... 474
RedirectView .......................................................................................... 474
The redirect: prefix ................................................................................. 475
The forward: prefix ................................................................................. 475
ContentNegotiatingViewResolver ..................................................................... 475
16.6. Using flash attributes ..................................................................................... 478
16.7. Building URIs ................................................................................................. 479
16.8. Building URIs to Controllers and methods ....................................................... 480
16.9. Using locales ................................................................................................. 480
Obtaining Time Zone Information .................................................................... 481
AcceptHeaderLocaleResolver .......................................................................... 481
CookieLocaleResolver ..................................................................................... 481
SessionLocaleResolver ................................................................................... 481
LocaleChangeInterceptor ................................................................................ 482
16.10. Using themes ............................................................................................... 482
Overview of themes ........................................................................................ 482
Defining themes ............................................................................................. 482
Theme resolvers ............................................................................................. 483
16.11. Spring’s multipart (file upload) support ........................................................... 483
Introduction .................................................................................................... 483
Using a MultipartResolver with Commons FileUpload ........................................ 484
Using a MultipartResolver with Servlet 3.0 ....................................................... 484
Handling a file upload in a form ...................................................................... 484
Handling a file upload request from programmatic clients .................................. 486
16.12. Handling exceptions ..................................................................................... 486
HandlerExceptionResolver ............
0
46
4.44MB
2015-05-28
10
