Simple Login Application Using Spring MVC and Hibernate – Part 1

 I hope developers working in web application development might hear about MVC architecture. Almost all technologies provide support for MVC based web application development, but the success is based on many factors like reusable of the code, maintenance of the code, future adaption of the code, etc..,

 The success of the Spring MVC is “Open for extension and closed for modification” principle. Using Spring MVC the developers can easily develop MVC based web application. We don’t need any steep learning curve at the same time we need to know the basics of spring framework and MVC architecture. The Spring MVC consists of following important components.

1. Dispatcher servlet
2. Controller
3. View Resolver
4. Model

Spring MVC - Overview

 The overall architecture of Spring MVC is shown here.

 1. When “Dispatcher Servlet” gets any request from client, it finds the corresponding mapped controller for the request and just dispatches the request to the corresponding controller. The requests and corresponding controller information are loaded into the context when application starts based on xml configuration or Meta data. We have many way for loading this information, we will discuss at this one at later point of time.

 2. We know, the controllers are used for connecting business and service layer. The controller get inputs from request, process the inputs, finally it returns the view and model information.

 3. The view resolver gets those information, find the corresponding view, it updates the view with model data and finally it send the response back to the “Dispatcher Servlet”.

 4. Finally the “Dispatcher Servlet” sends this response back to the client.

 Ok, let’s start developing our application. I have created the dynamic web project using STS and included all necessary jar files into class path of the application.

Step 1: Defining Dispatcher Servlet into web.xml file.

 Here “DispatcherServlet” class is configured with name as “dispatcher” and the url pattern as “*.spring”.

Step 2: Creating login.html page.

 Here I have created the html form with action as “Login.spring”. If user submits the page, the request is send to Login controller. Let’s create a login controller for handling the request.

Step 3: Creating Login Controller.

 @Controller annotation is very important because when context loads, the spring will find all controller class using this annotation and it's maps to the corresponding view (URL).

 @RequestMapping annotation is used for specifying action of the request.

 So now the dispatcher servlet gets any request from “Login.spring” that automatically redirects the request to “LoginController”.

 @RequestParam annotation is used for getting value from request parameters. It’s equivalent to request.getParameter() method in servlet.

  In my login controller, the processCredentials method just gets the username, password details from parameters and check whether both are equal. If it’s equal, it just returns the object of “ModelAndView” class with next redirecting page as a parameter.

 Hey In my login form, I have given action as “Login.spring” only. How that action automatically trigger my processCredentials method?

 Red indicated “results” is indicates redirecting page, this is resolved by “View resolver”, and another one is request attribute key and value pair. Now we need to configure our view resolver.

Step 4: Configuring view resolver.

 For configuring view resolver, we need to create one more xml file into inside the WEB-INF folder. The name of the xml file is very important, it’s is based on our dispatcher servlet name configured in web.xml file. The name should be “dispatcher servlet name-servlet.xml”. In our case, the “dispatcher” is our servlet name, so the name of the file is “dispatcher-servlet.xml”.

 Spring have lot of view resolver classes, for example ResourceBundleViewResolver, InternalResourceViewResolver, XsltViewResaolver, etc.., but by default spring use InternalResourceViewResolver class.

 In this XML file I have configured InternalResoureViewResolver class properties. Here I have given prefix value as “/” and suffix value as “.jsp”. In this situation, the view resolver get the view name from ModelAndView object (“results”) and append the prefix and suffix value (/results.jsp). So in our login controller we have verified user name, password values and redirected our request to results.jsp page. So we need to create results.jsp page.

 Before going to create results.jsp, I have to explain about the purpose of context:component-scan tag. This tag automatically scans all the controller class presents in base-package and registered into context. In other words, it’s just looks what are all the classes have @Controller annotation and map the controller into corresponding view. This information is maintained in context of the application.

 Ok let’s create a results.jsp page.

Step 5: Creating result.jsp file.

 This is my result.jsp page; here I have just get the message value from request attributes and displayed the message.

Step 5: Creating applicationContext.xml file.

 Spring MVC application needs applicationContext.xml file. Using this file we can configure our web related beans. As of now we don’t use any beans, so this file don’t have any bean definition.

 Ok. Let’s deploy our application into web server and will check the result.

 As of now, we didn’t integrate hibernate. In my next part, I will explain the stpes for integrating Hibernate ORM framework into our application. The part1 application source code is uploaded into my GitHub repository for your reference.

For integrating into hibernate, refer the below link.

http://www.pointerunits.com/2012/11/simple-login-application-using-spring_12.html