Core

Classloader

o Classloader is a subsystem of
JVM that is used to load class
files

1. BootStrap ClassLoader
2. Extension ClassLoader
3. SystemClassLoader
o Bootstrap class loader loads all
java core classes, which are at
the part of runtime.
Bootstrap ClassLoader JRE/lib/rt.jar

o Extension ClassLoader JRE/lib/ext or any directory

denoted by java.ext.dirs
o Application ClassLoader
- CLASSPATH environment
variable, -classpath or -cp opti
on, Class-Path attribute of
Manifest inside JAR file.
Aggregation
o

If a class have an entity reference, it is known

as Aggregation. Aggregation represents HASA relationship.
We are passing object instance from outside
in Aggregation.
Uses

o
o

For Code Reusability

Inheritance should be used only if the
relationship is-a is maintained throughout
the lifetime of the objects involved;
otherwise, aggregation is the best choice
Address.java

Emp.java

Composition

Composition is the design technique to

implement has-a relationship in classes. We
can use java inheritance or Object
composition for code reuse.
We are creating object instance from inside in
Composition.
Address.java

Emp.java

String, StringBuffer and StringBuilder

String

String is immutable in Java. Immutability

offers lot of benefit to the String hashcode
value can be cached which makes it a faster
hashmap key and one of the reasons why

String is a popular key in HashMap. Because

String is final it can be safely shared
between multiple threads without any
extra synchronization.
StringBuffer

StringBuffer is very good with mutable String

but it has one disadvantage all its public
methods are synchronized which makes
it thread-safe but same time slow.
StringBuilder

In JDK 5 they provided similar class called

StringBuilder in Java which is a copy of
StringBuffer but without synchronization. Try
to use StringBuilder whenever possible it
performs better in most of cases than
StringBuffer class.
JSP
1.What are the advantages of JSP over Servlet?
JSP is a serverside technology to make content generation a simple appear.The advantage of
JSP is that they are document-centric. Servlets, on the other hand, look and act like
programs. A Java Server Page can contain Java program fragments that instantiate and
execute Java classes, but these occur inside an HTML template file and are primarily used to
generate dynamic content. Some of the JSP functionality can be achieved on the client, using
JavaScript. The power of JSP is that it is server-based and provides a framework for Web
application development.
2.What is the life-cycle of JSP?
When a request is mapped to a JSP page for the first time, it translates the JSP page into a
servlet class and compiles the class. It is this servlet that services the client requests.
A JSP page has seven phases in its lifecycle, as listed below in the sequence of occurrence:

Translation

Compilation

Loading the class

Instantiating the class

jspInit() invocation

_jspService() invocation

jspDestroy() invocation

3.What is the jspInit() method?

The jspInit() method of the javax.servlet.jsp.JspPage
interface is similar to the init() method of servlets. This
method is invoked by the container only once when a JSP
page is initialized. It can be overridden by a page author
to initialize resources such as database and network
connections, and to allow a JSP page to read persistent
configuration data.

4.What is the _jspService() method?

SThe _jspService() method of the
javax.servlet.jsp.HttpJspPage interface is invoked every
time a new request comes to a JSP page. This method
takes the HttpServletRequest and HttpServletResponse
objects as its arguments. A page author cannot override
this method, as its implementation is provided by the
container.

5.What is the jspDestroy() method?

The jspDestroy() method of the javax.servlet.jsp.JspPage
interface is invoked by the container when a JSP page is
about to be destroyed. This method is similar to the
destroy() method of servlets. It can be overridden by a
page author to perform any cleanup operation such as
closing a database connection.

6.What JSP lifecycle methods can I override?

You cannot override the _jspService() method within a

JSP page. You can however, override the jspInit() and
jspDestroy() methods within a JSP page. jspInit() can be
useful for allocating resources like database connections,
network connections, and so forth for the JSP page. It is
good programming practice to free any allocated
resources within jspDestroy().

7.How can I override the jspInit() and jspDestroy()

methods within a JSP page?
The jspInit() and jspDestroy() methods are each executed
just once during the lifecycle of a JSP page and are
typically declared as JSP declarations:

<%!
public void jspInit() {

. . .

%>

<%!

public void jspDestroy() {

. . .

%>
8.What are implicit objects in JSP?
Implicit objects in JSP are the Java objects that the JSP
Container makes available to developers in each page.
These objects need not be declared or instantiated by
the JSP author. They are automatically instantiated by
the container and are accessed using standard variables;
hence, they are called implicit objects.The implicit
objects available in JSP are as follows:
o

request

response

pageContext

session

application

out

config

page

exception

The implicit objects are parsed by the container and

inserted into the generated servlet code. They are
available only within the jspService method and not in
any declaration.
9.What are the different types of JSP tags?
The different types of JSP tags are as follows:

10.What are JSP directives?

o

JSP directives are messages for the JSP engine.

i.e., JSP directives serve as a message from a JSP
page to the JSP container and control the
processing of the entire page

They are used to set global values such as a class

declaration, method implementation, output
content type, etc.

They do not produce any output to the client.

Directives are always enclosed within <%@ .. %>

tag.

Ex: page directive, include directive, etc.

11.What is page directive?

o

A page directive is to inform the JSP engine about

the headers or facilities that page should get from
the environment.

Typically, the page directive is found at the top of

almost all of our JSP pages.

There can be any number of page directives within

a JSP page (although the attribute value pair
must be unique).

The syntax of the include directive is: <%@ page

attribute="value">

Example:<%@ include file="header.jsp" %>

12.What are the attributes of page directive?

There are thirteen attributes defined for a page directive
of which the important attributes are as follows:
o

import: It specifies the packages that are to be

imported.

session: It specifies whether a session data is

available to the JSP page.

contentType: It allows a user to set the contenttype for a page.

isELIgnored: It specifies whether the EL

expressions are ignored when a JSP is translated
to a servlet.

13.What is the include directive?

There are thirteen attributes defined for a page directive
of which the important attributes are as follows:
o

The include directive is used to statically insert

the contents of a resource into the current JSP.

This enables a user to reuse the code without

duplicating it, and includes the contents of the
specified file at the translation time.

The syntax of the include directive is as follows:

This directive has only one attribute

called file that specifies the name of the file to
be included.

<%@ include file = "FileName" %>

14.What are the JSP standard actions?

o

The JSP standard actions affect the overall

runtime behavior of a JSP page and also the
response sent back to the client.

They can be used to include a file at the request

time, to find or instantiate a JavaBean, to forward
a request to a new page, to generate a browserspecific code, etc.

Ex: include, forward, useBean,etc. object

15.What are the standard actions available in JSP?

The standard actions available in JSP are as follows:
o

<jsp:include>: It includes a response from a

servlet or a JSP page into the current page. It
differs from an include directive in that it includes
a resource at request processing time, whereas
the include directive includes a resource at
translation time.

<jsp:forward>: It forwards a response from a

servlet or a JSP page to another page.

<jsp:useBean>: It makes a JavaBean available to

a page and instantiates the bean.

<jsp:setProperty>: It sets the properties for a

JavaBean.

<jsp:getProperty>: It gets the value of a property

from a JavaBean component and adds it to the
response.

<jsp:param>: It is used in conjunction with

<jsp:forward>;, <jsp:, or plugin>; to add a
parameter to a request. These parameters are
provided using the name-value pairs.

<jsp:plugin>: It is used to include a Java applet or

a JavaBean in the current JSP page.

16.What is the <jsp:useBean> standard action?

The <jsp:useBean> standard action is used to locate an
existing JavaBean or to create a JavaBean if it does not
exist. It has attributes to identify the object instance, to
specify the lifetime of the bean, and to specify the fully
qualified classpath and type.

17.What are the scopes available in <jsp:useBean>?

The scopes available in <jsp:useBean> are as follows:
o

page scope:: It specifies that the object will be

available for the entire JSP page but not outside
the page.

request scope: It specifies that the object will be

associated with a particular request and exist as
long as the request exists.

application scope: It specifies that the object will

be available throughout the entire Web
application but not outside the application.

session scope: It specifies that the object will be

available throughout the session with a particular
client.

18.What is the <jsp:forward> standard action?

o

The <jsp:forward> standard action forwards a

response from a servlet or a JSP page to another
page.

The execution of the current page is stopped and

control is transferred to the forwarded page.

The syntax of the <jsp:forward> standard action is

:
<jsp:forward page="/targetPage" />

Here, targetPage can be a JSP page, an HTML

page, or a servlet within the same context.
o

If anything is written to the output stream that is

not buffered before <jsp:forward>, an
IllegalStateException will be thrown.

Note : Whenever we intend to use <jsp:forward> or

<jsp:include> in a page, buffering should be enabled. By
default buffer is enabled.

19.What is the <jsp:include> standard action?

The <jsp:include> standard action enables the current
JSP page to include a static or a dynamic resource at
runtime. In contrast to the include directive, the include
action is used for resources that change frequently. The
resource to be included must be in the same context.The
syntax of the <jsp:include> standard action is as follows:
<jsp:include page="targetPage" flush="true"/>

Here, targetPage is the page to be included in the current

JSP.

20.What is the difference between include directive

and include action
Include directive
The include directive, includes the content of the specified

Include action

The include action, includes the response gene

file during the translation phasewhen the page is converted

to a servlet.

executing the specified page (a JSP page or a s

the request processing phasewhen the page is
a user.

The include directive is used to statically insert the contents The include standard action enables the curren
of a resource into the current JSP.
include a static or a dynamic resource at runtim
Use the include directive if the file changes rarely. Its the
fastest mechanism.

Use the include action only for content that ch

and if which page to include cannot be decided
main page is requested.

21.Differentiate between pageContext.include and jsp:include?

The <jsp:include> standard action and the pageContext.include() method are both used
to include resources at runtime. However, the pageContext.include() method always
flushes the output of the current page before including the other components,
whereas <jsp:include> flushes the output of the current page only if the value of flush is
explicitly set to true as follows:

<jsp:include page="/index.jsp" flush="true"/>

22.What is the jsp:setProperty action?
You use jsp:setProperty to give values to properties of beans that have been referenced
earlier. You can do this in two contexts. First, you can use jsp:setProperty after, but
outside of, a jsp:useBean element, as below:

<jsp:useBean id="myName" ... />

...
<jsp:setProperty name="myName" property="myProperty" ... />
In this case, the jsp:setProperty is executed regardless of whether a new bean was instantiated
or an existing bean was found.
A second context in which jsp:setProperty can appear is inside the body of
a jsp:useBean element, as below:
<jsp:useBean id="myName" ... >
...
<jsp:setProperty name="myName"
property="someProperty" ... />
</jsp:useBean>
Here, the jsp:setProperty is executed only if a new object was instantiated, not if an existing one
was found.

23.What is the jsp:getProperty action?

The <jsp:getProperty> action is used to access the properties of a bean that was set using the
<jsp:getProperty> action. The container converts the property to a String as follows:

If it is an object, it uses the toString() method to convert it

to a String.

If it is a primitive, it converts it directly to a String using the

valueOf() method of the corresponding Wrapper class.

The syntax of the <jsp:getProperty> method

is: <jsp:getProperty name="Name"
property="Property" />

Here, name is the id of the bean from which the property was set. The property attribute is the
property to get. A user must create or locate a bean using the <jsp:useBean> action before
using the <jsp:getProperty> action.
24.What is the <jsp:param> standard action?
The <jsp:param> standard action is used with <jsp:include> or <jsp:forward> to pass parameter
names and values to the target resource. The syntax of the <jsp:param> standard action is as
follows:
<jsp:param name="paramName" value="paramValue"/>

25.What is the jsp:plugin action ?

This action lets you insert the browser-specific OBJECT or EMBED element needed to specify that
the browser run an applet using the Java plugin.
26.What are scripting elements?
JSP scripting elements let you insert Java code into the servlet that will be generated from the
current JSP page. There are three forms:
1. Expressions of the form <%= expression %> that are
evaluated and inserted into the output,
2. Scriptlets of the form <% code %> that are inserted into
the servlet's service method,
3. Declarations of the form <%! code %> that are inserted
into the body of the servlet class, outside of any existing
methods.
27.What is a scriptlet?
A scriptlet contains Java code that is executed every time a JSP is invoked. When a JSP is
translated to a servlet, the scriptlet code goes into the service() method. Hence, methods and
variables written in scriptlets are local to the service() method. A scriptlet is written between
the <% and %> tags and is executed by the container at request processing time.

28.What are JSP declarations?

As the name implies, JSP declarations are used to declare class variables and methods in a
JSP page. They are initialized when the class is initialized. Anything defined in a declaration is
available for the whole JSP page. A declaration block is enclosed between the <%! and
%> tags. A declaration is not included in the service() method when a JSP is translated to a
servlet.
29.What is a JSP expression?
A JSP expression is used to write an output without using the out.print statement. It can be
said as a shorthand representation for scriptlets. An expression is written between the <%= and
%> tags. It is not required to end the expression with a semicolon, as it implicitly adds a
semicolon to all the expressions within the expression tags.
30.How is scripting disabled?
Scripting is disabled by setting the scripting-invalid element of the deployment descriptor to true.
It is a subelement of jsp-property-group. Its valid values are true and false. The syntax for
disabling scripting is as follows:
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>

Servlet
What is the Servlet?
A servlet is a Java programming language class that is used to extend the capabilities of servers
that host applications accessed by means of a request- response programming model.
2.What are the new features added to Servlet 2.5?
Following are the changes introduced in Servlet 2.5:

A new dependency on J2SE 5.0

Support for annotations

Loading the class

Several web.xml conveniences

A handful of removed restrictions

Some edge case clarifications

Learn more about Servlets 2.5 features

3.What are the uses of Servlet?

Typical uses for HTTP Servlets include:

Processing and/or storing data submitted by an HTML

form.

Providing dynamic content, e.g. returning the results of a

database query to the client.

A Servlet can handle multiple request concurrently and be

used to develop high performance system

Managing state information on top of the stateless HTTP,

e.g. for an online shopping cart system which manages
shopping carts for many concurrent customers and maps
every request to the right customer.

4.What are the advantages of Servlet over CGI?

Servlets have several advantages over CGI:

A Servlet does not run in a separate process. This

removes the overhead of creating a new process for each
request.

A Servlet stays in memory between requests. A CGI

program (and probably also an extensive runtime system
or interpreter) needs to be loaded and started for each CGI
request.

There is only a single instance which answers all requests

concurrently. This saves memory and allows a Servlet to
easily manage persistent data.

Several web.xml conveniences

A handful of removed restrictions

Some edge case clarifications

5.What are the phases of the servlet life cycle?

The life cycle of a servlet consists of the following phases:

Servlet class loading : For each servlet defined in the

deployment descriptor of the Web application, the servlet
container locates and loads a class of the type of the
servlet. This can happen when the servlet engine itself is

started, or later when a client request is actually delegated

to the servlet.

Servlet instantiation : After loading, it instantiates one or

more object instances of the servlet class to service the
client requests.

Initialization (call the init method) : After instantiation,

the container initializes a servlet before it is ready to
handle client requests. The container initializes the servlet
by invoking its init() method, passing an object
implementing the ServletConfig interface. In the init()
method, the servlet can read configuration parameters
from the deployment descriptor or perform any other onetime activities, so the init() method is invoked once and
only once by the servlet container.

Request handling (call the service method) : After the

servlet is initialized, the container may keep it ready for
handling client requests. When client requests arrive, they
are delegated to the servlet through the service() method,
passing the request and response objects as parameters.
In the case of HTTP requests, the request and response
objects are implementations of HttpServletRequest and
HttpServletResponse respectively. In the HttpServlet class,
the service() method invokes a different handler method for
each type of HTTP request, doGet() method for GET
requests, doPost() method for POST requests, and so on.

Removal from service (call the destroy method) : A

servlet container may decide to remove a servlet from
service for various reasons, such as to conserve memory
resources. To do this, the servlet container calls the
destroy() method on the servlet. Once the destroy()
method has been called, the servlet may not service any
more client requests. Now the servlet instance is eligible
for garbage collection
The life cycle of a servlet is controlled by the container in
which the servlet has been deployed.

6.Why do we need a constructor in a servlet if we use the init method?

Even though there is an init method in a servlet which gets called to initialize it, a constructor is
still required to instantiate the servlet. Even though you as the developer would never need to
explicitly call the servlet's constructor, it is still being used by the container (the container still
uses the constructor to create an instance of the servlet). Just like a normal POJO (plain old
java object) that might have an init method, it is no use calling the init method if you haven't
constructed an object to call it on yet.
7.How the servlet is loaded?
A servlet can be loaded when:

8.How a Servlet is unloaded?

First request is made.

Server starts up (auto-load).

There is only a single instance which answers all requests

concurrently. This saves memory and allows a Servlet to
easily manage persistent data.

Administrator manually loads.

A servlet is unloaded when:

Server shuts down.

Administrator manually unloads.

9.What is Servlet interface?

The central abstraction in the Servlet API is the Servlet interface. All servlets implement this
interface, either directly or , more commonly by extending a class that implements it.

Note: Most Servlets, however, extend one of the standard implementations of that interface,
namely javax.servlet.GenericServlet andjavax.servlet.http.HttpServlet.

webMethods Interview Questions

JSF Standard Components
Spring Tutorial
Hibernate Vs iBatis
JSP Interview Questions

People who read this, also read:10.What is the GenericServlet class?

GenericServlet is an abstract class that implements the Servlet interface and the ServletConfig
interface. In addition to the methods declared in these two interfaces, this class also provides
simple versions of the lifecycle methods init and destroy, and implements the log method
declared in the ServletContext interface.
Note: This class is known as generic servlet, since it is not specific to any protocol.
11.What's the difference between GenericServlet and HttpServlet?

GenericServlet
The GenericServlet is an abstract class that is extended by HttpServlet to
provide HTTP protocol-specific methods.

An abstract class that simplifies wr

base class and provides an framewo

The GenericServlet does not include protocol-specific methods for handling request
parameters, cookies, sessions and setting response headers.

The HttpServlet subclass passes ge

doGet() or doPost() method.

GenericServlet is not specific to any protocol.

HttpServlet only supports HTTP an

12.Why is HttpServlet declared

abstract?
The HttpServlet class is declared abstract because the default implementations of the main
service methods do nothing and must be overridden. This is a convenience implementation of
the Servlet interface, which means that developers do not need to implement all service
methods. If your servlet is required to handle doGet() requests for example, there is no need to
write a doPost() method too.
13.Can servlet have a constructor ?
One can definitely have constructor in servlet.Even you can use the constrctor in servlet for
initialization purpose,but this type of approch is not so common. You can perform common
operations with the constructor as you normally do.The only thing is that you cannot call that
constructor explicitly by the new keyword as we normally do.In the case of servlet, servlet
container is responsible for instantiating the servlet, so the constructor is also called by servlet
container only.
14.What are the types of protocols supported by HttpServlet ?
It extends the GenericServlet base class and provides a framework for handling the HTTP
protocol. So, HttpServlet only supports HTTP and HTTPS protocol.
15.What is the difference between doGet() and doPost()?
#

doGet()

doPost()

In doPost(), on the other hand will

In doGet() the parameters are appended
(typically) send the information through
1 to the URL and sent along with header
a socket back to the webserver and it
information.
won't show up in the URL bar.
The amount of information you can
2 send back using a GET is restricted as
URLs can only be 1024 characters.

You can send much more information to

the server this way - and it's not restricted
to textual data either. It is possible to
send files and even binary data such as
serialized Java objects!

doGet() is a request for information; it

doPost() provides information (such as
does not (or should not) change
3
placing an order for merchandise) that
anything on the server. (doGet() should
the server is expected to remember
be idempotent)
4 Parameters are not encrypted

Parameters are encrypted

doPost() is generally used to update or

doGet() is faster if we set the response
post some information to the
content length since the same
5
server.doPost is slower compared to
connection is used. Thus increasing the
doGet since doPost does not write the
performance
content length
doGet() should be idempotent. i.e.
6 doget should be able to be repeated
safely many times

This method does not need to be

idempotent. Operations requested
through POST can have side effects for
which the user can be held accountable.

doGet() should be safe without any side

This method does not need to be either
7 effects for which user is held
safe
responsible
8 It allows bookmarks.

It disallows bookmarks.

When to use doGet() and when doPost()?

Always prefer to use GET (As because GET is faster than POST), except mentioned in the
following reason:

If data is sensitive

Data is greater than 1024 characters

If your application don't need bookmarks.

17.How do I support both GET and POST from the same Servlet?
The easy way is, just support POST, then have your doGet method call your doPost method:

public void doGet(HttpServletRequest request, HttpServletResponse

response)
throws ServletException, IOException
{
doPost(request, response);
}
18.Should I override the service() method?
We never override the service method, since the HTTP Servlets have already taken care of it .
The default service function invokes the doXXX() method corresponding to the method of the
HTTP request.For example, if the HTTP request method is GET, doGet() method is called by
default. A servlet should override the doXXX() method for the HTTP methods that servlet
supports. Because HTTP service method check the request method and calls the appropriate
handler method, it is not necessary to override the service method itself. Only override the
appropriate doXXX() method.

19.How the typical servlet code look like ?

20.What is a servlet context object?

A servlet context object contains the information about the Web application of which the servlet
is a part. It also provides access to the resources common to all the servlets in the application.
Each Web application in a container has a single servlet context associated with it.
21.What are the differences between the ServletConfig interface and the ServletContext
interface?
ServletConfig

The ServletConfig interface is implemented by the servlet container in order to pass

A ServletContext defines a set of m
configuration information to a servlet. The server passes an object that implements the
servlet container.
ServletConfig interface to the servlet's init() method.
There is one ServletConfig parameter per servlet.

There is one ServletContext for the

share it.

The param-value pairs for ServletConfig object are specified in the <init-param>
within the <servlet> tags in the web.xml file

The param-value pairs for ServletC

tags in the web.xml file.

22.What's the difference between forward() and sendRedirect() methods?

forward()
A forward is performed internally by the servlet.

A redirect is a two step process, wh

fetch a second URL, which differs

The browser is completely unaware that it has taken place, so its original URL
remains intact.

The browser, in this case, is doing t

Any browser reload of the resulting page will simple repeat the original request, with
the original URL

A browser reloads of the second UR

rather fetch the second URL.

Both resources must be part of the same context (Some containers make provisions
for cross-context communication but this tends not to be very portable)

This method can be used to redirec

context, or even in the same domain

Since both resources are part of same context, the original request context is retained

Because this involves a new reques

parameters and attributes are no lon
(Variables will need to be passed by

Forward is marginally faster than redirect.

redirect is marginally slower than a

not one.

23.What is the difference between the include() and forward() methods?

include()
The RequestDispatcher include() method inserts the the contents of the
specified resource directly in the flow of the servlet response, as if it were part of the
calling servlet.

The RequestDispatcher forwa

in place of the servlet that was orig

If you include a servlet or JSP document, the included resource must not attempt to
change the response status code or HTTP headers, any such request will be ignored.

The forwarded resource may be ano

the response is issued under the sam
words, it is not the same as a redire

The include() method is often used to include common "boilerplate" text or

template markup that may be included by many servlets.

The forward() method is often us

processing some input and deciding
page.

Spring Interview Questions

JDBC Questions
Spring Tutorial
iBatis an alternative to Hibernate
Hibernate Interview Questions

Peop
24.What's the use of the servlet wrapper classes??
The HttpServletRequestWrapper and HttpServletResponseWrapper classes are designed
to make it easy for developers to create custom implementations of the servlet request and
response types. The classes are constructed with the

standard HttpServletRequest and HttpServletResponse instances respectively and their

default behaviour is to pass all method calls directly to the underlying objects.

25.What is the directory structure of a WAR file?

26.What is a deployment descriptor?

A deployment descriptor is an XML document with an .xml extension. It defines a component's
deployment settings. It declares transaction attributes and security authorization for an
enterprise bean. The information provided by a deployment descriptor is declarative and
therefore it can be modified without changing the source code of a bean.
The JavaEE server reads the deployment descriptor at run time and acts upon the component
accordingly.
27.What is the difference between the getRequestDispatcher(String path) method of
javax.servlet.ServletRequest interface and javax.servlet.ServletContext interface?
ServletRequest.getRequestDispatcher(String path)

ServletContext.ge

The getRequestDispatcher(String path) method

ofjavax.servlet.ServletRequest interface accepts parameter the path
to the resource to be included or forwarded to, which can be relative to the
request of the calling servlet. If the path begins with a / it is interpreted
as relative to the current context root.

The getRequestDispatcher(S
ofjavax.servlet.ServletCon
All path must start with a / a
context root.

28.What is preinitialization of a
servlet?
A container does not initialize the servlets as soon as it starts up, it initializes a servlet when
it receives a request for that servlet first time. This is called lazy loading. The servlet
specification defines the element, which can be specified in the deployment descriptor to
make the servlet container load and initialize the servlet as soon as it starts up. The process
of loading a servlet before any request comes in is called preloading or preinitializing a
servlet.
29.What is the <load-on-startup> element?
The <load-on-startup> element of a deployment descriptor is used to load a servlet file
when the server starts instead of waiting for the first request. It is also used to specify the
order in which the files are to be loaded. The <load-on-startup> element is written in the
deployment descriptor as follows:

<servlet>
<servlet-name>ServletName</servlet-name>
<servlet-class>ClassName</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

Note: The container loads the servlets in the order specified in the <load-on-startup>
element.
What is Servlet Chaining?
Servlet Chaining is a method where the output of one servlet is piped into a second servlet.
The output of the second servlet could be piped into a third servlet, and so on. The last
servlet in the chain returns the output to the Web browser.
43.How are filters?
Filters are Java components that are used to intercept an incoming request to a Web resource
and a response sent back from the resource. It is used to abstract any useful information
contained in the request or response. Some of the important functions performed by filters
are as follows:

Security checks

Modifying the request or response

Data compression

Logging and auditing

Response compression

Filters are configured in the deployment descriptor of a Web application. Hence, a user is not
required to recompile anything to change the input or output of the Web application.
44.What are the functions of an intercepting filter?
The functions of an intercepting filter are as follows:

It intercepts the request from a client before it reaches

the servlet and modifies the request if required.

It intercepts the response from the servlet back to the

client and modifies the request if required.

There can be many filters forming a chain, in which case

the output of one filter becomes an input to the next
filter. Hence, various modifications can be performed on
a single request and response.

45.What are the functions of the Servlet container?

The functions of the Servlet container are as follows:

Lifecycle management : It manages the life and death of

a servlet, such as class loading, instantiation,
initialization, service, and making servlet instances
eligible for garbage collection.

Communication support : It handles the communication

between the servlet and the Web server.

Multithreading support : It automatically creates a new

thread for every servlet request received. When the
Servlet service() method completes, the thread dies.

Declarative security : It manages the security inside the

XML deployment descriptor file.

JSP support : The container is responsible for converting

JSPs to servlets and for maintaining them.