Spring Framework 4.0 is the next generation of the popular open source framework for Enterprise Java developers, focusing on the future with support for Java SE 8 and Java EE 7. In this presentation core Spring committer Sam Brannen will provide attendees an overview of the new enterprise features in the framework as well as new programming models made possible with the adoption of JDK 8 language features and APIs.
Specifically, this talk will cover support for lambda expressions and method references against Spring callback interfaces, JSR-310 Date-Time value types for Spring data binding and formatting, Spring's new @Conditional mechanism for activation of bean definitions, and a new WebSocket endpoint model. Regarding enterprise APIs, the presentation will cover Spring 4.0's new support for JMS 2.0, JPA 2.1, Bean Validation 1.1, Servlet 3.1, JCache, and JSR-236 concurrency. Last but not least, Sam will discuss improvements to Spring's testing support and point out which deprecated APIs have been pruned from the framework.
Spring Framework 4.0 - The Next Generation - Soft-Shake 2013
1. Spring Framework 4.0
The Next Generation
Sam Brannen
@sam_brannen
Soft-Shake | Geneva, Switzerland | 24 October 2013
2. Sam Brannen
• Spring and Java Consultant @ Swiftmind
• Java Developer for over 15 years
• Spring Framework Core Committer since 2007
• Spring Trainer
• Presenter on Spring, Java, OSGi, and testing
2
3. Swiftmind
Your experts for Enterprise Java
Areas of expertise
• Spring *
• Java EE
• OSGi
• Agile Methodologies
• Software Engineering Best Practices
Where you find us
• Zurich, Switzerland
• Twitter: @swiftmind
• http://www.swiftmind.com
3
7. Spring 3.x: Component Model
• Powerful annotated component model
– stereotypes, configuration classes, composable
annotations, profiles
• Spring Expression Language (SpEL)
– XML config files
– @Value, @Cacheable, etc.
– JSPs
7
8. Spring 3.x: Component Model
• Comprehensive REST support
– and other Spring @MVC additions
• Support for async MVC processing
– Spring MVC interacting with Servlet 3.0 async
callbacks
8
9. Spring 3.x: Component Model
• Declarative validation and formatting
– integration with JSR-303 Bean Validation
• Declarative scheduling
– trigger abstraction and cron support
• Declarative caching
– in-memory, Ehcache, etc.
9
10. Spring 3.x: Testing
• Embedded databases via <jdbc /> namespace
• @Configuration classes & @ActiveProfiles
• @WebAppConfiguration
• @ContextHierarchy
• Spring MVC Test framework
10
17. New Baselines
• Java SE 6+
• Java EE 6+
– Servlet 3.0 focused, Servlet 2.5 compatible
• All deprecated packages removed
• Many deprecated methods removed as well
17
18. Third Party Libraries
• Minimum versions ~ mid 2010 now
• For example
– Hibernate 3.6+
– Quartz 1.8+
– Ehcache 2.1+
18
19. Java 8 Language and API Features
• Lambda expressions
• Method references
• JSR-310 Date and Time
• Repeatable annotations
• Parameter name discovery
19
20. Groovy + Spring 4.0
• A smooth out-of-the-box experience for Groovy-based
Spring applications
• AOP adaptations
– special handling of GroovyObject calls
– consider a Spring application with all components
written in the Groovy language instead of Java
• Groovy-based bean definitions
– formerly known as the Bean Builder in Grails
– now to live alongside Spring's configuration class
model
20
21. Conditional Bean Definitions
• A generalized model for conditional bean definitions
– a more flexible and more dynamic variant of bean
definition profiles (as known from Spring 3.1)
– can be used for smart defaulting
– see Spring Boot J
• @Conditional with programmatic Condition
implementations
– can react to rich context (existing bean definitions,
etc.)
– profile support now simply a ProfileCondition
implementation class
21
22. Annotation-based Components
• Custom annotations may override specific attributes of
meta-annotations
• Purely convention-based
– use of same attribute name
@MyTransactional(readOnly = true)
@MySessionScope(scopedProxyMode = TARGET_CLASS)
22
24. Ordered Injection of Lists & Arrays
• Ordered / @Order on candidate beans
• Relative order within specific injection result
24
25. DI and Generics
• Type matching based on full generic type
– e.g., MyRepository<Customer>
• Generic factory methods now fully supported in XML
config files
– Mockito, EasyMock, etc.
25
27. WebSockets
• WebSocket endpoint model along the lines of Spring MVC
• JSR-356 but also covering SockJS and STOMP
• Endpoints using generic messaging patterns
27
30. Java EE Support (1/2)
• Spring 2.5
– completed Java EE 5 support
– J2EE 1.3 à Java EE 5
• Spring 3.0
– introduced Java EE 6 support
– J2EE 1.4 à Java EE 6
30
31. Java EE Support (2/2)
• Spring 3.1 / 3.2
– strong Servlet 3.0 focus
– J2EE 1.4 (deprecated) à Java EE 6
• Spring 4.0
– introduces explicit Java EE 7 support
– Java EE 5 (with JPA 2.0 feature pack) à Java EE 7
31
32. Enterprise API Updates
• JMS 2.0
– delivery delay, JMS 2.0 createSession() variants, etc.
• JTA 1.2
– javax.transaction.Transactional annotation
• JPA 2.1
– unsynchronized persistence contexts
• Bean Validation 1.1
– method parameter and return value constraints
32
37. The State of Java 8
• Delayed again...
• Scheduled for GA in September 2013
• Now just Developer Preview in September
• OpenJDK 8 GA as late as March 2014 L
37
38. IDE Support for Java 8
• IntelliJ
– available since IDEA 12, released in Dec 2012
• Eclipse
– announced for June 2014 L
• Spring Tool Suite
– Eclipse-based beta support earlier
38
39. Java 8 Bytecode Level
• Generated by -target 1.8
– compiler's default
• Not accepted by ASM 4.x
– Spring's bytecode parsing library
• Spring Framework 4.0 comes with a patched (jarjar’ed)
ASM 4.1 variant
39
40. HashMap / HashSet Differences
• Different hash algorithms in use
• Leading to different hash iteration order
• Code shouldn't rely on such an order but sometimes does
40
41. Java 8 Lambda Conventions
Simple rule: interface with single method
– typically callback interfaces
– for example: Runnable, Callable
– formerly “Single Abstract Method” (SAM) types
– now “functional interfaces”
41
42. Lambda + Spring = Natural Fit
Many Spring APIs are candidates for lambdas
– by naturally following the lambda interface conventions
42
46. Ex: Lambdas with JdbcTemplate #1
JdbcTemplate jt = new JdbcTemplate(dataSource);
jt.query(
"SELECT name, age FROM person WHERE dep = ?",
ps -> { ps.setString(1, "Sales"); },
(rs, rowNum) -> new Person(rs.getString(1),
rs.getInt(2))
);
46
47. Ex: Lambdas with JdbcTemplate #2
JdbcTemplate jt = new JdbcTemplate(dataSource);
jt.query(
"SELECT name, age FROM person WHERE dep = ?",
ps -> {
ps.setString(1, "Sales");
},
(rs, rowNum) -> {
return new Person(rs.getString(1), rs.getInt(2));
}
);
47
48. Method References
public List<Person> getPersonList(String department) {
JdbcTemplate jt = new JdbcTemplate(dataSource);
return jt.query(
"SELECT name, age FROM person WHERE dep = ?",
ps -> {
ps.setString(1, "Sales");
},
this::mapPerson);
}
private Person mapPerson(ResultSet rs, int rowNum)
throws SQLException {
return new Person(rs.getString(1), rs.getInt(2));
}
48
49. JSR-310 Date and Time
import java.time.*;
import org.springframework.format.annotation.*;
public class Customer {
// @DateTimeFormat(iso=ISO.DATE)
private LocalDate birthDate;
@DateTimeFormat(pattern="M/d/yy h:mm")
private LocalDateTime lastContact;
// ...
}
49
51. Parameter Name Discovery
• Java 8 defines a Parameter reflection type for methods
– application sources to be compiled with –parameters
• Spring's StandardReflectionParameterNameDiscoverer
– reading parameter names via Java 8's new Parameter
type
• Spring's DefaultParameterNameDiscoverer
– now checking Java 8 first (-parameters)
– ASM-based reading of debug symbols next (-debug)
51
53. Spring Framework 4.0 Roadmap
• RC1: end of October
• RC2: mid November
• GA:
end of 2013
53
54. Upgrade Considerations
• Spring 3.2 does not support 1.8 bytecode level
– upgrade to Spring 4.0 to enable Java 8 language
features
• Spring Framework 4.0 still compatible with JDK 6 and 7
• Spring Framework 3.2 is in maintenance mode
54
56. Spring Resources
• Spring Framework
– http://projects.spring.io/spring-framework
• Spring Forums
– http://forum.spring.io
• Spring JIRA
– https://jira.springsource.org
• Spring on GitHub
– https://github.com/spring-projects/spring-framework
56