JSP
Here is some basics of jsp technology
JSP Tags
|
TAGS
|
Syntax
|
|
1.Directive
|
<%@
Directive %>
1. <%@ page attribute-list %>
2. <%@ include attribute-list %>
3. <%@ taglib attribute-list %>
|
|
2.Declaration
|
<%! Java Declarations %>
|
|
3.Expression
|
<%= An Expression %>
|
|
4.Scriptlet
|
<% Some Java code %>
|
|
5.Action
|
<jsp:actionName />
• jsp:include
• jsp:forward
• jsp:useBean
• jsp:setProperty
• jsp:getProperty
• jsp:plugin
|
|
6.Comment
|
<%-- Any Text --%>
|
JSP Life cycle
A JSP page goes through seven phases in its lifetime. These
phases are called life-cycle
phases. Although, structurally, a JSP page looks like an HTML page, it actually runs as a servlet.
The JSP engine parses the JSP file and creates a
corresponding Java file. This file
declares a servlet class whose members map directly to the
elements of the JSP file. The
JSP engine then compiles the class, loads it into memory,
and executes it as it would
any
other servlet. The output of this servlet is then sent to the client.
You might have observed that when a JSP page is accessed for
the first time, the server
is slower in responding than it is in the second, third, and
subsequent accesses. This is
because, as we mentioned previously, every JSP page must be
converted into an
instance of a servlet class before it can be used to service
client requests. For each
request, the JSP engine checks the timestamps of the source JSP
page and the corresponding
servlet class file to determine if the JSP page is new or if
it has already been
converted into a class file. Therefore, if we modify a JSP page,
the whole process of converting
the JSP
page into a servlet is performed again.
|
Phase
name
|
Description
|
|
1. Page translation
|
The page is
parsed and a Java file containing the corresponding servlet
is created.
|
|
2. Page compilation
|
The
Java file is compiled
|
|
3. Load class
|
The
compiled class is loaded
|
|
4. Create instance
|
An instance
of the servlet is created.
|
|
5. Call jspInit()
|
This method
is called before any other method to allow initialization.
|
|
6. Call _jspService()
|
This method
is called for each request.
|
|
7. Call jspDestroy()
|
This method
is called when the servlet container decides to take the
servlet
out of service.
|
JSP
Page Directive Attribute
A page directive informs the JSP engine about
the overall properties of a JSP page.
This directive applies to the entire translation unit and
not just to the page in which
it is
declared.
- Import Attribute:
The import attribute of a page directive
is similar to the import statement in a
Java class. For example, if we want to use the Date class
of the package java.util,
then we have to either use the fully qualified class name in
the code or import it using
the page directive. At the time of translation,
the JSP engine inserts an import statement
into
the generated servlet for each of the packages declared using this attribute.
Ex:
<%@ page import="java.util.* " %>
<%@ page import="java.io.* " %>
<%@ page import="java.text.* " %>
<%@ page
import="com.mycom.*, com.mycom.util.MyClass " %>
- Session Attribute:
The session attribute indicates whether the JSP page
takes part in an HTTP session.
The default value is true, in which case the JSP engine declares
the implicit
variable session. (We will learn more about implicit
variables in chapter 11.) If we
do not want the page to participate in a session, then we
have to explicitly add the
following line:
<%@ page
session="false" %>
- errorPage and isErrorPage attributes:
In this
approach, a JSP page uses
the errorPage attribute to delegate the exception to
another JSP page that
has the errorhandling code.
Ex:
Hello.jsp
<%@ page errorPage="errorHandler.jsp" %>
<html>
<body>
<%
if (request.getParameter("name")==null)
{
throw new RuntimeException("Name not specified");
}
%>
Hello, <%=request.getParameter("name")%>
</body>
</html>
errorHandler.jsp
<%@ page isErrorPage="true" %>
<html>
<body>
Unable to process your request:
<%=exception.getMessage()%><br>
Please try again.
</body>
</html>
- language and extends attributes:
The language
attribute specifies the language used
by a page in declarations,
scriptlets, and expressions. The
default value is java, which is also the only value
allowed by the JSP Specification 2.0.
Needless to say, adding the following line to a
JSP page is redundant:
<%@ page language="java" %>
The extends attribute specifies that the supplied
class be used as a base class of the
generated servlet. This is useful only
if we want to customize the behavior of the generated
servlet class. The default base class
is vendor specific and is designed to work
efficiently with the rest of the
framework. Consequently, this attribute is seldom used.
The following line shows the syntax for
this attribute:
<%@ page
extends="mypackage.MySpecialBaseServlet" %>
- buffer and autoFlush attributes:
The buffer attribute specifies the minimum size
required by the output buffer that
holds the generated content until it is sent to the client.
The default size of the buffer
is JSP engine implementation dependent, but the
specification mandates it to be at
least 8kb.
<%@ page buffer="32kb" %>
The autoFlush attribute specifies whether the data in
the output buffer should
be sent to the client automatically as soon as the buffer is
full. The default value for
autoFlush is true.
If it is set to false and the buffer is full, an exception is
raised
when we attempt to add more data to the buffer. Here is the
syntax for this attribute:
<%@ page autoFlush="false" %>
- info attribute:
The info attribute allows us to specify the
value of the string returned by the get-
ServletInfo() method
of the generated servlet. The following line shows one possible
use:
<%@ page info="This is a sample Page.
" %>
The default value of this attribute is
implementation dependent.
- contentType and pageEncoding attributes
The contentType
attribute specifies the MIME type and
character encoding of the
output. The default value of the MIME type
is text/html; the default value of the
character encoding is ISO-8859-1.
The MIME type and character encoding are separated
by a semicolon, as shown here:
<%@ page
contentType="text/html;charset=ISO-8859-1" %>
This is equivalent to writing the
following line in a servlet:
response.setContentType("text/html;charset=ISO-8859-1");
The pageEncoding
attribute specifies the character
encoding of the JSP page. The
default value is ISO-8859-1.
The following line illustrates the syntax:
<%@ page pageEncoding="ISO-8859-1"
%>
No comments:
Post a Comment