Scribd
Upload
112 views

Mike Calvo Citronella Software

Spring MVC is a web framework that aims to simplify Java web development. It handles request mapping, data binding, and passing data to views. The core classes are ContextLoaderListener, which loads the application context, and DispatcherServlet, which handles requests. Controllers interpret user input, services handle business logic, and view resolvers select views to render. Configuration involves setting up these components with XML or annotations.

Uploaded by

javamk6
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
112 views

Mike Calvo Citronella Software

Spring MVC is a web framework that aims to simplify Java web development. It handles request mapping, data binding, and passing data to views. The core classes are ContextLoaderListener, which loads the application context, and DispatcherServlet, which handles requests. Controllers interpret user input, services handle business logic, and view resolvers select views to render. Configuration involves setting up these components with XML or annotations.

Uploaded by

javamk6
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 19

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

You might also like