Building Web Applications with Spring 3.0 by Bob McCune
www.bobmccune.com
Monday, May 18, 2009
1
Agenda Spring MVC Overview Spring MVC Infrastructure Developing Controllers RESTful Web Services Demo
Monday, May 18, 2009
2
Spring MVC Overview
Monday, May 18, 2009
3
What is MVC? Model Domain-specific data and processing logic Entities, services, repositories, etc.
View User-facing presentation JSPs, Velocity/Freemarker Templates, XSLT, etc.
Controller Mediator between model and view Responsible for routing requests and responses Monday, May 18, 2009
4
What is Spring MVC? Core web component of the Spring Framework Foundation of Spring’s web strategy Similar to Struts but with improvements: Better separation of concerns Robust data binding and validation Customizable type coercion with property editors
Supports wide variety of view technologies: JSP/JSTL, XML/XSLT, Freemarker, Velocity, PDF, etc.
Significantly enhanced in 2.5 release and further refined in 3.0
Monday, May 18, 2009
5
Spring MVC Basics
Monday, May 18, 2009
6
Request/Response Handling 2 Handler Mapping Request Controller
Request
1
Request DispatcherServlet
Response
Response Model
Controller
ModelAndView
View Name View
5
3
4 View Resolver
View
Monday, May 18, 2009
7
DispatcherServlet Front Controller implementation in Spring MVC Handles incoming request and dispatches to appropriate handler
Coordinates communication between infrastructural components Wired as standard servlet in web.xml Upon initialization looks for servletname-servlet.xml Default values defined in DispatcherServlet.properties Overriding defaults replaces default values!
Monday, May 18, 2009
8
Configuring web.xml Servlet Configuration <servlet> <servlet-name>spring <servlet-class> org.springframework.web.servlet.DispatcherServlet DispatcherServlet
1 finds context
Servlet Mapping
configuration based on name
<servlet-mapping> <servlet-name>spring
/v3/*
Monday, May 18, 2009
9
HandlerMapping Defines interface to select appropriate handler (Controller) DispatcherServlet consults HandlerMapping collection to locate appropriate controller Interceptors can be applied to customize pre/post processing Common implementations: BeanNameUrlHandlerMapping: SimpleUrlHandlerMapping:
Maps requests based on bean names
Maps request URLs to Controller beans
ControllerClassNameHandlerMapping: DefaultAnnotationHandlerMapping:
Monday, May 18, 2009
Auto generates mappings by class name
Maps request based on annotations
10
Controller Controller defines the interface to handle and process requests. Provides access to the HttpServletRequest and HttpServletResponse
Returns ModelAndView Composite data holder for the data model and a view Model is typically a Map variant View can be logical view name or actual View instance public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception { // Forward request to “artists list” view return new ModelAndView(“artists”); }
Monday, May 18, 2009
11
ViewResolver ViewResolver
defines the interface to select an appropriate View for the
response ViewResolver
instances can be chained together into an ordered
collection Common implementations include: InternalResourceViewResolver ResourceBundleViewResolver XmlViewResolver
<property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/>
Monday, May 18, 2009
12
View Defines the interface for objects rendering a client response Iterates through the values in the model to generate response Framework provides a wide variety of View choices: Common Web View: JstlView, FreemarkerView,VelocityView, XsltView
Special Format View: AbsractExcelView, AbstractPdfView, JasperReportsView
New Views in Spring 3.0:
New in 3.0
MarshallingView, AbstractAtomFeedView, AbstractRssFeedView
Monday, May 18, 2009
13
spring-servlet.xml
<property name="mappings"> <props> <prop key="/v3/genres.html">genreController <prop key="/v3/artists.html">artistController <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/>
Monday, May 18, 2009
14
spring-servlet.xml <property name="mappings"> <props> <prop key="/v3/genres.html">genreController <prop key="/v3/artists.html">artistController <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/>
Monday, May 18, 2009
15
spring-servlet.xml <property name="mappings"> <props> <prop key="/v3/genres.html">genreController <prop key="/v3/artists.html">artistController <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/>
Monday, May 18, 2009
16
spring-servlet.xml <property name="mappings"> <props> <prop key="/v3/genres.html">genreController <prop key="/v3/artists.html">artistController <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/>
Monday, May 18, 2009
17
Developing Spring MVC Controllers
Monday, May 18, 2009
18
Controller Controllers historically built on Controller interface Specialized implementations included: Simple Form Controllers Form processing lifecycle Databinding and validation
Wizard Form Controllers Multi-page navigation
Multi-action Controllers Grouped related, stateless operations
Monday, May 18, 2009
19
Controller Hierarchy
d e t a c
Controller
AbstractController
e r p e
MultiActionController
D
AbstractUrlViewController
BaseCommandController
AbstractCommandController
AbstractFormController
SimpleFormController
Monday, May 18, 2009
20
Controller to @Controller Designates a class as a Spring MVC Controller Removes the need to implement or extend Spring-specific classes @Controller stereotype automatically be picked up if using component scanning
Flexible method signatures No need to implement/override lifecycle methods
Can eliminate dependencies on Servlet API No need to “mock out” dependencies in unit tests
Monday, May 18, 2009
21
Flexible Method Arguments Method signatures are very flexible Arguments can be: Servlet types: HttpServletRequest, HttpServletResponse, HttpSession WebRequest: wrapper over Servlet specifics I/O types: InputStream, OutputStream, Reader, Writer Model types: Model, ModelMap, Map Model attributes, Request parameters Locale
Monday, May 18, 2009
22
Flexible Return Types ModelAndView: Wraps model and View or logical view name Model or Map: Return model with view implicitly defined Will use RequestToViewNameTranslator
View: View instance to be used to render response String: Interpreted as logical view name void: Can return void if Controller handles response Any object: Will be used as single model value
Monday, May 18, 2009
23
@RequestMapping Used to map URL patterns to controllers Can be applied at either a class and/or method level Multi-action controllers commonly defined at method level Form controllers applied at class level with method level annotations used to narrow request to particular type
Greater mapping flexibility than previous releases
Monday, May 18, 2009
24
@RequestParam Used to bind request parameters to method parameters Limits or removes needs to rely on Servlet API @RequestParam designates a required parameter Can be made optional with required=false @Controller @RequestMapping("/edit.do") public class EditController { @RequestMapping(method = RequestMethod.GET) public String configure( @RequestParam("id") int id, ModelMap model) { model.put(service.getContact(id)); return “edit”; } }
Monday, May 18, 2009
25
@ModelAttribute/ @SessionAttribute Used to map model data into controller Used at a method level to maps model attribute to method argument No need to work directly with HttpServletRequest
Can also be used at method level to provide reference data is processed before @RequestMappings so data is pre-populated before controller processing @ModelAttribute
Can use @SessionAttribute to store and retrieve session data
Monday, May 18, 2009
26
@InitBinder and WebBindingInitializer Spring’s data binding capabilities are one of the more compelling reasons to use Spring MVC Built in support for all primitive/wrapper types Uses standard Java SE PropertyEditor instances for type coercion. Can write custom editors for advanced binding. Custom editors can be mapped: Controller using the @InitBinder annotation Application level use implementation of WebBindingInitializer New type conversion SPI and converter API
New in 3.0
Provides Java 5 friendly data type converter strategy
Monday, May 18, 2009
27
Convention / Configuration ControllerClassNameHandlerMapping
Automatically generates mapping based on Controller name Removes “Controller” from name and lowercases resulting value E.g. ArtistController maps to /artist*
Model and ModelMap
Generates attribute names from model types Artist
produces “artist” attribute
List
produces “artistList” attribute
RequestToViewNameTranslator
Generates logical view name from incoming request E.g. Request for http:/server/artists.html produces logical view name of “artists”
Monday, May 18, 2009
28
REST Support
Monday, May 18, 2009
29
What is REST? REpresentational State Transfer Lightweight, resource-oriented architectural style Unlike SOAP or XML-RPC, is not a standard
Stateless, cacheable, scalable communication protocol Uses standard HTTP methods to read and write data Provides uniform interface for interacting with resources Nouns used to represent resources: artists, albums, etc. Verbs defined through standard HTTP methods
Monday, May 18, 2009
30
HTTP Methods Resource interaction through standard HTTP methods GET: Gets a representation of resource. Safe operation. POST: Creates or updates resource. PUT: Creates or updates resource. Idempotent. DELETE: Deletes a resource. Idempotent. HEAD: GET request without body. Returns headers only. OPTIONS: Discovery method to determine allows.
Monday, May 18, 2009
31
Spring 3.0 REST Support Builds on Spring 2.5’s @Controller Model Focuses on making it simple to expose and consume RESTful Web Services Client-side access greatly simplified via RestTemplate Server-side development enhanced with expanded request mappings and path variables
Provides competing approach to JAX-RS implementations: Jersey RESTEasy Restlet
Monday, May 18, 2009
32
URI Templates RESTful services define resource locations through URIs http://www.host.com/orders/{orderId}
Variable expansion would convert URI to: http://www.host.com/orders/8675309
Spring MVC implements URI Templates through its standard @RequestMapping annotation @PathVariable annotation can extract template values
from template variables
Monday, May 18, 2009
33
Mapping Requests Uses standard Spring MVC @RequestMapping annotation Supports URI templates in path expressions @Controller @RequestMapping("/artists/{artistId}") public class ArtistController { @RequestMapping(method = RequestMethod.POST) public String create(Artist artist) { return "artist"; } @RequestMapping(method = RequestMethod.DELETE) public String delete(Long id) { return "artist"; } }
Monday, May 18, 2009
34
@PathVariable @PathVariable maps URI template placeholders to argument values Can use multiple @PathVariable annotations Values can be explicitly defined or inferred through debug info @Controller public class AlbumController {
@RequestMapping(value = "/artists/{artistId}/albums/{albumId}" method = RequestMethod.GET) public Album getAlbum(@PathVariable("artistId") Long artistId, @PathVariable("albumId") Long albumId) { return service.findAlbum(artistId, albumId); }
}
Monday, May 18, 2009
35
3.0 Controller Annotations @RequestHeader Allows request headers to be bound to method arguments
@CookieValue Allows cookie values to be bound to method arguments
@RequestBody Allows binding request body to a method argument Request body converted using HttpMethodConverter implementations Implementations provided for converting byte arrays, strings, form values, XML sources, and JSON (forthcoming)
Monday, May 18, 2009
36
3.0 Views Feed Views based on ROME project: AbstractRssFeedView: renders an RSS feed AbstractAtomFeedView: renders an ATOM feed
MarshallingView: returns XML representation using Spring’s OXM framework JacksonJsonView: renders a response in JSON format Currently only available in Spring JS project Hopefully moved to core in final release
Monday, May 18, 2009
37
3.0 JSP Tags Spring MVC JSP tags have been expanded to support REST tag enhanced to support all HTTP methods
Browsers only support sending GET and POST requests HiddenHttpMethodFilter converts specified method to hidden
form field <spring:url> tag enhanced to support URI templates
Monday, May 18, 2009
38
Content Negotiation A key feature of REST is the ability to return multiple representations of a resource XML, HTML, Text, JSON, etc.
Two strategies for client to request content type: Specify the resource’s file extension Set the appropriate Accept Header
Spring provides a ContentNegotiationViewResolver Allows mapping mime types to views
Monday, May 18, 2009
39
ETag Caching ETags (entity tags) are a response header sent to determine if resource has changed Unchanged content will return 304: Not Modified header
Spring supports shallow ETag caching with ShallowEtagHeaderFilter Standard javax.servlet.Filter Doesn’t save processing, but does reduce bandwidth Generates MD5 Hash for rendered view Subsequent requests use this value in If-None-Match to compare if response should be resent
Monday, May 18, 2009
40
RestTemplate Provides simplified client access to REST services Interacting with resources often a single line of code
Conceptually similar to other Spring templates: JdbcTemplate JmsTemplate
Provides callback methods to customize response handling Uses ClientHttpRequest object based on java.net.URLConnection and Jakarata Commons Configurable with HttpMessageConverters
Monday, May 18, 2009
41
RestTemplate Methods HTTP Method
RestTemplate Method
GET
getForObject(String url, Class responseType, String... urlVariables)
POST
postForLocation(String url, Object request, String... urlVariables)
PUT
put(String url, Object request, String... urlVariables)
DELETE
delete(String url, String... urlVariables)
OPTIONS
optionsForAllow(String url, String... urlVariables)
HEAD
headForHeaders(String url, String… urlVariables)
Monday, May 18, 2009
42
RestTemplate Example Source RestTemplate template = new RestTemplate(); String URI = "http://localhost:8080/springmvc/v3/genres.xml"; Source source = template.getForObject(URI, Source.class); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); transformer.transform(source, new StreamResult(System.out));
Produces <list> 1Rock 2Jazz 3Country
Monday, May 18, 2009
43
Demo
Monday, May 18, 2009
44
Summary Spring MVC is a simple, yet powerful Model 2 web framework @Controllers provide more flexibility that Controller hierarchy Broad range of argument values Any object type can be returned from controller method
@RequestMappings enhanced to support RESTful services URI Template variables extracted using @PathVariable
New annotations provided to meet needs of REST developers RestTemplate greatly simplifies client access to REST services
Monday, May 18, 2009
45