Mike Calvo
Citronella Software
What is Spring MVC?
Web development framework part of Spring
Aims to simplify many of the tasks that are typically
cumbersome in Java web development:
Wiring requests to backend code
Mapping form parameters to backend values
Passing data to the view (JSP Page)
Testability of request handling code
Integration of request handling code with service layer
Spring MVC Core Classes
ContextLoaderListener
A web container listener that runs at context load
(startup) time that loads your application context and
puts it into a well defined location
DispatcherServlet
Rather than mapping a different servlet to each request,
this Spring-provided servlet is mapped to all handling
requests and forwards the request to the correct handler
High Level Approach
*From Spring 2.6 Reference
Configuring ContextLoaderListener
Register the listener in web.xml
Comma separated values possible
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-
class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
Registering DispatcherServlet
1. Create a Servlet entry in your web.xml file with class
defined as
org.springframework.web.servlet.DispatcherServlet
(load-on-startup should be 1)
2. Create a Servlet mapping entry in your web.xml file
mapped to the DispatcherServlet with a pattern that will
match all handler code
Common examples include extension-based (*.do) or path-
based (/controller/*)
3. Create a spring application context file named
[servletname]-servlet.xml in your
src/main/webapp/WEB-INF folder
WebApplicationContext
The file WEB-INF/[servletname]-servlet.xml defines a
Spring application context specific to web request
handling
It can reference and inject beans defined in contexts
loaded by the ContextLoaderListener
Use it to define
Define Controllers, View Resolvers & Handler Mappings
Enable annotation-based Spring MVC features
Spring MVC Components
Controllers
The “C” in MVC
Interpret user input and transform it for service layer
processing
Prepares data for rendering by the “V”iew
Handler Mappings
Define the execution of controller code based on specific
URL mappings
View Resolvers
Converts logical names into view files for rendering
Controllers &View Mappings
Prior to Spring 2.5 implementing classes with specific
Interfaces was the only way to define
Spring 2.5 introduced an annotation-based approach
to defining them
Recommended approach is annotations for reduced
configuration and flexibility
Enabling Spring MVC-Annotations
Add the following to your [servletname]-servlet.xml
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package=“your-controller-package" />
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapte
r“ />
Controller Annotation
Add the @Controller annotation to any class to mark it
as a Spring MVC controller
The class can be a POJO
Methods within the controller class can be annotated
with the @RequestMapping annotation.
This marks a method as a responder for a particular url
mapping
Setter methods for your service layer interfaces can be
annotated with the @Autowired annotation
This will tell Spring to inject the object implementing
that interface into that property
@RequestMapping
value attribute – the URL that should be mapped to
this method
method attribute – the HTTP method that the
mapping supports (GET or POST)
Many methods can be mapped within the same
controller
Can be applied at the class level if all the request
mapped methods respond to the same URL
Method level annotations required to distinguish
handlers for different methods
Request Mapping Methods
Spring offers a great deal of flexibility in the signature of
methods marked with @RequestMapping
Examples of supported argument types
HttpServletRequest and HttpServletResponse
Map, Model, ModelMap – maps with params/arguments
@RequestParam annotated values– automatically pulls values
from request
Examples of supported return types
String – get’s converted to a JSP name
ModelAndView – return values and view JSP name
Model or Map – return values
View
Void
@RequestParam Example
@Controller
@RequestMapping("/editPet.do")
@SessionAttributes("pet")
public class EditPetForm {
// ...
@RequestMapping(method = RequestMethod.GET)
public String setupForm(@RequestParam("petId") int petId,
ModelMap model) {
Pet pet = this.clinic.loadPet(petId);
model.addAttribute("pet", pet);
return "petForm";
}
View Resolving
Register a view resolver that converts a String to the
corresponding JSP file
Add to your [servletname]-servlet.xml:
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/" />
<property name="suffix" value=".jsp"/>
</bean>
Other implementations exist such as
ControllerClassNameHandlerMapping which
automatically take the controller name as the JSP file to
load (use with caution, can be tricky to figure out)
Spring Form Taglib
JSP custom tags providing support for data binding to
controller and view mapping values
To reference Spring Form tag library add to the top of
your JSP pages:
<%@ taglib prefix="form"
uri="http://www.springframework.org/tags/form" %>
Allows you to define a form that is bound to a
Command object. All fields defined in the form using
the taglib are defined with paths (properties) relative
to the Command object
Example Tags
<form:form>
<form:input>
<form:checkbox>, <form:checkboxes>
<form:radiobuttons>
<form:password>
<form:select>
Ex: <form:select path=“state” items=“${states}” />
<form:option>, <form: options>
<form:textarea>
<form:hidden>
Displaying Errors
Integrates with Spring Validators
Pass an Errors object into your RequestMapping
method to populate error messages.
JSP Tag
<form:errors>
Takes a path argument to limit showing of errors to
specific fields in specific locations
Sample Projects
Download Spring 3.0 M1
Look in projects
Petclinic project shows example usage of annotation-
based Spring MVC
