Creating Hello World Application using Spring MVC on Eclipse IDE

In this tutorial we will go into some detail on how to set up your Eclipse IDE environment so that you can develop Spring MVC projects. In this post, we will create our first Spring MVC project with the all to familiar “Hello World” sample program. However, it will teach you some valuable concepts and provide some insight into setting up your MVC project.

Getting Started

In order to run this tutorial yourself, you will need the following:

Java JDK 1.5 or greater
Eclipse IDE, Spring Tool Suite (STS), NetBeans or other popular IDE
Tomcat 7 or greater or other popular container (Weblogic, Websphere, Glassfish, JBoss, etc)
Spring 3.0.1 or greater Web MVC jar files

Required JAR Files

commons-logging-1.2.jar
jstl-1.2.jar
org.springframework.asm-3.0.1.RELEASE-A.jar
org.springframework.beans-3.0.1.RELEASE-A.jar
org.springframework.context-3.0.1.RELEASE-A.jar
org.springframework.core-3.0.1.RELEASE-A.jar
org.springframework.expression-3.0.1.RELEASE-A.jar
org.springframework.web-3.0.1.RELEASE-A.jar
org.springframework.web.servlet-3.0.1.RELEASE-A.jar

Create Dynamic Web Project in Eclipse

Now that you have downloaded all dependencies, we can go ahead and create our Dynamic Web Project in Eclipse.

Open Eclipse and click on File -> New -> Dynamic Web Project or use the shortcut Alt + Shift + N.

Once you get the New Dynamic Web Project Dialog, choose the project name, in my case I chose SpringMVCExamples but you can use any name you prefer. Make sure you select the appropriate Target Runtime. In my case, I chose “Apache Tomcat version 7.0”.

Once you create the Dynamic Web Project, your Eclipse Project Explorer will look like:

Copy JAR Files

You will need to copy all dependency libraries to the WebContent -> WEB-INF -> lib folder. Your folder should look like:

Configure DispatcherServlet (web.xml)

Spring MVC framework is built around a main servlet DispatcherServlet, also called Front Controller, that handles request from clients and dispatches to back end components like handler mapping, controller, view resolver and views and sends responses back to clients. This servlet must be defined in the deployment descriptor (web.xml). You will notice that there are servlet tags to define the dispatcher servlet. In this example, the dispatcher servlet will be mapped to any pattern from the root of the directory onwards.

<?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" 
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
     id="WebApp_ID" version="3.0">
  
  <display-name>SpringMVCExamples</display-name>
  
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  
</web-app>

Configure Spring Web DispatcherServlet (dispatcher-servlet.xml)

The name of the file will be based on the web.xml entry for servlet-mapping, so in my case since I called the servlet-name dispatcher, the config file will be called dispatcher-servlet.xml.

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

 <context:component-scan base-package="com.avaldes.controller" />

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

</beans>

The Spring Controller

As mentioned in previous tutorial, the DispatcherServlet will take client requests and consult the appropriate handlermapping and then dispatches the request to the appropriate controllers to handle the request. The following class shows you a typical setup for a controller. You will notice, that we have added two annotations already defined in the HelloController class. The @Controller annotation indicates that this particular class is playing the role of a controller. The @RequestMapping annotation tells Spring that the this method will process requests beginning with /hello in the URL path. You will also notice, that I have added method=RequestMethod.GET parameter. This parameter states that it will only handle requests using HTTP GET. The default is GET, so I could have left this out and the end result would have been the same. The method parameter can also accept method=RequestMethod.POST method but I will be explaining that in a subsequent tutorial.

In our controller method helloWorld(), you will notice that we have added an Object called message, with the String of “Hello World from Spring MVC 3.0 !!!”. The method returns a ModelAndView object which gets resolved to a view called HelloWorld.jsp and the model is returned as well to be used when rendering the view by the JSP using the embedded JSTL tag(s).

Controller Class (HelloController.java)

package com.avaldes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloController {

  @RequestMapping(value="/hello", method=RequestMethod.GET)
  public ModelAndView helloWorld() {
    ModelAndView model = new ModelAndView("HelloWorld");
    model.addObject("message", "Hello World from Spring MVC 3.0 !!!");

    return model;
  }    
}

Spring JSP Views

Spring MVC supports many types of views for the presentation layer. These include many template based technologies including JSPs, Velocity, FreeMarker, or ThymeLeaf. However, the most commonly used technology for Spring MVC View is JSP templates embedded with JSTL.

View file (HelloWorld.jsp)

<html>
<head>
  <title>Spring MVC Examples</title>
</head>
<body>
    <h1>Creating Hello World Application using Spring MVC on Eclipse IDE</h1>
    
    <h2>${message}</h2>
</body>
</html>

Complete Project Overview

I have added the project overview to give you a full view of the structure and show you all files contained in this sample project.

Hello World Output

Download the Code

That’s It!

I hope you enjoyed this tutorial. It was certainly a lot of fun putting it together and testing it out. Please continue to share the love and like us so that we can continue bringing you quality tutorials. Happy Coding!!!