Spring Web

Spring WEB and Spring WEB MVC
—----------------------------------------------
The main purpose of Spring Web Module is to integrate some MVC based
framework applications to Spring Applications.
EX: Struts applications with Spring
EX: JSF applications with Spring
—---
—---
It is an outdated content in Spring Framework.
Spring WEB MVC:

The main purpose of the Spring WEB MVC is to prepare web applications with
MVC design patterns.
Spring WEB MVC is an alternative to the web Frameworks like Struts, JSF,....
Q)To prepare web applications, we already have Struts, JSF MVC based
frameworks then what is the requirement to use Spring WEB MVC ?
—----------------------------------------------------------------------
Ans:
—----
1. Struts, JSF are web frameworks, which are used to prepare and
execute only web applications.
Spring Framework is an application Framework, it can be used to

prepare all the types of applications like
a. Standalone Applications
b. Web Applications
c. Distributed Applications
d. Database Related Applications
—----
—---
2. In the enterprise Application Development, Struts and JSF are able

to
have a main focus on the presentation layer.
Spring is able to have a very good focus on all the layers of the
enterprise Applications like Presentation layer[WEB Module, WEB MVC
Module], Business Layer[Core Module, AOP, Module, J2EE Module],
Persistence Layer[JDBC Module, ORM Module, Transactions Module].
3. Struts and JSF are not layered or moduled Frameworks.
Spring Framework is a layered / Moduled Framework.
4. Struts and JSF Frameworks are Heavyweight Frameworks, to prepare

simple web applications like to display a simple welcome message the
entire struts and JSF frameworks must be loaded with or without the
requirement.
Spring Framework is lightweight, because, In the case of Spring

Framework, if we prepare a simple application , only the required
module libraries must be loaded, not required to load the complete
Spring Framework.
5. Struts and JSF are more API dependent, because Struts and JSF are
using Action classes to prepare application logic, they require a more
predefined library.
Spring Framework is less API dependent, because Spring Framework is

able to use POJO classes to define application logic.
6. In case of Struts and JSF Debugging and Testing are very much
difficult as they are more API dependent.
In the case of Spring Framework, Debugging and Testing are very simple
as it is less API dependent.
7. Struts and JSF are using only MVC and its co-related design
patterns.
Spring WEB MVC module is only using MVC and its co-related design
patterns, remaining modules of Spring Framework are using other design
patterns like IOC or Dependency Injection, Factory Design Pattern,
Singleton Design pattern,....
Spring Web MVC Features:
—------------------------
1. Spring WEB MVC contains a number of components like Controller, Validator,
Command object Form object,Model Object, DispatcherServlet, Handler Mapping,
View Resolver,........ to prepare web applications. Where each and every
component has their own responsibilities.
2. Spring Web MVC allows a Powerful and Straightforward configuration of both

Framework and the application classes as Java beans . This configuration is
able to make us navigate from one module to another module easily.
3. Spring WEB MVC has the Command and Form objects to reuse the business code
instead of extending the Framework provided API libraries.
4. Spring WEB MVC has very good data binding , data Validations,....
Services.
5. Spring WEB MVC is providing very good View Resolvers, Handler mapping
,.... in a customizable way in order to simplify the application development.
6. Spring WEB MVC is providing very good Theme resolutions, Locale,... in a

Custamizable way.
7. Spring WEB MVC allows all JSP and JSTL tag libraries along with its own
tag library.
Spring WEB MVC Components:

—-------------------------
To prepare Spring Web MVC applications we have to use the following
components.
1. View
2. web.xml
3. DispatcherServlet
4. HandlerMapping
5. Controller Component
6. Command Class
7. ViewResolver
8. Spring Configuration File
1. Client Send a request to the Server.
2. Server will Identify the FrontController Servlet through a web.xml
file.
3. Server will forward the request to the DispatcherServlet.
4. DispatcherServlet will goto the Configuration file to get the name and
location of the HandlerMapping component.
5. DispatcherServlet will goto HandlerMapping to get the name and location
of the Controller class.
6. DispatcherServlet will go to the Controller component and execute
business logic.
7. After executing the Business logic , COntroller component will return
ModelAndView object.
8. DispatcherServlet will go to the Spring COnfiguration file to know the
name and location of the ViewResolver.
9. DispatcherServlet will goto the ViewResolver to identify the name and
location of the View page.
10. DispatcherServlet will forward the request to the View page.
11. View Page will be executed and generate the dynamic response to the
respective client.
View or User Interface:

—-----------------------
1. It will improve the look and feel of enterprise applications.
2. It will provide an entry point to enterprise applications.
3. It is able to provide a very good environment to take data from the
users and to submit that data to the enterprise application.
4. To submit different request types like GET, POST, HEAD,.... We need a
user interface or view.
5. To perform data validations by using java script functions we have to
use the View part.
IN general, in enterprise applications, we will use technologies like Html,

CSS, Bootstrap, Java script,.....
To prepare User interface in spring web mvc applications Spring framework has
provided its own set of tag libraries.
There are two types of User Interface or View.

1. Informational User Interface
2. Form Based User Interface
Informational User Interface:

It is able to provide some information to the client like results of the
server side actions like Login Success, Login Failure, …. Table data from
the database.
Form Based User Interface:

It includes forms to collect data from the users and to submit that data to
the server side application.
Web.xml or Deployment Descriptor:

—---------------------------------
Web.xml file is a deployment description, it will provide some data or
description about the web application which are required by the container
inorder to identify the server side resources and in order to execute the
server side resources.
In general, in web applications, web.xml file is responsible for the

following configurations.
1. Welcome Files configurations

2. Display Names configurations
3. Servlets configurations
4. Filters configurations
5. Listeners configurations
6. InitiALization Parameters configurations
7. Context Parameters configurations
8. Security configurations
9. User defined Tag libraries configurations
—----
—----
In Spring Web mvc applications, the main responsibility of the web.xml file
is to provide the DispatcherServlet configurations like below.
a. DispatcherServlet class configuration:

1. Logical Name COnfiguration
2. DispatcherServlet class configuration
3. Initialization Parameters Configuration
4. Load on startup configuration
b. URL Mapping Definitions:

1. Servlet Name Configuration
1. URL Pattern
web.xml
—--------
<web-app>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
Where the <servlet-name> tag will take the logical name of the
DispatcherServlet, with this name only we have to save the spring
configuration file.
Where <servlet-class> tag is able to provide the fully qualified name of the
DispatcherServlet class.
Where <load-on-startup> will take the load on startup value, it will make
ready DispatcherServlet at the time of Server startup, that is, At Server
startup DispatcherServlet loading, Instantiation and initialization will be
performed.
Where <url-pattern> tag is able to define the url pattern for the
DispatcherServlet.
IN general, in web applications there are three ways to define url patterns
for the Servlets.
1. Exact Match Method

2. Directory Match Method
3. Extension Match Method
In general, in MVC based web applications we will define URL Patterns for the
Controller Servlets by using either Directory Match Method or Extension Match
Method.
In Spring WEB MVC applications , if we want to use Directory Match method to

define URL pattern for the DispatcherServlet then we have to use “/*” as an
url pattern in order to get all requests to DispatcherServlet.
<web-app>
<servlet>
<servlet-class>
</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
In Spring WEB MVC applications , if we want to use Extension Match method to

define URL pattern for the DispatcherServlet then we have to use “*.do” as an
url pattern in order to get all requests to DispatcherServlet..
<web-app>
<servlet>
<servlet-class>
</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
DispatcherServlet:
—-----------------
The main responsibilities of the Front Controller in Spring WEB MVC is,
1. Getting a request from the client.
2. Identify the Business component or Model component that include
business logic.
3. Execute the Business logic which we have provided in the Business
component or in the mOdel component.
4. Identify the view component to generate dynamic response.
5. Forward request to the View Component.
In Spring WEB MVC applications, DispatcherServlet is acting as a front

controller, here Spring Framework has provided the DispatcherServlet in the
following structure.
Where HttpServletBean is able to inject beans properties using the Servlet

init param values received from the web.xml file.
Where the FrameworkServlet integrates the servlet functionality with the web
application context.
When we start the Server , Server or Container will perform the following
actions.
1. Server will deploy the application.
2. At the time of application deployment, Container will recognize the
web.xml file and it will perform loading, parsing and reading the
content of the web.xml file.
3. Container will create a ServletContext object with the content of the
web.xml file.
When Container parsing web.xml file, Container will perform the following
actions.
1. Container will recognize the load-on-startup configuration in
DispatcherServlet configuration.
2. Container will perform DispatcherServlet Loading, Instantiation and
initialization.
When Container performs DispatcherServlet Initialization, DispatcherServlet
will perform the following actions.
1. DispactherServlet will recognize the WebApplicationContext container
class.
2. DispatcherServlet will load WebApplicationContext class, instantiate
and initialize.
When DispatcherServlet performs WebApplicationContext Initialization,

WebApplicationContext will perform the following actions.
1. WebApplicationContext will recognize the Spring Configuration file with

the name “DSLogicalName-servlet.xml”.
2. WebApplicationContext will load , parse and read the data from the
Spring COnfiguration File into Config object.
3. After creating the Configuration object, WebApplicationContext will

create all bean objects which we declared in the spring configuration
file.
4. After Creating all Bean objects, WebApplicationContext will create all
Framework objects like HandlerMapping, HandlerAdapter, ViewResolver,
LocalResolver,....
When we submit a request from the client browser then Protocol will perform
the following actions.
1. Protocol will establish connection between client and Server on the
basis of the Server port number, Server IP address.
2. Protocol will create a RequestFormat with the Header part and Body
Part, where Header part is able to manage all the request headers and
Body Part is able to manage all request parameters.
3. Protocol will carry that request format to the Server.
When a Request is coming to the Server , Server will check whether it is the
request for any static resource or not, if it is not for static resources and
if the request is for dynamic resource then the Server will forward the
request to the Container, where the Container will perform the following
actions.
1. Container will take the request data like the URL pattern from Request
Format.
2. Container will search for Servlet COnfiguration with the client
submitted url Pattern, where COntainer will identify DispatcherServlet
as a Servlet for the URL pattern.
3. Container will execute doGet() or doPost() or,... methods depending on
the request type in DispatcherServlet.
When a request is coming to the DispatcherServlet , DispatcherServlet will
perform the following actions.
1. DispatcherServlet will keep all the Frameworks objects like

HandlerMapping, HandlerAdapter, ViewResolver,.... In the Request Scope
in order to make available these objects to the COntroller class and
View part.
2. DispatcherServlet will interact with the HandlerMapping for getting
Handler/Controller class details by calling getHandler() method.
3. When DispatcherServlet accesses the getHandler() method on the
HandlerMapping object, HandlerMapping will identify the respective
Handler class and its associated Interceptors list in the spring
configuration file.
4. HandlerMapping object will arrange all the interceptors and
HandlerMapping will create HandlerExecutionCghain object with the
Handler class and interceptors list.
5. HandlerMapping will return HandlerExecutionChain to the
DispatcherServlet.
Note: Interoceptors are like Filters in Servlets, they will perform

Pre-Processing and Post-Processing services for any web resources.
6. DispatcherServlet will get Handler class object reference from

HandlerExecutionChain, DispatcherServlet will access Handler method
which has the business logic.
7. When DispatcherServlet access handler class method, HandlerAdapter will
take that method call and HandlerADapter will execute all the
interceptors in forward direction in order to perform pre-processing
activities before Handler execution, here to access interceptors
HandlerAdapter executes preHandle() method internally.
8. After executing all the interceptors, HandlerAdapter will access
Handler Method and it executes the business logic.
9. After executing the Handler class business method, Handler class return
ModelAndView object to the HandlerAdapter by executing all the
INterceptors in Backward direction, here to execute all the
interceptors in the backward direction HandlerAdapter access
postHandle() method.
10. HandlerAdapter receives ModelAndView object from Handler class and
It will return that ModelAndView object to DispatcherServlet.
11. When DispatcherServlet receives a ModelAndView object from
HandlerAdapter, DispatcherServlet will take the view name and interact
with the ViewResolver.
12. ViewResolver will identify the view JSP page name on the basis of
the View name and ViewResolver will send the View JSP page and its url
to the DispatcherServlet.
13. When a View JSP page name is received from the ViewResolver ,
DispatcherServlet will forward a request to the View JSP page, it will
be executed and the generated response will be sent to the
DispatcherServlet through all the interceptors in the backward
direction.
14. When a response is received to the DispatcherServlet,
DispatcherServlet will send a response to the Container.
When the Container receives a response from the DispatcherServlet, Container

will send a response to the MainServer, where Main Server will send a
response to the Protocol.
When Protocol receives a response from Main Server then it will perform the
following actions.
1. Protocol will create ResponseFormat containing both Header part and

Body part, where Header part is able to manage all the response headers
and Body part is able to manage the actual response.
2. Protocol will carry response to the Client browser.
3. Protocol will terminate the connection between client and Sre3ver.
4. Container will perform DispatcherServlet Instantiation, where
DispatcherServlet will destroy all the Framework objects and it will
unload the complete Framework.
HandlerMapping:
—--------------
The main purpose of the Handler Mapping is to map the input requests to the
Handler class that can handle the request.
When we submit request to the Spring WEB MVC application , DispatcherServlet

will take the request kand DispatcherServlet will forward request to the
HandlerMapping , Where HandlerMapping will identify the Handler class and its
associated interceptors on the basis of the URL Pattern which we submitted
from CLient and HandlerMapping will create HandlerExecutionChain with the
interceptors list and with the Handler class and Submitted that generated
HandlerExecutionChain to the DispatcherServlet.
Spring Web MVC Framework has provided the following list of HandlerMapping
classes.
1. BeanNameUrlHandlerMapping
2. SimpleUrlHandlerMapping
3. ControllerClassNameHandlerMapping
4. CommonsPathMapHandlerMapping
BeanNameUrlHandlerMapping:
—--------------------------
It is a default Handler Mapping in Spring WEB MVC applications, it will be
used by the Spring Framework automatically when no HandlerMapping is
configured in the Spring Configuration File.
This HandlerMapping maps urls to the Beans with the names which are started
with /.
When we submit request with an URL pattern, BeanNameUrlHandlerMapping will

take the URL pattern name from the request, it will match the url pattern
name with the Controller class Bean name attribute value in the Spring
Configuration file , if the url pattern name and the Controller class bean
name is matched then HandlerMapping will identify the Controller and executes
the handler method.
Spring Framework has provided the BeanNameUrlHandlerMapping in the form of a

predefined class like
“org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping”.
EX:
Ds-servlet.xml
<beans>
<bean name=”/welcome” class=”com.durgasoft.controillers.WelcomeController”/>
<bean name=”/hello” class=”com.durgasoft.controillers.HelloController”/>
<bean name=”/hi” class=”com.durgasoft.controillers.HiController”/>
<bean name=”handlermapping” class=”.....BeanNameUrlHandlerMapping”/>
</beans>
If we want to execute the above Controller classes then we have to use the
below urls at client browser.
http://localhost:8080/app/welcome
http://localhost:8080/app/hello
http://localhost:8080/app/hi
SimpleUrlHandlerMapping:
This Handler Mapping is able to map Handler class or Controller class by
matching the url path with the property key of the properties.
Spring Framework has provided this HandleMapping in the form of a predefined

class like “org.springframework.web.servlet.handler.SimpleUrlHandlerMapping”.
<beans>
<bean name=”addEmp” class=”com.durgasoft.controller.AddEmpController”/>
<bean name=”searchEmp”
class=”com.durgasoft.controller.SearchEmpController”/>
<bean name=”updateEmp”
class=”com.durgasoft.controller.UpdateEmpController”/>
<bean name=”handlerMapping”
class=”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping”>
<property name=”mappings”>
<props>
<prop name=”add”>addEmp</prop>
<prop name=”search”>searchEmp</prop>
<prop name=”delete”>deleteEmp</prop>
</props>
</property>
</bean>
</beans>
To access the above controller classes we have to use the following URLs at
client browser.
http://localhost:8080/app/add
add—->addEmp—-->AddEmpController
http://localhost:8080/app/search
search—->searchEmp—-> SearchEmpController
http://localhost:8080/app/update
update—->updateEmp—-> UpdateEmpController
ControllerClassNameHandlerMapping:
—---------------------------------
This Handler mapping follows simple conventions for generating URL Path
Mappings from the class names of the Controller beans which are configured in
the Spring Configuration file or the annotated beans with the @Controller
annotation.
For Simple Controller Implementations the convention is to take the short

name of the class , remove the Controller suffix if it exists and return the
remaining text, lower case as the mapping with a leading /.
To represent this Handler Mapping Spring framework has provided a predefined

class in the form of
“org.springframework.web.servlet.mvc.support.COntrollerClassNameHandlerMappin
g”.
EX:
<beans>
<bean name=”welcome” class=”com.dss.controller.WelcomeController”/>
<bean name=”hello” class=”com.dss.controller.HelloController”/>
class=”org.springframework.web.servlet.mvc.support.ControllerClassNameHandler
Mapping”/>
</beans>
To access the above WelcomeController and HelloController we have to use the

following urls.
http://localhost:1010/app/welcome*
It is able to access WelcomeController .
http://localhost:1010/app/hello*
It is able to access HelloController
CommonsPathMapHandlerMapping:
This Handler Mapping is designed to recognize common metadata attributes of
type PathMap defined in the application controller and automatically
associated with the DispatcherServlet web application Context.
@PathMap(“/mycontroller”)
public class MyController implements Controller{
—-----
}
To access the above controller we have to use the following url.
http://localhost:8080/app/mycontroller
Controller Component:
—---------------------
The main purpose of the controller component is to manage the application
logic which we want to execute upon receiving requests from clients.
Where the Controller logic is to manage the Service layer methods access ,
where the Service layer is able to access Dao layer methods in order to
perform the operations.
To prepare Controller classes Spring Framework has provided the following

predefined classes.
In Spring Web MVC, all the Controller classes are the implementation classes
to the org.springframework.web.servlet.mvc.Controller interface.
The above Controller interface has provided the following method to manage
application logic.
public ModelAndView handleRequest(HttpServletRequest request,

HttpServletResponse response)throws Exception
EX:
public class LoginController implements Controller{
public ModelAndView handlerequest(HttpServletRequest hreq,
HttpServletResponse hres)throws Exception{
—---
return new ModelAndView(“success”);
}
}
Here the ModelAndView is an object , it contains Model data in the Model

object and View logical name in the form of View Object, Controller class
will return ModelAndView object to the DispatcherServlet, where
DispatcherServlet will take View Logical name and DispatcherServlet will
contact with ViewResolver to identify the view jsp page.
To create ModelAndView objects , ModelAndView class has provided the

following constructors.
public ModelAndView()
public ModelAndView(String viewName)
public ModelAndView(String viewName, Map model)
public ModelAndView(String viewName, HttpStatus status)
—--
—--
Command :
—---------
The main purpose of COmmand component is to manage form data at server side
applications.
EX:
public class User{
private String uname;
private String upwd;
setXxx() and getXxx()
}
ViewResolver:
—-------------
The main purpose of ViewResolver is to provide mapping between the view name
and the actual view JSP page name and location.
Spring Framework has provided the following list of VieweResolvers.
1. ViewResolver
2. ContentNegotiatingViewResolver
3. BeanNameViewResolver
4. UrlBasedViewResolver
5. InternalResourceViewResolver
6. FreeMarkerViewResolver
7. VelocityViewResolver
—---
—----
In Spring Web MVC applications, we will use mainly

InternalResourceViewResolver or BeanNameViewResolver or
UrlBasedVieweResolver.
In Spring WEB MVC applications we must configure ViewResolver with the name
“viewResolver” inorder to map the view name and the name and location of the
View Page.
EX:
<beans>
—----
<bean name=”viewResolver” class=”…InternalResourceViewResolver”>
<property name=”suffix” value=”/WEB-INF”>
<property name=”prefix” value=”.jsp”/>
</bean>
</beans>
Spring Configuration File:
—-------------------------
The main purpose of the Spring COnfiguration file is to provide all the
configuration details of the bean components, Controller classes, Handler
Mapping classes, ViewResolver,....
The name of the Spring Configuration file is

ServletLogicalName-servlet.xml
ds-servlet.xml
<beans>
<bean name=”/welcome” class=”....WelcomeController”/>
<bean name=”/hello” class=”.....HelloController”/>
<bean name=”handlerMapping” class=”....BeanNameUrlHandlerMapping”/>
<bean name=”viewResolver” class=”....InternalResourceViewResolver”>
<property name=”prefix” value=”/WEB-INF”/>
<property name=”suffix” value=”.jsp”/>
</bean>
</beans>
Steps to prepare First Web Application by using Spring WEB MVC:
—--------------------------------------------------------------
1. Java Software,Tomcat Server,IDE
2. Create a Dynamic Web Project with MAVEN.
3. Prepare User Forms as per the requirement.
4. Prepare Controller classes, Services classes, DAOs as per the
requirement.
5. Create COnfiguration File
6. Edit web.xml file with DispatcherServlet Configuration
EX:
EX:
wish.jsp
<%@page isELIgnored="false" %>
<html>
<head>
<title>Insert title here</title>
</head>
<body>
<h1>
${message}
</h1>
</body>
</html>
WishController.java
package com.durgasoft.controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
public class WishController implements Controller {
@Override
HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new
ModelAndView("wish","message","Hello User, Good Morning!");
return modelAndView;
}
ds-servlet.xml
<?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"
xmlns:context="http://www.springframework.org/schema/context"
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">
<bean name="/wish"
class="com.durgasoft.controller.WishController"/>
<bean name="handlerMapping"
class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMappi
ng"/>
<bean name="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolv
er">
<property name="prefix" value="/WEB-INF/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
web.xml
<!DOCTYPE web-app PUBLIC

"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>First Spring WEB MVC Application</display-name>
<servlet>
<servlet-name>ds</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</serv
let-class>
</servlet>
<servlet-mapping>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.durgasoft</groupId>
<artifactId>app01</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>app01 Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<maven.compiler.source>1.17</maven.compiler.source>
<maven.compiler.target>1.17</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>

<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>app01</finalName>
</build>
</project>
EX:
index.jsp
<html>
<body>
<h2>
<a href="http://localhost:1111/app02/hello">Hello</a> <br><br>
<a href="http://localhost:1111/app02/welcome">Welcome</a>
</h2>
</body>
</html>
hello.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" isELIgnored="false" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
</head>
<body>
<h1>
${message}
</h1>
</body>
</html>
welcome.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" isELIgnored="false" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
</head>
<body>
<h1>
${message}
</h1>
</body>
</html>
HelloController.java
package com.durgasoft.app02.controllers;
public class HelloController implements Controller {
@Override
return new ModelAndView("hello", "message", "Hello User,

Good Morning!....");
}
}
WelcomeController.java
package com.durgasoft.app02.controllers;
public class WelcomeController implements Controller {
@Override
return new ModelAndView("welcome", "message", "Welcome User, Good

Morning!.....");
}
}
ds-servlet.xml
<bean name="/hello"
class="com.durgasoft.app02.controllers.HelloController"/>
<bean name="/welcome"
class="com.durgasoft.app02.controllers.WelcomeController"/>
class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMappi
ng"/>
class="org.springframework.web.servlet.view.InternalResourceViewResolv
er">
<property name="prefix" value="/WEB-INF/"/>
</bean>
</beans>
web.xml
<!DOCTYPE web-app PUBLIC

"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</serv
let-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<version>0.0.1-SNAPSHOT</version>
<properties>
</properties>
<dependencies>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
</build>
</project>
EX:
index.jsp
<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"
%>
<!DOCTYPE html>
<html>
<head>
<title>JSP - Hello World</title>
</head>
<body>
<jsp:forward page="hellopage"/>
</body>
</html>
helloform.jsp
<%--
Created by IntelliJ IDEA.
User: Nagoor
Date: 22-06-2023
Time: 07:31
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form method="post" action="./hello">
<table align="center">
<tr>
<td>User Name</td>
<td><input type="text" name="uname"></td>
</tr>
<tr>
<td><input type="submit" value="SayHello"></td>
</tr>
</table>
</form>
</body>
</html>
hello.jsp
<%--
User: Nagoor
Date: 22-06-2023
Time: 07:34
--%>
<html>
<head>
</head>
<body>
<h1 align="center">
Hello ${name}!.
</h1>
</body>
</html>
HelloPageController.java
package com.durgasoft.app03.controller;
public class HelloPageController implements Controller {
@Override
return new ModelAndView("helloform");
}
}
HelloController.java
public class HelloController implements Controller {

@Override
return new ModelAndView("hello", "name",
request.getParameter("uname"));
}
}
ds-servlet.xml
<bean name="/hellopage"
class="com.durgasoft.app03.controller.HelloPageController"/>
<bean name="/hello"
class="com.durgasoft.app03.controller.HelloController"/>
<bean name="handlermapping"
class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapp
ing"/>
class="org.springframework.web.servlet.view.InternalResourceViewResol
ver">
<property name="prefix" value="/"/>
</bean>
</beans>
web.xml
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
version="5.0">
<servlet>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</ser
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<version>1.0-SNAPSHOT</version>
<name>app03</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.target>17</maven.compiler.target>
<maven.compiler.source>17</maven.compiler.source>
<junit.version>5.9.2</junit.version>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
</plugin> </plugins>
</build>
</project>
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="loginform"/>
</body>
</html>
loginform.jsp
<%--
User: Nagoor
Date: 23-06-2023
Time: 07:22
--%>
<html>
<head>
<title>Login Form</title>
</head>
<body>
<form method="post" action="./login">
<tr>
<td>User Name</td>
</tr>
<tr>
<td>Password</td>
<td><input type="password" name="upwd"></td>
</tr>
<tr>
<td><input type="submit" value="Login"></td>
</tr>
</table>
</form>
</body>
</html>
success.jsp
<%--
User: Nagoor
Date: 23-06-2023
Time: 07:26
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java"
isELIgnored="false" %>
<html>
<head>
<title>SUCCESS PAGE</title>
</head>
<body>
<h1 align="center">
Hello ${name} , Your Login Success
</h1>
</body>
</html>
failure.jsp
<%--
User: Nagoor
Date: 23-06-2023
Time: 07:27
--%>
<html>
<head>
<title>Failure Page</title>
</head>
<body>
<h1 align="center">
Hello ${name}, Your Login Failure.
</h1>
</body>
</html>
LoginFormController.java
package com.durgasoft.app04.controlleres;
public class LoginFormController implements Controller {
@Override
return new ModelAndView("loginform");
}
}
LoginController.java
package com.durgasoft.app04.controlleres;
public class LoginController implements Controller {
@Override
String uname = request.getParameter("uname");
String upwd = request.getParameter("upwd");
String status = "";
if(uname.equals("durga") && upwd.equals("durga")){
status = "success";
}else{
status = "failure";
}
return new ModelAndView(status, "name", uname);
}
}
ds-servlet.xml
<bean name="/loginform"
class="com.durgasoft.app04.controlleres.LoginFormController"/>
<bean name="/login"
class="com.durgasoft.app04.controlleres.LoginController"/>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app04</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
Controller Classes:
—------------------
The main purpose of the controller classes is to manage the application logic
to execute upon receiving requests from the client.
To prepare Controller classes we have to use some predefined library

provided by the Spring Framework in org.springframework.web.servlet.mvc.
AbstractController:
—------------------
This controller class will be used to prepare the Controller class in the
Spring web mvc applications where no form data is submitted and where to
display the dynamic content by clicking on the hyperlinks.
EX: When we click on the “View Profiles” link or “Contectus” link,... we will
get the required data on the client browser.
AbstractController has provided the following method to include application

logic.
public ModelAndView handleRequestInternal(HttpServletRequest request,

HttpServletResponse response)throws Exception
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="wish"/>
</body>
</html>
wish.jsp
<%--
User: Nagoor
Date: 24-06-2023
Time: 08:09
--%>
<html>
<head>
</head>
<body>
<h1 align="center" style="color: red;">
${message}
</h1>
</body>
</html>
WishController.java
import org.springframework.web.servlet.mvc.AbstractController;
import java.time.LocalTime;
public class WishController extends AbstractController {
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest
request, HttpServletResponse response) throws Exception {
LocalTime localTime = LocalTime.now();
int hour = localTime.getHour();
String message = "Hello User, ";
if(hour < 12){
message = message + "Good Morning!";
}else if(hour < 17){
message = message + "Good Afternoon!";
}else{
message = message + "Good Evening!";
}
return new ModelAndView("wish", "message", message);
}
}
ds-servlet.xml
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean name="/wish"
class="com.durgasoft.app05.controller.WishController"/>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app05</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
There are three types of AbstractController classes.

1. ParameterizableViewController
2. MultiActionController
3. BaseCommandController
ParameterizableViewController:
—-----------------------------
Spring Framework has provided this controller in the form of
org.springframework.web.servlet.mvc.ParameterizableViewController
The main purpose of this controller class is to display web pages without
processing requests.
In the case of ParameterizableViewController it is not required to define any

user defined controller classes, just we have to configure
ParameterizableViewController in the configuration file.
This Controller class configuration must take an input property with the name
“viewName” and it will take the logical name of the view.
In general, we will use it to get web pages by clicking on hyperlinks.
EX: Getting contact Page by clicking on Contact Us, getting about us page by
clicking on “About Us” links,...
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="home"></jsp:forward>
</body>
</html>
home.jsp
<%--
User: Nagoor
Date: 27-06-2023
Time: 07:29
--%>
<html>
<head>
</head>
<body>
<h1 style="color: red;" align="center">
Durga Software Solutions
</h1>
<h3 align="center">
<a href="contactUs">Contact US</a>
<a href="aboutUs">About US</a>
</h3>
</body>
</html>
contactUs.jsp
<%--
User: Nagoor
Date: 27-06-2023
Time: 07:34
--%>
<html>
<head>
<title>COntact Us</title>
</head>
<body>
ContactUS Page
</h1>
</body>
</html>
aboutUs.jsp
<%--
User: Nagoor
Date: 27-06-2023
Time: 07:35
--%>
<html>
<head>
<title>About Us</title>
</head>
<body>
AboutUs Page
</h1>
</body>
</html>
ds-servlet.jsp
<bean name="/home"
class="org.springframework.web.servlet.mvc.ParameterizableViewControl
ler">
<property name="viewName" value="home"/>
</bean>
<bean name="/contactUs"
ler">
<property name="viewName" value="contactUs"/>
</bean>
<bean name="/aboutUs"
ler">
<property name="viewName" value="aboutUs"/>
</bean>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app06</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
MultiActionController:
—---------------------
In general, in web applications we will prepare a number of forms to perform
different operations of an entity like StudentAddForm.jsp,
StudentSearchForm.jsp, StudentUpdateForm.jsp, StudentDeleteForm.jsp,....
In general, in the web applications we will take a separate COntroller class

for each and every form like below.
Studentaddform.jsp
SID:
SNAME:
SADDR:
ADD
public class StudentAddController implements Controller{

}
Studentsearchform.jsp
SID:
SEARCH
public class StudentSearchController implements Controller{

}
Studentupdateform.jsp
SID:
SNAME:
SADDR:
UDATE
public class StudentUpdateController implements Controller{

}
Studentdeleteform.jsp
SID:
DELETE
public class StudentDeleteController implements Controller{

}
The above approach will increase the number of Controller classes , it is not
suggestible in the web applications.
To overcome the above problem we need an alternative where we have to perform

all the operations of an entity.
EX: In a single StudentController class we have to perform multiple

operations like Student Add, Student Search, Student Update, Student
Delete,...
public class StudentController{

add(----){
}
search(----){
}
update(---){
}
delete(---){
}
}
To achieve the above requirement we have to use a MultiActionController .
The main intention of MultiActionController is to group the related actions

into a single controller class.
If we want to use the MultiActionController class in spring web mvc

applications then we have to use the following steps.
1. Declare an user defined class

2. Extend the MultiActionController class to the user defined class.
3. Define methods w.r.t the actions.
public ModelAndView methodName(HttpServletRequest req,
HttpServletResponse resp)throws Exception
EX:
public class StudentController extends MultiActionController{
public ModelAndView add(HttpServletRequest request, HttpServletResponse
response)throws Exception{
—----
}
public ModelAndView search(HttpServletRequest request,

HttpServletResponse response)throws Exception{
—----
}
public ModelAndView update(HttpServletRequest request,
—----
}
public ModelAndView delete(HttpServletRequest request,
—----
}
}
In the above context, if we submit requests with the URIs like add, search,
update, delete,... then all the requests must come to the StudentCOntroller
class only, for this we have to provide ‘/’ as name attribute value for
StudentController class configuration in Spring configuration file.
<beans>
—--
<bean name=”/*” class=”com.durgasoft.controller.StudentController”/>
—--
</beans>
http://localhost:1010/app/add —-----> StudentController

http://localhost:1010/app/search —-----> StudentController
http://localhost:1010/app/update —------> StudentController
http://localhost:1010/app/delete —------> StudentController
In the above context, in the Controller class MultiActionController will

execute an action method on the basis of the URI name which we provided along
with the URL.
http://localhost:1010/app/add —-----> add() in StudentController

http://localhost:1010/app/search —-----> search() in StudentController
http://localhost:1010/app/update —------> update() in StudentController
http://localhost:1010/app/delete —------> delete() in StudentController
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="home"/>
</body>
</html>
home.jsp
<%--
User: Nagoor
Date: 07-07-2023
Time: 22:45
--%>
<html>
<head>
<title>Home Page</title>
</head>
<body>
Student Management System
</h2>
<h3 align="center">
<a href="addpage">Student Add Form</a><br><br>
<a href="searchpage">Student Search Form</a><br><br>
<a href="updatepage">Student Update Form</a><br><br>
<a href="deletepage">Student Delete Form</a>
</h3>
</body>
</html>
addform.jsp
<%--
User: Nagoor
Date: 30-06-2023
Time: 08:46
--%>
<html>
<head>
<title>Student Add Form</title>
</head>
<body>
<h2 style="color: red;" align="center">Student Management System</h2>
<h3 style="color: blue;" align="center">Student Add Form</h3>
<form method="post" action="add">
<tr>
<td>Student Id</td>
<td><input type="text" name="sid"></td>
</tr>
<tr>
<td>Student Name</td>
<td><input type="text" name="sname"></td>
</tr>
<tr>
<td>Student Address</td>
<td><input type="text" name="saddr"></td>
</tr>
<tr>
<td><input type="submit" value="ADD"></td>
</tr>
</table>
</form>
</body>
</html>
searchform.jsp
<%--
User: Nagoor
Date: 08-07-2023
Time: 08:07
--%>
<html>
<head>
<title>Student Search Form</title>
</head>
<body>
<h3 style="color: blue;" align="center">Student Search Form</h3>
<form method="post" action="search">
<tr>
<td>Student Id</td>
</tr>
<tr>
<td><input type="submit" value="SEARCH"></td>
</tr>
</table>
</form>
</body>
</html>
updateform.jsp
<%--
User: Nagoor
Date: 08-07-2023
Time: 08:07
--%>
<html>
<head>
<title>Student Update Form</title>
</head>
<body>
<h3 style="color: blue;" align="center">Student Update Form</h3>
<form method="post" action="editform">
<tr>
<td>Student Id</td>
</tr>
<tr>
<td><input type="submit" value="GetEditForm"></td>
</tr>
</table>
</form>
</body>
</html>
editform.jsp
<%@ page import="com.durgasoft.app07.beans.Student" %><%--
User: Nagoor
Date: 08-07-2023
Time: 08:38
--%>
<%!
Student student = null;
%>
<%
student = (Student) request.getAttribute("student");
%>
<html>
<head>
<title>Student Edit Form</title>
</head>
<body>
<h3 style="color: blue;" align="center">Student Edit Form</h3>
<form method="post" action="update">
<tr>
<td>Student Id</td>
<td><%=student.getSid()%><input type="hidden" name="sid"
value='<%=student.getSid()%>'></td>
</tr>
<tr>
<td><input type="text" name="sname"
value='<%=student.getSname()%>'></td>
</tr>
<tr>
<td><input type="text" name="saddr"
value='<%=student.getSaddr()%>'></td>
</tr>
<tr>
<td><input type="submit" value="UPDATE"></td>
</tr>
</table>
</form>
</body>
</html>
deleteform.jsp
<%--
User: Nagoor
Date: 10-07-2023
Time: 07:30
--%>
<html>
<head>
<title>Student Delete Page</title>
</head>
<body>
<h3 style="color: blue;" align="center">Student Delete Form</h3>
<form method="post" action="delete">
<tr>
<td>Student Id</td>
</tr>
<tr>
<td><input type="submit" value="DELETE"></td>
</tr>
</table>
</form>
</body>
</html>
status.jsp
<%--
User: Nagoor
Date: 30-06-2023
Time: 08:50
--%>
<html>
<head>
<title>Status Page</title>
</head>
<body>
${message}
</h1>
</body>
</html>
Student.java
package com.durgasoft.app07.beans;
public class Student {

private String sid;
private String sname;
private String saddr;
public String getSid() {

return sid;
}
public void setSid(String sid) {

this.sid = sid;
}
public String getSname() {

return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSaddr() {

return saddr;
}
public void setSaddr(String saddr) {

this.saddr = saddr;
}
}
StudentDao.java
package com.durgasoft.app07.dao;
import com.durgasoft.app07.beans.Student;
public interface StudentDao {

public String add(Student student);
public Student search(String sid);
public String update(Student student);
public String delete(String sid);

}
StudentDaoImpl.java
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
public class StudentDaoImpl implements StudentDao{

private JdbcTemplate jdbcTemplate;
public JdbcTemplate getJdbcTemplate() {

return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public String add(Student student) {
int rowCount = jdbcTemplate.update("insert into student
values('"+student.getSid()+"','"+student.getSname()+"','"+student.get
Saddr()+"')");
String status = "";
if(rowCount == 1){
status = "success";
}else{
status = "failure";
}
return status;
}
@Override
public Student search(String sid) {
List<Student> stdList = jdbcTemplate.query("select * from student
where SID = '"+sid+"'", (rs, rowNum)->{
Student std = new Student();
std.setSid(rs.getString("SID"));
std.setSname(rs.getString("SNAME"));
std.setSaddr(rs.getString("SADDR"));
return std;
});
return stdList.isEmpty()?null:stdList.get(0);
}
@Override
public String update(Student student) {
int rowCount = jdbcTemplate.update("update student set SNAME =
'"+student.getSname()+"', SADDR = '"+student.getSaddr()+"' where SID
= '"+student.getSid()+"'");
String status = "";
if(rowCount == 1){
status = "success";
}else{
status = "failure";
}
return status;
}
@Override
public String delete(String sid) {
String status = "";
int rowCount = jdbcTemplate.update("delete from student where SID =
'"+sid+"'");
if(rowCount == 1){
status = "success";
}else{
status = "failure";
}
return status;
}
StudentService.java
package com.durgasoft.app07.service;
public interface StudentService {

public String addStudent(Student student);
public Student searchStudent(String sid);
public String updateStudent(Student student);
public String deleteStudent(String sid);

}
StudentServiceImpl.java
import com.durgasoft.app07.dao.StudentDao;
public class StudentServiceImpl implements StudentService{

private StudentDao studentDao;
public StudentDao getStudentDao() {

return studentDao;
}
public void setStudentDao(StudentDao studentDao) {

this.studentDao = studentDao;
}
@Override
public String addStudent(Student student) {
return studentDao.add(student);
}
@Override
public Student searchStudent(String sid) {
return studentDao.search(sid);
}
@Override
public String updateStudent(Student student) {
return studentDao.update(student);
}
@Override
public String deleteStudent(String sid) {
return studentDao.delete(sid);
}
}
StudentController.java
import com.durgasoft.app07.service.StudentService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import
org.springframework.web.servlet.mvc.multiaction.MultiActionController
;
public class StudentController extends MultiActionController {

private StudentService studentService;
public StudentService getStudentService() {
return studentService;
}
public void setStudentService(StudentService studentService) {

this.studentService = studentService;
}
public ModelAndView add(HttpServletRequest request,

String sid = request.getParameter("sid");
String sname = request.getParameter("sname");
String saddr = request.getParameter("saddr");
System.out.println(sid+","+sname+","+saddr);
Student student = new Student();
student.setSid(sid);
student.setSname(sname);
student.setSaddr(saddr);
String status = studentService.addStudent(student);
String message = "";
if(status.equalsIgnoreCase("success")){
message = "Student Added Successfully";
}else{
message = "Student Insertion Failure";
}
return new ModelAndView("status", "message", message);
}
public ModelAndView search(HttpServletRequest request,
Student student = studentService.searchStudent(sid);
if(student == null){
message = "Student Does Not Exist";
}else{
return new ModelAndView("display", "student", student);
}
}
public ModelAndView editform(HttpServletRequest request,
}else{
request.setAttribute("student", student);
return new ModelAndView("editform", "student", student);
}
}
public ModelAndView update(HttpServletRequest request,
String sname = request.getParameter("sname");
String saddr = request.getParameter("saddr");
Student student = new Student();
student.setSid(sid);
student.setSname(sname);
student.setSaddr(saddr);
String status = studentService.updateStudent(student);
message = "Student Updation Success";
}else{
message = "Student Updation Failure";
}
}
public ModelAndView delete(HttpServletRequest request,
}else{
String status = studentService.deleteStudent(sid);
message = "Student Deleted Successfully";
}else{
message = "Student Deletion Failure";
}
}
}
ds-servlet.xml
<bean name="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3300/durgadb"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<bean name="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean name="studentDao"
class="com.durgasoft.app07.dao.StudentDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
<bean name="studentService"
class="com.durgasoft.app07.service.StudentServiceImpl">
<property name="studentDao" ref="studentDao"/>
</bean>
<bean name="/*"
class="com.durgasoft.app07.controller.StudentController">
<property name="studentService" ref="studentService"/>
</bean>
<bean name="/home"
ler">
<property name="viewName" value="home"/>
</bean>
<bean name="/addpage"
ler">
<property name="viewName" value="addform"/>
</bean>
<bean name="/searchpage"
ler">
<property name="viewName" value="searchform"/>
</bean>
<bean name="/updatepage"
ler">
<property name="viewName" value="updateform"/>
</bean>
<bean name="/deletepage"
ler">
<property name="viewName" value="deleteform"/>
</bean>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app07</name>
<properties>
</properties>
<dependencies>
<dependency>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<dependency>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
Command Controllers:
—--------------------
Command class is a Java bean class, it will be instantiated by the Spring Web
MVC Framework and it is able to manage the data which is submitted by a
client from a particular form.
The main intention of storing User data in COmmand objects at Server side.
1. To make available user form data on the server side in order to use in
Business logic.
2. To transfer user form data from Controller layer to View Layer we have
to use Command object.
3. To perform Server side data validations before using data in the
business logic we have to use COmmand object.
To use command classes in the applications we have to use the following

guidelines.
1. COmmand Class should be a normal Java bean class.

2. It must be public , non abstract and non final.
3. It must have the properties with the names of the user form properties.
4. In Command class, we must provide a separate set of setXXX() and
getXXX() methods for each and every property.
5. In Command class, all properties must be declared as private and all
methods must be declared as public.
6. In Command class, if we want to provide a constructor then it must be a
public and 0-arg constructor.
7. It is suggestible to implement java.io.Serializable.
EX:
public class Student implements Serializable{
private String sid;
Private String snake;
Private String saddr;
setXXX() and getXXX()
}
In Spring WEB MVC applications, COntainer will create a separate COmmand
object for each and every request submitted by the User forms.
In Spring web MVC applications, if we want to use Command classes then we

have to use “COmmand COntroller classes.
Spring Framework has provided the following Command Controller classes.

1. BaseCommandController
2. AbstractCommandCOntroller
3. AbstractFormController
4. SimpleFormController
5. AbstractWizardFormController
BaseCommandController:
It is an abstract class provided by Spring Framework, it is a base class to
all Command controllers , it can be used to store all the form properties
data from request object to Command object.
It is a deprecated class, it does not exist from the Spring 4.x version.
AbstractCommandCOntroller:
—---------------------------
It is an abstract class provided by Spring Framework with the following
methods.
public ModelAndView handleRequestInternal(HttpServletRequest req,

HttpServletResponse resp)throws Exception
public ModelAndView handle(HttpServletRequest req, HttpServletResponse resp,

Object command, Exception e)throws Exception
When we submit a request with form data then this controller will create a
Command object with the form data and it passes the generated COmmand object
as parameter in the handle() method.
To prepare the Controller class we must define a user defined class , it must
be extended from AbstractController class and it must override the handle()
method.
If we want to use this Controller class in Spring applications then we must

configure this class in the spring configuration file with the following
properties.
1. commandName: logical name to the command class.
2. commandClass: Fully Qualified name of the command class.
EX:
<bean name=”/login” class=”copm.durgasoft.controllers.LoginController>
<property name=”commandName” value=”user”/>
<property name=”commandClass” value=”com.durgasoft.beans.User”/>
</bean>
Note: AbstractCommandController class existed up to Spring2.5 version, it was
removed from Spring 4.x version onwards.
AbstractFormController:
—-----------------------
It is able to populate form data from Request object to COmmand object and it
will pass the generated Command object to the handler method in the
controller class.
AstractFormController has the following two methods.
protected ModelAndView processFormSubmission(HttpServletRequest req,

HttpServletResponse resp, OBject command, BindException e)throws Exception
protected ModelAndView showForm(HttpServletRequest req, HttpServletResponse

resp, BindException e)throws Exception
The processFormSubmission() method will have the application logic which we

want to execute by getting a request from the form when we submit a post
request.
The shoeForm() method will be executed when we submit a GET request from the
client and it will prepare formName in order to generate a form at client
browser.
If we want to use this controller class then we have to configure the

Controller class with the following properties.
1. sessionForm : true
2. commandName: logical name
3. commandClass: Fully qualified Name of the Command class.
Note: It is a Deprecated class in Spring 3.x version and it has been removed
from the Spring 4.x version.
Spring MVC Tag Library:
—-----------------------
In general, to prepare the View part in MVC based applications we have to use
the view technologies like Html, CSS, Bootstrap, Java Script,.....
In Spring MVC Based web applications, to prepare the View part as per Spring
WEB MVC style , Spring WEB MVC has provided a separate set of tags called
Spring WEB MVC tags.
Spring WEB MVC has provided the tag library in the form of
spring-webmvc-version.jar file and to get Spring tag library support in the
JSP pages we have to use the following url to “uri” attribute in <%@taglib>
directive.
<%@taglib uri=”http://www.springframework.ord/tags/form” prefix=”form”%>
1. <form:form>
—-------------
It is the same as <form> tag in html, it will group up all the other html
components like Text Fields, Check boxes,....as a single unit inorder to
submit a request to the Server side application.
<form:form method=”---” action=”---” commandName=”--”>

—----
</form:form>
Where the “method” attribute will take an HTTP Method name like GET or
POST,...
Where “action” attribute will take an URI for the Controller action method.
Where “commandName” attribute will take the logical name of the command class
which we provided in the Command class configuration under controller class
configuration in Spring Configuration file.
EX:
<form:form method=”POST” action=”reg” commandName=”user”>
—--
</form:form>
public class User{

—--
}
<beans>
—--
<bean name=”reg” class=”com.durgasoft.controller.RegistrationController”>
<property name=”commandName” value=”user”/>
<property name=”commandClass” value=”com.durgasoft.beans.User”/>
</bean>
</beans>
2. <form:input>
—-----------------
This tag is the same as the html provided <input type=”--”> tag, it can be
used to prepare the components like Text Fields.
Syntax
—------
<form:input path=”--” size=”--” value=”--”/>
Where “path” attributes will take a property name of the COmmand Class
inorder to store value in the Command Object.
Where “size” attribute will provide text field size.
Where the “value” attribute will take the default value in the Text field.
EX:
<form:form ….. >
User Name <form:input path=”uname” size=”20”/>
</form:form>
public class User{

}
3. <form:password>
—------------------
It is the same as the password field in html, it will take password data from
the users.
<form:password path=”--” value=”--” showPassword=”--”/>
Where “path” attribute will take a property name in the Command class inorder
to store value.
Where the “value” attribute will take the default value for the password
field.
Where the “showPassword” field is able to take either true/false value to

display the password data.
<form:form …>
Password : <form:password path=”upwd” showPassword=”false”/>
</form:form>
public class User{

setXXX();
getXXX();
}
<form:checkbox>
—-----------------
It will provide a check box in the user form to select an item.
<form:checkbox path=”--” value=“--”/>
Where “path” attribute will take a property name in command class in order to
store its value.
Where “value” attributes will take a default value.
EX:
<form:form ….>
Graduate <form:checkbox path=”status” value=”Graduate”/>
</form:form>
public class User{

private String graduateStatus;
setXXX()
getXXX()
}
<form:checkboxes>
—----------------
It will provide a group of checkboxes to select items.
Syntax:
<form:checkboxes path=”--” items=”--”/>
Where the “path” attribute will take a property name from the command class
it must be of String[] type.
Where items attribute will provide an expression including a property from
the COmmand class providing checkbox labels and values or a property data
which is generated by overriding referenceData() method in Controller class.
<form:form … >
User Qualifications <form:checkboxes path=”uqual” items=”{qual_List}”/>
</form>
public class RegistrationController extends SImpleFormController{

Protected Map referenceData(HttpServletRequest request)throws Exception{
Map<String, Object> map = new HashMap<String, Object>();
List<String> uqual_List = new ArrayList();
uqual_List.add(“BSC”);
uqual_List.add(“BTECH”);
uqual_List.add(“MCA”);
uqual_List.add(“MTECH”);
uqual_List.add(“PHD”);
map.put(“qual_List”, uqual_List);
}
public ModelAndView onSubmit(Object command)throws Exception{
—---
}
}
public class User{

private String[] uqual;
setXXX();
getXXX();
}
<form:radioButton>
—-----------------
It is able to select a single item.
<form:radioButton path=”--” value=”--”/>
Where “path” is able to take a property of the COmmand class.

Where value is able to take a value inorder to send to the Server side
application.
<form:radioButton path=”gender” value=”Male”/>

<form:radioButton path=”gender” value=”Female”/>
public class User{

private String gender;
}
<form:radioButtons>
—------------------
It is able to create more than one radio button.
<form:radiobuttons path=”--” items=”--”/>
Where “path” attribute is able to take a property name of the command class
inorder to store selected value.
Where “items” is able to take the property name of the list or String []
which contains names of the radio buttons generated from referenceData()
method in the controller class.
<form:radioButtons path=”worklocations” items=”{uworkLocations}”/>
public class UserController extends SimpleFormController{

protected Map<String, Object> referenceData(HttpServletRequest
request)throws Exception{
Map<String, Object> map = new HashMap<String, Object>();
List<String> workLocations = new ArrayList<String>();
workLocations.add(“Hyderabad”);
workLocations.add(“Chennai”);
workLocations.add(“Mumbai”);
map.put(“uworkLocation”, workLocations);
return map;
}
}
<form:select>
—------------
It is able to provide a select box to display multiple items in order to
select single or multiple items.
<form:select path=”--” multiple=”--” items=”--”/>
Where the “path” attribute will take a property name from the command class,
in order to store the selected value / values.
Where “multiple” attribute will make the select box for single selection or
multiple selections.
Where the “items” attribute is able to take an expression containing a

variable name representing String[] or List of items generated from
referenceData() method from the controller class.
If we don't want to get the data from the controller class then we have to
use the following tag multiple times under <form:select> tag.
<form:options items=”--” itemValue=”--” itemLabel=”--”/>
Where items attribute is able to take an expression to get the values from
the referenceData() method of the controller class.
Where “itemValue” is able to take a single value.

Where “itemLabel” is able to take a single label for the item.
<form:select path=”uskillSet” multiple=”multiple”>

<form:option value=”C”>C</form:option>
<form:option value=”C++”>C++</form:option>
<form:option value=”JAVA”>Java</form:option>
<form:option value=”Python”>Python</form:option>
</form>
public class User{

private String[] skillSet;
}
Or
<form:select path=”uskillSet” items=”${skillSet}” multiple=”multiple”/>

protected Map referenceData(HttpServletRequest request)throws Exception{
Map<String, Object> map = new HashMap<>();
List<String> list = new Arraylist<>();
list.add(“C”);
list.add(“C++”);
list.add(“JAVA”);
map.put(“skillSet”,list);
Return map;
}
}
EX:
<form:select path=”uprofession” multiple=”single”>
<form:options items=”${uprofession}”/>
</form:select>
In Command Class:
public class User{
Private String uprofession;
setXXX(), getXXX()
}
In Controller class:
protected Map referenceData(HttpServletRequest request)throws Exception{
List<String> list = new Arraylist<>();
list.add(“Student”);
list.add(“Employee”);
list.add(“Former”);
map.put(“uprofession”,list);
return map;
}
}
<form:textarea>
—-------------------
It is able to provide a text area to take multiple lines of data from Users.
Syntax:
<form:textarea path=”---”/>
Where the “path” attribute is able to take a property name in the command
class.
EX:
<form:textarea path=”uaddr”/>
In Command class:
public class User{
Private String uaddr;
setXXX(), getXXX()
}
<form:hidden>:
—---------------
It is able to prepare hidden fields in User form, it is not visible but it is
able to hold data.
<form:hidden path=”--” value=”--”/>
Where the “path” attribute is able to take a property name in the command
class.
Where the “value” attribute is able to take a value to store in the command
class.
EX:
<form:hidden path=”sid” value=-”S-111”/>
In command class:
Public class Student{
private String sid;
setXXX(), getXXX()
}
SimpleFormController:
—--------------------
This controller class is able to support command classes in order to store
user form data in Command objects.
It was introduced in Spring2.5 version, but it was deprecated in Spring 3.x

version and it was removed from Spring 4.x version.
It is the best option for data validations.
If we want to use SimpleFormController class in Spring web mvc applications

then we have to declare an user defined class, and it must be extended from
SimpleFormController and we must implement either of the following methods.
Protected ModelAndView onSubmit(Object command)throws Exception
Protected ModelAndView onSubmit(HttpServletRequest request,

HttpServletResponse response, Object command)throws Exception
If we want to use this controller class in a Spring web mvc application then
we must configure it in the Spring Configuration file with the following
properties.
formView: It will take the form name to get the User form.
commandName: It will take a logical name to the command class.
commandClass: It will take the fully qualified name of the command class.
sessionForm: To keep COmmand objects in Session scope in order to reuse
command objects.
EX:
—---
index.jsp
<html>
<body>
<jsp:forward page="reg"/>
</body>
</html>
registratioinform.jsp
<%@taglib uri="http://www.springframework.org/tags/form"
prefix="form"%>
<html>
<head>
</head>
<body>
<h2 style="color: red;" align="center">Durga Software Solutions</h2>
<h3 style="color: blue;" align="center">User Registration Form</h3>
<form:form method="post" action="reg" commandName="user">
<tr>
<td>User Name</td>
<td><form:input path="uname" size="20"/></td>
</tr>
<tr>
<td>User Password</td>
<td><form:password path="upwd" size="20"/></td>
</tr>
<tr>
<td>R U Married?</td>
<td><form:checkbox path="maritalStatus1"/></td>
</tr>
<tr>
<td>R U Single?</td>
<td><form:checkbox path="maritalStatus2" value="Single"/></td>
</tr>
<tr>
<td>User Qualifications</td>
<td><form:checkboxes path="uqual" items="${uqualList}"/></td>
</tr>
<tr>
<td>User Work Location</td>
<td><form:radiobuttons path="uworkLocation"
items="${uworkLocations}"/> </td>
</tr>
<tr>
<td>User Skill Set</td>
<td>
<form:select path="uskillSet" multiple="multiple">
<form:option value="C">C</form:option>
<form:option value="C++">C++</form:option>
<form:option value="Java">JAVA</form:option>
<form:option value="Python">Python</form:option>
<form:option value=".Net">.Net</form:option>
</form:select>
</td>
</tr>
<tr>
<td>User Hobbies</td>
<td><form:select path="uhobbies" items="${uhobbies}"/> </td>
</tr>
<tr>
<td>User Profession</td>
<td>
<form:select path="uprofession" multiple="single">
<form:options items="${uprofession}"/>
</form:select>
</td>
</tr>
<tr>
<td>User Address</td>
<td><form:textarea path="uaddr"/></td>
</tr>
<tr>
<td><input type="submit" value="Register"></td>
</tr>
</table>
</form:form>
</body>
</html>
Status.jsp

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
</head>
<body>
<h3 style="color: blue;" align="center">User Registration
Details</h3>
<table align="center" border="1">
<tr>
<td>User Name</td>
<td>${user.uname}</td>
</tr>
<tr>
<td>${user.upwd}</td>
</tr>
<tr>
<td>R U Married?</td>
<td>${user.maritalStatus1}</td>
</tr>
<tr>
<td>R U Single?</td>
<td>${user.maritalStatus2}</td>
</tr>
<tr>
<td>
<c:forEach var="item" items="${user.uqual}">
<c:out value="${item}"/><br>
</c:forEach>
</td>
</tr>
<tr>
<td>User Work Locations</td>
<td>${user.uworkLocation}</td>
</tr>
<tr>
<td>User Skill Set</td>
<td>
<c:forEach var="item" items="${user.uskillSet}">
</c:forEach>
</td>
</tr>
<tr>
<td>User Hobbies</td>
<td>
<c:forEach var="item" items="${user.uhobbies}">
</c:forEach>
</td>
</tr>
<tr>
<td>User Profession</td>
<td>${user.uprofession}</td>
</tr>
<tr>
<td>User Address</td>
<td>${user.uaddr}</td>
</tr>
</table>
</body>
</html>
User.java
package com.durgasoft.command;
import java.io.Serializable;
public class User implements Serializable {

private boolean maritalStatus1;
private String maritalStatus2;
private String[] uqual;
private String uworkLocation;
private String[] uskillSet;
private String[] uhobbies;
private String uprofession;

private String uaddr;
public String getUaddr() {

return uaddr;
}
public void setUaddr(String uaddr) {

this.uaddr = uaddr;
}
public String getUprofession() {

return uprofession;
}
public void setUprofession(String uprofession) {

this.uprofession = uprofession;
}
public String[] getUhobbies() {

return uhobbies;
}
public void setUhobbies(String[] uhobbies) {
this.uhobbies = uhobbies;
}
public String[] getUskillSet() {

return uskillSet;
}
public void setUskillSet(String[] uskillSet) {

this.uskillSet = uskillSet;
}
public String getUworkLocation() {

return uworkLocation;
}
public void setUworkLocation(String uworkLocation) {

this.uworkLocation = uworkLocation;
}
public String[] getUqual() {

return uqual;
}
public void setUqual(String[] uqual) {

this.uqual = uqual;
}
public boolean isMaritalStatus1() {

return maritalStatus1;
}
public void setMaritalStatus1(boolean maritalStatus1) {

this.maritalStatus1 = maritalStatus1;
}
public String getMaritalStatus2() {

return maritalStatus2;
}
public void setMaritalStatus2(String maritalStatus2) {

if(maritalStatus2 == null || maritalStatus2.equals("")){
this.maritalStatus2 = "No";
}else {
this.maritalStatus2 = maritalStatus2;
}
}
public String getUname() {

return uname;
}
public void setUname(String uname) {

this.uname = uname;
}
public String getUpwd() {

return upwd;
}
public void setUpwd(String upwd) {

this.upwd = upwd;
}
}
UserController.java
package com.durgasoft.controller;
import com.durgasoft.command.User;
import org.springframework.ui.Model;
import org.springframework.web.servlet.mvc.SimpleFormController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class UserController extends SimpleFormController {

@Override
protected Map referenceData(HttpServletRequest request) throws
Exception {
List<String> uqualList = new ArrayList<>();
uqualList.add("BSC");
uqualList.add("BTECH");
uqualList.add("MCA");
uqualList.add("MTECH");
uqualList.add("PHD");
map.put("uqualList", uqualList);
List<String> uworkLocations = new ArrayList<>();

uworkLocations.add("Hyderabad");
uworkLocations.add("Chennai");
uworkLocations.add("Mumbai");
uworkLocations.add("Pune");
uworkLocations.add("Banglore");
map.put("uworkLocations", uworkLocations);
List<String> uhobbies = new ArrayList<>();

uhobbies.add("Playing Cricket");
uhobbies.add("Listening Music");
uhobbies.add("Chatting with Friends");
map.put("uhobbies", uhobbies);
List<String> uprofession = new ArrayList<>();

uprofession.add("Employee");
uprofession.add("Teacher");
uprofession.add("Former");
map.put("uprofession", uprofession);
return map;
}
@Override
protected ModelAndView onSubmit(Object command) throws Exception {
User user = (User)command;
return new ModelAndView("status", "user",user);
}
}
ds-servlet.xml
<bean name="/reg" class="com.durgasoft.controller.UserController">

<property name="formView" value="registrationform"/>
<property name="sessionForm" value="true"/>
<property name="commandName" value="user"/>
<property name="commandClass" value="com.durgasoft.command.User"/>
</bean>
ing"/>
ver">
</bean>
</beans>
pom.xml
<properties>
</properties>
<dependencies>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>

<dependency>
<artifactId>servlet-api</artifactId>
<version>3.0-alpha-1</version>
</dependency>

<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
<build>
</build>
</project>
AbstractWizardFormController:
—----------------------------
In general, in web applications, it is required to display more than one page
in order to complete a particular task.
In web applications, providing a sequence of pages in a single task is called

a “Wizard”.
IN general, in web applications, we will use multiple pages to enter user

details like general details, Qualification details, communication
details.,....in the user registration process, to achieve this we will use
“Wizard”.
In Spring WEB MVC, if we want to provide all web pages in Wizard we have to
use “AbstractWizardFormController”.
If we want to use “AbstractWizardFormController” in Spring web mvc

applications then we have to use the following steps.
1. Prepare Multiple web pages with the buttons whose names like below.
_finish: Finish the Wizard Form.

_cancel: Cancel the Wizard Form.
_targetx:Move to target page, where x is 0-based page index.
2. Prepare Controller class by extending “AbstractWizardFormController”

and override the following methods.
protected ModelAndView processFinish(

HttpServletRequest request,
HttpServletResponse response,
Object command,
BindException exception)throws Exception
protected ModelAndView processCancel(

HttpServletRequest request,
HttpServletResponse response,
Object command,
BindException exception)throws Exception
Where “processFinsh()” will handle Wizard Finish task.

Where “processCancel()” will handle Wizard Cancel Task.
3. COnfigure Controller class in Spring configuration file with the

property “pages”, where “pages” property must be of “list” type and it
must include all pages names in a sequence inorder to open in the web
pages when we click on “Next” button.
<bean name=”/reg” class=”com.durgasoft.controller.UserController”>

<property name=”pages”>
<list>
<value>form1</value>
</list>
</property>
</bean>
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="welcomepage"/>
</body>
</html>
welcomepage.jsp
<%--
User: Nagoor
Date: 27-07-2023
Time: 06:38
--%>
<html>
<head>
</head>
<body>
<h1 align="center">
<a href="reg">User Registration Form</a>
</h1>
</body>
</html>
form1.jsp
<%--
User: Nagoor
Date: 27-07-2023
Time: 06:40
--%>
prefix="form"%>
<html>
<head>
<title>Form1-Registration</title>
</head>
<body>
<form:form method="post" commandName="user">
<tr>
<td>First Name</td>
<td><form:input path="fname"/></td>
</tr>
<tr>
<td>Last Name</td>
<td><form:input path="lname"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="_target1" value="Next">
<input type="submit" name="_cancel" value="Cancel">
</td>
</tr>
</table>
</form:form>
</body>
</html>
form2.jsp
<%--
User: Nagoor
Date: 27-07-2023
Time: 06:48
--%>
prefix="form"%>
<html>
<head>
</head>
<body>
<tr>
<td><form:input path="uqual"/></td>
</tr>
<tr>
<td>User Designation</td>
<td><form:input path="udes"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="_target0" value="Previous">
<input type="submit" name="_target2" value="Next">
</td>
</tr>
</table>
</form:form>
</body>
</html>
form3.jsp
<%--
User: Nagoor
Date: 27-07-2023
Time: 06:51
--%>
prefix="form"%>
<html>
<head>
</head>
<body>
<tr>
<td>User Email Id</td>
<td><form:input path="uemail"/></td>
</tr>
<tr>
<td>User Mobile No</td>
<td><form:input path="umobile"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="_target1" value="Previous">
<input type="submit" name="_finish" value="Finish">
</td>
</tr>
</table>
</form:form>
</body>
</html>
userdetails.jsp
<%--
User: Nagoor
Date: 28-07-2023
Time: 06:16
--%>
<html>
<head>
<title>User Registration Details</title>
</head>
<body>
<table border="1" align="center">
<tr>
<td>User First Name</td>
<td>${user.fname}</td>
</tr>
<tr>
<td>User Last Name</td>
<td>${user.lname}</td>
</tr>
<tr>
<td>User Qualification</td>
<td>${user.uqual}</td>
</tr>
<tr>
<td>User Designation</td>
<td>${user.udes}</td>
</tr>
<tr>
<td>${user.uemail}</td>
</tr>
<tr>
<td>${user.umobile}</td>
</tr>
</table>
<h3 align="center">
<a href="welcomepage">|Welcome Page|</a>
</h3>
</body>
</html>
User.java
public class User {

private String fname;
private String lname;
private String uqual;
private String udes;
private String uemail;
private String umobile;
public String getFname() {

return fname;
}
public void setFname(String fname) {

this.fname = fname;
}
public String getLname() {

return lname;
}
public void setLname(String lname) {

this.lname = lname;
}
public String getUqual() {

return uqual;
}
public void setUqual(String uqual) {

this.uqual = uqual;
}
public String getUdes() {

return udes;
}
public void setUdes(String udes) {

this.udes = udes;
}
public String getUemail() {

return uemail;
}
public void setUemail(String uemail) {

this.uemail = uemail;
}
public String getUmobile() {
return umobile;
}
public void setUmobile(String umobile) {

this.umobile = umobile;
}
}
UserController.java
import com.durgasoft.app09.beans.User;
import org.springframework.validation.BindException;
import
org.springframework.web.servlet.mvc.AbstractWizardFormController;
public class UserController extends AbstractWizardFormController {

@Override
protected ModelAndView processFinish(HttpServletRequest
httpServletRequest, HttpServletResponse httpServletResponse, Object
command, BindException e) throws Exception {
User user = (User) command;
return new ModelAndView("userdetails", "user", user);
}
protected ModelAndView processCancel(HttpServletRequest
httpServletRequest, HttpServletResponse httpServletResponse, Object
o, BindException e) throws Exception {
return new ModelAndView("welcomepage");

}
}
ds-servlet.xml
<bean name="/welcomepage"
ler">
<property name="viewName" value="welcomepage"/>
</bean>
<bean name="/reg"
class="com.durgasoft.app09.controller.UserController">
<property name="pages">
<list>
</list>
</property>
<property name="commandClass"
value="com.durgasoft.app09.beans.User"/>
</bean>
<bean name="handleMapping"
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app09</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>

<dependency>
</dependency>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency> </dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
Annotations in Spring WEB MVC:

—-------------------------------
Spring Framework has introduced annotations from its Spring2.5 version, it
can be used to avoid the following configuration details in the configuration
file.
1. We can avoid all controller class configurations.

2. We can avoid HandlerMapping COnfigurations
—---
—----
Spring Framework has provided mainly the following annotations.
1. @Controller
2. @RequestMapping
3. @RequestParam
—---
—---
@Controller:
Before Spring2.5 version , all controller classes must be configured in
Spring Configuration file , but from Spring2.5 version no need to configure
Controller classes in the Spring Configuration file, alternatively we can use
@Controller annotation for the controller classes. If we provide @Controller
along with any controller class then Spring Container will understand the
respective class is a controller class and the Spring Container is able to
create an object for the controller class.
Note: If we want to @Controller annotation for the controller classes we must

use <context:component-scan base-package=”packageName where Controller
classes are existed”/>
The above tag will give information to the Container about the location where
these controller classes are available in order to scan and create objects.
EX:
@Controller
public class UserController{
—----
}
@RequestMapping:
This annotation is able to define the request urls based on the context root
and the Http Methods like GET, POST, HEAD,.... For the requests.
Note: @RequestMapping is Method Level and Class level Annotation, we can use
this either for classes or for methods.
Syntax:
@RequestMapping(value=”--”, method=---)
Where “value” is able to take the url pattern like “/login”, “/reg”,...
Where “method” is able to take the Http methods like GET, POST,... from
RequestMethod annotation.
EX:
@Controller
public class LoginController{
@RequestMapping(value=”/login”, method=RequestMethod.POST)
public ModelAndView checkLogin(HttpServlet request, httpServletResponse
response){
—----
return new ModelAndView(“success”);
}
}
Note: In the case of Annotations , the controller class methods are not
mandatory to return ModelAndView objects, simply they can return the viewName
in the form of String also.
@Controller
public String checkLogin(HttpServlet request, httpServletResponse
response){
—----
return “success”;
}
}
@RequestParam:
This annotation is able to bind the controller class methods parameters with
the request parameters which are provided by the users from User forms.
Syntax:
@RequestParam(“paramName”)
EX:
@Controller
public String checkLogin(@RequestParam(“username”)String uname,
@RequestParam(“userpwd”)String upwd){
—---
return “success”;
}
}
http://localhost:1010/app/login
Req Parameters: username=abc
userpwd=abc123
In the Controller class method we are able to use the ModelMap parameter to
manage the data which we want to share through a Session object. In the case
of ModelMap object, if we want to keep any attribute data, first we have to
define that attribute by using @SessionAttributes(--)
@SessionAttributes(“status”)
EX:
—---
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="loginpage"/>
</body>
</html>
loginform.jsp
<%--
User: Nagoor
Date: 29-07-2023
Time: 07:28
--%>
<html>
<head>
</head>
<body>
<h3 style="color: blue;" align="center">User Login Form</h3>
<form method="post" action="login">
<tr>
<td>User Name</td>
</tr>
<tr>
<td>Password</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
success.jsp
<%--
User: Nagoor
Date: 29-07-2023
Time: 07:33
--%>
<html>
<head>
<title>Success Page</title>
</head>
<body>
<h1 style="color: red"; align="center">User Login Success</h1>
<h3 align="center">
<a href="loginpage">|Login Form|</a>
</h3>
</body>
</html>
failure.jsp
<%--
User: Nagoor
Date: 29-07-2023
Time: 07:33
--%>
<html>
<head>
<title>Failure Page</title>
</head>
<body>
<h1 style="color: red"; align="center">User Login Failure</h1>
<h3 align="center">
<a href="loginpage">|Login Form|</a>
</h3>
</body>
</html>
package com.durgasoft.app10;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class LoginController {
@RequestMapping("/loginpage")
public String loginpage(){
return "loginform";
}
@RequestMapping(value = "/login", method = RequestMethod.POST)
public String checkLogin(@RequestParam("uname") String uname,
@RequestParam("upwd") String upwd){
String status = "";
status = "success";
}else{
status = "failure";
}
return status;
}
}
ds-servlet.xml
<context:component-scan base-package="com.durgasoft.*"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app10</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>

<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
<build>
<plugins>
<plugin>
</build>
</project>
In the above application, if we want to use status.jsp in place of

success.jsp and failure.jsp then we have to use ModelMap object to provide
login status and we have to use @SessionAttributes annotation to define the
session attribute value.
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="loginpage"/>
</body>
</html>
loginform.jsp
<%--
User: Nagoor
Date: 29-07-2023
Time: 07:28
--%>
<html>
<head>
</head>
<body>
<h3 style="color: blue;" align="center">User Login Form</h3>
<form method="post" action="login">
<tr>
<td>User Name</td>
</tr>
<tr>
<td>Password</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
status.jsp
<%--
User: Nagoor
Date: 29-07-2023
Time: 08:29
--%>
<html>
<head>
<title>User Login Status</title>
</head>
<body>
User Login Status : <%= session.getAttribute("status")%>
</h1>
</body>
</html>
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.SessionAttributes;
@Controller
@SessionAttributes("status")
public class LoginController {
@RequestMapping("/loginpage")
public String loginpage(){
return "loginform";
}
@RequestMapping(value = "/login", method = RequestMethod.POST)
public String checkLogin(@RequestParam("uname") String uname,
@RequestParam("upwd") String upwd, ModelMap modelMap){
String status = "";
modelMap.addAttribute("status", "User Login Success");
}else{
modelMap.addAttribute("status", "User Login Failure");
}
return "status";
}
}
ds-servlet.xml
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app10</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>

<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
<build>
<plugins>
<plugin>
</build>
</project>
Data Validations:
—----------------
The process of checking whether the data is valid or not before using data in
the business logic is called Data Validations.
There are two types of Data Validations.

1. Client Side Data Validations
2. Server Side Data Validations
Client Side Data Validations:

If we check whether the data is valid or not at client browser after entering
data and just before submitting a request to Server then it is called Client
Side Data Validations.
To perform Client side Data Validations we have to use Java Script functions.
Server Side Data Validations:

If we check whether the data is valid or not after sending data to the
Server, after storing data in the bean object at server machine and just
before using data in the business logic then it is called Server side Data
Validations.
In general, to perform Server side Data Validations we will use JAVA code.
To perform Server side Data Validations, Spring has the following two
approaches.
1. Using Spring provided Validator and Error classes.

2. Using Java provided Validations Annotations
Data Validations through Validator and Error:

—---------------------------------------------
1. Prepare the Validator class by implementing the Validator interface.
a) Declare an User defined class.
b) Implement Validator interface in the user defined class.
c) Provide implementation for the Validator interface methods .
public boolean supports(Class cls):

It will check whether the Data validations are supported or not
in the bean class.
public void validate(Object command, Errors, errors)

It will include the actual Data Validation logic.
If the data is invalid and if we want to define a validation

message then we have to use the following method from Errors.
public void rejectValue(String varName, String errorCode)

Where varName is the property name in the COmmand class.
Where Error code may be a direct Validation message or the key of
the validation message in the properties file.
2. Prepare properties file with all the validation messages in the form of
Key-Value pairs.
3. Configure Validator class and properties file with messageSource under
ResourceBundleMessageSource configuration.
4. Display Validation Messages in user forms by using <form:errors/> tag.
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
</body>
</html>
registrationform.jsp
<%--
User: Nagoor
Date: 30-07-2023
Time: 07:05
--%>
<%@ taglib uri="http://www.springframework.org/tags/form"
prefix="form"%>
<html>
<head>
<title>User Registration Form</title>
<style type="text/css">
.error{
color: red;
font-family: Consolas;
font-style: italic;
font-weight: bold;
font-size: large;
}
</style>
</head>
<body>
<form:form method="post" action="reg" commandName="user">
<tr>
<td>User Name</td>
<td><form:input path="uname"/></td>
<td><form:errors path="uname" cssClass="error"/></td>
</tr>
<tr>
<td><form:password path="upwd"/></td>
<td><form:errors path="upwd" cssClass="error"/></td>
</tr>
<tr>
<td>User Age</td>
<td><form:input path="uage"/></td>
<td><form:errors path="uage" cssClass="error"/></td>
</tr>
<tr>
<td><form:errors path="uemail" cssClass="error"/></td>
</tr>
<tr>
<td><form:errors path="umobile" cssClass="error"/></td>
</tr>
<tr>
<td><input type="submit" value="Registration"></td>
</tr>
</table>
</form:form>
</body>
</html>
registrationdetails.jsp
<%--
User: Nagoor
Date: 30-07-2023
Time: 07:13
--%>
<html>
<head>
</head>
<body>
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
<tr>
<td>User Age</td>
<td>${user.uage}</td>
</tr>
<tr>
</tr>
<tr>
</tr>
</table>
</body>
</html>
validationMessages.properties
uname.required = User Name Is Required.
upwd.required = User Password Is Required.

upwd.minLength = User Password Must be Minimum of 5 Characters.
upwd.maxLength = User Password Must be Maximum of 10 Characters.
uage.required = User Age Is Required.

uage.range = User Age Must Be In The Range From 18 to 30 Years.
uemail.required = User Email Id Is Requireed.

uemail.invalid = User Email Id Is Invalid.
umobile.required = User Mobile No Is Required.

umobile.invalid = User Mobile No Is Invalid.
UserController.java
import org.springframework.web.servlet.mvc.SimpleFormController;
public class UserController extends SimpleFormController {

@Override
protected ModelAndView onSubmit(HttpServletRequest request,
HttpServletResponse response, Object command, BindException errors)
throws Exception {
return new ModelAndView("registrationdetails", "user", user);
}
}
UserValidator.java
package com.durgasoft.app11.validator;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
public class UserValidator implements Validator {
@Override
public boolean supports(Class<?> cls) {
return User.class.isAssignableFrom(cls);
}
@Override
public void validate(Object command, Errors errors) {
if(user.getUname() == null || user.getUname().equals("")){

errors.rejectValue("uname", "uname.required");
}
if(user.getUpwd() == null || user.getUpwd().equals("")){

errors.rejectValue("upwd", "upwd.required");
}else{
if(user.getUpwd().length() < 5){
errors.rejectValue("upwd", "upwd.minLength");
}
if(user.getUpwd().length() > 10){
errors.rejectValue("upwd", "upwd.maxLength");
}
}
if(user.getUage() == 0 ){
errors.rejectValue("uage", "uage.required");
}else {
if(user.getUage() < 18 || user.getUage() > 30){
errors.rejectValue("uage", "uage.range");
}
}
if(user.getUemail() == null || user.getUemail().equals("")){

errors.rejectValue("uemail", "uemail.required");
}else{
if(!user.getUemail().endsWith("@durgasoft.com")){
errors.rejectValue("uemail", "uemail.invalid");
}
}
if(user.getUmobile() == null || user.getUmobile().equals("")){

errors.rejectValue("umobile", "umobile.required");
}else{
if(!user.getUmobile().startsWith("91-")){
errors.rejectValue("umobile", "umobile.invalid");
}
}
}
}
ds-servlet.xml
<bean name="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSourc
e">
<property name="basename" value="validationMessages"/>
</bean>
<bean name="userValidator"
class="com.durgasoft.app11.validator.UserValidator"/>
<bean name="/reg"
class="com.durgasoft.app11.controller.UserController">
<property name="formView" value="registrationform"/>
<property name="validator" ref="userValidator"/>
<property name="commandClass"
value="com.durgasoft.app11.beans.User"/>
</bean>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app11</name>
<properties>
</properties>
<dependencies>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
</dependency>

<dependency>
</dependency>
<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</plugin>
</plugins>
</build>
</project>
Data Validations By Using Java Provided Validations API[Annotations]:

—---------------------------------------------------------------------
Validation-API is a specification provided by JAVA and it is implemented by
some third party Vendors.
Hibernate has provided implementation for JAVA provided Validation-API and

some hibernate Annotations.
1. @NotEmpty:
a. It will be applied to the bean properties or getter methods.
b. It will check whether the data exists or not in the respective
bean property, if the data does not exist then this annotation
will raise a Validation error.
c. It is applicable for only String type properties.
2. @NotNull:
a. It will be applied to the bean properties or getter method.
b. It will check whether the data/ value exists or not in the
respective bean property, if the data does not exist then this
annotation will raise a Validation error.
c. It is applicable for only Numeric type properties.
3. @Size:
a. It will be applied for the bean property or getter method.
b. It will check whether the data is as per the minimum length and
maximum length constraint or not.
c. It is applicable for only String type properties.
d. It will take 2 parameters like min, max.
Note: We can use @Min and @Max annotations as an alternative to

@Size annotation.
4. @Range:
a. It will be applied to the bean properties and getter methods.
b. It will check whether the data is as per the range or not.
c. It is applicable for the NUmeric data types.
d. It should require two parameters like min, max.
5. @Pattern:
a. It will be applied to the property or getter method.
b. It will check whether the data is as per the provided regular
expression or not.
c. It will take an input parameter like ‘regexp’.
6. @Email:
b. It will check whether the data is as per the email id or not.
c. It does not require input parameters.
7. @DateTimeFormat:
b. It is applicable for the Date type properties.
c. It will check whether the data is as per the date format or not.
d. It will take an input parameter like “pattern” to represent date
format.
8. @Past:
b. It will check whether the date is a past date or not.
c. It is applicable for Date type property.
In Spring WEB MVC applications, if we want to use the above validations then
we have to use the following steps.
1. Create a Bean class and use all the validation related annotations.
2. Create Properties file and define validation messages in the properties
file or define Validation messages in the annotations directly.
3. Display Validation Messages in the web pages.
Note: Define the Validation messages in the properties like below.

AnnotationName.modelName.propName = Message.
EX:
NotEmpty.user.uname = User Name Is Required.
Note: If we want to use Stereotype annotations in Spring applications then we

have to activate these annotations by using <context:component-scan> tag. If
we want to use the above validation annotations then we have to use
<mvc:annotation-driven>
To use the above annotations in Spring applications we have to use

hibernate-validator-version dependency in the pom.xml file.
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
</body>
</html>
registrationform.jsp
<%--
User: Nagoor
Date: 30-07-2023
Time: 07:05
--%>
prefix="form"%>
<html>
<head>
<title>User Registration Form</title>
<style type="text/css">
.error{
color: red;
font-family: Consolas;
font-style: italic;
font-weight: bold;
font-size: large;
}
</style>
</head>
<body>
<form:form method="post" action="reg" modelAttribute="user">
<tr>
<td>User Name</td>
<td><form:input path="uname"/></td>
<td><form:errors path="uname" cssClass="error"/></td>
</tr>
<tr>
<td><form:password path="upwd"/></td>
<td><form:errors path="upwd" cssClass="error"/></td>
</tr>
<tr>
<td>User Age</td>
<td><form:input path="uage"/></td>
<td><form:errors path="uage" cssClass="error"/></td>
</tr>
<tr>
<td>User Date Of Birth</td>
<td><form:input path="udob"/></td>
<td><form:errors path="udob" cssClass="error"/></td>
</tr>
<tr>
<td><form:errors path="uemail" cssClass="error"/></td>
</tr>
<tr>
<td><form:errors path="umobile" cssClass="error"/></td>
</tr>
<tr>
<td><input type="submit" value="Registration"></td>
</tr>
</table>
</form:form>
</body>
</html>
registrationdetails.jsp
<%--
User: Nagoor
Date: 30-07-2023
Time: 07:13
--%>
<html>
<head>
</head>
<body>
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
<tr>
<td>User Age</td>
<td>${user.uage}</td>
</tr>
<tr>
<td>User Date Of Birth</td>
<td>${user.udob}</td>
</tr>
<tr>
</tr>
<tr>
</tr>
</table>
</body>
</html>
User.java
import jakarta.validation.constraints.*;
import org.hibernate.validator.constraints.Range;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
public class User {
@NotEmpty
@NotEmpty
@Size(min = 6, max = 10)
@NotNull
@Range(min = 18, max = 25)
private int uage;
@NotNull
@DateTimeFormat(pattern = "dd/MM/yyyy")
@Past
private Date udob;
@NotEmpty
@Email
private String uemail;
@NotEmpty
@Pattern(regexp = "91-[0-9]{10}")
private String umobile;
public Date getUdob() {

return udob;
}
public void setUdob(Date udob) {

this.udob = udob;
}
public String getUname() {

return uname;
}
public void setUname(String uname) {

this.uname = uname;
}
public String getUpwd() {

return upwd;
}
public void setUpwd(String upwd) {

this.upwd = upwd;
}
public int getUage() {

return uage;
}
public void setUage(int uage) {
this.uage = uage;
}
public String getUemail() {

return uemail;
}
public void setUemail(String uemail) {

this.uemail = uemail;
}
public String getUmobile() {

return umobile;
}
public void setUmobile(String umobile) {

this.umobile = umobile;
}
}
UserController.java
import jakarta.validation.Valid;
import org.springframework.ui.Model;
import org.springframework.validation.BeanPropertyBindingResult;
@Controller
@RequestMapping("/reg")
public class UserController{
@RequestMapping(method = RequestMethod.GET)
public String showPage(Model model){
model.addAttribute("user", new User());
return "registrationform";
}
@RequestMapping(method = RequestMethod.POST)
protected ModelAndView registration(@Valid User user,
BeanPropertyBindingResult errors, Model model ) throws Exception {
model.addAttribute("user", user);
if(errors.hasErrors()){
return new ModelAndView("registrationform","user", user);
}else{
return new ModelAndView("registrationdetails", "user",
user);
}
}
}
validationMessages.properties
typeMismatch = {0} is in invalid format.
NotEmpty.user.uname = User Name is Required.
NotEmpty.user.upwd = User Password is Required.

Size.user.upwd = User Password must be minimum {2} characters and
Maximum {1} characters.
NotNull.user.uage = User Age Is Required.

Range.user.uage = User Age must be in the range from {2} through {1}
Years.
NotNull.user.udob = User Date Of Birth is Required.

DateTimeFormat.user.udob = User Date of Birth Is Invalid.
Past.user.udob = User Date Of Birth must be a past value.
NotEmpty.user.uemail = User Email Id Is Required.

Email.user.uemail = User Email Id is Invalid.
NotEmpty.user.umobile = User Modile NUmber Is Required.

Pattern.user.umobile = User Mobile Number must be in 91-DDDDDDDDDD.
ds-servlet.xml
xmlns:mvc="http://www.springframework.org/schema/mvc"
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
">
<mvc:annotation-driven/>
<bean name="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSourc
e">
<property name="basename" value="validationMessages"/>
</bean>
ing"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app11.0</name>
<properties>
</properties>
<dependencies>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
</dependency>

<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>8.0.1.Final</version>
</dependency>
<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</plugin>
</plugins>
</build>
</project>
Handler Mappings:
—-----------------
Handler Mapping is a component in Spring Web MVC, it will take the incoming
request URI and it will identify the mapped controller class through Spring
Configuration file and return the COntroller class details to
DispatcherServlet.
Spring WEB MVC has provided the number of predefined Handler mappings in a
package “org.springframwork.web.servlet.handler”.
1. BeanNameUrlHandlerMapping
2. SimpleUrlHandlerMapping
3. ControllerClassNameHandlerMapping
4. DefaultAnnotationHandlerMapping
BeanNameUrlHandlerMapping:
—-------------------------
In Spring WEB MVC applications,if we use XML configurations then
BeanNameUrlHandlerMapping is the default Handler mapping mechanism, it is not
required to be configured in the Spring Configuration file.
It is able to identify the controller classes by mapping the incoming request

URI with bean Identity [id or name attribute values] which we defined in the
Spring configuration files.
EX:
<beans>
class=”org.springframework….BeanNameUrlHandlerMapping”/>
<bean name=”/welcome” class=”com.durgasoft.controller.WelcomeController”/>
—----
</beans>
If we submit the request with “welcome” uri then BeanNameUrlHandlerMapping is

able to map the “welcome” with the id or name attribute value in the <bean>
tag, if the value is matched then BeanNameUrlHandlerMapping will confirm the
respective controller class is “com.durgasoft.controller.WelcomeController”
and send its details to the DispatcherServlet.
http://localhost:1010/app/welcome
SimpleUrlHandlerMapping:
—-----------------------
SimpleUrlHandlerMapping is able to map the incoming request with a particular
controller class name , it will find the controller class and it will provide
controller class details to the DispatcherServlet with the following actions.
1. SimpleUrlHandlerMapping will take incoming request URI value.

2. It will search for the Request URI name in its properties which are
configured in the spring configuration file.
3. If any property key is matched with the incoming request URI value then
SimpleUrlHandlerMapping will take the respective property value that is
the logical name of the controller class .
4. SimpleUrlHandlerMapping will identify the controller class on the basis
of the logical name which we get from the matched property.
EX:
<beans>
<bean name=”wishController” class=”com.dss.controller.WishController”/>
<bean name=”welcomeController”
class=”com.dss.controller.WelcomeController”/>
<bean name=”handlerMapping” class=”org…SimpleUrlHandlerMapping”>
<props>
<prop key=”/wish”>wishController</prop>
<prop key=”/welcome”>welcomeController</prop>
</props>
</bean>
</beans>
As per the above configuration, if we submit request with the URI “wish” then
SImpleUrlHandlerMapping will map this URI with the property name under the
SimpleUrlHandlerMapping , where it will get the property value that is
wishController , on the basis of the wishController it will find the
respective controller class name com.dss.controller.WishController .
http://lh:1010/app/wish —-> wishController —--> WishController

http://lh:1010/app/welcome —-> welcomeController —-> WelcomeController
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="hello"/>
</body>
</html>
helloform.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:30
--%>
<html>
<head>
<title>Hello Form</title>
</head>
<body>
<h3 style="color: blue" align="center">User Hello Form</h3>
<form method="post" action="wish">
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
wish.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:35
--%>
<html>
<head>
<title>User Wish Page</title>
</head>
<body>
<h2 style="color: red;" align="center">Durga Software
Solutions</h2>
<h3 style="color: blue" align="center">User Hello Status</h3>
<h1 style="color: green;" align="center">Hello ${uname}, Good
Morning!</h1>
</body>
</html>
HelloFormCOntroller.java
public class HelloFormController implements Controller {

@Override
}
}
WishController.java

@Override
return new ModelAndView("wish", "uname", uname);

}
}
ds-servlet.xml
<bean name="helloFormController"
class="com.durgasoft.app12.controller.HelloFormController"/>
<bean name="wishController"
class="com.durgasoft.app12.controller.WishController"/>
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMappin
g">
<property name="mappings">
<props>
<prop key="/hello">helloFormController</prop>
<prop key="/wish">wishController</prop>
</props>
</property>
</bean>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app12</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
ControllerClassNameHandlerMapping:
—---------------------------------
ControllerClassNameHandlerMapping is able to take the incoming request URI ,
find the controller class and send the controller class details to
DispatcherServlet with the following actions.
1. It will take incoming request uri value and it will remove any
extension if it has.
2. It will make the first letter as Uppercase letter in the incoming
request URI.
3. It will append Controller as a suffix to the request URI, now it is the
controller class name.
4. It will search for the controller class with the above convention and
send the controller class details to DispatcherServlet.
If we send a request with the URI value “wish” then the
ControllerClassHandlerMapping will search the controller class name
“WishController” , in this context the “name” attribute must not be provided
in the controller class configuration.
<beans>
<bean class=”com.durgasoft.controller.WishController”/>
<bean class=”com.durgasoft.controller.WelcomeController”/>
class=”org….ControllerClassNameHandlerMapping”/>
</beans>
wish—--> WishController
helloForm—--->HelloFormController
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="helloForm"/>
</body>
</html>
helloform.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:30
--%>
<html>
<head>
</head>
<body>
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
wish.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:35
--%>
<html>
<head>
</head>
<body>
Solutions</h2>
Morning!</h1>
</body>
</html>
HelloFormController.java
//import jakarta.servlet.http.HttpServletRequest;
//import jakarta.servlet.http.HttpServletResponse;
public class HelloFormController implements Controller {

@Override
}
}
WishController.java
//import jakarta.servlet.http.HttpServletRequest;
//import jakarta.servlet.http.HttpServletResponse;

@Override

}
}
ds-servlet.xml
<bean class="com.durgasoft.app12.controller.HelloFormController"/>
<bean class="com.durgasoft.app12.controller.WishController"/>
class="org.springframework.web.servlet.mvc.support.ControllerClassNam
eHandlerMapping">
<property name="caseSensitive" value="true"/>
</bean>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app12</name>
<properties>
</properties>
<dependencies>

<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
DefaultAnnotationHandlerMapping:
—---------------------------------
DefaultAnnotationHandlerMapping is a default Handler mapping class in Spring
WEB MVC if we use annotations, it is not required to configure in Spring
configuration file.
It will map the incoming request URI with the name provided along with the
@Requestmapping annotation which we provided just above of the Controller
class or Controller class method.
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
</body>
</html>
helloform.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:30
--%>
<html>
<head>
</head>
<body>
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
wish.jsp
<%--
User: Nagoor
Date: 03-08-2023
Time: 06:35
--%>
<html>
<head>
</head>
<body>
Solutions</h2>
Morning!</h1>
</body>
</html>
WishController.java
//import org.springframework.web.servlet.mvc.Controller;
/*
*/
@Controller
@RequestMapping("/wish")
public class WishController{
public String helloForm(){
return "helloform";
}
public ModelAndView wish(HttpServletRequest request,

}
}
ds-servlet.xml
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app12</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
</dependency>


</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
HandlerInterceptor:
—------------------
IN general, in web applications, to provide preprocessing and post processing
services for the web resources like Servlets and JSPs we have to use
“Filters”.
In web applications, we are able to provide a single filter for multiple
servlet JSPs and we are able to provide multiple filters for single servlet
and JSP.
In web applications, when we submit a request from Client to a particular

Server side resource like Servlet then the Container will perform the
following actions.
1. Container will check whether any filter or filters configured for the
respective Servlet or not.
2. If any filter or filters are configured for the Servlet then the
container will execute all the firsts first before executing the
servlet.
3. When a container is executing one filter, if the request data is
satisfying the filter constraints then the container will forward the
request to the next filter, if no next filter is available then the
container forward request to the Servlet directly.
4. In the case if the request data is not satisfying filter constraints
then the container will generate a response back to the client through
all the filters in backward direction which it has executed already.
5. If the respective Servlets executed successfully then the generated
response will be submitted to the client through all the filters in
backward direction.
Similarly, in Spring WEB MVC applications, if we want to provide

pre-processing and post processing services to any controller or any web
resource then we have to use “Interceptors”.
If we provide Interceptors in Spring web MVC applications then they will be

executed before and after executing the controller.
If we want to use Interceptors in Spring WEB MVC applications then we have to

use the following steps.
1. Prepare Interceptor class

2. Configure Interceptor in Spring Configuration File.
Prepare Interceptor class:

—---------------------------
If we want to prepare an interceptor class we have to declare an user defined
class and it must implement a HandlerInterceptor interface or extend
HandlerInterceptorAdapter class.
HandlerInterceptor is an interface containing the following methods.
1. public boolean preHandle(HttpServletRequest req,

HttpServletResponse resp,
Object handler)throws Exception
This method will include logic before executing the controller class
method.
This method will return a boolean value like true or false.
If this method returns true then DispatcherServlet will understand that

the present interceptor executed successfully then the request must be
forwarded to the next filter or to the Controller if no next filter
exists.
If this method returns false value then the DispatcherServlet will

understand that the present request is not satisfying Interceptor
constraints, in this case Interceptor will generate a response back to
the client through all the interceptors in backward direction.
2. public void postHandle(HttpServletRequest req,

Object handler,
ModelAndView modelAndView)throws Exception
This method includes Post Processing logic, that is the logic which we
want to execute after executing the Controller class method and just
before dispatching a response to the client.
In general, we will use this method to add some attributes to the

ModelAndView object inorder to see the data in the View pages.
3. public void afterCompletion(HttpServletRequest req,

Object handler,
Exception e)throws Exception
This method will have logic to execute after executing the controller
class and after dispatching responses to the client.
This method will be executed only once for all the controller classes
that is after response rendering.
Note: In Spring WEB MVC applications, preHandle() method, postHandle()
methods are executed for each and every request , but afterCompletion()
method will be executed only once after response rendering.
If we provide more than one interceptor for a controller then all the
interceptors preHandle() method will be executed as per the interceptors
configuration in spring configuration file and postHandle() and
afterCompletion() methods are executed in reverse order of the Interceptors.
public class MyInterceptor extends INterceptorHandlerAdapter{

—--
}
Configure Interceptor in Spring Configuration File.

—---------------------------------------------------
There are three approaches to configure the Interceptors.
1. By Using the “interceptors” property of type list in HandlerMapping

configuration.
<bean name=”handlerMapping” class=”org…SimpleUrlHandlerMapping”>
<property name=”interceptors”>
<list>
<ref bean=”maintenanceInterceptor”/>
<ref bean=”executeTimeInterceptor”/>
</list>
</property>
</bean>
2. By Using <interceptors> tag in Spring configuration file directly.
<beans>
—--
<interceptors>
<interceptor>
<mapping path=”/home”/>
<beans:bean class=com.dss.interceptors.ReqProcTimeInterceptor/>
</interceptor>
</interceptors>
</beans>
3. By Using <mvc:interceptors> tag in Spring configuration File.
<beans>
<mvc:interceptors>
<bean class=”com.dss.interceptors.WishInterceptor”/>
<mvc:interceptor>
<mvc:mapping path=”/coursesList”>
<bean class=”com.dss.interceptors.CourseInterceptor”/>
</mvc:interceptor>
</mvc:interceptors>
—----
</beans>
EX:
index.jsp
<%@ page contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
</body>
</html>
helloform.jsp
<%--
User: Nagoor
Date: 06-08-2023
Time: 08:03
--%>
%>
<html>
<head>
<title>User Hello Form</title>
</head>
<body>
Solutions</h2>
<tr>
<td>User Name</td>
</tr>
<tr>
</tr>
</table>
</form>
</body>
</html>
wish.jsp
<%--
User: Nagoor
Date: 06-08-2023
Time: 08:04
--%>
%>
<html>
<head>
</head>
<body>
Solutions</h2>
Morning!</h1>
<h2 style="color:red;" align="center">Request Processing
Details</h2>
<h3 align="center">
Start Time : ${startTime} <br>
End Time : ${endTime} <br>
Processing Time : ${processingTime}
</h3>
</body>
</html>
WishConroller.java
//import org.springframework.web.servlet.mvc.Controller;
/*
*/
@Controller
@RequestMapping("/wish")
public class WishController {
public String helloForm(){
return "helloform";
}
public ModelAndView wish(HttpServletRequest request,

}
}
ProcessingTimeInterceptor.java
package com.durgasoft.app13.interceptors;
import org.springframework.web.servlet.HandlerInterceptor;
public class ProcessingTimeInterceptor implements
HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception
{
long startTime = System.currentTimeMillis();

System.out.println("Start Time : "+startTime);
request.setAttribute("startTime", startTime);
return true;
}
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler, ModelAndView
modelAndView) throws Exception {
long startTime = (long)
request.getAttribute("startTime");
long endTime = System.currentTimeMillis();
System.out.println("End Time : "+endTime);
long processingTime = endTime - startTime;
System.out.println("Processing Time :
"+processingTime);
request.removeAttribute("startTime");
modelAndView.addObject("startTime", startTime);
modelAndView.addObject("endTime", endTime);
modelAndView.addObject("processingTime",
processingTime);
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("Response Rendering.....");
}
}
ds-servlet.xml
xmlns:mvc="http://www.springframework.org/schema/mvc"
http://www.springframework.org/schema/context/spring-context.xs
d
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<mvc:interceptors>

<mvc:interceptor>
<mvc:mapping path="/wish"/>
<bean
class="com.durgasoft.app13.interceptors.ProcessingTimeIntercept
or"/>
</mvc:interceptor>
</mvc:interceptors>
class="org.springframework.web.servlet.view.InternalResourceVie
wResolver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
<servlet-class>org.springframework.web.servlet.DispatcherServle
t</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app13</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncodi
ng>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
<build>
<plugins>
<plugin>
</build>
</project>
File Uploading in Spring WEB MVC:

—---------------------------------
IN general, in web applications, it is a very frequent requirement to upload
the files .
To perform file uploading in Spring web mvc applications, Spring WEB MVC has
provided some predefined libraries in the form of CommonsMultipartResolver.
To perform File Uploading operation in Spring WEB MVC applications we have to

use the following actions.
1. Prepare a form with file components.
a. Use the POST request type as Http method.
b. Use “multipart/form-data” as encType in <form> tag.
<form method=”POST” action = “upload” enctype=”multipart/form-data”>

File Name: <input type=”file” name=”file”/><br>
<input type=”submit” value=”Upload”/>
</form>
2. Prepare a Controller class to receive File data and to save File data in
the Server machine.
@Controller
public class UploadController{
@RequestMapping(value=”/upload”, method=RequestMethod.POST)
public ModelAndView uploadFiles(@RequestParam MultipartFile file){
String status = “”;
try{
String fileName = file.getOriginalFileName();
FileOutputStream fos = new FileOutputStream(“E:/uploads/”+fileName);
Byte[] btArray = file.getBytes():
fos.write(btArray);
Status = “SUCCESS”;
}catch(Exception e){
Status = “FAILURE”;
e.printStackTrace();
}
return new ModelAndView(“status”, “status”, status);
}
}
3. Configure CommonsMultipartResolver class as a bean with the name

“multipartResolver” in the Spring Configuration file.
ds-servlet.xml
<beans>
<bean name=”multipartResolver”
class=”org.springframework…CommonsMultipartResolver”/>
—-----
</beans>
Note: For File Uploading Operations, Spring Framework uses Commons file
upload and commons io libraries, so we must provide them in the project
libraries.
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="upload"/>
</body>
</html>
uploadform.jsp
<%--
User: Nagoor
Date: 08-08-2023
Time: 06:41
--%>
<html>
<head>
<title>File Upload Form</title>
</head>
<body>
<h3 style="color: blue;" align="center">File Upload Form</h3>
<form method="POST" action="upload" enctype="multipart/form-data">
<tr>
<td>File1</td>
<td><input type="file" name="file"></td>
</tr>
<tr>
<td>File2</td>
</tr>
<tr>
<td>File2</td>
</tr>
<tr>
<td><input type="submit" value="Upload"></td>
</tr>
</table>
</form>
</body>
</html>
status.jsp
<%--
User: Nagoor
Date: 08-08-2023
Time: 06:45
--%>
<html>
<head>
<title>File Upload Status Page</title>
</head>
<body>
<h1 style="color: red;" align="center">File Upload Status
${status}</h1>
</body>
</html>
UploadController.java
import org.springframework.web.multipart.MultipartFile;
import java.io.FileOutputStream;
@Controller
public class UploadController {
@RequestMapping(value = "/upload", method = RequestMethod.GET)
public String showForm(){
return "uploadform";
}
@RequestMapping(value = "/upload", method = RequestMethod.POST)
public ModelAndView uploadFiles(@RequestParam MultipartFile[]
file){
String status = "";
try{
for (MultipartFile multipartFile : file){
String fileName = multipartFile.getOriginalFilename();
FileOutputStream fileOutputStream = new
FileOutputStream("E:/uploads/"+fileName);
byte[] btArray = multipartFile.getBytes();
fileOutputStream.write(btArray);
}
status = "SUCCESS";
}catch (Exception e){
status = "FAILURE";
e.printStackTrace();
}
return new ModelAndView("status", "status", status);
}
}
ds-servlet.xml
<bean name="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartReso
lver"/>
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
File Downloading:
—-----------------
In General, in web applications, it is very frequent to perform file download
operations.
To perform File Downloading operation in Spring WEB MVC applications we have

to use the following steps.
1. Prepare a form with the “Download” button with the downloadable Resource.
<form method=”post” action=”download”>
<img src=”E:/images/MyImage.jpg”/><br>
<input type=”submit” value=”Download”/>
</form>
2. Prepare Controller class:

a. Set “APPLICATION/OCTET-STREAM” as content type.
response.setContentType(“APPLICATION/OCTET-STREAM”);
b. Set “content-disposition” response header with the downloadable
resource.
response.setHeader(“content-disposition”,
“attachment;filename=\””+fileName+”\””);
c. Create File and FileInputStream object:
File file = new File(“E:/images/myIUmage.jpg”);
FileInputStream fis = new FileInputStream(file);
d. Create OutputStream:
OutputStream os = response.getOutputStream();
e. Get bit by bit from FileInputStream and send bit by bit to OutputSteam.
int val = fis.read();
if(val != -1){
os.write(val);
Val = fis.read();
}
EX:
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<jsp:forward page="download"/>
</body>
</html>
downloadform.jsp
<%--
User: Nagoor
Date: 09-08-2023
Time: 06:35
--%>
<html>
<head>
<title>Download Form</title>
</head>
<body>
<form method="post" action="download">
<tr>
<td><img alt="newbatches.jpg"
src="E:/images/newbatches.jpg" width="300" height="300"/></td>
</tr>
<tr>
<td><input type="submit" value="Download"></td>
</tr>
</table>
</form>
</body>
</html>
DownloadCotroller.java
import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
@Controller
public class DownloadController {
@RequestMapping( value = "/download",method = RequestMethod.GET)
public String showForm(){
return "downloadform";
}
@RequestMapping(value = "/download", method = RequestMethod.POST)
public void download(HttpServletRequest request,
response.setContentType("APPLICATION/OCTET-STREAM");
File file = new File("E:/images/newbatches.jpg");
FileInputStream fileInputStream = new FileInputStream(file);
String fileName = file.getName();
response.setHeader("content-disposition","attachment;filename=\""+fil
eName+"\"");
OutputStream outputStream = response.getOutputStream();
int val = fileInputStream.read();
while (val != -1){
outputStream.write(val);
val = fileInputStream.read();
}
fileInputStream.close();
outputStream.close();
}
ds-servlet.xml
xsi:schemaLocation="http://www.springframework.org/schema/beans
ver">
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
pom.xml
<name>app15</name>
<properties>
</properties>
<dependencies>
<dependency>
</dependency>
<dependency>
<scope>test</scope>
</dependency>
<dependency>
<scope>test</scope>
</dependency>

<dependency>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
</build>
</project>
Spring Web MVC Tiles:

—--------------------
In general, in web applications, we have to organize the web pages in
standardization in order to improve look and feel.
To manage all the web pages in a standardization we have to use Templates.
In general , in web applications we will use the following templates to

prepare web pages.
To create and manage all the above templates and to provide flow of execution
between the templates web pages we have to use Apache provided Tiles
Framework.
Apache Software Foundations has provided the complete tiles framework in the
form of the following jar files.
1. tiles-api-version.jar
2. tiles-core-version.jar
3. tiles-jsp-version.jar
4. tiles-servlet-version.jar
5. tiles-template-version.jar
Spring WEB MVC framework is providing inbuilt support for tiles framework in
order to prepare web applications.
If we want to use Tiles Framework in Spring Web MVC applications then we have
to use the following steps.
1. Prepare Template page by using Tiles Tags.

2. Prepare Tiles Pages.
3. Prepare Tiles Definitions.
4. Prepare Controller class.
5. Prepare Configuration File.
Prepare Template page by using Tiles Tags:

—------------------------------------------
The main intention of the Template page is to define a standard template to
define the web pages.
To prepare Template pages we have to use the following Tiles Tag library
which is available with the following URI.
<%@taglib uri=”http://tiles.apache.org/tags-tiles” prefix=”tiles”%>
<tiles:insertAttribute name=”--”/>
This tag can be used to define a logical name to the tile in Template.
Where “name” attribute will take logical name to the tile in Template.
<%@taglib uri=”http://tiles.apache.org/tags-tiles” prefix=”tiles”%>

<html>
<body>
<table width=”100%” height=”100%”>
<tr height=”20%”>
<td colspan=”2” align=”center”>
<tiles:insertAttribute name=”header”/>
</td>
</tr>
<td width=”20%”>
<tiles:insertAttribute name=”menu”/>
</td>
<td width=”80%”>
<tiles:insertAttribute name=”body”/>
</td>
</tr>
<td colspan=”2” align=”center”>
<tiles:insertAttribute name=”footer”/>
</td>
</tr>
</table>
</body>
</html>
Prepare Tiles Pages:

—-------------------
In Tiles Framework, Tile is a JSP page, it is able to represent Header,
Footer, menu, body,....
header.jsp
<html>
<body>
<h1 style=”color: white;”>DURGA SOFTWARE SOLUTIONS<\h1>
</body>
</html>
menu.jsp
<html>
<body>
<h3>
<a href=”add”>Add Student</a><br>
<a href=”search”>Search Student</a><br>
<a href=”delete”>Delete Student</a>
</h3>
</body>
</html>
Prepare Tiles Definitions:

—--------------------------
The main intention of Tiles definitions is to define a combination of tiles
pages in the form of definitions.
To provide tiles definition in web applications we have to use the following

tags in an XML file.
<!DOCTYPE ….. >

<tiles-definitions>
<definition name=”---” template=”---”>
<put-attribute name=”--” value=”--”/>
—----
</definition>
—----
</tiles-definitions>
Where <tiles-definitions> tag is a root tag , it will include tiles

definitions.
Where <definition> tag is able to provide a single definition which includes
tiles pages.
Where “template” attribute in <definition> tag will take the name and
location of the layout or template page.
Where <put-attribute> tag will assign the tile jsp page to the respective
logical name of the tile in the jsp page.
Where “name” attribute in <put-attribute> tag will take the logical name of
the tag.
Where “value” attribute will take the name and location of the tile jsp page.
IN tiles definitions, we are able to extend one definition to another

definition in order to reuse tiles configurations.
tiles-defs.xml
<!DOCTYPE…..>
<tiles-definitions>
<definition name=”welcomeDef” template=”/layout.jsp”>
<put-attribute name=”header” value=”/header.jsp”/>
<put-attribute name=”menu” value=”/menu.jsp”/>
<put-attribute name=”body” value=”/welcome.jsp”/>
<put-attribute name=”footer” value=”/footer.jsp”/>
</definition>
<definition name=”addDef” extends=”welcomeDef”>
<put-attribute name=”body” value=”/addform.jsp”/>
</definition>
<definition name=”searchDef” extends=”welcomeDef”>
<put-attribute name=”body” value=”/searchform.jsp”/>
</definition>
<definition name=”deleteDef” extends=”welcomeDef”>
<put-attribute name=”body” value=”/deleteform.jsp”/>
</definition>
—-----
Prepare Controller Class:

—-------------------------
IN Tiles based applications, we will prepare the controller classes like
normal controller classes, but the business methods have to return tiles
definitions with logical names only , not jsp page names.
EX:
@Controller
public class StudentController{
@RequestMapping(value=”/welcome”, method=RequestMethod.GET)
public String welcome(){
return “welcomeDef”;
}
@RequestMapping(value=”/add” method=RequestMethod.GET)
public ModelAndView addStudent(){
return new ModelAndView(“addDef”, “student”, new Student());
}
—-----
—----
public ModelAndView add(Student student){

return new ModelAndView(“statusDef”,”status”, status);
}
—-----
—-----
}
Prepare Configuration File:

—---------------------------
In the Spring Configuration File we have to use the following configurations.
1. UrlBasedViewResolver with TilesView class.
2. TilesConfigurer with “definition” property of list type with tiles
definitions xml file.
<beans>
—---
<bean id=”viewResolver” class=”org……UrlBasedViewResolver>
<property name=”viewClass”>
<value>org.springframework…..TilesView
</property>
</bean>
<bean id=”tilesConfigurer” class=”org…..TilesConfigurer”>
<property name=”definitions”>
<list>
<value>/WEB-INF/tiles-def.xml</value>
</list>
</property>
</bean>
—---
</beans>
EX:
—---
index.jsp
%>
<!DOCTYPE html>
<html>
<head>
<title>Index Page</title>
</head>
<body>
<jsp:forward page="welcome"/>
</body>
</html>
layout.jsp
<%--
User: Nagoor
Date: 12-08-2023
Time: 07:08
--%>
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles"%>
<html>
<head>
<title>Layout Page</title>
</head>
<body>
<table width="100%" height="100%">
<tr height="20%">
<td colspan="2" align="center" bgcolor="maroon">
<tiles:insertAttribute name="header"/>
</td>
</tr>
<tr height="65%">
<td width="20%" bgcolor="aqua">
<tiles:insertAttribute name="menu"/>
</td>
<td width="80%" bgcolor="#FFD9B7">
<tiles:insertAttribute name="body"/>
</td>
</tr>
<tr height="15%" align="center">
<td colspan="2" bgcolor="blue">
<tiles:insertAttribute name="footer"/>
</td>
</tr>
</table>
</body>
</html>
header.jsp
<%--
User: Nagoor
Date: 12-08-2023
Time: 07:18
--%>
<html>
<head>
<title>Header Page</title>
</head>
<body>
<h1 style="color: white;" align="center">DURGA SOFTWARE
SOLUTIONS</h1>
</body>
</html>
menu.jsp
<%--
User: Nagoor
Date: 12-08-2023
Time: 07:21
--%>
<html>
<head>
<title>Menu Page</title>
</head>
<body>
<br><br><br>
<h3>
<a href="add">ADD Student</a><br><br>
<a href="search">SEARCH Student</a><br><br>
<a href="delete">DELETE Student</a>
</h3>
</body>
</html>
welcome.jsp
<%--
User: Nagoor
Date: 12-08-2023
Time: 07:23
--%>
<html>
<head>
<title>Welcome Page</title>
</head>
<body>
<h2 style="color: #241468;" align="center">
<marquee>
Welcome to Durga Software Solutions
</marquee>
</h2>
</body>
</html>
footer.jsp
<%--
User: Nagoor
Date: 12-08-2023
Time: 07:24
--%>
<html>
<head>
<title>Footer Page</title>
</head>
<body>
<h3 style="color: white" align="center">
Durga Software Solutions, 202, HMDA, Mitrivanam, Ameerpet,
Hyderabad-38
</h3>
</body>
</html>
addstudent.jsp
<%--
User: Nagoor
Date: 13-08-2023
Time: 06:41
--%>
prefix="form"%>
<html>
<head>
<title>Student Add Form</title>
</head>
<body>
<br><br>
<form:form method="post" action="add" modelAttribute="student">
<tr>
<td>Student Id</td>
<td><form:input path="sid"/></td>
</tr>
<tr>
<td><form:input path="sname"/></td>
</tr>
<tr>
<td><form:input path="saddr"/></td>
</tr>
<tr>
<td><input type="submit" value="ADD"/></td>
</tr>
</table>
</form:form>
</body>
</html>
searchstudent.jsp
<%--
User: Nagoor
Date: 13-08-2023
Time: 06:45
--%>
prefix="form"%>
<html>
<head>
<title>Student Search Form</title>
</head>
<body>
<br><br>
<form:form method="post" action="search" modelAttribute="student">
<tr>
<td>Student Id</td>
</tr>
<tr>
<td><input type="submit" value="SEARCH"></td>
</tr>
</table>
</form:form>
</body>
</html>
deletestudent.jsp
<%--
User: Nagoor
Date: 13-08-2023
Time: 06:45
--%>
prefix="form"%>
<html>
<head>
<title>Student Delete Form</title>
</head>
<body>
<br><br>
<form:form method="post" action="delete" modelAttribute="student">
<tr>
<td>Student Id</td>
</tr>
<tr>
<td><input type="submit" value="DELETE"></td>
</tr>
</table>
</form:form>
</body>
</html>
status.jsp
<%--
User: Nagoor
Date: 13-08-2023
Time: 07:33
--%>
<html>
<head>
<title>Student Status Page</title>
</head>
<body>
<br><br>
<h1 style="color: deeppink" align="center">${status}</h1>
</body>
</html>
studentdetails.jsp
<%--
User: Nagoor
Date: 13-08-2023
Time: 07:35
--%>
<html>
<head>
<title>Student Details Page</title>
</head>
<body>
<br><br>
<table align="center" border="1">
<tr>
<td>Student Id</td>
<td>${student.sid}</td>
</tr>
<tr>
<td>${student.sname}</td>
</tr>
<tr>
<td>${student.saddr}</td>
</tr>
</table>
</body>
</html>
Student.java
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
public class Student {
private String sid;
private String sname;
private String saddr;
public String getSid() {

return sid;
}
public void setSid(String sid) {

this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {

this.sname = sname;
}
public String getSaddr() {

return saddr;
}
public void setSaddr(String saddr) {

this.saddr = saddr;
}
}
StudentController.java
import com.durgasoft.app16.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
@Controller
public class StudentController {
@Autowired
private StudentService studentService;
@RequestMapping(value = "welcome", method = RequestMethod.GET)

public String welcome(){
return "welcomeDef";
}
@RequestMapping(value = "/add", method = RequestMethod.GET)
public ModelAndView addStudentForm(){
return new ModelAndView("addDef", "student", new Student());
}
@RequestMapping(value = "/search", method = RequestMethod.GET)
public ModelAndView searchStudentForm(){
return new ModelAndView("searchDef", "student", new
Student());
}
@RequestMapping(value = "/delete", method = RequestMethod.GET)
public ModelAndView deleteStudentForm(){
return new ModelAndView("deleteDef", "student", new
Student());
}
@RequestMapping(value = "/add", method = RequestMethod.POST)

public ModelAndView add(Student student){
return new ModelAndView("statusDef", "status", status);
}
@RequestMapping(value = "/search", method = RequestMethod.POST)

public ModelAndView search(Student student){
Student std = studentService.searchStudent(student.getSid());
if(std == null){
return new ModelAndView("statusDef", "status", "Student
Does Not Exist");
}else{
return new ModelAndView("studentDetailsDef", "student",
std);
}
}
@RequestMapping(value="/delete", method = RequestMethod.POST)
public ModelAndView delete(Student student){
String status =
studentService.deleteStudent(student.getSid());
return new ModelAndView("statusDef", "status", status);
}
}
StudentService.java
public interface StudentService {

public String addStudent(Student student);
public Student searchStudent(String sid);
public String deleteStudent(String sid);
}
StudentServiceImpl.java
import com.durgasoft.app16.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class StudentServiceImpl implements StudentService{
@Autowired
private StudentDao studentDao;
@Override
public String addStudent(Student student) {
String status = studentDao.add(student);
return status;
}
@Override
public Student searchStudent(String sid) {
Student student = studentDao.search(sid);
return student;
}
@Override
public String deleteStudent(String sid) {
String status = studentDao.delete(sid);
return status;
}
}
StudentDao.java
public interface StudentDao {

public String add(Student student);
public Student search(String sid);
public String delete(String sid);
}
StudentDaoImpl.java
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@Repository
public class StudentDaoImpl implements StudentDao{
@PersistenceContext
private EntityManager entityManager;
@Transactional
@Override
public String add(Student student) {
String status = "";
Student std = search(student.getSid());
if(std == null){
entityManager.persist(student);
status = "Student Inserted Successfully";
}else{
status = "Student Existed Already";
}
return status;
}
@Override
public Student search(String sid) {
Student student = null;
student = entityManager.find(Student.class,sid);
return student;
}
@Transactional
@Override
public String delete(String sid) {
String status = "";
Student student = entityManager.find(Student.class, sid);
status = "Student Does Not Exist";
}else{
entityManager.remove(student);
status = "Student Deleted Successfully";
}
return status;
}
}
Student.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.durgasoft.app16.beans.Student" table="student">
<id name="sid"/>
<property name="sname"/>
<property name="saddr"/>
</class>
</hibernate-mapping>
tiles-defs.xml
<!DOCTYPE tiles-definitions PUBLIC "-//Apache Software
Foundation//DTD Tiles Configuration 3.0//EN"
"http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
<tiles-definitions>
<definition name="welcomeDef" template="/layout.jsp">
<put-attribute name="header" value="/header.jsp"/>
<put-attribute name="menu" value="/menu.jsp"/>
<put-attribute name="body" value="/welcome.jsp"/>
<put-attribute name="footer" value="/footer.jsp"/>
</definition>
<definition name="addDef" extends="welcomeDef">
<put-attribute name="body" value="/addstudent.jsp"/>
</definition>
<definition name="searchDef" extends="welcomeDef">
<put-attribute name="body" value="/searchstudent.jsp"/>
</definition>
<definition name="deleteDef" extends="welcomeDef">
<put-attribute name="body" value="/deletestudent.jsp"/>
</definition>
<definition name="statusDef" extends="welcomeDef">
<put-attribute name="body" value="/status.jsp"/>
</definition>
<definition name="studentDetailsDef" extends="welcomeDef">
<put-attribute name="body" value="/studentdetails.jsp"/>
</definition>
ds-servlet.xml
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
<tx:annotation-driven/>
<bean name="tilesConfigurer"
class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
<property name="definitions">
<list>
<value>/WEB-INF/tiles-defs.xml</value>
</list>
</property>
</bean>
class="org.springframework.web.servlet.view.UrlBasedViewResolver">
<property name="viewClass">
<value>org.springframework.web.servlet.view.tiles3.TilesView</value>
</property>
</bean>
<bean name="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3300/durgadb"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<bean name="entityManagerFactoryBean"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactory
Bean">
<property name="dataSource" ref="dataSource"/>
<property name="persistenceUnitName" value="std"/>
<property name="jpaVendorAdapter">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/
>
</property>
<property name="mappingResources">
<list>
<value>Student.xml</value>
</list>
</property>
<property name="jpaProperties">
<props>
<prop
key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean name="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory"
ref="entityManagerFactoryBean"/>
</bean>
</beans>
web.xml
version="5.0">
<servlet>
vlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>

Spring Web

Uploaded by

Spring Web

Uploaded by

Spring WEB and Spring WEB MVC

Spring WEB MVC:

Spring Framework is an application Framework, it can be used to

2. In the enterprise Application Development, Struts and JSF are able

Spring Framework is a layered / Moduled Framework.

4. Struts and JSF Frameworks are Heavyweight Frameworks, to prepare

Spring Framework is lightweight, because, In the case of Spring

Spring Framework is less API dependent, because Spring Framework is

2. Spring Web MVC allows a Powerful and Straightforward configuration of both

6. Spring WEB MVC is providing very good Theme resolutions, Locale,... in a

Spring WEB MVC Components:

View or User Interface:

IN general, in enterprise applications, we will use technologies like Html,

There are two types of User Interface or View.

Informational User Interface:

Form Based User Interface:

Web.xml or Deployment Descriptor:

In general, in web applications, web.xml file is responsible for the

1. Welcome Files configurations

a. DispatcherServlet class configuration:

b. URL Mapping Definitions:

1. Exact Match Method

In Spring WEB MVC applications , if we want to use Directory Match method to

In Spring WEB MVC applications , if we want to use Extension Match method to

In Spring WEB MVC applications, DispatcherServlet is acting as a front

Where HttpServletBean is able to inject beans properties using the Servlet

When DispatcherServlet performs WebApplicationContext Initialization,

1. WebApplicationContext will recognize the Spring Configuration file with

3. After creating the Configuration object, WebApplicationContext will

1. DispatcherServlet will keep all the Frameworks objects like

Note: Interoceptors are like Filters in Servlets, they will perform

6. DispatcherServlet will get Handler class object reference from

When the Container receives a response from the DispatcherServlet, Container

1. Protocol will create ResponseFormat containing both Header part and

When we submit request to the Spring WEB MVC application , DispatcherServlet

When we submit request with an URL pattern, BeanNameUrlHandlerMapping will

Spring Framework has provided the BeanNameUrlHandlerMapping in the form of a

Spring Framework has provided this HandleMapping in the form of a predefined

For Simple Controller Implementations the convention is to take the short

To represent this Handler Mapping Spring framework has provided a predefined

To access the above WelcomeController and HelloController we have to use the

To prepare Controller classes Spring Framework has provided the following

public ModelAndView handleRequest(HttpServletRequest request,

Here the ModelAndView is an object , it contains Model data in the Model

To create ModelAndView objects , ModelAndView class has provided the

Spring Framework has provided the following list of VieweResolvers.

In Spring Web MVC applications, we will use mainly

The name of the Spring Configuration file is

public class WishController implements Controller {

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE web-app PUBLIC

return new ModelAndView("hello", "message", "Hello User,

public class WelcomeController implements Controller {

return new ModelAndView("welcome", "message", "Welcome User, Good

<!DOCTYPE web-app PUBLIC

public class HelloController implements Controller {

public class LoginFormController implements Controller {

public class LoginController implements Controller {

To prepare Controller classes we have to use some predefined library

AbstractController has provided the following method to include application

public ModelAndView handleRequestInternal(HttpServletRequest request,

There are three types of AbstractController classes.

In the case of ParameterizableViewController it is not required to define any

In general, we will use it to get web pages by clicking on hyperlinks.

In general, in the web applications we will take a separate COntroller class

public class StudentAddController implements Controller{

public class StudentSearchController implements Controller{

public class StudentUpdateController implements Controller{

public class StudentDeleteController implements Controller{

To overcome the above problem we need an alternative where we have to perform

EX: In a single StudentController class we have to perform multiple

public class StudentController{

To achieve the above requirement we have to use a MultiActionController .

The main intention of MultiActionController is to group the related actions

If we want to use the MultiActionController class in spring web mvc

1. Declare an user defined class