JSP basics lecture
Download
Report
Transcript JSP basics lecture
Object-Oriented Enterprise
Application Development
JavaServer Pages
Topics
During this class we will examine:
Anatomy of a JavaServer Page
Merging markup with Java
Configuring our JSPs with directives
Integrating servlets and JSPs
JavaServer Pages
Justification
JavaServer Pages (JSPs) are a technology
that allow developers to mix static with
dynamic content.
JavaServer Pages have been successful for
two (2) reasons:
JSPs are supported across multiple platforms.
JSPs give developers access to all Java
technologies instead of using a scripting
language.
Roles and Responsibilities
Although servlets can generate dynamic
content, it's often advantageous to separate
the business logic in the servlet from the
presentation logic.
By using JSPs we can have application
programmers building servlets while
content designers and graphic artists
construct the JSPs.
Versions
We'll use version 1.1 of the JavaServer
Pages specification.
The 1.0 and 1.1 version JSPs are almost
totally incompatible with the 0.92 version of
the specification.
JSP Structure
Basic Concepts
At their heart, basic JSPs look just like
regular HTML markup.
A static HTML document can be turned into a
JSP simply by changing its extension to .jsp.
The key difference is that JSPs are dynamic.
When a JSP is executed, the JSP engine
converts that JSP into an equivalent servlet
which then follows the normal lifecycle.
Sample Code - HelloWorld
1.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
2. <%-- comments look like this --%>
3. <HTML>
4.
<HEAD>
5.
<TITLE>HelloWorld JSP</TITLE>
6.
</HEAD>
7.
<BODY>
8.
<H2>Hello, World!</H2>
9.
</BODY>
10. </HTML>
Dynamic Content
If all we needed was static content, then
we'd just use HTML. The strength of JSPs
lie in their ability to generate and
manipulate dynamic content.
There are three common ways of
performing this generation using JSPs:
Expressions,
Scriptlets
Declarations
Lifecycle
Even though JSPs are ultimately compiled
into servlets, there are a few differences in
their lifecycle.
Most of the tags for generating dynamic
content are placed within the JSP's
jservice() method.
This method is called by the JSP's service()
method for both GET and POST requests.
JSP Tags
Basic Tags
In the 0.92 version of the JSP specification,
we identified dynamic content using special
tags.
In version 1.1 of the JSP specification we
can still use some of these tags. We can also
use equivalent XML tags.
JSP Expressions
The simplest form of dynamic content is the
JSP expression. This is used to send a value
back to the client.
The tag format of an expression is given by:
<%= java expression %>
Sample Code DynamicHelloWorld
1.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
2. <HTML>
3.
<HEAD><TITLE>
4.
DynamicHelloWorld JSP
5.
</TITLE></HEAD>
6.
<BODY>
7.
<H2>Hello, World!</H2><BR>
8.
<H3>It’s now
9.
<%= new java.util.Date() %>
10.
</H3>
11.
</BODY>
12. </HTML>
Implicit Variables
(1 of 3)
There are eight (8) implicit variables for
each JSP. The four (4) most common are:
request: The HttpServletRequest
object passed to the JSP.
response: The HttpServletResponse
object passed to the JSP.
session: The client's HttpSession object.
out: The PrintWriter object used to send
output to the client that initiated the request.
Implicit Variables
(2 of 3)
Other useful variables include:
application: The ServletContext
object.
config: The ServletConfig object.
pageContect: The PageContext object.
page: The this object (not currently used).
Implicit Variables
(3 of 3)
These implicit variable can be used within
JSP expressions and scriptlets, but not
within JSP declarations.
Sample Code – Status
(1 of 2)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>
StatusHelloWorld JSP
</TITLE></HEAD>
<BODY>
<H2>Hello, World!</H2><BR>
<H3>Current Time:
<%= new java.util.Date() %>
</H3><BR>
<H3>Session ID:
<%= session.getId() %>
</H3><BR>
Sample Code – Status
(2 of 2)
14.
<H3>Hostname:
15.
<%= request.getRemoteHost() %>
16.
</H3><BR>
17.
<H3>Parameter:
18.
<%= request.getParameter("test") %>
19.
</H3>
20.
</BODY>
21. </HTML>
JSP Scriptlets
Often a single expression isn't adequate for
the complexity of the output we want the
JSP to generate.
JSPs allow us to embed complete segments
of Java code within a scriptlet.
The tag format of a scriptlet is given by:
<% java code %>
Sample Code – Scriptlet
(1 of 2)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0
Transitional//EN">
<HTML>
<HEAD>
<TITLE>Scriptlet JSP</TITLE>
</HEAD>
<BODY>
<H2>Hello, World!</H2><BR>
<H3>Current Time:
<%= new java.util.Date() %>
</H3><BR>
<H3>Session ID:
<%= session.getId() %>
</H3><BR>
Sample Code – Scriptlet
(2 of 2)
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
<H3>Hostname:
<%= request.getRemoteHost() %>
</H3><BR>
<%
String testString =
request.getParameter("test");
if (null == testString) {
testString = "no.such.parameter";
}
%>
<H3>Parameter: <%= testString %></H3>
</BODY>
</HTML>
Conditional Tags
JSP scriptlets are useful for including
conditional content.
This cuts down on the amount of data
returned to the client.
This technique can be used to implement
basic security features.
Sample Code – Scriptlet (rev.)
(1 of 3)
1.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
2. <HTML>
3.
<HEAD>
4.
<TITLE>Scriptlet JSP</TITLE>
5.
</HEAD>
6.
<BODY>
7.
<H2>Hello, World!</H2><BR>
8.
<H3>Current Time:
9.
<%= new java.util.Date() %>
10.
</H3><BR>
Sample Code – Scriptlet (rev.)
(2 of 3)
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
<%
if (session.getId() != null) {
%>
<H3>Session ID:
<%= session.getId() %>
</H3><BR>
<%
}
%>
<H3>Hostname:
<%= request.getRemoteHost() %>
</H3><BR>
Sample Code – Scriptlet (rev.)
(3 of 3)
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
<%
String testString =
request.getParameter("test");
if (null == testString) {
testString = "no.such.parameter";
}
%>
<H3>Parameter:
<%= testString %>
</H3>
</BODY>
</HTML>
Translated Code – Scriptlet
(1 of 8)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
import
import
import
import
import
import
import
import
import
import
import
import
javax.servlet.*;
javax.servlet.http.*;
javax.servlet.jsp.*;
javax.servlet.jsp.tagext.*;
java.io.PrintWriter;
java.io.IOException;
java.io.FileInputStream;
java.io.ObjectInputStream;
java.util.Vector;
org.apache.jasper.runtime.*;
java.beans.*;
org.apache.jasper.JasperException;
Translated Code – Scriptlet
(2 of 8)
13. public class
_0002fHtml_0002fscriptlet_0002ejspscriptlet_j
sp_0 extends HttpJspBase {
14. static { }
15. public
_0002fHtml_0002fscriptlet_0002ejspscriptlet_j
sp_0( ) { }
16. private static
boolean _jspx_inited = false;
17. public final void _jspx_init() throws
JasperException { }
Translated Code – Scriptlet
(3 of 8)
18. public void _jspService(
HttpServletRequest request,
HttpServletResponse response)
19. throws IOException, ServletException {
20.
JspFactory _jspxFactory = null;
21.
PageContext pageContext = null;
22.
HttpSession session = null;
23.
ServletContext application = null;
24.
ServletConfig config = null;
25.
JspWriter out = null;
26.
Object page = this;
27.
String _value = null;
Translated Code – Scriptlet
(4 of 8)
28.
29.
30.
31.
32.
33.
34.
35.
36.
try {
if (_jspx_inited == false) {
_jspx_init();
_jspx_inited = true;
}
_jspxFactory =
JspFactory.getDefaultFactory();
response.setContentType(
"text/html;charset=8859_1");
pageContext =
_jspxFactory.getPageContext(
this, request, response,
"", true, 8192, true);
Translated Code – Scriptlet
(5 of 8)
37.
38.
39.
40.
41.
application =
pageContext.getServletContext();
config =
pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write("<!DOCTYPE HTML PUBLIC \"//W3C//DTD HTML 4.0
Transitional//EN\">\r\n<HTML>\r\n
<HEAD>\r\n
<TITLE>Scriptlet
JSP</TITLE>\r\n
</HEAD>\r\n
<BODY>\r\n\t\t\t<H2>Hello,
World!</H2>\t<BR>\r\n\t\t\t<H3>Current Time:
");
Translated Code – Scriptlet
(6 of 8)
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
out.print( new java.util.Date() );
out.write("</H3>\r\n\t\t\t"<BR>\r\n\t\t\t");
if (session.getId() != null) {
out.write("\r\n\t\t\t\t<H3>"Session ID: ");
out.print( session.getId() );
out.write("</H3><BR>\r\n\t\t\t");
}
out.write("\r\n\t\t\t<H3>"Hostname: ");
out.print( request.getRemoteHost() );
out.write("</H3><BR>\r\n\t\t\t");
Translated Code – Scriptlet
(7 of 8)
52.
53.
54.
55.
56.
57.
58.
String testString =
request.getParameter("test");
if (null == testString) {
testString = "no.such.parameter";
}
out.write("\r\n\t\t\t<H3>"Parameter: ");
out.print( testString );
out.write("</H3>\r\n\t</BODY>"\r\n</HTML>");
Translated Code – Scriptlet
(8 of 8)
59.
60.
61.
62.
63.
64.
65.
66.
67. }
68. }
} catch (Exception ex) {
if (out.getBufferSize() != 0)
out.clearBuffer();
pageContext.
handlePageException(ex);
} finally {
out.flush();
_jspxFactory.
releasePageContext(pageContext);
}
JSP Declarations
A JSP declaration exists outside of the
jservice() method.
This means that code in a declaration cannot
make use of the implicit variables.
This allows us to declare JSP-level
variables and methods.
The tag format of an expression is given by:
<%! java declaration %>
Sample Code – Declaration
(1 of 2)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>Declaration JSP</TITLE>
</HEAD>
<BODY>
<H2>Declarations</H2><BR>
<H3>Current Time:
<%= new java.util.Date() %>
</H3><BR>
<H3>Session ID:
<%= session.getId() %>
</H3><BR>
Sample Code – Declaration
(2 of 2)
14.
15.
16.
17.
18.
19.
20.
<H3>Hostname:
<%= request.getRemoteHost() %>
</H3><BR>
<%! private int accesses = 0; %>
<H3>
<%= ++accesses %>
Accesses to the page since JSP
was loaded.
21.
</H3>
22.
</BODY>
23. </HTML>
JSP Directives
Overview
We use directives to customize the JSP's
behavior. Each directive affects the structure
of the servlet resulting from the JSP's
compilation.
There are three (3) types of directives:
page: Controls the servlet's structure.
include: Inserts a file into the servlet class.
taglib: Defines custom markup tags.
Page Directives
There are many page directives. We'll look
at a few of the most common attributes:
import
isThreadSafe
session
errorPage
We use the directive tag to indicate that we
want a directive to take effect:
<%@ directive %>
Import Attribute
The import attribute allows a JSP to
import class libraries:
<%@ page import="java.util.*" %>
By default a JSP automatically imports:
java.lang.*
java.servlet.*
java.servlet.http.*
java.servlet.jsp.*
Sample Code - Import
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
<%@ page import=“java.util.Date” %>
<HTML>
<HEAD>
<TITLE>Import JSP</TITLE>
</HEAD>
<BODY>
<H2>Imports</H2><BR>
<H3>Current Time:
<%= new Date() %>
</H3>
</BODY>
</HTML>
isThreadSafe Attribute
The isThreadSafe attribute forces the
JSP's servlet to implement the
SingleThreadedModel interface:
<%@ page isThreadSafe="true" %>
By default a JSP is assumed to be thread
safe in the same way that servlets are.
If this isn't the case you can:
Make it thread-safe using synchronized blocks
Set isThreadSafe to false.
Sample Code – IsThreadSafe
(1 of 2)
1. <%! private int id = 0; %>
2. <%
3.
String userId = "id" + id;
4.
out.println("Your id is " + id);
5.
id++;
6. %>
Sample Code – IsThreadSafe
(2 of 2)
1. <%! private int id = 0; %>
2. <%
3.
synchronized (this) {
4.
String userId = "id" + id;
5.
out.println("Your id is " + id);
6.
id++;
7.
}
8. %>
Sample Code - IsThreadSafe
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
<%@ page import=“java.util.Date” %>
<%@ page isThreadSafe=“false” %>
<HTML>
<HEAD>
<TITLE>Single Thread JSP</TITLE>
</HEAD>
<BODY>
<%! private int accesses = 0; %>
<%= ++accesses %>
Accesses since JSP was loaded.
</BODY>
</HTML>
Session Attribute
The session attribute controls whether or
not the JSP can access the client's session:
<%@ page session="true" %>
By default a JSP participates in the client's
session.
<%@ page session="true" %>
If this isn't the behavior we want, we can
turn it off:
<%@ page session="false" %>
errorPage Attribute
The errorPage attribute specifies the
URL to which the client will be sent if an
unhandled exception is encountered:
<%@ page errorPage="some URL" %>
The exception that caused the problem will
be provided to the page via the
exception variable.
Sample Code - ErrorPage
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
<%@ page errorPage=“error.jsp” %>
<HTML>
<HEAD>
<TITLE>ErrorPage JSP</TITLE>
</HEAD>
<BODY>
<H3>Session Variable:
<%=
session.
getAttribute("var").toString()
%>
</BODY>
</HTML>
Integrating Servlets and
JavaServer Pages
Integration
JavaServer Pages allow graphic designers to
achieve reasonable separation between their
roles and the role of the servlet developer.
However, since all of these components will
be used together in the final application, we
need to integrate them.
Request Dispatcher
We've already looked at one approach to
integrating servlets and JSPs: the
RequestDispatcher class.
This remains the simplest way of invoking a
JSP from a servlet.
Shared Data
It isn't uncommon to need to share data
between a servlet and a JSP.
The servlet may perform all of the business
processing necessary to generate the data to be
displayed by the JSP.
We could use the client's session, but what
if the data isn't required beyond a single
request-response pair?
Request Attributes
(1 of 2)
For data that needs to exist only for a single
client request, we can use the
HttpServletRequest object to store
our data.
In addition to the parameters passed in by
the client, the HttpServletRequest
contains attributes which can be set by
servlets and JSPs.
Request Attributes
(2 of 2)
As with session attributes, request attributes
are nothing more than a name-value pair.
To manipulate these attributes you can use
the following methods:
public void
setAttribute(String, Object)
public Object
getAttribute(String)
Sample Code – SetData
(1 of 3)
1.
2.
3.
4.
5.
6.
7.
import
import
import
import
java.io.*;
java.util.*;
javax.servlet.*;
javax.servlet.http.*;
public class SendData
extends HttpServlet {
public void
doPost(HttpServletRequest rqst,
HttpServletResponse resp)
8.
throws ServletException, IOException {
9.
doGet(rqst, resp);
10.
}
Sample Code – SetData
(2 of 3)
11.
12.
13.
14.
15.
public void
doGet(HttpServletRequest rqst,
HttpServletResponse resp)
throws ServletException, IOException {
rqst.setAttribute("parm", "skippy");
chain(rqst, resp, "GetData.jsp");
}
Sample Code – SetData
(3 of 3)
16.
17.
18.
19.
20.
21. }
private void
chain(HttpServletRequest rqst,
HttpServletResponse resp,
String URL)
throws ServletException, IOException {
RequestDispatcher dispatcher =
getServletContext().
getRequestDispatcher(URL);
dispatcher.forward(rqst, resp);
}
Sample Code - GetData
1.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0 Transitional//EN">
2. <HTML>
3.
<HEAD>
4.
<TITLE>GetData JSP</TITLE>
5.
</HEAD>
6.
<BODY>
7.
<H2>Get Shared Value</H2><BR>
8.
<H3>The shared value is...
9.
<%= request.getAttribute("parm") %>
10.
</H3>
11.
</BODY>
12. </HTML>
Review
During this class we have discussed:
Anatomy of a JavaServer Page
Merging markup with Java
Configuring our JSPs with directives
Integrating servlets and JSPs
Resources
Core Servlets and JavaServer Pages
Marty Hall, Prentice-Hall, Inc., 2000.
ISBN: 0-13-089340-4
Java 2 Platform, Enterprise Edition
B. Shannon, et al., Addison-Wesley, 2000.
ISBN: 0-201-70456-0
Coming Attractions
Next week we'll add custom tags to our
JavaServer Pages.
Please read Chapter 14 in your text.