Simplify Your Web App Development Using the Spring MVC Framework : Page 3

Struts is in fairly widespread use in the Java world, but the Spring MVC framework promises to provide a simpler alternative to Struts for separating presentation layer and business logic. Learn how to build a simple stock trading Web application using Spring's MVC framework.

by Javid Jamae

Oct 11, 2004

Page 3 of 5

The Portfolio Page
I first want to change the index.jsp page to redirect to my portfolio page by going through the PortfolioController. I'll also create a JSP called include.jsp that all of my JSP files can include in order to inherit a common set of properties and tag library definitions.


/index.jsp
<%@ include file="/WEB-INF/jsp/include.jsp" %>

<core:redirect url="/portfolio.htm"/>

/WEB-INF/jsp/include.jsp
<%@ page session="false"%>

Now I'll create a simple portfolio view and have my controller route to it just to make sure everything is working.


/WEB-INF/jsp/portfolio.jsp
<%@ include file="/WEB-INF/jsp/include.jsp" %>

<html>
<head><title>Portfolio Page</title></head>
<body>
Portfolio Page
</body>
</html>

Before writing the Controller, you should add a few jar files to your /WEB-INF/lib directory:

Jar	Description	Source
spring.jar	Main spring jar file	[spring-dist]/dist
log4j-1.2.8.jar	log4j logging package	[spring-dist]/lib/log4j
commons-logging.jar	Jakarta Commons logging package	[spring-dist]/lib/jakarta-commons
jstl.jar	Java standard tag library	[spring-dist]/lib/j2ee
standard.jar	Jakarta standard tag library	[spring-dist]/lib/jakarta-taglibs
taglibs-string.jar	Jakarta tag library used for String manipulation	http://jakarta.apache.org/taglibs/
commons-lang-2.0.jar	Jakarta Commons language API	http://jakarta.apache.org/commons
jfl.jar	Financial library used to get stock-quotes online	http://www.neuro-tech.net/archives/000032.html

Most of these jars are available in the Spring distribution. All of them are available with the downloadable code for this article.

Now create a class called PortfolioController:


/WEB-INF/src/com/devx/tradingapp/web/PortfolioController.java
package com.devx.tradingapp.web;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class PortfolioController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) {

        return new ModelAndView("/WEB-INF/jsp/portfolio.jsp");
    }

}

The Controller interface defines a single method signature:


public ModelAndView handleRequest(HttpServletRequest request, 
HttpServletResponse response) throws java.lang.Exception;


Figure 2. Back to the Portfolio: The index.jsp page should now redirect you to the Portfolio Page.

The object that is returned by the handleRequest method is of the type ModelAndView. As you probably guessed, the ModelAndView object represents the Model and View in the MVC pattern. ModelAndView has several contructors. The one we're using right now just takes a string that represents the view that we want to forward to. Because our portfolio.jsp page doesn't have any dynamic content (yet), we don't need to return a model object.

Compile the PortfolioController and make sure the compiled file is under the WEB-INF/classes directory structure (i.e. /WEB-INF/classes/com/devx/tradingapp/web/PortfolioController.class). Now you can deploy your application and pull up the index.jsp page again. Go to http://localhost:8080/tradingapp/index.jsp and you should see what is shown in Figure 2.

Now I'll make it a little easier to specify views from within the Controller objects. The goal is to avoid having to type out the full path to a JSP inside of my Controller code. I can achieve this through use of a ViewResolver that I'll define in my tradingapp-servlet.xml file. The ViewResolver appends a prefix and suffix to the view that the Controller returns.


/WEB-INF/tradingapp-servlet.xml
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"><value>org.springframework.web.servlet.view.JstlView</value></property>
        <property name="prefix"><value>/WEB-INF/jsp/</value></property>
        <property name="suffix"><value>.jsp</value></property>
    </bean>

Now I can simplify my PortfolioController:


/WEB-INF/src/com/devx/tradingapp/web/PortfolioController.java 
package com.devx.tradingapp.web;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class PortfolioController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) {

        return new ModelAndView("portfolio");
    }

}

Just to make sure that the Portfolio Page still loads after this change, reload the page in your Web browser (you may have to reload the application context or restart your application server if your application server does not support hot-deploy functionality).

Now I want to make the portfolio page more interesting! First, I'll add some custom-tag library definitions to the include.jsp file. Using custom tags helps me keep my presentation logic separate from the presentation itself.


/WEB-INF/jsp/include.jsp
<%@ page session="false"%>

<%@ taglib prefix="core" uri="http://java.sun.com/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
<%@ taglib prefix="str" uri="http://jakarta.apache.org/taglibs/string-1.1" %>

Next, update your PortfolioController (see the code in Listing 1).

In the new version of the Controller, I've added a model. I use the three-argument constructor for ModelAndView that takes the view, the string name that the JSPs will use to refer to the model, and the model object itself. In Spring, a model is usually just a java.util.Map object. I put two elements on the model, a cash amount, and a list of portfolio line items. Each line item is of type PortfolioItemBean, a JavaBean that I created. This bean is primarily for View purposes and is created using data from the underlying business object called Portfolio. Listing 2 shows these classes.

You'll also notice that I'm using a class called QuoteFactory to obtain a Quote object using a stock symbol. These classes are part of the Neurotech Java Financial Library, a simple, open source API that can be used to retrieve stock quotes from the Web as well as other simple financial tasks.

Listing 3 shows the updated tradingapp-servlet.xml file and the portfolio.jsp file. If all goes well, when you deploy and reload the page you should see something very similar to Figure 3.


Figure 3. Improving the Portfolio: The portfolio view uses custom tags to display model data that is provided by the PortfolioController.

The cool thing is that the PortfolioController retrieves quotes from the Web using the Java Financial Library, so if you keep refreshing the page during trading hours, you'll get updated quotes.

In summary, here is the flow to this page:

The user goes to the portfolio.htm page.
He is routed to the dispatcher Servlet (because all .htm pages are directed to the dispatcher Servlet).
The DispatcherServlet loads the tradingapp-servlet.xml file and routes the user to the PortfolioController.
The PortfolioController creates the model and view and passes control back to the DispatcherServlet.
The DispatcherServlet makes the model data accessible via session or request parameters.
The DispatcherServlet routes to the JSP pages.
The JSP is rendered and the presentation is sent back to the user.

Download The Code for this Article

« Previous Page 1 234 5 Next Page »

0 Comments (click to add your comment)

Comment and Contribute