In this third installment of the Spring series, I introduce you to the Spring Model-View-Controller (MVC) framework. As in the previous articles, I use a banking example to show you how to model and build a simple application. The example application will encompass some of the techniques you've already learned -- such as dependency injection -- but will primarily demonstrate features of Spring MVC.

Download the article source before you begin. See Resources to access the Spring framework and Tomcat 5.0, which you will need to run the examples.

The Spring MVC framework

The Spring framework provides a full-featured MVC module for building Web applications. With Spring's pluggable MVC architecture, you can choose whether you want to use the built-in Spring Web framework or a Web framework such as Struts. The framework is highly configurable through strategy interfaces and accommodates multiple view technologies such as JavaServer Pages (JSP) technology, Velocity, Tiles, iText, and POI. The Spring MVC framework is view agnostic, so does not push you to use only JSP technology. Spring MVC separates the roles of the controller, the model object, the dispatcher, and the handler object, which makes them easier to customize.

Spring's Web MVC framework is designed around a DispatcherServlet that dispatches requests to handlers, with configurable handler mappings, view resolution, locale, and theme resolution as well as support for upload files. The default handler is a very simple Controller interface with just one method, ModelAndView handleRequest(request, response). Spring provides a controller hierarchy that can be subclassed. If your application needs to process user entry forms you might subclass AbstractFormController. If you need to process a multi-page entry into a single form you can subclass AbstractWizardFormController.

An example application will help you learn about these features first hand. The banking application will allow users to retrieve their account information. In the process of building it, you'll learn how to configure the Spring MVC framework and implement the framework's view layer, which will consist of JavaServer Pages technology with JSTL tags for rendering the output data.

Back to top

Configure Spring MVC

To start building the example application, configure Spring MVC's DispatcherServlet. Register all configurations in your web.xml file. Listing 1 shows how to configure the sampleBankingServlet.

<servlet>
   <servlet-name>sampleBankingServlet</servlet-name>  
   <servlet-class>
      org.springframework.we.servlet.DispatcherServlet
   <servlet-class>
   <load-on-startup>1<load-on-startup>
<servlet>        

The DispatcherServlet loads a Spring application context from the XML file whose name is based on the name of the servlet, with -servlet appended to it. In this case, the DispatcherServlet will load its application context from the sampleBankingServlet-servlet.xml file.

Configure application URLs

The next step is to configure the URLs that you want the sampleBankingServlet to handle. Again, you will register these configurations in the web.xml file.

<servlet-mapping>
<servlet-name> sampleBankingServlet<servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>

Load the configuration files

Next, load the configuration files. To do this, register the ContextLoaderListener for Servlet 2.3 specifications or ContextLoaderServlet for Servlet 2.2 containers and below. Use ContextLoaderServlet for backward compatibility. The ContextLoaderServlet will load the Spring configuration files when you start the Web application. Listing 3 registers the ContextLoaderServlet.

<servlet>
  <servlet-name>context>servlet-name>
  <servlet-class>
     org.springframework.web.context.ContextLoaderServlet
  </servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

The contextConfigLocation parameter defines the Spring configurations files to load, as shown in the servlet context below.

<context-param>
<param-value>contextConfigLocation</param-value>
<param-value>/WEB-INF/sampleBanking-services.xml</param-value>
</context-param>

The sampleBanking-services.xml file represents the configuration and bean configuration of services for the example banking application. If I wanted to load multiple Spring configuration files, I could use a comma as a delimiter in a <param-value> tag.

Back to top

A Spring MVC example

The example banking application allows users to view account information based on a unique ID and password. Although Spring MVC offers other options, I'll use JSP technology for my view pages. This simple application will consist of one view page for user input (ID and password) and a second page to display the user's account information.

I start with a LoginBankController that extends Spring MVC's SimpleFormController. SimpleFormContoller provides the functionality to display the form upon receiving an HTTP GET request and process the same form data upon receiving an HTTP POST. LoginBankController uses AuthenticationService and AccountServices services for authentication and carrying out account activities. Listing 5 in "Configure view properties" describes how to wire AuthenticationService and AccountServices to LoginBankController. Listing 4 shows the code for the LoginBankController.

Configure view properties

Next, I must register the page that displays on receipt of the HTTP GET request. I register the page in the Spring configuration using the formView property, as Listing 5 shows. The sucessView property represents the page which displays after form data is posted and logic is successfully executed in the doSubmitAction() method. Both the formView and sucessView properties represent the logical name of the view defined, which maps to the actual view page.

  
   <bean id="loginBankController"
         class="springexample.controller.LoginBankController">
      <property name="sessionForm"><value>true</value></property>
   <property name="commandName"><value>loginCommand</value></property>
   <property name="commandClass">
      <value>springexample.commands.LoginCommand</value>
   </property>

      <property name="authenticationService">
         <ref bean="authenticationService" />
      </property>
      <property name="accountServices">
         <ref bean="accountServices" />
      </property>
      <property name="formView">
         <value>login</value>
      </property>
      <property name="successView">
         <value>accountdetail</value>
      </property>

   </bean>

The commandClass and commandName tags determine the bean that will be active in the view page. For example, the loginCommand bean will be accessible through login.jsp, which is the application's login page. Once the user submits the login page, the application can retrieve the form data from the command object in the onSubmit() method of the LoginBankController.

The view resolver

Spring MVC's view resolver resolves each logical name to an actual resource, that is a JSP file that contains account information. I use Spring's InternalResourceViewResolver, as shown in Listing 6.

The user's login name resolves to the resource /jsp/login.jsp and the viewClass becomes JstlView, since I've used JSTL tags in my JSP pages.

Authentication and account services

As previously noted, the LoginBankController has Spring's AccountServices and AuthenticationService wired into it. The AuthenticationService class handles authentication for the banking application. The AccountServices class handles typical banking services such as viewing transactions and wire transfers. Listing 7 shows the configuration for the banking application's authentication and account services.

<beans>

   <bean id="accountServices" 
      class="springexample.services.AccountServices">

   </bean>

   <bean id="authenticationService" 
      class="springexample.services.AuthenticationService">

   </bean>

</beans>

You register the above services in the sampleBanking-services.xml, which is then loaded in a web.xml file, as previously discussed. With the controller and services configured, this simple application is complete. Now let's see what happens when I deploy and test it!

Back to top

Deploy the application

I deploy the example application in a Tomcat servlet container. Tomcat is the servlet container that is used in the official reference implementation for the Java Servlet and Java ServerPages technologies. If you've not already done so, download jakarta-tomcat-5.0.28.exe and run it to install Tomcat to any location you'd like -- c:\tomcat5.0, for instance.

Next, download the example code and extract it to a drive, say c:\. Once you create the Spring project folder, open it and copy the spring-banking subfolder into c:\tomvat5.0\webapps. The spring-banking folder is a Web archive that contains the Spring MVC example application. The lib folder contains the Spring framework, Spring-related MVC libraries, and JSTL tag libraries and jar files required by the application.

To start the Tomcat server, issue the following command:

cd bin C:\Tomcat 5.0\bin> catalina.bat start

Tomcat should start up and deploy the Spring MVC example application.

Back to top

Test the application

To test the application, open your Web browser and point to http://localhost:tomcatport/springbanking and replace tomcatport with the port where you run your Tomcat server. You should see the login screen shown in Figure 1. Type in the user ID of "admin" and the password of "password" and press the Login button. Any other user ID or password will result in an error from the authorization service.

Once you successfully log in, you'll see the account detail page shown in Figure 2.

Back to top

In conclusion

In this third article in the Spring series, I introduced you to the features of the Spring MVC framework. I showed you how to configure and develop a Spring MVC application, how to configure and inject dependencies into Spring MVC controllers, and how to develop application views using JavaServer Pages technology, as well as how to integrate your pages with the Spring MVC view layer. To conclude the article, I showed you how to deploy the application in a Tomcat servlet container and test it in your browser.

Stay tuned for the next article in the Spring series, in which I'll show you how to integrate JMS-based applications with the Spring framework. In the meantime, see Resources to learn more about the Spring framework and Spring MVC.

Back to top

Download

Information about download methods

Resources

Learn

• "The Spring series, Part 1: Introduction to the Spring framework" (developerWorks, June 2005) and "The Spring series, Part 2: When Hibernate meets Spring" (developerWorks, August 2005): Introduce how to build lightweight, robust J2EE apps with Spring technology and how to integrate Hibernate transactions with Spring aspect-oriented programming (AOP) for a reliable persistence framework.
  
  
• "AOP tools comparison, Part 1" (Mik Kersten, developerWorks, February 2005): Compare Spring AOP to other AOP frameworks.
  
  
• "The emergence of Spring" (Bruce Tate, developerWorks, June 2005): Demonstrates Spring's significance as a lightweight container.
  
  
• "Ruby on Rails and J2EE: Is there room for both?" (Aaron Rustad, developerWorks, July 2005): Compares a lesser-known alternative to J2EE frameworks like EJB and Spring.
  
  
• The Web Architecture zone: Find hundreds of articles covering Web-based solutions.
  
  

Get products and technologies

• Spring homepage: Download the Spring framework.
  
  
• Ant homepage: Download Apache Ant.
  
  

Discuss

• Participate in the discussion forum.
  
  
• developerWorks blogs: Get involved in the developerWorks community.
  
  

About the author

Comments (Undergoing maintenance)

Back to top

Trademarks  |  My developerWorks terms and conditions

Table of contents

• The Spring MVC framework
• Configure Spring MVC
• A Spring MVC example
• Deploy the application
• Test the application
• In conclusion
• Download
• Resources
• About the author
• Comments

Next steps from IBM

Rational Application Developer features provide the comprehensive Integrated Development Environment (IDE) used to develop J2EE applications requiring Servlets and JavaServer Pages (JSPs).

---

• Try: Try the free Rational Application Developer, which helps developers quickly design, develop, test, analyze, and deploy high-quality Java, Javaserver pages, and J2EE applications.
• Article: Learn how you can deliver accurate, higher-quality J2EE apps with Rational Application Developer, open source JUnit and JUnitEE test frameworks.
• Tutorial: Build a Facebook application using PHP, the Spring framework, and J2EE.
• Buy: Rational Application Developer

My developerWorks community

Dig deeper into Web development on developerWorks

Rate a product. Write a review.

Write a review for Rational products today!

Special offers