InstanceOfJava: Servlets Tutorial

Java Servlet Interview Questions

Posted by: Instanceofjava Posted date: May 18, 2015 / comment : 2 Concept and Interview Questions , Java EE , Servlets Tutorial

1.Explain Servlet life cycle in java.

Servlet engine controls the life cycle of servlet
Servlet life cycle is described by three life cycle methods under 5 life cycle phases
life cycle methods are

init(ServletConfig obj)
service(servletRequest, servletResponse)
destroy()

When ever somethings happens in the life of servlet. servlet engine calls these methods on the servlet instance and hence the name.

2.What is ServletConfig ?

Request parameters are used by the servlet to receive data from client to process the request.
Some specific data must be supplied to the servlet at the time of initialization of the servlet and this data is specific to the client.But data is not supplied by the client via request parameters
Use initialization parameters to supply the data to the servlet at the time of initialization of the servlet. initialization parameters are set in deployment descriptor (Web.xml).
Servlet can access these parameters during the run time
Request parameters change form Request to request
Initialization parameters change from servlet to servlet.

3. What is ServletContext?

We can deploy multiple web applications in a servlet container.
Each web application contains its own resources in a separate environment. This environment called ad Web Application context or ServletContext.
The resources belongs to the one web application context are not available to the other web application context.
A Servlet context contains zero or more number of servlets. For every servlet object the container creates separate ServletConfig object.

4. Can we define a Constructor in servlet?

Yes we can define a constructor in servlet but we can not call the constructor explicitly because servlet container will create the object of servlet so it will be called by the servlet container.

5. Can we call destroy() method inside init() method of a servlet. If yes what will happen?

Yes we can call destroy() method inside a init() method.
Actually container will call destroy() method if we call that method explicitly nothing will happen.
If we override destroy() method and called from init(). method will be called and code will be executed.

6.What are the difference between GenericServlet and HttpServlet?

GenericServlet	HttpServlet
Abstract Class	Abstract Class
Protocol Independent	Http Protocol Dependent
Subclass of Servlet	Subclass of GenericServlet
public void service(ServletRequest req,ServletResponse res ).	Supports public void service() and protected void service(), doGet(),doPost(),doPut(),doDelete(),doHead(),doTrace(),doOptions()etc.

7.What are the differences between doGet() and doPost()?

doGet()	doPost()
protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, java.io.IOException	Protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
handles client's GET request	handles client's POST request
Request parameters appended to the URL and sent along with header information	Request parameters are submitted via form.
Request Parameters are not encrypted	Request Parameters are encrypted
Maximum size of data that can be sent using doget() method is 240 bytes	There is no maximum size for data.

8. Can we call a servlet from another servlet?

Yes. We can call a servlet from another servlet this is known as inter servlet communication.
By using RequestDispatcher object we can do this.
RequestDispatcher rd=request.getRequestDispatcher("other servlet url name");
rd.forward(req, res);

9. What are the differences between forward() and sendRedirect() methods?

forward()	sendRedirect()
request.getRequestDispathcer("example.jsp"). forward(request, response);	response.sendRedirect ("http://www.instanceofjava.com");
Used to forward the Request to resources available in within the server	Used to redirect the Request to other resources or domains

10.How can you get the information about one servlet context in another servlet?

By using setAttribut() method we can set the data in one servlet and get in another
Context.setAttribute (“name”,” value”)
Context.getAttribute (“name”)

11.Explain Servlet architecture?

Frequently asking java interview question in servlets you may get questions like
explain the architecture of java servlet?
explain the architecture of java servlet with diagram?
define the servlet architecture?
servlet architecture overview?
Servlets read the explicit data sent by the clients (browsers). This includes an HTML form on a Web page or it could also come from an applet or a custom HTTP client program.
Read the implicit HTTP request data sent by the clients (browsers). This includes cookies, media types and compression schemes the browser understands, and so forth.

The Servlet architecture in Java is a Java-based framework for building web applications. It is a specification defined by the Java Community Process (JCP) and is implemented by various web containers such as Apache Tomcat, Jetty, and GlassFish.

The Servlet architecture consists of several components, including:

Servlets: These are the core components of the Servlet architecture. They are Java classes that handle HTTP requests and responses. Servlets are executed by a web container, which is responsible for managing their lifecycle, threading, and security.

Web Containers: Also known as servlet engines, web containers are responsible for managing the lifecycle of servlets, providing services such as request handling, thread management, and security.

JSP (JavaServer Pages): These are Java-based pages that are used to create dynamic web content. JSPs are compiled into servlets by the web container and executed by the servlet engine.

JSP Tag Libraries: These are collections of custom tags that can be used in JSP pages to simplify the creation of dynamic web content.

JavaBeans: These are Java classes that encapsulate business logic and data. They can be used in JSP pages to create dynamic web content.

Filters: These are Java classes that can intercept and modify the requests and responses sent to and from servlets. They can be used to implement security, logging, and other common functionality.

Listeners: These are Java classes that are notified of certain events that occur within the web container, such as a servlet being initialized or a session being created.

In summary, the Servlet architecture provides a powerful and flexible framework for building web applications in Java, by providing a set of components and services to handle HTTP requests and responses, providing a powerful and flexible way to handle web content, and providing a set of components to handle security, logging, and other common functionality.

Read More : servlet architecture with diagram

Servlet example programs in eclipse

Posted by: Instanceofjava Posted date: March 15, 2015 / comment : 0 Java EE , Servlets Tutorial

1.Run eclipse.File -> new -> dynamic web project

2. Give project name : example MyFirstApp and click on next

3. Please check Generate web.xml deployment descriptor to auto generate web.xml file

4.click on finish. now project structure will be created.

5.Go to webcontent and create a folder with name Jsp to place jsp files and create a index.jsp.

6. index.jsp will have an error because it is not having servlet jar. file so we need to include servler-apt.jar file.

now its fine. modify index.jsp with one text box and submit button.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org
/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Login</title>
</head>
<body>
<form action="/MyFirstApp/hello" method="post">
Name:<input type="text" name="name" value="">
<input type="submit" name="name" value="submit">
</form>
</body>
</html>

7. create a servlet

package com.instanceofjava;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Hello extends HttpServlet{
private static final long serialVersionUID = 1L;
public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException,
ServletException{
String str= (String) req.getParameter("name");
req.setAttribute("name", str);
req.getRequestDispatcher("/Jsp/welcome.jsp").forward(req, res);
}
}

8. create a welcome.jsp page.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org
/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>welcome</title>
</head>
<body>
<%
String str=null;
try{
str=(String)request.getAttribute("name");
}catch(Exception e){
}
%>
<p>Welcome: <%=str %></p>
</body>
</html>

8. go to we.xml and include our servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns
/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>MyFirstApp</display-name>
<welcome-file-list>
<welcome-file>/Jsp/index.jsp</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>com.instanceofjava.Hello</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>

9. run the project , select tomcat 7 from apache.

10. Enter your name and click on submit.

RequestDispatcher in servlet

Posted by: Instanceofjava Posted date: December 07, 2014 / comment : 0 Java EE , Servlets Tutorial

One servlet delegating request processing duty to other servlet is known as request dispatching.
To implement inter-servlet communication and servlet -jsp communication we need request dispatching.
When servlet receives a simple client request it need to communicate with any other servlet. if the incoming client request is complex one.
A servlet process some portion of the request and remaining portion it need to communicate with other servlet known as inter-servlet communication.

Implementing Request dispatching:

Step 1: Creating RequestDispatcher object.

RequestDispatcher rd=request.getRequestDispatcher("other servlet url name");

Step 2: Dispatching the request to the other servlet.

RequestDispatcher having two methods to switch the control from one servelt to other

public void include(ServletRequest request,ServletResponse response)throws ServletException,java.io.IOException:Includes the content of a resource (servlet, JSP page, or HTML file) in the response.
public void forward(ServletRequest request,ServletResponse response)throws ServletException,java.io.IOException:Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server.

By calling any of the above two methods request dispatching is implemented

rd.forward(req, res) or rd.include(req, res)

forward();

In case of forward mechanism of request dispatching one servlet receives the control , performs a portion of processing and switches the control to another servlet for the remaining portion of the processing
That second servlet performs remaining portion of the request processing , produces the response page and handle over to the same web server.

Include():

In case of include mechanism of request dispatching one servlet receives the control , performs a portion of processing and switches the control to another servlet for the remaining portion of the processing. gets control back from the next servlet and produces the dynamic web page on the web server.

Servlet Tutorial

Posted by: Instanceofjava Posted date: December 06, 2014 / comment : 1 Servlets Tutorial

Introduction to Servlets:

Java servlets are small, platform-independent Java programs that can be used to extend the functionality of a Web server in variety of ways.
Small java programs compiled to bytecode that can be loaded dynamically and that extends the capabilities of the host.
A client program , which could be a web browser or some other program that can make connections across the internet, accesses a web server and makes a request.
This request is processed by the servlet engine that runs with the web server , which returns response to a servlet.
the servlet in turn sends a response in HTTP form to the client.
In functionality servlets lie somewhere between Common Gateway Interface (CGI) programs.

What is Servlet?

Servlet is a java based web technology to develop server side programs to make a web site interactive.
Servlet is an API.
A collection of library interfaces and classes of two pavkages is nothing but servlet API.
javax.servlet.
javax.servlet.http
A collection of library methods of above two packages is nothing but servlet API.
Servlet is specification.
Servlet is a J2EE technology.

A Servlet is a Java programming language class that extends the capabilities of a server to handle client requests and generate dynamic web content. Servlets form the foundation of Java-based web development and are essential for common operations like login systems, form processing, and session management.

In this tutorial, you'll learn how to set up, create, and deploy Servlets while understanding key concepts like HTTP methods, session management, and more.

Prerequisites

Before you dive in, make sure you have:

Basic knowledge of Java programming.
JDK (Java Development Kit) installed.
A web server like Apache Tomcat.
An IDE (Eclipse, IntelliJ, or NetBeans).
Familiarity with HTML and web concepts (optional but helpful).

Setting Up Your Servlet Project

Step 1: Create a Dynamic Web Project

In your IDE (e.g., Eclipse), create a Dynamic Web Project.
Name it ServletDemo and configure Tomcat as the runtime server.

Step 2: Add Servlet Dependencies

For Maven projects, add the javax.servlet dependency into your pom.xml file:

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>4.0.1</version>
  <scope>provided</scope>
</dependency>

Creating Your First Servlet

Let's build a simple "Hello World" Servlet.

Step 1: Create a Servlet Class

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>Hello, World! This is my first Servlet.</h1>");
        out.println("</body></html>");
    }
}

Step 2: Configure Servlet Mapping

In web.xml (or, for modern setups, use annotations):

<servlet>
  <servlet-name>HelloServlet</servlet-name>
  <servlet-class>HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name>HelloServlet</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>

Alternatively, use annotations in the Servlet class:

@WebServlet("/hello")
public class HelloServlet extends HttpServlet { ... }

Step 3: Deploy and Test

Deploy the project to Tomcat.
Visit http://localhost:8080/ServletDemo/hello to see the output!

Handling Different HTTP Methods

Servlets can handle different HTTP request types using methods such as doGet() and doPost().

Example: Handling a POST Request

protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    String username = request.getParameter("username");
    response.getWriter().println("Welcome, " + username + "!");
}

An HTML Form to Test the POST Request:

<form action="hello" method="post">
  <input type="text" name="username">
  <input type="submit" value="Submit">
</form>

Important Servlet Concepts

Request and Response Objects:
- HttpServletRequest: Contains client request data (parameters, headers).
- HttpServletResponse: Sends data back to the client.

Session Management:
Use HttpSession to track user sessions:

HttpSession session = request.getSession();
session.setAttribute("user", "John");

Request Dispatching:
Forward requests to other resources:

RequestDispatcher dispatcher = request.getRequestDispatcher("welcome.jsp");
dispatcher.forward(request, response);

Filters:
Intercept requests/responses for logging, authentication, etc.

Servlet Development Best Practices

Separation of Concerns: Keep business logic separate from presentation (use JSP or MVC frameworks).
Use Annotations: Simplify configuration with @WebServlet, @WebFilter, etc.
Exception Handling: Implement error pages for uncaught exceptions.
Security: Sanitize inputs, use HTTPS, and manage sessions securely.

Servlets are a powerful tool in Java web development. Learning them provides a strong foundation for working with advanced frameworks like Spring MVC or Jakarta EE. Start by experimenting with small projects, session management, and later integrate databases to build full-stack applications.

Explore JSP (JavaServer Pages) for dynamic views.
Learn about Servlet Context and Listeners.
Dive into Spring Boot for modern web development..

Subscribe to: Posts ( Atom )