Spring 3 emphasizes annotation configuration over XML. Key changes include support for JSR 250, 299/330, and 303 annotations as well as a simplified MVC framework with @Controller and @RequestMapping annotations. Validation is integrated using JSR 303 annotations and executed automatically by the framework. Configuration is also simplified through @Configuration classes and the @Bean annotation.

1. Spring 3
An overview of changes from version 2.5
Ted Pennings
8 December 2010

2. Overview of Changes
Annotations
Fewer interfaces
MVC overhaul
Dropped binary compatibility with Java 1.4
Java 5 generics, for(), autoboxing, etc

3. Spring 3 = Annotations
Spring 3 emphasizes annotation config
@Component, @Configuration, etc
JSR 250 Common Annotations
JSR 299/330 Bean Injection
JSR 303 Bean Validation
Java Persistence API (JPA)

4. Enabling Annotation
Configuration
<context:component-scan base-package=”com.foo.bar”>
<mvc:annotation-driven>
also, <aspectj:auto-proxy /> for @Aspects

5. Annotation Config
Example
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://
www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/
beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/
spring-mvc-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/
context/spring-context-3.0.xsd">
<!--
Scans within the base package of the application for @Components to
configure as beans
-->
<context:component-scan base-package="com.tedpennings.bu.cs667" />
<mvc:annotation-driven />
</beans>

6. Annotation
Taxonomy
@Component and its specializations
@Service, @Repository
@Controller
@Configuration + @Bean
@Autowired
@Value

7. @Component
Example
@Component("rssView")
public class RomeRssView extends AbstractView {
@Override
protected void renderMergedOutputModel(Map model,
HttpServletRequest request, HttpServletResponse
response) throws Exception {
doStuff();
}
}

8. @Service Example
@Service
public class TwitterStatusProvider implements StatusProvider {
@Autowired
private CacheRepository cache;
@Override
public String getStatus(boolean skipCache) {
String status = cache.findString(CACHE_KEY);
if (skipCache || status == null) {
status = getStatusFromTwitter();
cache.cacheString(CACHE_KEY, status, DEFAULT_CACHE_EXPIRY);
}
return status;
}
}

9. @Configuration
Classes
Java classes that do the work of XML
Application Context files
Allow much more control over object creation
Instantiated before XML beans
@Configuration @Beans can be referenced by
XML beans/config
Can also reference XML beans

10. @Config Example
@Configuration
public class MongoConfiguration {
@Value("${db.host}")
private String dbHost;
@Value("${db.port}")
private int dbPort;
@Bean
@Lazy
public Mongo mongo() throws UnknownHostException {
return new Mongo(dbHost, dbPort);
}
}

11. MVC Changes
Controller interfaced dropped
@RequestMapping instead of XML config
@Controller instead of explicit XML config
Lots of return types possible
Simplicity

12. The Simplicity of
Controllers
@Controller makes a class a controller “bean”
Specialization of @Component
@RequestMapping defines the URL paths handled by a
class and/or method.
It is possible to nest paths, as in example on next slide.
Many different RequestMethods allowed in a @Controller
{} in @RM path define @PathVariable/@ReqParam
Value of Inheritance
Annotation caveat

13. @Controller Example
@Controller
@RequestMapping({ "/yacht", "/yachts", "/mah-boats" })
public class YachtController {
@Autowired
private YachtService service;
private static final String YACHT_PAGE_VIEW = "yachts/view";
@RequestMapping(value = "/{yachtKey}", method = GET)
public String displayYacht(@PathVariable(“yachtKey”) String yachtKey,
Model model) {
LOG.debug("Displaying Yacht " + yachtKey);
Yacht yacht = service.findYachtByKey(yachtKey);
model.addAttribute("yacht", yacht);
return YACHT_PAGE_VIEW;
}
}

14. MVC Annotations
@Controller – an MVC Controller
@RequestMapping
@ModelAttribute
@RequestParam and @PathVariable
@SessionAttributes

15. Demo
Annotation Config
Working forms
Bean validation (JSR-303)

16. Controller Method
Return Types
@Controller methods can return many different types. Often:
Model
ModelAndView (use Model.setView(View) or
Model.setViewName(String))
Distinction between View and View Name
String for the view name to display
Can return void if you’ve drank plenty of convention over configuration
koolaid.
Dangerous if you refactor a lot (or the next person does).
Methods can also be annotated with @RequestBody
Used to return a value without going through MVC apparatus
Generally bad form, but good for testing or mock apps.
@ModelAttribute has the same two distinct meanings as @ModelAttribute

17. Bean Validation
(JSR-303)
Constraints are defined by @Entity
public class Yacht {
annotations on the actual data @Id
@GeneratedValue(strategy = GenerationType.AUTO)
entities private Long id;
Validation is executed @Size(min = 4, max = 35, message = "Key must be
between {min} and {max} characters long.")
automagically by framework @NotEmpty(message = "Key is required.")
@Pattern(regexp = "[A-Za-z0-9_-]*", message = "Only
letters, numbers, underscores and hyphens may be used.")
User-friendly errors appear private String key;
automagically on the view.
@Size(min = 4, max = 35, message = "Name must be
between {min} and {max} characters long.")
Object graphs can be traversed @NotEmpty(message = "Name is required.")
private String name;
and nested objects are validated
@ValidDate
(or not, if you wish). private Date acquisitionDate;
}

18. Setting Up And Using
Bean Validation
As simple as @Valid
Can be applied inside domain to validate child/2nd degree
objects
BindingResult for errors
MUST be argument after @Valid argument (quirk)
RuntimeException if not
toString() is your friend.
Validating a large object graph is risky.
Complicates future changes
On the other hand, very hard to merge BindingResults

19. Updated Controller
@Controller
public class YachtController {
@RequestMapping(method = POST)
public ModelAndView saveYacht(@Valid Yacht yacht, BindingResult
result, ModelAndView mv) {
LOG.debug("Attempting to save Yacht: " + yacht.getKey());
if (result.hasErrors()) {
LOG.debug("Submission has errors " + result);
mv.setViewName(MODIFY_YACHT_VIEW);
return mv;
}
service.store(yacht);
FlashMap.setSuccessMessage("Successfully saved Yacht");
return createRedirect(yacht);
}
}

20. Handling Validation
Errors
Ensure that you have a BindingResult.hasErrors() check in @Controller
When returning edit view, ensure all needed model attributes are present
This includes the object being validated if you construct a new Model/
MV
You may need a call to the root-level form:errors in order to capture object-
level errors (not field-level).
<form:errors path=“” />
Be sure you interrupt flow so you don’t persist invalid objects
VALIDATION ERRORS ARE NOT EXCEPTIONS
There is a Hibernate option to validate pre-persist, but this is nuanced
Legacy objects
May be incompatible with Spring-managed dependencies

21. Writing Your Own
Constraints
Constraints can be combined and composed
For example, @NotEmpty actually means @NotNull, @Size(min=1) &
@ReportAsSingleViolation
Write an annotation class
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented (or not)
@Constraint(validatedBy = YourCustomValidator.class)
Be sure to add a default message
These can be Java properties read from a file (Internationalization/i18n)
Write a validator
Implement ConstraintValidator<AnnotationType, TargetClass>
Return boolean for isValid(TargetClass object, …)
Statefulness (via initialize() method)
Dependency Injection, Constructors, and Hibernate ORM issue

22. Writing Unit Tests For Validation
Magic
A lot of JSR-303 is wizardry and magic beans.
Write unit tests so you ensure code execution is
predictable.
Easiest to write using Spring’s JUnit Test Runner
Point to an application context field that contains
<bean id="validator“
class="org.springframework.validation.beanvalidation.Loca
lValidatorFactoryBean" />
Ensure a JSR-303-compliant validator is on your test
classpath
Eg, Hibernate Validator

23. Example Unit Test
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath:your-persistence.xml",
"classpath:your-persistence-test.xml" })
public class YachtValidationTest {
@Autowired
private javax.validation.Validator validator;
private Yacht emptyYacht;
@Before
public void setUpEmptyYacht() {
emptyYacht = new Yacht();
}
@Test
public void theKeyFieldIsRequired() {
Set<ConstraintViolation<Yacht>> constraintViolations = validator
.validate(emptyYacht);
boolean containsYachtKeyViolation = false;
for (ConstraintViolation<Yacht> violation : constraintViolations) {
if ("key".equals(violation.getPropertyPath().toString())
&& violation.getMessageTemplate().contains("required")) {
containsYachtKeyViolation = true;
}
}
assertTrue(containsYachtKeyViolation);
}
}

24. Even More
Annotations
JSR 250 Resource Management
JSR 299/330 Bean Injection
JPA!

25. JSR 250 Resource
Management
@Resource (typically fields)
@PostConstruct (method)
Replaces InitializingBean + afterPropertiesSet()
@PreDestroy (method)
Replaces DisposableBean + destroy()

26. Bean Injection JSR
javax.inject package:
@Inject (equivalent to @Autowired)
@Qualifier (to resolve ambiguities)
@Named
@Scope
@Singleton

27. JPA Annotations
@PersistenceContext / @PersistenceUnit
@Entity
@Column, @Id, @Enumerated, @ManyToOne, etc
Mixes well with Spring-tx and @Transactional

28. Basic JPA Configuration
in Spring 3.0
PersistenceAnnotationBeanPostProcessor for
@PersistenceContext/Unit EntityManagers
LocalContainerEntityManagerFactoryBean to
bootstrap JPA and read persistence.xml
Still need to configure provider, eg, Hibernate
Need to provide data source, either as a
constructed bean or JNDI reference

29. Hibernate as JPA
Provider
HibernateJpaVendorAdapter + Properties
<bean id="jpaVendorAdapter"
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="showSql" value="true" />
<property name="generateDdl" value="true" />
<property name="databasePlatform" value="org.hibernate.dialect.MySQL5Dialect" />
</bean>
<bean id="hibernateProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath:hibernate.properties</value>
hibernate.properties:
</list>
</property> hibernate.hbm2ddl.auto=update
</bean> hibernate.connection.autocommit=true
hibernate.show.sql=true
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" hibernate.generate_statistics=true
destroy-method="close"> javax.persistence.validation.mode=ddl
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/yourdb" />
<property name="username" value="user" />
<property name="password" value="pass" />
</bean>

30. Resources
http://static.springsource.org/spring/docs/
3.0.x/spring-framework-reference/html/
http://static.springsource.org/spring/docs/
3.0.x/javadoc-api/
Spring In Action, 3rd Edition by Craig Walls
(Manning). Excellent survey.

31. Questions?
http://ted.pennin.gs /ted@pennin.gs
@thesleepyvegan on twitter
not always Java related