Web Technology (KCS 602)

Unit 5
Servlet Overview
A servlet is a Java class that extends the capabilities of a web server and responds to
incoming HTTP requests. Servlets are used to create dynamic web pages that are
generated on the server side. This means that the content of the web page is not
stored in a static file, but is instead generated by the servlet code each time the page
is requested.

Servlets offer a number of advantages over other technologies for creating dynamic
web pages, such as CGI and ASP. Servlets are platform-independent, meaning that
they can be run on any platform that supports Java. They are also more scalable than
CGI, as they can handle multiple requests simultaneously. Additionally, servlets are
more secure than CGI, as they can be used to implement user authentication and
authorization.

Servlet Architecture
The servlet architecture consists of three main components:

• The servlet container: This is the software that runs the servlets and provides
the environment in which they can execute.
• The servlet: This is the Java class that extends the capabilities of the web
server and responds to incoming HTTP requests.
• The web container: This is the software that provides the infrastructure for
running web applications, such as HTTP routing, session management, and
security.

The servlet container and the web container are often combined into a single
software package.

Servlet Life Cycle

A servlet goes through a number of states during its life cycle. These states are:

• Initialized: The servlet is created and initialized by the servlet container.

• Ready: The servlet is ready to service requests.
• Active: The servlet is servicing a request.
• Destroyed: The servlet is destroyed by the servlet container.
The servlet container will automatically manage the servlet life cycle. However,
developers can also manually control the life cycle of their servlets by using the
init() and destroy() methods.

Servlet Programming
Servlets are programmed using the Java programming language. Servlets must
implement the Servlet interface, which provides a number of methods that are used
to handle HTTP requests and responses.

Servlets can be programmed in a number of different ways. However, the most

common approach is to use the HttpServlet class, which provides a number of
convenience methods for handling HTTP requests.

Servlet Deployment
Servlets are deployed to a servlet container by placing them in a specific directory on
the server. The servlet container will automatically scan this directory for servlets and
load them into memory.

Servlets can also be deployed using a web application server, such as Tomcat or
JBoss. Web application servers provide a number of features that make it easier to
develop and deploy servlet-based web applications.

Servlets vs. Other Technologies

Servlets are often compared to other technologies for creating dynamic web pages,
such as CGI and ASP.

• CGI: CGI stands for Common Gateway Interface. It is a programming

interface that allows a web server to execute external programs. CGI
programs are typically written in languages such as Perl or C.
• ASP: ASP stands for Active Server Pages. It is a Microsoft technology that
allows web pages to be generated dynamically using server-side scripting.
ASP pages are typically written in Visual Basic.

Servlets offer a number of advantages over CGI and ASP, including:

• Platform-independent: Servlets are platform-independent, meaning that they

can be run on any platform that supports Java.
• Scalable: Servlets are more scalable than CGI, as they can handle multiple
requests simultaneously.
 • Secure: Servlets can be used to implement user authentication and
authorization.

Conclusion
Servlets are a powerful technology that can be used to create dynamic web pages.
Servlets offer a number of advantages over other technologies for creating dynamic
web pages, such as platform-independence, scalability, and security.

Servlet interface and the Servlet life cycle:

• The Servlet interface is a Java interface that defines the basic methods that
all servlets must implement. These methods include:

o init(): This method is called by the web container when the servlet is
first created. It is used to initialize the servlet's state, such as loading
any resources that the servlet needs.
o service(): This method is called by the web container to handle a
request from a client. It is responsible for processing the request and
generating a response.
o destroy(): This method is called by the web container when the servlet
is being destroyed. It is used to clean up any resources that the servlet
is using.
• The Servlet life cycle is the process by which a servlet is created, initialized,
used, and destroyed. The life cycle of a servlet is as follows:

1. The web container loads the servlet's class file.

2. The web container creates an instance of the servlet class.
3. The web container calls the servlet's init() method.
4. The web container calls the servlet's service() method to handle
requests from clients.
5. When the web container is shutting down, it calls the
servlet's destroy() method.

The Servlet life cycle is managed by the web container. The web container is
responsible for loading, initializing, and destroying servlets. The web container also
manages the resources that servlets use.

• Servlet listeners can be used to monitor and react to events in a servlet's life
cycle. Servlet listeners are classes that implement
the ServletListener interface. When a servlet event occurs, the web
container will call the appropriate methods in the servlet listeners that are
registered with the web container.
Servlet listeners can be used to perform a variety of tasks, such as:

Code snippet
* Logging servlet events
* Monitoring servlet performance
* Initiating transactions
* Pooling servlet resources

Servlet listeners are a powerful tool that can be used to improve the performance,
reliability, and security of servlet-based applications.

Handling HTTP GET and POST requests in a servlet:

• Handling HTTP GET requests

GET requests are used to retrieve data from a server. The data that is retrieved can
be anything, such as a web page, an image, or a file. To handle a GET request, you
can override the doGet() method in your servlet. The doGet() method takes two
parameters: * HttpServletRequest: This object represents the request that was sent
by the client. * HttpServletResponse: This object represents the response that will be
sent back to the client.

The doGet() method can be used to perform any task that is required to handle the
request. For example, you can use the doGet() method to:

Code snippet
* Retrieve data from a database
* Render a web page
* Send an email

• Handling HTTP POST requests

POST requests are used to send data to a server. The data that is sent can be
anything, such as a form submission, a file upload, or a chat message. To handle a
POST request, you can override the doPost() method in your servlet. The doPost()
method takes two parameters: * HttpServletRequest: This object represents the
request that was sent by the client. * HttpServletResponse: This object represents
the response that will be sent back to the client.

The doPost() method can be used to perform any task that is required to handle the
request. For example, you can use the doPost() method to:

Code snippet
* Save data to a database
* Update a record in a database
* Send an email

Here is an example of a servlet that handles a GET request:

public class HelloServlet extends HttpServlet {

Code snippet
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
// Get the name of the user from the request
String name = request.getParameter("name");

// Create a response
response.setContentType("text/html");
response.getWriter().write("<h1>Hello, " + name + "!</h1>");
}

This servlet will get the name of the user from the request and then create a
response that includes a greeting for the user.

Here is an example of a servlet that handles a POST request:

public class SaveServlet extends HttpServlet {

Code snippet
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
// Get the name and age of the user from the request
String name = request.getParameter("name");
int age = Integer.parseInt(request.getParameter("age"));

// Save the user's information to a database

User user = new User(name, age);
UserDAO.save(user);

// Create a response
response.setContentType("text/html");
response.getWriter().write("<h1>User saved successfully!</h1>");
}

This servlet will get the name and age of the user from the request and then save the
user's information to a database.

Redirecting requests to other resources in a servlet:

• Redirecting requests
Redirecting requests is a common task in web development. It allows you to send a
client to a different resource, such as a different page, a different servlet, or a
different website.

• How to redirect requests

There are two ways to redirect requests in a servlet:

Code snippet
* **Using the `sendRedirect()` method**

The sendRedirect() method of the HttpServletResponse interface is used to redirect

a request to a new resource. The sendRedirect() method takes one parameter: *
url: The URL of the new resource.

For example, the following code redirects the request to the /home page:

Code snippet
response.sendRedirect("/home");

Code snippet
* **Using the `forward()` method**

The forward() method of the HttpServletRequest interface is used to forward a

request to a new resource. The forward() method takes one parameter: *
servletPath: The path of the new resource.

For example, the following code forwards the request to the /home servlet:

Code snippet
request.getRequestDispatcher("/home").forward(request, response);

• When to redirect requests

There are many situations when you might want to redirect requests. Here are a few
examples:

Code snippet
* **To redirect the user to a different page**

You might want to redirect the user to a different page if you want them to see
different content, such as a confirmation page or an error page.

Code snippet
* **To redirect the user to a different servlet**
You might want to redirect the user to a different servlet if you want them to perform
a different task, such as logging in or registering for a service.

Code snippet
* **To redirect the user to a different website**

You might want to redirect the user to a different website if you want them to access
a third-party service, such as a payment processor or a social media platform.

• Pros and cons of redirecting requests

Redirecting requests has both pros and cons. Here are a few of the pros and cons to
consider:

Pros:

Code snippet
* **Redirecting requests can be used to improve the user experience**

Redirecting requests can be used to improve the user experience by directing the
user to the correct resource. For example, if a user tries to access a page that does
not exist, you could redirect them to a home page or an error page.

Code snippet
* **Redirecting requests can be used to improve the performance of your
application**

Redirecting requests can be used to improve the performance of your application by

reducing the number of requests that are made to the server. For example, if you
have a page that is frequently accessed, you could redirect the user to a cached
version of the page.

Cons:

Code snippet
* **Redirecting requests can be disruptive to the user experience**

Redirecting requests can be disruptive to the user experience if the user is not
expecting it. For example, if you redirect the user to a different page without warning,
they might be confused or annoyed.

Code snippet
* **Redirecting requests can be used to hide errors from the user**
Redirecting requests can be used to hide errors from the user. For example, if an
error occurs while processing a request, you could redirect the user to an error page
instead of displaying the error message to the user.

• Conclusion

Redirecting requests is a powerful tool that can be used to improve the user
experience and performance of your web application. However, it is important to use
it carefully to avoid disrupting the user experience.

Session Tracking, Cookies, and Session Tracking with Http Session:

Session Tracking

Session tracking is a technique used by web servers to keep track of users as they
navigate through a website. This is done by assigning each user a unique identifier,
which is stored on the server and used to identify the user's requests. Session
tracking allows web servers to remember things about the user, such as their login
status, their shopping cart contents, or the pages they have visited.

There are several different ways to implement session tracking, including:

• Cookies: Cookies are small text files that are stored on the user's computer by
the web server. The cookie contains the user's unique identifier, which is used
by the server to identify the user's requests.
• Hidden form fields: Hidden form fields are fields that are not visible to the
user, but are submitted with the form data. The hidden form field contains the
user's unique identifier, which is used by the server to identify the user's
requests.
• URL rewriting: URL rewriting is a technique where the server appends the
user's unique identifier to the URL of each page that they visit. This allows the
server to identify the user's requests even if they do not have cookies
enabled.
• HttpSession: HttpSession is a Java object that is used to store session data.
The HttpSession object is created by the server when a user first visits a
page. The HttpSession object is then used to store data about the user, such
as their login status, their shopping cart contents, or the pages they have
visited.

Cookies

Cookies are small text files that are stored on the user's computer by the web server.
The cookie contains the user's unique identifier, which is used by the server to
identify the user's requests. Cookies are a popular way to implement session
tracking because they are easy to use and supported by most web browsers.
However, cookies can be disabled by users, which can prevent session tracking from
working.

Session Tracking with HttpSession

HttpSession is a Java object that is used to store session data. The HttpSession
object is created by the server when a user first visits a page. The HttpSession
object is then used to store data about the user, such as their login status, their
shopping cart contents, or the pages they have visited. HttpSession is a more secure
way to implement session tracking than cookies, because the data is stored on the
server and not on the user's computer. However, HttpSession can be more difficult to
use than cookies.

Advantages and Disadvantages of Session Tracking

Session tracking has several advantages, including:

• It allows web servers to remember things about the user, such as their login
status, their shopping cart contents, or the pages they have visited.
• It allows web servers to provide a more personalized experience for the user.
• It allows web servers to track the user's activity on the website.

However, session tracking also has some disadvantages, including:

• It can be a security risk, if the data is not stored securely.

• It can slow down the website, if the session data is not stored efficiently.
• It can be difficult to implement, if the web server does not support session
tracking.

Conclusion

Session tracking is a valuable tool that can be used to improve the user experience
on a website. However, it is important to weigh the risks and benefits of session
tracking before implementing it.

Introduction to JSP

Java Server Pages (JSP) is a server-side scripting language that is used to create
dynamic web pages. JSP pages are compiled into Java servlets, which are then
executed by a web server. JSP pages can be used to generate HTML, XML, or other
types of documents.

JSP pages are made up of two types of elements:

 • HTML elements: These elements are used to create the static content of the
web page.
• JSP elements: These elements are used to insert Java code into the web
page.

When a JSP page is requested by a web browser, the web server first compiles the
JSP page into a Java servlet. The servlet is then executed by the web server, and
the resulting HTML, XML, or other document is sent back to the web browser.

JSP Overview

JSP is a powerful technology that can be used to create dynamic web applications.
JSP pages are easy to learn and use, and they can be used to create a wide variety
of web applications.

Some of the benefits of using JSP include:

• Ease of development: JSP pages are easy to learn and use.

• Flexibility: JSP pages can be used to create a wide variety of web
applications.
• Performance: JSP pages can be very efficient, especially when they are used
in conjunction with other Java technologies, such as servlets and JSTL.

If you are looking for a powerful and flexible technology for creating dynamic web
applications, then JSP is a good option to consider.

Here are some of the key features of JSP:

• Easy to learn and use: JSP pages are easy to learn and use, even for
beginners.
• Dynamic content: JSP pages can be used to generate dynamic content, such
as product lists, customer information, and so on.
• Security: JSP pages can be secured using Java security mechanisms.
• Scalability: JSP pages can be scaled to handle large numbers of users.
• Portability: JSP pages are portable to any platform that supports Java.

A First Java Server Page Example

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<head>
<title>My First JSP Page</title>
</head>
<body>
<h1>This is my first JSP page!</h1>
</body>
</html>

This JSP page simply prints the text "This is my first JSP page!" to the web browser.

To run this JSP page, you need to have a Java web server installed. For example,
you can use the Apache Tomcat web server. Once you have installed Tomcat, you
need to create a new web application. In the web application, you need to create a
new JSP file and save it with the .jsp extension. In this example, the JSP file is
named index.jsp.

Once you have created the JSP file, you need to start the Tomcat web server. Then,
you can open a web browser and navigate to the following URL:

Code snippet
http://localhost:8080/myapp/index.jsp

This will load the JSP page in the web browser.

Here is a breakdown of the code in the JSP page:

• The <%@ page %> directive tells the web server that this is a JSP page.
• The language="java" attribute specifies that the JSP page will be written in
Java.
• The contentType="text/html; charset=UTF-8" attribute specifies that the
output of the JSP page will be HTML and that the character encoding will be
UTF-8.
• The <h1> tag creates a heading element with the text "This is my first JSP
page!"
• The </h1> tag closes the heading element.

Implicit objects, scripting, and standard actions in JSP:

Implicit Objects

JSP provides a number of implicit objects that are available to all JSP pages. These
objects are pre-defined variables that can be used to access information about the
request, response, session, application, and other aspects of the web application.

The following table lists the nine implicit objects in JSP:

Object Description

out This object is used to write output to the response.

request This object represents the HTTP request that was made to the JSP page.

response This object represents the HTTP response that will be sent back to the client.

session This object represents the HTTP session that is associated with the JSP page.

application This object represents the application context that is associated with the JSP page.

config This object represents the servlet configuration for the JSP page.

pageContext
This object provides access to information about the JSP page itself, such as
the page's attributes and its scope.

exception This object represents any exceptions that occur during the execution of the JSP page.

Scripting

JSP pages can contain both HTML and Java code. The Java code is executed by
the web server and can be used to manipulate data, generate output, and control the
flow of the JSP page.

JSP pages use the <% and %> delimiters to indicate the start and end of Java code.
For example, the following code will print the text "Hello World!" to the web browser:

Code snippet
<%
out.println("Hello World!");
%>

Standard Actions

JSP provides a number of standard actions that can be used to perform common
tasks, such as including other JSP pages, creating JavaBeans, and forwarding
requests to other pages.
 The following table lists some of the standard actions in JSP:

Action Description

jsp:include
This action includes the contents of another JSP page into the current JSP
page.

jsp:useBean
This action creates a JavaBean and associates it with a variable in the current
JSP page.

jsp:setProperty This action sets the value of a property in a JavaBean.

jsp:getProperty This action gets the value of a property in a JavaBean.

jsp:forward This action forwards the request to another JSP page.

These are just a few of the features that are available in JSP. For more information,
you can refer to the JSP documentation.

Directives, Custom Tag Libraries

Directives

JSP directives are used to control the compilation and execution of JSP pages.
There are three types of directives:

• page directive - This directive specifies the language, contentType, and other
properties of the JSP page.
• include directive - This directive includes the contents of another JSP page
into the current JSP page.
• taglib directive - This directive specifies the location and prefix of a tag library.

Custom Tag Libraries

Custom tag libraries are used to create reusable tags that can be used in JSP
pages. Custom tags are written in Java and are compiled into servlets. When a
custom tag is used in a JSP page, the servlet is executed and the output of the
servlet is inserted into the JSP page.
To create a custom tag library, you need to create a tag library descriptor (TLD) file.
The TLD file contains information about the tag library, such as the tag's name,
attributes, and functionality.

Once you have created the TLD file, you need to compile it into a JAR file. The JAR
file can then be deployed to the web application.

To use a custom tag library in a JSP page, you need to use the taglib directive to
specify the location and prefix of the tag library. Then, you can use the tag's name in
the JSP page.

For example, the following code uses the custom tag library mytags to create a
heading element:

Code snippet

<%@ taglib prefix="my" uri="mytags" %>

<my:heading>This is a heading</my:heading>

This will create a heading element with the text "This is a heading".

Custom tag libraries can be used to greatly simplify the development of JSP pages.
They can also be used to add functionality to JSP pages that would be difficult or
impossible to implement using standard JSP tags.