Spring Web Tier

Alef Arendsen
Erwin Vervaet
Overall Presentation Goal

Practical session on
Spring Web MVC and
Spring Web Flow
Speakers

Alef Arendsen
Principal Consultant at Interface21
Spring Core Developer
Author, Professional Development with
Spring
Erwin Vervaet
Consultant at Ervacon
Extensive experience in J2SE and J2EE
Founder of the Spring Web Flow project
Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Spring MVC - Topics
Positioning of Spring MVC in the
application architecture
Spring MVC general concepts
Request-processing flow
Spring MVC Introduction
Request-driven MVC framework
Some similarities with Struts
Tight integration with other parts of
Spring
Basis for other HTTP-based functionality
in Spring
Can be used in combination
with other MVC frameworks
Web MVC layer
(Spring MVC, Spring Web Flow
JSF, Struts, Tapestry, …)

Service objects

Data access objects

Understanding request-driven MVC

Browser issue requests: GET, POST

Requests need to be handled
Invoke the appropriate business process
Example: search for list of items
Responses must be rendered
Show the result of the business process
Example: display the items to the user
Understanding request-driven MVC

The result:
Controller – handling requests,
interacting with the business layer and
preparing the model and the view
View – rendering the response to the
user based on the Model
Model – the contract between the View
and the Controller
Request-driven MVC – Controller
(or: everything you need to know about Spring MVC – 1/5)

Processes logical requests

Parses and validates input
Invokes business logic
Creates model
Selects a view
Often also called a request processor or
handler
Request-driven MVC – Model
(or: everything you need to know about Spring MVC - 2/5)

Data returned by the controller and

rendered by the view
(In Spring) implemented as a
java.util.Map
Technology-agnostic
(e.g. no references to HttpServletRequest)
Request-driven MVC – View
(or: everything you need to know about Spring MVC – 3/5)

Identified by a logical view name (a String)

Renders responses to users
Accesses data in the Model
Renders a response
(Typically) does not contain business logic
• Just simple ‘scripts’ to access and
display Model data
Clear contract
• Controller populates Model with data
• View renders data from the Model
Request-driven MVC – ViewResolver
(or: everything you need to know about Spring MVC – 4/5)

Resolves logical view names to

Java Server Pages
Velocity templates
Freemarker templates
Views rendering PDF or Excel files
XSLT files transforming XML
…
Request-driven MVC - DispatcherServlet
(or: everything you need to know about Spring MVC – 5/5)

Controls the entire request/response flow

Controller/View handling
Localization / Multipart (upload) handling
…
Implemented as a Front Controller
(read more in PoEAA by Martin Fowler)
Typically wire one Servlet per application
Loads a Spring ApplicationContext
Just a servlet, handling all HTTP-requests
Request-driven MVC – the flow

request DispatcherServlet

Model Controller

User

response View
Some code - the Controller

public interface Controller {

public ModelAndView handleRequest(

HttpSservletRequest req,
HttpServletResponse res)
throws Exception;

}
Some code - the ModelAndView
public class ModelAndView {

public Map get/setModel();

public String get/setViewName();

...

}
Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Sample: Pimp My Shirt
Compose new shirts
Select long or short sleeve
Enter graphical or text print
Select color
Rate previously created shirts
Delete previously created shirts
DEMO
composeShirt flow
&
RateShirtsController

<<ShirtService>>

<<ShirtDao>> & <<RatingDao>>

Pimp my Shirt – layout
ShirtService interface and implementation
Implementation of the use cases
RateShirtsController Spring MVC Controller
Spring MVC controller
enabling user to rate shirts
composeShirt flow Spring Web Flow
Backed by Web Flow action
(covered later on)
Setting up the infrastructure
Configure a Spring DispatcherServlet
Define web-specific ApplicationContext
Loaded automatically by DispatcherServlet
Middle-tier ApplicationContext
(loaded by ContextLoadListener)
is automatically linked in
Setting up the DispatcherServlet

<servlet>
<servlet-name>pimpmyshirt</servlet-name>
<servlet-class>

org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
Defines name of
<servlet-mapping> ApplicationContext
<servlet-name>pimpmyshirt</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
Layout of a typical Spring application
Pimp my Shirt – layout

composeShirt flow RateShirtsController

pimpmyshirt-servlet.xml

ShirtServiceImpl
ShirtServiceImpl
ShirtDaoImpl

applicationContext.xml
Implementing a Controller
Implement Controller interface…
or implement AbstractController…
or implement another controller
MultiActionController
SimpleFormController
…
RateShirtsController

public RateShirtsController extends Abstractcontroller {

private ShirtService shirtService;

public void setShirtService(ShirtService service) {...}

public ModelAndView handleRequestInternal(

HttpServletRequest req, HttpServletResponse res) {
ModelAndView mav = new ModelAndView(“frontpage”);
// add data to MaV using shirtService
return mav;
}
}
Wire the Controller

<bean name=“/index.html”
class=“...RateShirtsController”>
<property name=“shirtService”
ref=“shirtService”/>
</bean>
RateShirtsController
In reality uses MultiActionController
Multiple related actions grouped
together in one class
Selection handler method done
by MethodNameResolver
(e.g. using an HTTP parameter value)
Each action method must
return ModelAndView
DEMO
Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Data binding
Binding request parameters to objects
Domain objects
Data transfer objects
…
Primitives as well as complex objects
Uses java.beans.PropertyEditors

Central class: WebDataBinder

Data binding - example
public class ShirtFbo {
private String shirtText;
private Date date;
public void set/getShirtText() { ... }
public void set/getDate() { ... }
}

<input type=“text”
name=“shirtText”/>
<input type=“text”
name=“date” value=“2005-12-13 14:30”/>
Used in SimpleFormController

Controller to model simple form workflow

GET request display the form
(User fills in HTML form and submits)
POST request trigger submit logic
• Bind HTTP parameters to form backing object
• Perform validation of form backing object
• Something wrong? redisplay HTML form
• All okay? perform some action (eg save
object)
Simple Form Controller Flow

formView

submit
errors

Process
submitted data

success

successView
Binding and validation process
1. formBackingObject()
• Create object to which
HTTP parameters will be bound
2. bindAndValidate()
• initBinder()
• Prepare WebDataBinder to convert
complex types using PropertyEditors
• Bind using WebDataBinder
• Validation using Validators
3. processSubmitAction() either one of
• doSubmitAction()
• onSubmit()
• …
PropertyEditors
Convert Strings to complex objects
Convert complex objects to Strings
Standard JavaBeans infrastructure

Shirt ID as text <input name=“shirtId”/>

converted to Shirt objects

Out of the box implementations in Java as well

as Spring (Date, Class, Number, et cetera)
PropertyEditors - example
// don’t use this at home!!
public class StupidClassEditor
extends PropertyEditorSupport {

public void setAsText(String text) {

setValue(Class.forName(text));
}

public void getAsText(String text) {

return getValue().toString();
}
}

public void initBinder(HttpServletRequest request,

ServletRequestDataBinder dataBinder) {
dataBinder.registerCustomEditor(Class.class, new StupidClassEditor());
}
<spring:bind/>
Spring tag library to use property editors
in web pages
Simplifies setting up HTML forms
Enables looking at status of given
property
String-representation of property value
Error messages for the property
(conversion or validation errors)
Does not produce HTML!
<spring:bind/> - example
<spring:bind path=“shirtFbo.shirtText”>

<input type=“text”
name=“${status.expression}”
value=“${status.value}”/>

<c:if test=“${status.error}”>
<span class=“error”>
${status.errorMessage}
Corresponds
</span>
to shirtText property
</c:if>
in ShirtFbo object

</spring:bind>
Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Spring Web Flow
In a nutshell
An advanced controller for Web MVC
targeting use cases demanding controlled
navigation
Integrates with several frameworks
• Spring Web MVC & Spring Portlet MVC
• Struts
• JSF
•…
Typical Example
A wizard to compose a shirt
Spans several steps
Some steps require user input
Some steps are decision points
Some steps perform logic (calculations, …)
Navigation is controlled
Classic Implementation
What would this look like with Spring MVC?
Use AbstractWizardFormController …
Manage session scoped form backing
object to hold wizard data
Controller (and View) for each step
Expose each Controller at a request URL
Views submit to particular to particular
URL:
a controller handling one step in the flow
Result

Store form
backing
/page1.html
object

view1
Controller 1 HTTP
Session

/step2.html
Update
form
view2
backing
Controller 2
object

/step3.html Business
processTx Service
view3
Controller 3
Problems with this approach
Request centric
No concept of a conversation or flow
The flow is chopped up in individual
controllers
Brittle dependency on request URLs
Manual state management
Loosely controller navigation
…
Consequences
Custom code to handle problems
Hard to maintain
Hard to reuse
A key abstraction is missing: the flow!
A web conversation: longer than a single
request but shorter than a user’s session
Refactored with Spring Web Flow

start “compose shirt”

view1

store
next Flow
view2 Execution
Storage
load

submit
view3
“Compose Shirt”
Flow
Spring Web Flow – Concepts (1)

One flow controls entire conversation

When user input is required, the flow
pauses and a view is rendered
Clients signal events to tell the flow
something happened
The flow responds to the events and
decides what to do next
Spring Web Flow – Concepts (2)

A flow is a simple finite state machine

A set of states with transitions between
them
SWF is not a general purpose work flow
engine
Lacks things like split/join
Focus on web conversations allow many
simplifications
Spring Web Flow – Concepts (3)

Flow states execute behavior when

entered
View state renders view & solicits user
input
Action state executes a command
Subflow state spawns child flows
Decision state selects paths through flow
End state terminates a flow
Events drive state transitions
Spring Web Flow – Concepts (4)

A flow is a reusable application module

Flow logic fully encapsulated
Flows can easily use other flows as
subflows
A flow defines an input-output contract
Defining a flow
Start with a simple state transition
diagram
Capture that in a flow definition
Typically XML
Other definition formats possible (e.g.
Java)
Compose shirt flow

Setup
1: Enter Basic Graphical
Reference
Shirt Params Print?
Data
no yes

2: Enter Print 2: Upload Print

Text Graphic

3: Shirt
End Create Shirt
Preview

Action View Decision End

State State State State
Flow definition XML (1)

An Action State
<action-state id="referenceData">
<action bean="composeShirtAction"/>
<transition on="success" to="step1"/>
</action-state>

A Decision State
<decision-state id="printSwitch">
<if test="${flowScope.shirtFbo.graphical}"
then="step2Graphical"
else="step2Text"/>
</decision-state>
Flow Definition XML (2)

A View (Form) State

<view-state id="step1" view="composeShirtStep1">
<entry>
<action bean="composeShirtAction" method="setupForm"/>
</entry>
<transition on="ok" to="printSwitch">
<action bean="composeShirtAction" method="bindAndValidate">
<property name="validatorMethod" value="validateStep1"/>
</action>
</transition>
<transition on="cancel" to="end"/>
</view-state>
An End State

<end-state id="end" view="redirect:/index.html"/>

Where is composeShirtAction?

Defined as a bean in the application context

Implementation of Action interface

<bean id="composeShirtAction"
class="org.pimpmyshirt.web.ComposeShirtAction">
<property name="shirtService" ref="shirtService"/>
</bean>

Support for multi-actions is provided

public interface Action {
public Event execute(RequestContext context)
throws Exception;
}

public Event methodName(RequestContext context)

throws Exception;
The FlowExecution?
The data associated with the execution of
a flow for a particular client
Flow ~ Class
FlowExecution ~ Object
Has a unique identifier
Client will have to maintain this id
Client code (Action) uses RequestContext
to interact with the flow execution
Flow Scope & Request Scope?
Flow Scope (RequestContext.getFlowScope())

Storage that spans the entire flow execution

Request Scope (RequestContext.getRequestScope())

Storage that spans a single request

Flow Scope

Request Scope

Setup
1: Enter Basic
Reference End
Shirt Params
Data
Deploying the flow
Add a FlowController to your application
<bean id="flowController"
name="/flow.html"
class="org.springframework.webflow.mvc.FlowController"
/>

Single Flowcontroller for entire

application
Define the flow as a bean
<bean id="composeShirt"
class="org.springframework.webflow.config.XmlFlowFactoryBean">
<property name="location"
value="/WEB-INF/composeShirtFlow.xml"/>
</bean>
Interacting with a flow (1)
Launching a new flow
<a href=“<c:url
value=“flow.html?_flowId=composeShirt”/>”>Add Shirt</a>
Send _flowId but not _flowExecutionId

Participating in a flow
<a href=“<c:url value=“flow.html?_eventId=cancel
&_flowExecutionId=${flowExecutionId}”/>”>Cancel</a>

Send _eventId and _flowExecutionId but not _flowId

Interacting with a flow (2)
Also possible with HTML forms
<form action="<c:url value="flow.html"/>" method="post">
<input type="hidden" name="_eventId" value="ok"/>
<input type="hidden" name="_flowExecutionId"
value="${flowExecutionId}"/>
<input type="hidden" name="_currentStateId"
value="step1"/>
...
<input type="submit" value="Next"/>
</form>

Notice optional _currentStateId

Also available in model:
${currentStateId}
Spring Web Flow - Advantages
A clear and encapsulated flow definition
capturing all navigation rules
State management is automatic
(FlowExecutionStorage)
Flows are reusable application modules
HTTP independent
Observable flow life cycle
(FlowExecutionListener)
Spring Web Flow - Considerations

Don’t overuse!
Targeted at controlled navigations!
Side by side with Spring MVC controllers
Be careful with browser back button
Consider continuations
Guard against double submit
(with back button)
Consider TransactionSynchronizer
Advanced data binding
WebDataBindernot usable in all situations
Manual data binding still possible
Using HttpServletRequest
Using convenient RequestUtils and
WebUtils
If things became nasty,
just use manual data binding
Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Redirect-After-Post
Most important HTTP request methods
POST: submit user input to server
GET: retrieve data from server
(idempotent)
Really Redirect-After-Submit
Sometimes GET has side effects;
e.g. because it’s used to submit data
Best practice: only use HTTP POST for
submits
Double submit problem
What if the server returns data (a page)
in response to a submit (POST) request?

Submit Data

Server

Browser Result Page

Solution: Redirect-After-Submit

Submit Data

Redirect (HTTP 303/302)

Browser Server

Get Result

Result Page
Be careful with caching
Don’t cache submit result pages
<bean id="flowController" name="/flow.html"
class="org.springframework.webflow.mvc.FlowController">
<property name="cacheSeconds" value="0"/>
</bean>
Redirecting in Spring MVC, SWF

Use the RedirectView

RedirectView rv = new RedirectView(“/index.html”);
rv.setContextRelative(true);
return new ModelAndView(rv);

Use the redirect: prefix

Detected by UrlBasedViewResolver
return new ModelAndView("redirect:/index.html");

<end-state id="end" view="redirect:/index.html"/>

Agenda
Spring and Spring MVC
The Sample Application
Data Binding
Spring Web Flow
Redirect-After-Post
File Upload
Handle File Uploads
Spring Web MVC fully supports file upload
Leverages existing frameworks
• Commons fileupload
• O’Reilly COS (buy-a-book license)
SWF can use Spring Web MVC file upload
support
Just like with data binding
Understanding File Upload
DispatcherServlet needs a
MultipartResolver
Wraps multi-part requests in a
MultipartHttpServletRequest containing
MultipartFile objects
Deploy in web context
<bean id="multipartResolver"
class="org...multipart.commons.CommonsMultipartResolver"/>
Uploading a file
Use a special HTML form
<form action="<c:url value="flow.html"/>"
method="post" enctype="multipart/form-data">
...
<spring:bind path="shirtFbo.shirt.print">
<input type="file" name="${status.expression}">
<c:if test="${status.error}">
...
</c:if>
</spring:bind>
...
</form>
Handling Uploaded Data (1)

Directly in controller
if (request instanceof MultipartHttpServletRequest) {
MultipartFile print = (Multipartfile)
((MultipartHttpServletRequest)request)
.getFile(“shirt.print”);
...
}

Using ByteArrayMultipartFileEditor
binder.registerCustomEditor(byte[].class,
new ByteArrayMultipartFileEditor());
Handling Uploaded Data (2)
Using a custom PropertyEditor
Bind multiple properties of the uploaded file to a
domain layer object
binder.registerCustomEditor(Print.class,
new PropertyEditorSupport() {
public void setValue(Object value) {
if (value instanceof MultipartFile) {
MultipartFile multipartFile = (MultipartFile) value;
ImagePrint print = new ImagePrint();
try {
print.setImage(multipartFile.getBytes());
print.setContentType(multipartFile.getContentType());
print.setFilename(multipartFile.getOriginalFilename());
}
catch (IOException ex) { ... }
super.setValue(print);
}
...