Spring 3.1 introduces several eagerly awaited features including bean definition profiles (a.k.a., environment-specific beans), enhanced Java-based application and infrastructure configuration (a la XML namespaces), a new cache abstraction, and MVC improvements. This session will provide attendees an in-depth look at these major new features as well as an overview of additional enhancements to the framework such as the new c: namespace for constructor arguments, updates regarding Servlet 3.0, and improvements to Spring's integration testing support.

1. Spring 3.1 in a Nutshell
Sam Brannen
Swiftmind
Java Track 12.2
Talk #394

2. Speaker Profile
> Java developer with 13+ years' experience
> Spring Framework Core Developer
> Lead author of Spring in a Nutshell
> Previous SpringSource dm Server™ developer
> Presenter on Spring, Java, OSGi, and testing
> Senior Software Consultant @ Swiftmind
2

3. Agenda
> Major Themes in 3.x
> Environment and Profiles
> Java-based Configuration
> Testing
> Caching
> MVC and REST
> Servlet 3.0
> Odds & Ends
3

4. Major Themes in Spring 3.x
4

5. Spring Framework 3.0: A Quick Review
> Annotation-based component model
– Stereotypes, autowiring, factory methods, JSR-330
> Spring Expression Language
– Unified EL++
> REST support in Spring MVC
– Various @MVC programming model improvements
> Portlet API 2.0
– Event/Resource requests
> Declarative model validation
– JSR-303 bean validation
> Java EE 6 support
– JPA 2.0, JSF 2.0 but also JSR-330, JSR-303 5

6. Spring Framework 3.1: Major Themes
> Environment Abstraction
– PropertySources, Bean Profiles, TestContext support
> Java-based Application Configuration
– Equivalents for XML namespaces, FactoryBeans, TestContext support
> High-level Cache API
– Transparent use of various caching solutions
> Customizable @MVC Processing
– New infrastructure for annotated controllers
> Explicit Support for Servlet 3.0
– ServletContainerInitializer and MultipartResolver
6

7. Environment and Profiles
7

8. Environment Abstraction
> Injectable environment abstraction API
– org.springframework.core.env.Environment
> Two core concepts
– Property Sources
– Bean Profiles
Property Source: Bean Profile:
A variety of sources: property A logical group of bean
files, system properties, servlet definitions. Registered only if
context, JNDI, etc. the profile is active.
8

9. Property Source Abstraction
> Property resolution SPI
– org.springframework.core.env.PropertyResolver
– Environment extends PropertyResolver
> PropertySource
– a single property source
> PropertySources
– a hierarchy of PropertySource objects
– potentially varying across deployment environments
> Custom resolution of placeholders
– dependent on the actual environment
– PropertySourcesPlaceholderConfigurer supersedes
PropertyPlaceholderConfigurer
9

10. Managing Property Sources
> Standalone code
> Web application
– Implement ApplicationContextInitializer
– Register via contextInitializerClasses context parameter in web.xml
10

11. Accessing Properties
> By injecting the Environment
11

12. Bean Definition Profiles
> Logical grouping of bean definitions
– for activation in specific environments
– e.g., dev, staging, prod
– possibly different deployment platforms
> Configuration
– XML via <beans profile=“…”>
– Java-based configuration via @Profile
> Activation
– programmatically
– in web.xml
– system property
– in tests via @ActiveProfiles 12

13. Configuring Profiles in XML
> All bean definitions
> Subset of bean definitions
13

14. Configuring Profiles in Java Config
> @Profile can also be used on components
– @Component, @Service, @Repository, etc. 14

15. Activating Profiles (1/2)
> Standalone code
> In Web applications
15

16. Activating Profiles (2/2)
> Via Java system properties
– -Dspring.profiles.active=“dev”
– -Dspring.profiles.default=“common”
> With the Spring TestContext Framework
16

17. Java-based Configuration
17

18. Java Configuration Enhancements
> Java-based equivalent to mechanisms available in XML
– XML namespaces  @Enable*
– FactoryBeans  builders
– GenericXmlContextLoader  AnnotationConfigContextLoader
> Not a one-on-one mapping
– Make the most of what Java has to offer
– Intuitive annotation-oriented container configuration
> Typical infrastructure setup
– transactions
– scheduling
– MVC customization
18

19. @Enable* Annotations
> Applied at the class-level on @Configuration classes
> Roughly equivalent to their XML namespace counterparts
> Available in Spring 3.1 M2:
– @EnableTransactionManagement
– @EnableAsync
– @EnableScheduling
– @EnableLoadTimeWeaving
– @EnableWebMvc
19

20. Hibernate and JPA
> Hibernate SessionFactory builder APIs
– SessionFactoryBuilder
– AnnotationSessionFactoryBuilder
> XML-free JPA configuration
– LocalContainerEntityManagerFactoryBean has a new property
– packagesToScan: analogous to AnnotationSessionFactoryBean
20

21. Java Configuration Example
21

22. Testing with @Configuration Classes
> @ActiveProfiles
– declares active profiles for test
> @ContextConfiguration supports a new classes attribute
– Not supported by existing ContextLoader SPI
> SmartContextLoader supersedes ContextLoader
– can process resource locations and configuration classes
– can set active bean definition profiles
> AnnotationConfigContextLoader
– SmartContextLoader that supports @Configuration classes
– convention over configuration: static inner class
> Context cache key generation
– updated to take locations, classes, profiles, and loader into account 22

23. @Configuration Testing Example
23

24. Caching
24

25. Caching Abstraction
> Declarative caching for Spring applications
– Minimal impact on code
– Plug in various caching solutions
> Key annotations @Cacheable and @CacheEvict
25

26. @Cacheable Options
> The cache key
– All method arguments used by default
– Use SpEL to select more specifically (use class, method, or argument name)
> Conditional caching
26

27. Cache Providers
> Cache and CacheManager SPI
– org.springframework.cache
> Cache Implementations
– EhCacheCache
– ConcurrentMapCache and ConcurrentMapCacheFactoryBean
> CacheManager Implementations
– EhCacheCacheManager
– SimpleCacheManager
> Any other implementation can be plugged in
– GemFire, Coherence, etc. 27

28. Cache Configuration
> Cache namespace
– <cache:annotation-driven />
– “cacheManager” bean
28

29. MVC and REST
29

30. How We Configure Spring MVC Today
> Built-in defaults
– Based on DispatcherServlet.properties
> Spring MVC namespace
– <mvc:annotation:driven>, <mvc:interceptors>, …
30

31. Why Java-based Configuration For Spring MVC?
> Most Spring MVC configuration is in Java already
– @Controller, @RequestMapping, etc.
> Servlet 3.0 enhancements will further reduce the need for web.xml
> XML namespace is convenient but …
– Not transparent
– Not easy to offer the right degree of customization
> … What should a Java equivalent to the MVC namespace look like?
31

32. Java-based Configuration With @EnableWebMvc
> Adding it enables Spring MVC default configuration
– Registers components expected by the DispatcherServlet
> Provides configuration similar to the Spring MVC namespace
– … and the DispatcherServlet.properties combined
32

33. A More Complete Example …
> Add component scanning for @Controllers and other beans
33

34. Q: Where Is The “Enabled” Configuration ?!
> A: a framework-provided @Configuration class (actually
DelegatingWebMvcConfiguration)
34

35. How Do I Customize All This?
> Simply implement the WebMvcConfigurer interface
Allows selective overriding
35

36. Updated @MVC Support
> HandlerMethod
– A proper abstraction for the selected “handler” in Spring MVC
> Not just for @RequestMapping methods
– Also @InitBinder, @ModelAttribute, @ExceptionHandler methods
– Not limited to the above
> “HandlerMethod” support classes
– RequestMappingHandlerMapping
– RequestMappingHandlerAdapter
– ExceptionHandlerExceptionResolver
36

37. Configuring the New @MVC Support Classes
> Enabled by default
– XML namespace … <mvc:annotation-driven />
– Java-based configuration … @EnableWebMvc
> Existing support classes continue to exist
– No new functionally will be developed for them
> But the new support classes are recommended
– They are generally functionally equivalent
37

38. Path Variables in The Model
> @PathVariable arguments automatically added to the model
These can be deleted
38

39. URI Templates in Redirect Strings
> URL templates supported in “redirect:” strings
Expanded from model attributes,
which now include @PathVariables
39

40. URI Template Variables in Data Binding
> URI template variables used in data binding
40

41. Matching MediaTypes before Spring MVC 3.1
> Using the 'headers' condition
41

42. Matching MediaTypes in Spring MVC 3.1
> The 'consumes' and 'produces' conditions
If not matched, results in:
UNSUPPORTED_MEDIA_TYPE (415)
If not matched, results in:
NOT_ACCEPTABLE (406)
42

43. Servlet 3.0
43

44. Support for Servlet 3.0
> Explicit support for Servlet 3.0 containers
– Tomcat 7 and GlassFish 3
– while preserving compatibility with Servlet 2.4+
> Support for XML-free web application setup (no web.xml)
– Servlet 3.0's ServletContainerInitializer plus Spring 3.1's
AnnotationConfigWebApplicationContext plus the environment abstraction
> Exposure of native Servlet 3.0 functionality in Spring MVC
– support for asynchronous request processing
– standard Servlet 3.0 file upload support behind Spring's MultipartResolver
abstraction
44

45. WebApplicationInitializer Example
45

46. Odds & Ends
46

47. "c:" Namespace for XML Configuration
> Shortcut for <constructor-arg>
– inline argument values
– analogous to existing "p:" namespace
> Use of constructor argument names
– recommended for readability
– debug symbols have to be available in the application's class files
47

48. The Spring Roadmap
> Spring 3.1 M2: June 9, 2011
> Spring 3.1 RC1: Coming soon! (no M3 planned)
> Spring 3.1 GA: Soon after RC1
> Spring 3.2: Planned for early 2012
– Java SE 7
– JDBC 4.1
– Fork-join framework
– Java EE: JSF 2.2, JPA 2.1
48

49. Spring 3.1 in a Nutshell
> Environment and Profiles
> Java-based Configuration and @Enable*
> Testing with @Configuration and Profiles
> Cache Abstraction
> MVC and REST Improvements
> Servlet 3.0
> c: Namespace
49

50. Further Resources
> Spring Framework
– http://springframework.org
– Spring Reference Manual
– JavaDoc
> Spring Forums
– http://forum.springframework.org
> Spring JIRA
– http://jira.springframework.org
> SpringSource Team Blog – category 3.1
– http://blog.springsource.com/category/spring/31/
> Swiftmind Blog
– http://www.swiftmind.com/blog/ 50

51. Special Thanks to…
> Jürgen Höller, Chris Beams, and Rossen Stoyanchev of SpringSource
– for donating examples and content to make this presentation possible
51

52. Q&A
Sam Brannen sam.brannen@swiftmind.com
Swiftmind twitter: @sam_brannen
www.slideshare.net/sbrannen
www.swiftmind.com
“Spring in a Nutshell”
http://oreilly.com/catalog/9780596801946
available from O’Reilly in early 2012