ppt

Download Report

Transcript ppt 

JSP – Java Server Page
DBI – Representation and
Management of Data on the Internet
1
What is JSP
• http://java.sun.com/products/jsp
• A way to create dynamic web pages
• Based on Java Technology
– Large library base
– Platform independence
• Server side processing
• Separates the graphical design from the
dynamic content
2
Relationships
• In servlets,
– HTML code is printed from java code
• In JSP pages
– Java code is embadded in HTML code
3
Java
HTML
HTML
Java
Template
text
In General Lines
• JSP-enabled server
–
–
–
–
picks up .jsp page
parses it
converts it to runnable form
runs it
• Converts page to a Java servlet (JspPage), with
your code inside the _jspService() method
– compiles it
– runs servlet protocol
4
Separating Graphical Design and
Dynamic Content
• Not a new idea (e.g. PHP, mod_perl, shtml, ASP)
• Graphical Design and System Design are two
separate and distinct specialities:
– Different languages (HTML vs. Java)
– Different goals
– Different Training
• Should be separated for optimal project
management
• JSP does this by allowing special Java tags in
HTML
5
An Example
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0
Transitional//EN">
<HTML>
<HEAD>
<TITLE>Hello World Example</TITLE>
</HEAD>
<BODY>
<H2>Hello World Example</H2>
<B><% out.println("Hello World"); %></B>
</BODY>
</HTML>
6
7
Translating and Executing JSP Pages
• A JSP page is executed in a JSP container,
generally installed in a Web server
– Think of a “JSP container” as a JVM with suitable
software installed
• The underlying semantic model is that of a servlet
• A typical JSP container will translate the JSP page
to a Java servlet
• By default, translation and compilation of a JSP
page is likely to occur the first time the page is
accessed
8
The Source Code
• In Tomcat 3.2.1, you can find the generated Java
and the class files in a subdirectory under
tomcat_home/work.
9
Translation
<H1>A Random Number</H1>
<%= Math.random() %>
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
request.setContentType("text/html");
HttpSession session = request.getSession(true);
JspWriter out = response.getWriter();
out.println("<H1>A Random Number</H1>");
out.println(Math.random());
...
}
10
JSP Features
• Standard directives guiding translation of a JSP
page to a servlet
• Standard actions in the form of predefined JSP
tags
• Script language declarations, scriptlets, and
expressions for including Java (or other language)
fragments that embed dynamic content
• A portable tag extension mechanism, for
building tag libraries—effectively extending the
11 JSP language
More Details
Writing JSP Pages
12
Template HTML
• The HTML code that wraps the code is like
a template
• Created as an ordinary HTML
• The dynamic parts are created on runtime
and are inserted into the template
13
JSP Scripting Elements
• JSP scripting elements let you insert Java code
into the servlet that will be generated from the 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, and
3. Declarations of the form <%! code %> that are
inserted into the body of the servlet class, outside of
any existing methods
14
JSP Expressions
• A JSP expression is used to insert Java values
directly into the output
• It has the following form:
<%= Java Expression %>
• The Java expression is
– evaluated,
– converted to a string, and
– inserted into the page
• This evaluation is performed at runtime (when the
page is requested), and thus has full access to
information about the request
15
Predefined Variables
• The following predefined variables can
be used:
– request, the HttpServletRequest
– response, the HttpServletResponse
– session, the HttpSession associated with the
request (if any)
– out, the PrintWriter (a buffered version of
type JspWriter) used to send output to the
client
16
Examples
• For example, the following shows the
date/time that the page was requested:
Current time: <%= new java.util.Date() %>
• For example, the following shows the
hostname:
Your hostname:
<%= request.getRemoteHost() %>
17
<HTML>
<HEAD>
<TITLE>JSP Expressions</TITLE>
</HEAD>
<BODY>
<H2>JSP Expressions</H2>
<UL>
<LI>Current time: <%= new java.util.Date() %>
<LI>Your hostname: <%= request.getRemoteHost() %>
<LI>Your session ID: <%= session.getId() %>
<LI>The <CODE>testParam</CODE>
form parameter:
<%= request.getParameter("testParam") %>
</UL>
</BODY>
</HTML>
18
19
JSP Scriplets
• JSP scriptlets let you insert arbitrary code
into the servlet method that will be built to
generate the page ( _jspService )
• Scriptlets have the following form:
<% Java Code %>
• Scriptlets have access to the same
automatically defined variables as
expressions
20
Producing Code
• Scriplets produce output HTML by printing
into the out variable
• Example:
<%
String queryData = request.getQueryString();
out.println("Attached GET data: " + queryData);
%>
21
HTML Code in Scriptlets
• HTML code before and after the scriplets is
converted to print methods:
<% if (Math.random() < 0.5) { %>
You <B>won</B> the game!
<% } else { %>
You <B>lost</B> the game!
<% } %>
if (Math.random() < 0.5) {
out.println("You <B>won</B> the game!");
}
else {
out.println("You <B>lost</B> the game!");
}
22
<%= foo() %>
<% bar(); %>
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
request.setContentType("text/html");
HttpSession session = request.getSession(true);
JspWriter out = response.getWriter();
out.println(foo());
bar();
...
}
23
Example of Using Scriplets (1)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>Color Testing</TITLE>
</HEAD>
<%
String bgColor = request.getParameter("bgColor");
boolean hasExplicitColor;
if (bgColor != null) {
hasExplicitColor = true;
} else {
hasExplicitColor = false;
bgColor = "WHITE";
}
%>
24
Example of Using Scriplets (2)
<BODY BGCOLOR="<%= bgColor %>">
<H2 ALIGN="CENTER">Color Testing</H2>
<%
if (hasExplicitColor) {
out.println("You supplied an explicit
background color of "+ bgColor + ".");
} else {
out.println("Using default background color ” +
“of WHITE. Supply the bgColor request ” +
“attribute to try a standard color, “ +
“an RRGGBB value, or to see if your browser” +
“supports X11 color names.");
}
%>
</BODY>
</HTML>
25
26
JSP Declaration
• A JSP declaration lets you define methods or
fields that get inserted into the main body of the
servlet class (outside of the service method
processing the request)
• It has the following form:
<%! Java Code %>
• Declarations do not produce output
• They are used, for example, to define variables
27
Example
• We want to print out the number of times
the current page has been requested since
the server booted (or the servlet class was
changed and reloaded):
<%! private int accessCount = 0; %>
Accesses to page since server reboot:
<%= ++accessCount %>
28
Predefined Variables
• As we have seen before, there are variables
that can be used in the code
• There are eight automatically defined
variables, sometimes called implicit objects
• The available variables are request,
response, out, session, application,
config, pageContext, and page
29
request
• This is the HttpServletRequest
associated with the request
• It lets you
– look at the request parameters (via
getParameter),
– the request type (GET, POST, HEAD, etc.),
and
– the incoming HTTP headers (cookies, etc.)
30
response
• This is the HttpServletResponse
associated with the response to the client
• The output stream is buffered,
• Thus, it is legal to set HTTP status codes
and response headers, even though this is
not permitted in regular servlets once any
output has been sent to the client
31
out
• This is the PrintWriter used to send
output to the client
• However, in order to make the response
object useful, this is a buffered version of
PrintWriter called JspWriter
• Note that you can adjust the buffer size, or even turn
buffering off, through use of the buffer attribute of the
page directive
32
session
• This is the HttpSession object associated
with the request
• Sessions are created automatically, so this
variable is bound even if there was no
incoming session reference (unless session was
turned off using the session attribute of the page
directive)
33
application
• This is the ServletContext as obtained
via getServletConfig().getContext()
• Servlets and JSP pages can hold constant
data in the ServletContext object
• Getting and setting attributes is with
getAttribute and setAttribute
• The ServletContext is shared by all the
servlets in the server
34
config
• This is the ServletConfig of the page
35
pageContext
• JSP introduced a new class called
PageContext
• It encapsulate use of server-specific features
like higher performance JspWriters
• The idea is that, if you access the serverspecific features through this class rather
than directly, your code will still run on
"regular" servlet/JSP engines
36
page
• This is simply a synonym for this
• page is not very useful in Java codes in JSP
pages
• It was created as a placeholder for the time
when the scripting language could be
something other than Java
37
JSP Directives
• A JSP directive affects the overall structure of the
servlet class that is created from the JSP page
• It usually has the following form:
<%@ directive attribute="value" %>
• Multiple attribute settings for a single directive
can be combined:
<%@ directive
attribute1="value1"
attribute2="value2"
...
attributeN="valueN" %>
38
Directives
• There are three main types of directive:
• page, which lets you do things like
– import classes
– customize the servlet superclass
• include, which lets you
– insert a file into the servlet class at the time the JSP file
is translated into a servlet
• taglib directive
– indicates a library of custom tags that the page can
include
39
The page Directive
• The page directive lets you define the following
attributes:
– import="package.class“
<%@ page import="java.util.*" %>
– contentType="MIME-Type"
<%@ page contentType="text/plain" %>
(it is the same as
<% response.setContentType("text/plain"); %>)
40
More Page Directives
• isThreadSafe=“true|false”
– Normal servlet processing or implementing
SingleThreadModel
• session=“true|false”
– Allowing/disallowing sessions
• buffer=“sizekb|none”
– specifies the buffer size for the JspWriter out
• autoflush=“true|false”
– Flush buffer when full or throws an exception when
buffer isfull
41
And More Directives
• extends=“package.class”
• info=“message”
– A message for the getServletInfo method
• errorPage=“url”
– Define a JSP page that handles uncaught
exceptions
• isErrorPage=“true|false”
• language=“java”
42
The include Directive
• This directive lets you include files at the
time the JSP page is translated into a servlet
• The directive looks like this:
<%@ include file="relative url" %>
43
Writing JSP in XML
• We can replace the JSP tags with XML tags
that represent
–
–
–
–
44
Expressions
Scriptles
Declarations
Directives
<%= Java Expression %>
<jsp:expression>
Java Expression
</jsp:expression>
<% Code %>
<jsp:scriptlet>
Code Java
</jsp:scriptlet>
<%! declaration %>
<jsp:declaration>
Java Declaration
</jsp:declaration>
<%@ directive %>
45
<jsp:directive.type
Attribute = value/>
Actions
• JSP actions use constructs in XML syntax
to control the behavior of the servlet engine
• You can
–
–
–
–
46
dynamically insert a file,
reuse JavaBeans components,
forward the user to another page, or
generate HTML for the Java plugin
Available Actions
• 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 new page
– jsp:plugin - Generate browser-specific code that makes
an OBJECT or EMBED tag for the Java plugin
47
The jsp:include Action
• This action lets you insert files into the page
being generated
• The file inserted when page is requested
• The syntax looks like this:
<jsp:include page="relative URL"
flush="true" />
48
The jsp:forward Action
• Forwards request to another page
• Syntax:
<jsp:forward page="relative URL"/>
• It has a single attribute, page, which should consist of a
relative URL
• This could be a static value, or could be computed at
request time
• Examples:
<jsp:forward page="/utils/errorReporter.jsp" />
<jsp:forward page="<%= someJavaExpression %>" />
49
Using Beans
• JavaBeans are reusable software components that
can be manipulated visually in a builder tool
– Introspaction – analyze how the bean works
– Customization – the user can customize the look of the
bean
– Events support
– Properties support
– Persistence – allowing saving the bean on a persistent
mechanism and loading it
50
Some Facts about Beans
• The bean Class should include a constructor
with no arguments
• The bean class should not include public
variables (fields)
• Access to the attributes of the bean is
through methods that look like
– getName / setName for non-boolean fields
– isName / setName for boolean fields
51
The jsp:useBean Action
• This action lets you load in a JavaBean to
be used in the JSP page
• The simplest syntax for specifying that a
bean should be used is:
<jsp:useBean id="name“
class="package.class" />
52
Using a Bean
<jsp:useBean id="name”
class="package.class" />
•Create an object of the given class
•Bind the object to a variable with the given name
53
Using a Bean
<jsp:useBean id=“db”
class=“dbiClasses.WebDatabase" />
<% dbiClasses.WebDatabase db = new
dbiClasses.WebDatabase(); %>
54
Using a Bean
<jsp:useBean id=“handler“
class=“ConnectionHandler" type=“Runnable”/>
<% Runnable handler = new
ConnectionHandler(); %>
55
More on Beans
• Creating a Bean with jsp:useBean is like
creating an object
• The scope of the bean can be beyond the
page where it is declared
• Beans are used for resource collaboration
56
Getting the Properties of a Bean
• Use jsp:getProperty to get a property of
a bean
• Use the attributes name and property to
get the requested property
<jsp:getProperty name=“db”
property=“login” />
<%= db.getLogin() %>
57
Setting the Properties of a Bean
• Use jsp:setProperty to set a property of
a bean
• Use the attributes name, property and
value to set the value to the property
<jsp:setProperty name=“db”
property=“login” value=“snoopy”/>
<%= db.setLogin(“snoopy”); %>
58
Example
package dbiTests;
public class SimpleBean {
private String message="No message specified";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}
}
59
<HTML>
<HEAD> <TITLE>Reusing JavaBeans in JSP</TITLE>
</HEAD>
<BODY>
<CENTER> <TABLE BORDER=5>
<TR><TH CLASS="TITLE"> Reusing JavaBeans in JSP
</TABLE> </CENTER>
<P>
<jsp:useBean id="test" class=“dbiTest.SimpleBean" />
<jsp:setProperty name="test" property="message"
value="Hello WWW" />
<H1>Message: <I>
<jsp:getProperty name="test" property="message" />
</I></H1>
</BODY>
</HTML>
60
Getting the Values from the
Request
<jsp:setProperty name=“db”
property=“login”
value=‘<%=
request.getParameter(“login”)%>’
/>
61
Getting the Parameter
Automatically
• If we wand that the value of the parameter
dblogin of the request will be set to the bean
db automatically we can use:
<jsp:setProperty name=“db”
property=“login”
param=“dblogin” />
62
All Input Parameters
• What will the following do?
<jsp:setProperty name=“db”
property=“*” />
63
Shared Beans
• So far, we assumed that object that were
created using jsp:useBean were bound to
to the local variables in the _jspService
method
• The scope attribute of jsp:useBean gives
us more possibilities
64
The page Value of scope
• The default value of scope
• The object has a binding to the local
variable
• The object is positioned in the
PageContext for the current request
• A servlet can get the value by
pageCotext.getAttribute
65
The application Value of
scope
• The object has a binding to the local variable
• The object is positioned in the ServletContext
• A servlet can get the value by
application.getServletCotext().getAttri
bute
• Allows both servlets and JSP pages to work with
the same object
• Allows a servlet to create a bean that will be used
in JSP pages
66
The session Value of scope
• The object has a binding to the local
variable
• The object is positioned in the
HttpSession for the current request
• A servlet can get the value by
session.getAttribute
67
The request Value of scope
• The object has a binding to the local
variable
• The object is positioned in the
ServletRequest for the current request
• A servlet can get the value by
request.getAttribute
68
A Conditional Bean
• The jsp:useBean component will create a
new bean only if there is no existing bean
with the same id and scope
• If an existing bean is found, it will be bound
to the variable defined by id
• Since bean objects are not always created
you can have a java code that is executed
only if a new bean is created
69
public class AccessCounterBean {
private String firstPage;
private int accessCount = 1;
public String getFirstPage() {
return(firstPage);
}
Example of
Conditional
Bean
public void setFirstPage(String firstPage) {
this.firstPage = firstPage;
}
public int getAccessCount() {
return(accessCount++);
}
}
70
Example of Conditional Bean
<jsp:useBean id=“counter“
class=“AccessCounterBean"
scope=“application”/>
<jsp:setProperty name=“counter”
property=“firstPage”
value=“Current Page Name”/>
</jsp:useBean>
71
Comments
• <%-- comment --%>
– A JSP comment
– Ignored by JSP-to-scriptlet translator
– Any embedded JSP scripting elements, directives,
or actions are ignored
• <!-- comment -->
– An HTML comment
– Passed through to resultant HTML
– Any embedded JSP scripting elements, directives,
or actions are executed normally
• /* comment */ or // comment
72
– Java comment
– Part of the Java code
Quoting Conventions
• <\% - used in template text (static
HTML) and in attributes where you
really want “<%”
• %\> - used in scripting elements and in
attributes where you really want “%>”
• \‘ \” - for using quotes in attributes
• \\ for having \ in an attribute
73
Init and Destroy
• JSP pages, like regular servlets, sometimes
want to use init and destroy
• Problem: the servlet that gets built from the
JSP page might already use init and destroy
– Overriding them would cause problems
– Thus, it is illegal to use JSP declarations to
declare init or destroy
74
Init and Destroy
• Solution: use jspInit and jspDestroy
– The auto-generated servlet is guaranteed to call
these methods from init and destroy
– The standard versions of jspInit and jspDestroy
are empty (placeholders for you to override)
75
JSP vs. Javascript
• Javascript
–
–
–
–
76
Client side
Less secure
Browser Dependent
Unstable
JSP vs. ASP
• Active Server Pages (ASP)
– Similarities:
•
•
•
•
Server side dynamic web page generators
Share similar syntax <% %>
Modular programming (e.g. ActiveX, JavaBeans)
Focus on database connectivity
– Differences:
• ASP is a product while JSP is a specification
77
JSP vs. ASP (cont.)
• JSP
– Based on Java Technology
– Platform independence
• Unix, AS400, VMS, Windows
– More vendors choice
• ASP
– Microsoft programming languages
– Near Monopoly
78
JSP vs. Servlets
• But JSP pages are converted to Servlets?
Aren’t they the same?
• Similarities
– Provide identical results to the end user
– JSP is an additional module to the Servlet
Engine
79
JSP versus Servlets (cont.)
• Differences
– Servlets: “HTML in Java code”
• HTML code inaccessible to Graphics Designer
• Everything very accessible to Programmer
– JSP: “Java Code Scriptlets in HTML”
• HTML code very accessible to Graphics Designer
• Java code very accessible to Programmer
(Seperating content from appearance)
80