JSP Examples - Revision & QA

Java Server Pages (JSP) is a server side component for the generation of dynamic

information as the response. Best suitable to implement view components (presentation

layer components). It is part of SUN's J2EE platform.

These are some of the benefits due to the usage of JSP they are:

Yes, it is. JSP technology is extensible through the development of custom actions, or tags,

which are encapsulated in tag libraries.

The big difference between both of these technologies lies with the design of the software.

JSP technology is server and platform independent whereas ASP relies primarily on

Microsoft technologies.

Yes. Preemptive termination of request processing on an error condition is a good way to

maximize the throughput of a high-volume JSP engine. The trick (assuming Java is your

scripting language) is to use the return statement when we want to terminate further

processing.

If the JSP is secured resource then we can place inside WEB-INF folder so that end user is

not allowed to access directly by the name. We can provide the url pattern by configuring in

web.xml

The JSP API contains only one package : javax.servlet.jsp

It contains the following 2 interfaces:

Life cycle of JSP contains the following phases:

Page translation: -converting from .jsp file to .java file

Page compilation: converting .java to .class file

Page loading : This class file is loaded.

Create an instance :- Instance of servlet is created

jspInit() method is called

_jspService() is called to handle service calls

jspDestroy() is called to destroy it when the servlet is not required.

The jspInit()- The container calls the jspInit() to initialize te servlet instance.It is called

before any other method, and is called only once for a servlet instance.

The _jspservice()- The container calls the _jspservice() for each request, passing it the

request and the response objects.

The jspDestroy()- The container calls this when it decides take the instance out of service. It

is the last method called n the servlet instance.

JSP contains 3 life cycle methods namely jspInit( ), _jspService() and jspDestroy().

In these, jspInit() and jspDestroy() can be overridden and we cannot override _jspService().

Webcontainer always generate _jspService() method with JSP content. If we are writing

_jspService() method , then generated servlet contains 2 _jspService() methods which will

cause compile time error.

To show this difference _jspService() method is prefixed with `_' by the JSP container and

the other two methods jspInit() and jspDestroy() has no special prefixes.

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.

The _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.

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.

We can override jspInit() and jspDestroy() methods but we cannot override _jspService()

method.

By using JSP declation tag

A java server page is executed within a Java container. A Java container converts a Java file

into a servlet. Conversion happens only once when the application is deployed onto the web

server. During the process of compilation Java compiler checks for modifications if any

modifications are present it would modify and then execute it.

_jspService() method will be written by the container hence any methods which are not to be

overridden by the end user are typically written starting with an '_'. This is the reason why we

don't override _jspService() method in any JSP page.

Add jsp_precompile as a request parameter and send a request to the JSP file. This will

make the jsp pre-compile.

http://localhost:8080/jsp1/test.jsp?jsp_precompile=true

It causes excution of JSP life cycle until jspInit() method without executing _jspService()

method.

It removes the start-up lag that occurs when a container must translate a JSP page upon

receipt of the first request.

Inside JSP 4 types of scripting elements are allowed.

Can be used to place java code.

Can be used to declare class level variables and methods

To print java expressions in the JSP

JSP scriptlet can be used to place java code.

Syntax:

<%

Any java code

%>

The java code present in the scriptlet will be placed directly inside _jspService() method

JSP declarations are used to declare class variables and methods (both instance and static) in

a JSP page. These declations will be placed directly at class level in the generated servlet and

these are available to the entire JSP.

Syntax:

<%! This is my declarative %>

Eg: <%! int j = 10; %>

We can declare methods by using JSP declarative tag.

<%!

public int add(inti, intj) {

return i+j;

}

%>

declared in scriplet ?

Variable declared inside declaration part is treated as a instance variable and will be placed

directly at class level in the generated servlet.

<%! int k = 10; %>

Variable declared in a scriptlet will be placed inside _jspService() method of generated

servlet.It acts as local variable.

<%

int k = 10;

%>

JSP Expression can be used to print expression to the JSP.

Syntax:

<%= java expression %>

Eg: <%= new java.util.Date() %>

The expression in expression tag should not ends with semi-colon

The expression value will become argument to the out.pritln() method in the generated

servlet

3 types of comments are allowed in JSP

The comment which is visible in the source of the response is called output comment.

<!-- this is HTMl comment -- >

<%-- this is jsp comment --%>

This is also known as JSP comment and it is visible only in the JSP and in rest of phases of

JSP life cycle it is not visible.

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>

Implicit objects are by default available to the JSP. Being JSP author we can use these and

not required to create it explicitly.

You can use the errorPage attribute of the page directive to have uncaught run-time

exceptions automatically forwarded to an error processing page.

For example:

<%@ page errorPage="error.jsp" %> redirects the browser to the JSP page error.jsp if an

uncaught exception is encountered during request processing.

Within error.jsp, if you indicate that it is an error-processing page, via the directive:

<%@ page isErrorPage="true" %>

In the error pages we can access exception implicit object.

Disadvantages of using it?

You can make your JSPs thread-safe by having them implement the

SingleThreadModel interface. This is done by adding the directive in the JSP.

<%@ page isThreadSafe="false" %>

The generated servlet can handle only one client request at time so that we can make JSP as

thread safe. We can overcome data inconsistency problems by this approach.

The main limitation is it may affect the performance of the system.

ServletContext: Gives the information about the container and it represents an application.

PageContext: Gives the information about the Request and it can provide all other implicit

JSP objects .

Yes, there is. The page implicit object is equivalent to "this", and returns a reference to the

generated servlet.

Yes . By using getOutputStream() method on response implicit object we can get it.

session object is by default available to the JSP. We can make it unavailable by using page

directive as follows.

<%@ page session="false">

Model Interface OR Synchronization?

Synchronized keyword is recommended to use to get thread-safety.

Page directive contains the following 13 attributes.

This command is used to autoflush the contents. If a value of true is used it indicates to flush

the buffer whenever it is full. In case of false it indicates that an exception should be thrown

whenever the buffer is full. If you are trying to access the page at the time of conversion of a

JSP into servlet will result in error.

You first set "errorPage" attribute of PAGE directive to the name of the error page (ie

errorPage="error.jsp")in your jsp page .

Then in the error.jsp page set "isErrorpage=TRUE".

When an error occur in your jsp page, then the control will be automatically forward to error

page.

There are 4 types of scopes are allowed in the JSP.

session is available to end user till session closed or browser closed.

in application scope and other can get the data from application scope.

If we want to make our data available to the entire application then we have to use

application scope.

The different scope values for <jsp:useBean> are

jsp:useBean action may optionally have a body. If the body is specified, its contents will be

automatically invoked when the specified bean is instantiated. Typically, the body will

contain scriptlets or jsp:setProperty tags to initialize the newly instantiated bean, although

you are not restricted to using those alone.

The following example shows the "today" property of the Foo bean initialized to the current

date when it is instantiated. Note that here, we make use of a JSP expression within the

jsp:setProperty action.

<jsp:useBean id="foo" class="com.Bar.Foo" >

<jsp:setProperty name="foo" property="x"

value="<%=java.text.DateFormat.getDateInstance().format(new java.util.Date()) %>" / >

<%-- scriptlets calling bean setter methods go here --%>

</jsp:useBean >

No problem! The use Bean action specifies the beanName attribute, which can be used for

indicating a serialized bean.

For example:

A couple of important points to note. Although you would have to name your serialized file

"filename.ser", you only indicate "filename" as the value for the beanName attribute. Also,

you will have to place your serialized file within the WEB-INF/jspbeans directory for it to be

located by the JSP engine.

We can include static files in JSP by using include directive (static include)

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

The content of the header.jsp will be included in the current jsp at translation time. Hence

this inclusion is also known as static include.

In JSP, we can perform inclusion in the following ways.

pageContext.include("/header.jsp");

%>

This inclusion also happened at request processing time(run time).

RequestDispatcher rd = request.getRequestDispatcher("/header.jsp");

Rd.incliude(request,response);

%>

If the target resource ( included resource) won't change frequently, then it is recommended to

use static include.

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

If the target resource(Included page) will change frequently , then it is recommended to use

dynamic include.

< jsp:include page="header.jsp" />

OCWCD

Question Bank