JSP Interview Question and Answer

JSP-JAVA SERVER PAGES(72 question and answer)

1) What is JSP page?

A JSP page is a text-based document that contains two types of text: static template data, which can be expressed in any text-based format such as HTML, SVG, WML, and XML, and JSP elements, which construct dynamic content.

JSP is a dynamic scripting capability for web pages that allows Java as well as a few special tags to be embedded into a web file (HTML/XML, etc). The suffix ends with .jsp to indicate to the web server that the file is a JSP files. JSP is a server side technology - you can't do any client side validation with it.

JSP (java server pages ) is an extension of java programming technology. This is to add server side programming functionalities to java

The advantages are:

a) The JSP assists in making the HTML more functional. Servlets on the other hand allow outputting of HTML but it is a tedious process.

b) It is easy to make a change and then let the JSP capability of the web server you are using deal with compiling it into a servlet and running it.

2) What are JSP scripting elements?

JSP scripting elements let’s to insert Java code into the servlet that will be generated from the current JSP page.

There are three forms:

a) Expressions of the form <%= expression %> that are evaluated and inserted into the output,

b) Scriptlets of the form <% code %> that are inserted into the servlet's service method,

c) Declarations of the form <%! Code %> that are inserted into the body of the servlet class, outside of any existing methods.

3) What are JSP Directives?

A JSP directive affects the overall structure of the servlet class. It usually has the following form:

<%@ directive attribute="value" %>

However, you can also combine multiple attribute settings for a single directive, as follows:

<%@ directive attribute1="value1"

attribute 2="value2"

...

attributeN ="valueN" %>

There are two main types of directive: page, which lets to do things like import classes, customize the servlet superclass, and the like; and include, which lets to insert a file into the servlet class at the time the JSP file is translated into a servlet

4) What are predefined variables or implicit objects?

Implicit objects are created by the web container and contain information related to a particular request, page, or application. They are request, response, pageContext, session, and application, out, config, page and exception.

5) What are JSP ACTIONS?

JSP actions use constructs in XML syntax to control the behavior of the servlet engine. You can dynamically insert a file, reuse JavaBeans components, forward the user to another page, or generate HTML for the Java plugin.

Available actions include:

? jsp:include - Include a file at the time the page is requested.

? jsp:useBean - Find or instantiate a JavaBean.

? jsp:setProperty - Set the property of a JavaBean.

? jsp:getProperty - Insert the property of a JavaBean into the output.

? jsp:forward - Forward the requester to a newpage.

? Jsp: plugin - Generate browser-specific code that makes an OBJECT or EMBED

6) How do you pass data (including JavaBeans) to a JSP from a servlet?

(1) Request Lifetime: Using this technique to pass beans, a request dispatcher (using either "include" or forward") can be called. This bean will disappear after processing this request has been completed.

Servlet:

request.setAttribute("theBean", myBean);

RequestDispatcher rd = getServletContext().getRequestDispatcher("thepage.jsp");

rd.forward(request, response);

JSP PAGE:

(2) Session Lifetime: Using this technique to pass beans that are relevant to a particular session (such as in individual user login) over a number of requests. This bean will disappear when the session is invalidated or it times out, or when you remove it.

Servlet:

HttpSession session = request.getSession(true);

session.putValue("theBean", myBean);

/* You can do a request dispatcher here,

or just let the bean be visible on the

next request */

JSP Page:

(3) Application Lifetime: Using this technique to pass beans that are relevant to all servlets and JSP pages in a particular app, for all users. For example, I use this to make a JDBC connection pool object available to the various servlets and JSP pages in my apps. This bean will disappear when the servlet engine is shut down, or when you remove it.

Servlet:

GetServletContext(). setAttribute("theBean", myBean);

JSP PAGE:

7) How can I set a cookie in JSP?

response.setHeader("Set-Cookie", "cookie string");

To give the response-object to a bean, write a method setResponse

(HttpServletResponse response)

- to the bean, and in jsp-file:

<%

bean.setResponse (response);

%>

8) How can I delete a cookie with JSP?

Say that I have a cookie called "foo," that I set a while ago & I want it to go away. I simply:

<%

Cookie killCookie = new Cookie("foo", null);

KillCookie.setPath("/");

killCookie.setMaxAge(0);

response.addCookie(killCookie);

%>

9) How are Servlets and JSP Pages related?

JSP pages are focused around HTML (or XML) with Java codes and JSP tags inside them. When a web server that has JSP support is asked for a JSP page, it checks to see if it has already compiled the page into a servlet. Thus, JSP pages become servlets and are transformed into pure Java and then compiled, loaded into the server and executed.

10) How many JSP scripting elements and what are they?

There are three scripting language elements: declarations, scriptlets, and expressions.

11) Why are JSP pages the preferred API for creating a web-based client program?

Because no plug-ins or security policy files are needed on the client systems(applet does). Also, JSP pages enable cleaner and more module application design because they provide a way to separate applications programming from web page design. This means personnel involved in web page design do not need to understand Java programming language syntax to do their jobs.

12) What do you understand by JSP Actions?

JSP actions are XML tags that direct the server to use existing components or control the behavior of the JSP engine. JSP Actions consist of a typical (XML-based) prefix of "jsp" followed by a colon, followed by the action name followed by one or more attribute parameters.

There are six JSP Actions:

-------------------------------------------------------------------------------------------

13). What is the difference between and
<%@ include file = ... >?.
Answer: Both the tag includes the information from one page in another. The differences are as follows:
: This is like a function call from one jsp to another jsp. It is executed ( the included page is executed and the generated html content is included in the content of calling jsp) each time the client page is accessed by the client. This approach is useful to for modularizing the web application. If the included file changed then the new content will be included in the output.

<%@ include file = ... >: In this case the content of the included file is textually embedded in the page that have <%@ include file=".."> directive. In this case in the included file changes, the changed content will not included in the output. This approach is used when the code from one jsp file required to include in multiple jsp files.

14). What is the difference between and
response.sendRedirect(url),?.
The element forwards the request object containing the client request information from one JSP file to another file. The target file can be an HTML file, another JSP file, or a servlet, as long as it is in the same application context as the forwarding JSP file.
sendRedirect sends HTTP temporary redirect response to the browser, and browser creates a new request to go the redirected page. The response.sendRedirect kills the session variables.

15). Identify the advantages of JSP over Servlet.

a) Embedding of Java code in HTML pages
b) Platform independence
c) Creation of database-driven Web applications
d) Server-side programming capabilities

Answer :- Embedding of Java code in HTML pages

16) What are implicit Objects available to the JSP Page?
Implicit objects are the objects available to the JSP page. These objects are created by Web container and contain information related to a particular request, page, or application.

Certain objects that are available for the use in JSP documents without being declared first. These objects are parsed by the JSP engine and inserted into the generated servlet.

The JSP implicit objects are:

Variable	Class	Description
application	javax.servlet.ServletContext	The context for the JSP page's servlet and any Web components contained in the same application.
config	javax.servlet.ServletConfig	Initialization information for the JSP page's servlet.
exception	java.lang.Throwable	Accessible only from an error page.
out	javax.servlet.jsp.JspWriter	The output stream.
page	java.lang.Object	The instance of the JSP page's servlet processing the current request. Not typically used by JSP page authors.
pageContext	javax.servlet.jsp.PageContext	The context for the JSP page. Provides a single API to manage the various scoped attributes.
request	Subtype of javax.servlet.ServletRequest	The request triggering the execution of the JSP page.
response	Subtype of javax.servlet.ServletResponse	The response to be returned to the client. Not typically used by JSP page authors.
session	javax.servlet.http.HttpSession	The session object for the client.

-------------------------------------------------------------------------------------------

17)What are all the different scope values for the tag?
tag is used to use any java object in the jsp page. Here are the scope values for tag:
a) page
b) request
c) session and
d) application

18) What is expression in JSP?
Expression tag is used to insert Java values directly into the output. Syntax for the Expression tag is:
<%= expression %>
An expression tag contains a scripting language expression that is evaluated, converted to a String, and inserted where the expression appears in the JSP file. The following expression tag displays time on the output:
<%=new java.util.Date()%>
--------------------------------------------------------------------------------------------

19) What types of comments are available in the JSP?
There are two types of comments are allowed in the JSP. These are hidden and output comments. A hidden comments does not appear in the generated output in the html, while output comments appear in the generated output.
Example of hidden comment:
<%-- This is hidden comment --%>
Example of output comment:

--------------------------------------------------------------------------------------------

20) What is JSP declaration?
JSP Decleratives are the JSP tag used to declare variables. Declaratives are enclosed in the <%! %> tag and ends in semi-colon. You declare variables and functions in the declaration tag and can use anywhere in the JSP. Here is the example of declaratives:

<%@page contentType="text/html" %>

<%!
int cnt=0;
private int getCount(){
//increment cnt and return the value
cnt++;
return cnt;
}
%>

Values of Cnt are:

<%=getCount()%>

--------------------------------------------------------------------------------------------

21) What is JSP Scriptlet?
JSP Scriptlet is jsp tag which is used to enclose java code in the JSP pages. Scriptlets begins with <% tag and ends with %> tag. Java code written inside scriptlet executes every time the JSP is invoked.
Example:
<%
//java codes
String userName=null;
userName=request.getParameter("userName");
%>
--------------------------------------------------------------------------------------------

22.) What are the life-cycle methods of JSP?

Life-cycle methods of the JSP are:
a) jspInit(): The container calls the jspInit() to initialize the servlet instance. It is called before any other method, and is called only once for a servlet instance.
b)_jspService(): The container calls the _jspservice() for each request and it passes the request and the response objects. _jspService() method cann't be overridden.
c) jspDestroy(): The container calls this when its instance is about to destroyed.
The jspInit() and jspDestroy() methods can be overridden within a JSP page.

--------------------------------------------------------------------------------------------

23) What is a JSP Custom tag?

JSP Custom tags are user defined JSP language element. JSP custom tags are user defined tags that can encapsulate common functionality. For example you can write your own tag to access the database and performing database operations. You can also write custom tag for encapsulate both simple and complex behaviors in an easy to use syntax and greatly simplify the readability of JSP pages.

24) What is the role of JSP in MVC Model?
JSP is mostly used to develop the user interface, It plays the role of View in the MVC Model.

--------------------------------------------------------------------------------------------

25) What do you understand by context initialization parameters?
The context-param element contains the declaration of a web application's servlet context initialization parameters.

name
value

The Context Parameters page lets you manage parameters that are accessed through the ServletContext.getInitParameterNames and ServletContext.getInitParameter methods.

--------------------------------------------------------------------------------------------

26) Can you extend JSP technology?
JSP technology lets the programmer to extend the jsp to make the programming more easier. JSP can be extended and custom actions and tag libraries can be developed.

--------------------------------------------------------------------------------------------

27) What do you understand by JSP translation?
JSP translators generate standard Java code for a JSP page implementation class. This class is essentially a servlet class wrapped with features for JSP functionality.

--------------------------------------------------------------------------------------------

28) What you can stop the browser to cash your page?
Instead of deleting a cache, you can force the browser not to catch the page.
<%
response.setHeader("pragma","no-cache");//HTTP 1.1
response.setHeader("Cache-Control","no-cache");
response.setHeader("Cache-Control","no-store");
response.addDateHeader("Expires", -1);
response.setDateHeader("max-age", 0);
//response.setIntHeader ("Expires", -1); //prevents caching at the proxy server
response.addHeader("cache-Control", "private");

%>
put the above code in your page.

--------------------------------------------------------------------------------------------

29) What you will handle the runtime exception in your jsp page?
The errorPage attribute of the page directive can be used to catch run-time exceptions automatically and then forwarded to an error processing page.

For example:
<%@ page errorPage="customerror.jsp" %>
above code forwards the request to "customerror.jsp" page if an uncaught exception is encountered during request processing. Within "customerror.jsp", you must indicate that it is an error-processing page, via the directive: <%@ page isErrorPage="true" %>.

30) What are the lifecycle phases of a JSP?
JSP page looks like a HTML page but is a servlet. When presented with JSP page the JSP engine does the following 7 phases.

1. Page translation: -page is parsed, and a java file which is a servlet is created.

2. Page compilation: page is compiled into a class file

3. Page loading : This class file is loaded.

4. Create an instance :- Instance of servlet is created

5. jspInit() method is called

6. _jspService is called to handle service calls

7. _jspDestroy is called to destroy it when the servlet is not required.

31) What is a translation unit?

JSP page can include the contents of other HTML pages or other JSP files. This is done by using the include directive. When the JSP engine is presented with such a JSP page it is converted to one servlet class and this is called a translation unit, Things to remember in a translation unit is that page directives affect the whole unit, one variable declaration cannot occur in the same unit more than once, the standard action jsp:useBean cannot declare the same bean twice in one unit.

32) What are context initialization parameters?

Context initialization parameters are specified by the in the web.xml file, these are initialization parameter for the whole application and not specific to any servlet or JSP.

33) What is a output comment?

A comment that is sent to the client in the viewable page source. The JSP engine handles an output comment as un-interpreted HTML text, returning the comment in the HTML output sent to the client. You can see the comment by viewing the page source from your Web browser.

34) What is a Hidden Comment?

A comment that documents the JSP page but is not sent to the client. The JSP engine ignores a hidden comment, and does not process any code within hidden comment tags. A hidden comment is not sent to the client, either in the displayed JSP page or the HTML page source. The hidden comment is useful when you want to hide or “comment out” part of your JSP page.

35) What is a Expression?

Expressions are act as placeholders for language expression; expression is evaluated each time the page is accessed

36) What’s the difference between forward and sendRedirect?

When you invoke a forward request, the request is sent to another resource on the server, without the client being informed that a different resource is going to process the request. This process occurs completely with in the web container And then returns to the calling method. When a sendRedirect method is invoked, it causes the web container to return to the browser indicating that a new URL should be requested. Because the browser issues a completely new request any object that are stored as request attributes before the redirect occurs will be lost. This extra round trip a redirect is slower than forward.

37) What is difference between custom JSP tags and beans?

Custom JSP tag is a tag you defined. You define how a tag, its attributes and its body are interpreted, and then group your tags into collections called tag libraries that can be used in any number of JSP files. Custom tags and beans accomplish the same goals — encapsulating complex behavior into simple and accessible forms. There are several differences:

· Custom tags can manipulate JSP content; beans cannot.

· Complex operations can be reduced to a significantly simpler form with custom tags than with beans.

· Custom tags require quite a bit more work to set up than do beans.

· Custom tags usually define relatively self-contained behavior, whereas beans are often defined in one servlet and used in a different servlet or JSP page.

· Custom tags are available only in JSP 1.1 and later, but beans can be used in all JSP 1.x versions.

38) What is the difference b/w variable declared inside a declaration part and variable declared in scriplet part?

Variable declared inside declaration part is treated as a global variable.that means after convertion jsp file into servlet that variable will be in outside of service method or it will be declared as instance variable.And the scope is available to complete jsp and to complete in the converted servlet class.where as if u declare a variable inside a scriplet that variable will be declared inside a service method and the scope is with in the service method.

39) Is there a way to execute a JSP from the comandline or from my own application?

There is a little tool called JSPExecutor that allows you to do just that. The developers (Hendrik Schreiber & Peter Rossbach ) aim was not to write a full blown servlet engine, but to provide means to use JSP for generating source code or reports. Therefore most HTTP-specific features (headers, sessions, etc) are not implemented, i.e. no reponseline or header is generated. Nevertheless you can use it to precompile JSP for your website.

40) What is the difference between getAttribute and getParameter()?

getParameter() is used to get form field values. it will take form field name as argument, it is totally client side and returns. String.getAttribute() is used to get object value, which is set by setAttribute(),this method will take object key as arguments,

41) What is the difference between application server and web server?

42) what are the advantage of JSP?

1) Auto compilation(translation.....)2) Not deployment descritpor specific3)Multiple deployment is avoided

43) How to perform redirect action without using response.sendRedirect (“”)?

By using the requestdispatcher.dispatch() method we can redirect to another page

44) what is the difference scriptlet and expression?

Scriptelet are used to write the code in any language but that language is mentioned in page language attribute.

45) Can we implement interface or extends class in JSP?

We cannot implement an interface in a jsp but we can extend a class in JSP by using extends attribute of the page directive.extends="package.class".

46) What is the default scope of jsp ?

Page is the default scope of jsp .

47) What is the difference between session and cookies?

Session are used as server side means for session tracking whereas cookies are used as client side means of sesion tracking. There can be only 20 cookies per server. Size of each cookie is 4k

48). Why should we use setContentType in Servlet?

To tell the browser what type of output posted from server.

49) What is the difference between static include and dynamic include?

50) How to refresh jsp page?

response.setHeader("refresh","2");

51) Which element enables JSP to integrate with JavaBeans?

A) Scriptlets.

B) Directives.

C) Declarations.

D) Actions.

Ans: D)

52) Can a interface be implemented in a jsp file?

A) Yes.

B) No.

C) Only when static pages are included.

D) Only when dynamic pages are included.

Ans: B)

53) What is a Scriplet?

Scriptlet can contain any number of language statements, variable or method declarations, or expressions that are valid in the page scripting language.

54) What is the purpose of Jsp forward method?

This method will forward the control to another resource available in the same web application on the same container.

55) Briefly explain about Java Server Pages technology?

JavaServer Pages (JSP) technology provides a simplified, fast way to create web pages that display dynamically-generated content. The JSP specification, developed through an industry-wide initiative led by Sun Microsystems, defines the interaction between the server and the JSP page, and describes the format and syntax of the page.

56) Why do I need JSP technology if I already have servlets?

JSP pages are compiled into servlets, so theoretically you could write servlets to support your web-based applications. However, JSP technology was designed to simplify the process of creating pages by separating web presentation from web content. In many applications, the response sent to the client is a combination of template data and dynamically-generated data. In this situation, it is much easier to work with JSP pages than to do everything with servlets.

58) How are the JSP requests handled?

The following sequence of events happens on arrival of jsp request:
a. Browser requests a page with .jsp file extension in webserver.
b. Webserver reads the request.
c. Using jsp compiler,webserver converts the jsp into a servlet class that implement the javax.servletjsp.jsp page interface. the jsp file compiles only when the page is first requested or when the jsp file has been changed.
d. The generated jsp page servlet class is invoked to handle the browser request.
e. The response is sent to the client by the generated servlet.
-----------------------------------------------------------------------------------

59) What are the advantages of JSP?

The following are the advantages of using JSP:

a. JSP pages easily combine static templates, including HTML or XML fragments, with code that generates dynamic content.
b. JSP pages are compiled dynamically into servlets when requested, so page authors can easily make updates to presentation code. JSP pages can also be precompiled if desired.
c. JSP tags for invoking JavaBeans components manage these components completely, shielding the page author from the complexity of application logic.
d. Developers can offer customized JSP tag libraries that page authors access using an XML-like syntax.
e. Web authors can change and edit the fixed template portions of pages without affecting the application logic. Similarly, developers can make logic changes at the component level without editing the individual pages that use the logic.

60) How is a JSP page invoked and compiled?
Pages built using JSP technology are typically implemented using a translation phase that is performed once, the first time the page is called. The page is compiled into a Java Servlet class and remains in server memory, so subsequent calls to the page have very fast response times.
-----------------------------------------------------------------------------------

61) What are Directives?

Directives are instructions that are processed by the JSP engine when the page is compiled to a servlet. Directives are used to set page-level instructions, insert data from external files, and specify custom tag libraries. Directives are defined between < %@ and % >.
< %@ page language=="java" imports=="java.util.*" % >
< %@ include file=="banner.html" % >

62) What are the different types of directives available in JSP?

The following are the different types of directives:
a. include directive : used to include a file and merges the content of the file with the current page
b. page directive : used to define page specific attributes like scripting language, error page, buffer, thread safety, etc
c. taglib : used to declare a custom tag library which is used in the page.

63) What are JSP actions?

JSP actions are executed when a JSP page is requested. Action are inserted in the jsp page using XML syntax to control the behavior of the servlet engine. Using action, we can dynamically insert a file, reuse bean components, forward the user to another page, or generate HTML for the Java plugin. Some of the available actions are as follows:
- include a file at the time the page is requested.
- find or instantiate a JavaBean.
- set the property of a JavaBean.
- insert the property of a JavaBean into the output.
- forward the requester to a new page.
- generate browser-specific code that makes an OBJECT or EMBED tag for the Java plugin.

-----------------------------------------------------------------------------------

64) What are Scriptlets?

Scriptlets are blocks of programming language code (usually java) embedded within a JSP page. Scriptlet code is inserted into the servlet generated from the page. Scriptlet code is defined between <% and %>

65) What are Decalarations?

Declarations are similar to variable declarations in Java.Variables are defined for subsequent use in expressions or scriptlets. Declarations are defined between <%! and %>.
< %! int i=0; %>

66) How to declare instance or global variables in jsp?

Instance variables should be declared inside the declaration part. The variables declared with JSP declaration element will be shared by all requests to the jsp page.
< %@ page language=="java" contentType="text/html"% >
< %! int i=0; %>

67) What are Expressions?

Expressions are variables or constants that are inserted into the data returned by the web server. Expressions are defined between <% = and % >
< %= scorer.getScore() %>

14) What is meant by implicit objects? And what are they?

Ans : Implicit objects are those objects which are avaiable by default. These objects are instances of classesdefined by the JSP specification. These objects could be used within the jsp page without being declared.

The following are the implicit jsp objects:
1. application
2. page
3. request
4. response
5. session
6. exception
7. out
8. config
9. pageContext

68) How do I use JavaBeans components (beans) from a JSP page?
The JSP specification includes standard tags for bean use and manipulation. The tag creates an instance of a specific JavaBean class. If the instance already exists, it is retrieved. Otherwise, a new instance of the bean is created. The and tags let you manipulate properties of a specific bean.

69) What is the difference between and %@include:?

Both are used to insert files into a JSP page.
<%@include:> is a directive which statically inserts the file at the time the JSP page is translated into a servlet.
is an action which dynamically inserts the file at the time the page is requested.
-----------------------------------------------------------------------------------

70) What is the difference between forward and sendRedirect?
Both requestDispatcher.forward() and response.sendRedirect() is used to redirect to new url.

forward is an internal redirection of user request within the web container to a new URL without the knowledge of the user(browser). The request object and the http headers remain intact.

sendRedirect is normally an external redirection of user request outside the web container. sendRedirect sends response header back to the browser with the new URL. The browser send the request to the new URL with fresh http headers. sendRedirect is slower than forward because it involves extra server call.
-----------------------------------------------------------------------------------

71) Can I create XML pages using JSP technology?

Yes, the JSP specification does support creation of XML documents. For simple XML generation, the XML tags may be included as static template portions of the JSP page. Dynamic generation of XML tags occurs through bean components or custom tags that generate XML output.

72) How is Java Server Pages different from Active Server Pages?

JSP is a community driven specification whereas ASP is a similar proprietary technology from Microsoft. In JSP, the dynamic part is written in Java, not Visual Basic or other MS-specific language. JSP is portable to other operating systems and non-Microsoft Web servers whereas it is not possible with ASP