Spring MVC 4.0: Consuming RESTFul Web Services using RestTemplate

This article is a continuation of my previous article on Spring MVC 4.0 RESTFul web services. So far I have written two articles on how to create restful web service using Spring MVC 4.0. Last tutorial explained how to create a RESTFul web service in spring that would return user information from mysql table in JSON format. Let us now implement a Spring MVC application that issues web service requests and fetches the response returned by the web service.

Articles on Spring MVC RESTFul Web Services

• CRUD using Spring Data Rest and AngularJS using Spring Boot
• CRUD using Spring MVC 4.0 RESTful Web Services and AngularJS
• Spring MVC 4.0 RESTFul Web Services Simple Example
• Spring MVC 4.0 RESTFul Web Service JSON Response with @ResponseBody
• Spring MVC 4.0: Consuming RESTFul Web Services using RestTemplate

In this tutorial, we will extend our previous example to include a class that fetches user data from the spring service we had already created and display it in a jsp page (view). Spring MVC is a complete framework with lot of inbuilt features that facilitates easy and quick web development, including a template class - 'RestTemplate' for consuming web services.

I assume that you have gone through my previous article and have created a web service as explained. I am not going to repeat anything here. Let me start from where I left in my previous tutorial. You can download the sample application provided in my previous tutorial and start from there. Make sure to create mysql table and change connection string configuration in the downloaded application.

RestTemplate

Spring MVC provides a template class called RestTemplate to support client side access to REST web service. This class has methods to support the six HTTP methods listed below,

HTTP	RESTTEMPLATE
DELETE	delete(String, String...)
GET	getForObject(String, Class, String...)
HEAD	headForHeaders(String, String...)
OPTIONS	optionsForAllow(String, String...)
POST	postForLocation(String, Object, String...)
PUT	put(String, Object, String...)

Table Source : https://spring.io/blog/2009/03/27/rest-in-spring-3-resttemplate

The above link has an excellent article explaining the usage of RestTemplate for client side access.

Enough of theory, now let us proceed with the sample application.

1. Download the application we created in previous article from here. Take a look at the article and create mysql table accordingly.

2. Import the downloaded project in eclipse and alter connection string configuration in 'config.properties' file to match your mysql configuration.

3. The idea is to issue request to the web service methods present in 'SpringServiceController' class and display the response in views (jsp's). In order to do this, we need to add a viewresolver to spring configuration file.

Add 'InternalResourceViewResolver' to 'rest-servlet.xml' file present in Webcontent/WEB-INF folder,

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">    
<context:component-scan 
    base-package=
            "com.programmingfree.springservice.controller" /> 

<mvc:annotation-driven /> 
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
 <property name="viewClass"  value="org.springframework.web.servlet.view.JstlView" />  <property name="prefix" value="/WEB-INF/jsp/" /> 
 <property name="suffix" value=".jsp" /> 
 </bean> 
</beans>


Configuration code to be added to existing code is highlighted above. The view-resolver will look for jsp files as the 'suffix' property contains '.jsp' in it and in the path 'WEB-INF/jsp/' as the prefix propery is set as such.

2. Let us add a controller class which uses RestTemplate to query the web service we had already created. Create a new class called 'ListUsersController.java' under 'com.programmingfree.springservice.controller' and copy the below code in it.

package com.programmingfree.springservice.controller;

import java.util.LinkedHashMap;
import java.util.List;

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

import com.programmingfree.springservice.domain.User;

@Controller
public class ListUsersController {
 
  @RequestMapping("/listUsers")
     public ModelAndView listUsers() { 
    RestTemplate restTemplate = new RestTemplate();
   String url="http://localhost:8080/SpringServiceJsonSample/service/user/";    List<LinkedHashMap> users=restTemplate.getForObject(url, List.class);
         return new ModelAndView("listUsers", "users", users);
     }
  
  @RequestMapping("/dispUser/{userid}")
     public ModelAndView dispUser(@PathVariable("userid") int userid) { 
    RestTemplate restTemplate = new RestTemplate();
   String url="http://localhost:8080/SpringServiceJsonSample/service/user/{userid}";
   User user=restTemplate.getForObject(url, User.class,userid);
         return new ModelAndView("dispUser", "user", user);
     }

}

In the previous example, the url 'http://localhost:8080/SpringServiceJsonSample/service/user/' returned list of all users in json format. This controller contains two methods, one to list all users in a table and the other to list a single user information. Each method uses different jsp pages - 'listUsers.jsp & dispUser.jsp' to display data retreived from web service. RestTemplate automatically converts the json response to Java model class, in this case 'User' class for us.

3. Create two jsp files under "WEB-INF/jsp/" folder and copy the code given below. Make sure to use the same name as given below for the jsp files as we have used these names already in the controller class.

listUsers.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>List of Users</title>
</head>
<body>
<table border="1" align="center" style="width:50%">
        <thead>
            <tr>
                <th>User Id</th>
                <th>First Name</th>
                <th>Last Name</th>
                <th>Email</th>
            </tr>
        </thead>
        <tbody>
            <c:forEach var="users" items="${users}" >
                <tr>
                    <td>${users.userid}</td>
                    <td>${users.firstName}</td>
                    <td>${users.lastName}</td>                   
                    <td>${users.email}</td>                   
                </tr>
            </c:forEach> 
        </tbody>
    </table> 
</body>
</html>

I have used JSTL(Java Standard Tag Libraries) to loop through the list of user objects here. 

dispUser.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>User Details</title>
</head>
<body> 
<table border="1" align="center" style="width:50%">
        <thead>
            <tr>
                <th>User Id</th>
                <th>First Name</th>
                <th>Last Name</th>
                <th>Email</th>
            </tr>
        </thead>
        <tbody>
                <tr>
                    <td>${user.userid}</td>
                    <td>${user.firstName}</td>
                    <td>${user.lastName}</td>                   
                    <td>${user.email}</td>                   
                </tr>
        </tbody>
    </table> 
</body>
</html>

This is how the project structure will look after creating all necessary classes and files,

4. Finally, add the below servlet mapping to web.xml file. This is to avoid 'no mapping found error' for jsp pages, caused by the '/*' mapping we have given for dispatcher servlet.

<servlet>
    <servlet-name>jsp</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
</servlet>
  <servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>/WEB-INF/jsp/*</url-pattern>
 </servlet-mapping>

That is all. Now run the application in Tomcat server and hit this url, 'http://localhost:8080/SpringServiceJsonSample/listUsers'. This request will be routed to ListUsersController and the response will be displayed utilizing the corresponding view (listUser.jsp) such as this,

To display specific user information, hit 'http://localhost:8080/SpringServiceJsonSample/dispUser/2',

Keep yourself subscribed via email or social networking sites to get notified whenever a new article is published. Thanks for reading!

Subscribe to GET LATEST ARTICLES!