Home Java Programming Learn how to create a Spring MVC application

Learn how to create a Spring MVC application

Spring MVC application

Spring MVC application
In the current era of web application development, there are plenty of Model-View-Controller frameworks for Java. Most of these frameworks also integrate with Spring. However, the best of such integrations happen with Spring’s very own module for MVC. As far as development of enterprise applications is concerned, the Spring Framework is undoubtedly the best option for several businesses. The primary reason for this is the lightweight nature of Spring, something that outdoes the Java Enterprise Edition platform. It is also transparent. So, the use of Spring MVC for the development of Web applications can help you in reaping several benefits.

In this article, we will try to explore different aspects of Spring MVC framework along with some practical coding examples.

Spring MVC framework
As already mentioned, the Spring MVC framework is known to offer a model-view-controller architecture that is meant for the development of applications that are both flexible and loosely coupled. The MVC model separates the application into three major parts – input, business and UI.
Model – This is made up of the application data and the objects with which they react.
View – This visualises the model data and mostly made up of the HTML code that a browser can interpret.
Controller – The controller is meant for the processing of requests, following it up with the model build-up and then passing it to the view for display.
Spring MVC Architecture
Spring promises to be a one-stop solution for all your enterprise applications. Keeping in line with this, it offers about twenty modules that may be picked as per your requirements.

Core Container Layer

  • This module consists of some of the primary parts and has the IoC (Inversion of Control) and Dependency Injection features.
  • There is a Bean module that offers an implementation of the factory pattern.
  • The Context module is built atop the Core and Beans modules and is the means to access defined and configured objects.
  • The SpEL is another part that allows querying and manipulation of object graphs at runtime.

Data Access Layerc

  • The JDBC module offers an abstraction layer that helps in avoiding tedious coding.
  • ORM is meant to serve integration purposes for object-relational mapping APIs like Castor, XMLBeans, XStream, etc.
  • There is a Java Messaging Service module for the production and consumption of messages.
  • The Transaction module supports the management of programmable and declarative transaction classes.

Web Layer

  • The Web module is responsible for providing web-oriented features. These include the likes of initialization of IoC containers, multi-part file upload, etc.
  • The Web-MVC module has Spring’s model-view-controller for web applications.
  • The Web-Socket module offers two-way communication between the client and the server side, using WebSockets.
  • The Web-Portlet module is known to offer MVC implementation in a portlet environment and offers similar functionalities like the Web-Servlet module.

Miscellaneous Layers

  • There is an AOP module for implementing aspect-oriented programming. One can define pointcuts and method interceptors to decouple and separate functionalities.
  • The Aspects module is meant for integration with AspectJ. AspectJ is a powerful AOP framework.
  • The Instrumentation module is meant to offer support for class instrumentation and class loader instrumentations that are required in certain application servers.
  • The Messaging module offers support for STOMP. It also supports annotation programming model for the routing and processing of STOMP messages.
  • The Test unit is for testing out Spring with JUnit and TestNG frameworks.

Spring MVC features
There are two major features that are largely identified with Spring. One of them is the Dependency Injection flavour of Inversion of Control and the other is the Aspect Oriented Programming feature.
With the Dependency Injection feature, one can create application classes that are independent of other classes. When writing applications in Java, it is a necessity to have classes that are as independent as possible. This promotes independent testing and the reuse of classes during the unit testing phase of development. Dependency Injection (DI) helps in keeping these classes glued together in a way but also independent of each other.

One very important feature of Spring is its Aspect Oriented Programming framework. In any application, there are various functions that can be found in multiple points of an application. They are known as cross-cutting concerns. These are separate from the application’s business logic and such examples are logging, security, declarative transactions, etc. Aspect is the key unit of modularity in AOP. AOP simply helps in decoupling these cross-cutting concerns from the affected objects.

Lastly, Spring happens to be arranged in a modular fashion. Even though there are plenty of classes and packages, one can pick the ones that are only required for their work.

Environment setup
Setting up the Spring environment involves just four major steps.

  • Setting up Java Development Kit

One needs to download JDK from the Oracle site and then, install and configure them. Then set the PATH and JAVA_HOME environment variables.

  • Installing of Apache Common Logging API

The Apache Commons Logging API can be downloaded from this link http://commons.apache.org/proper/commons-logging/download_logging.cgi.
After downloading, it is important to unpack the binary distribution to a convenient location. Also, make sure that you set the CLASSPATH variable.

  • Setting of Eclipse IDE

Eclipse can be downloaded from the official website. Once downloaded, unpack the binaries and then set the PATH as well.

  • Setting up Spring libraries

The Spring libraries may be obtained from http://repo.spring.io/release/org/springframework/spring/. Again, it is important to set the CLASSPATH correctly.

Once you have finished these four steps, you are good to go.

Let’s build the sample application
Now let us try some coding examples to check how different components of Spring MVC application works. In this sample application we will have the following components.

Controller class: This is the controller class of a spring MVC application. It controls all the application flows.
Listing 1: Controller class

package com.dashboardapp.controller;
 * @author Kaushik Pal
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.dashboardapp.domain.KoiVoice;
import com.dashboardapp.services.DashBoardService;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.reflect.TypeToken;

public class DashBoardPageController {

 DashBoardService dashboardservice;

 public ModelAndView getKoiVoiceList() {
  List<KoiVoice> koivalueList1 = dashboardservice.getKoiVoiceList();
  JsonArray koivalueList = null;
 //This is for JSON conversion
	 System.out.println("Inside JSON ********");
	 Gson gson = new Gson();
	 JsonElement element = gson.toJsonTree(koivalueList1, new TypeToken<List<KoiVoice>>() {}.getType());
	 koivalueList = element.getAsJsonArray();
	 System.out.println("Json array :"+ koivalueList);
	 System.out.println("end JSON ********");
 catch(Exception e)
	 System.out.println("exception *************** :"+e); 
return new ModelAndView("koivalueList", "koivalueList", koivalueList);


Service class: This class is responsible to get the relevant data from the DAO layer for various needs. Here we are retrieving some specific values only.
Listing 2: Service implementation class

package com.dashboardapp.services;
 * @author Kaushik Pal
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.dashboardapp.dao.KoiVoiceDao;
import com.dashboardapp.domain.KoiVoice;
public class DashBoardServiceImpl implements DashBoardService {
 KoiVoiceDao koivoicedao;
 public List<KoiVoice> getKoiVoiceList() { 
  return koivoicedao.getKoiValueList();

Domain class: This are basically classes having getter and setter methods for various domain objects.
Listing3: Domain class

package com.dashboardapp.domain;
 * @author Kaushik Pal
public class KoiVoice {
 private String service;
 private String category;
 private String region;
 private String kqivalue;
	public String getService() {
		return service;
	public void setService(String service) {
		this.service = service;
	public String getCategory() {
		return category;
	public void setCategory(String category) {
		this.category = category;
	public String getRegion() {
		return region;
	public void setRegion(String region) {
		this.region = region;
	public String getKqivalue() {
		return kqivalue;
	public void setKqivalue(String kqivalue) {
		this.kqivalue = kqivalue;


Dao class: This is the data access layer to interact with the data base. Here we have used some predefined data to make the sample program easy to understand.
Listing 4: DAO class

package com.dashboardapp.dao;
 * @author Kaushik Pal

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import com.dashboardapp.domain.KoiVoice;
import com.dashboard.jdbc.DBRowMapper;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.Properties;

public class KoiVoiceDaoImpl implements KoiVoiceDao {

// DataSource dataSource;

 public List<KoiVoice> getKoiValueList() {
  List koivalueList = new ArrayList();
  KoiVoice koivoice = new KoiVoice(); 
  koivoice.setService("Mobile Voice");

  return koivalueList;


Spring configuration xml: This is the spring configuration file for identifying different components of the application and their mapping.
Listing 5: Spring-servlet.xml file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

 <!-- telling container to take care of annotations stuff -->
 <context:annotation-config />

 <!-- declaring base package -->
 <context:component-scan base-package="com.dashboardapp,com.dashboard,com.dashboardapp.controller" />
 <!-- adding view resolver to show jsp's on browser -->
 <bean id="viewResolver"
  <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
  <property name="prefix" value="/WEB-INF/jsp/" />
  <property name="suffix" value=".jsp" />

 <!-- declare beans - More beans will be added here -->
 <bean id="koiVoiceDao" class="com.dashboardapp.dao.KoiVoiceDaoImpl" />
 <bean id="dashboardservice" class="com.dashboardapp.services.DashBoardServiceImpl" />

 <!-- declare datasource bean - This is sample code by using mysql database -->


Spring configuration file
Image1: Spring configuration file

Web configuration xml: This is the web configuration file.
Listing 6: web.xml file

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 id="WebApp_ID" version="2.5">


Web Xml file
Image2: Web.xml file
Now, run the application and you will get the following output on the console.
Showing output
Image3: Showing output on the console
Spring MVC is a highly powerful framework that can be used for developing web applications based on the model-view-controller model. Although there are other MVC frameworks available in the market, Spring MVC is the most popular one and widely used. This tutorial gives a fair idea about the framework and its code implementation. Hope it will help developers gain expertise and work confidently with the Spring MVC framework.



Please enter your comment!
Please enter your name here

Become An Insider!

Discover latest news, tech updates, fresh 
arrivals, sale announcements and exciting offers!
I'm In!
Hurry up! Offer valid till stocks last.