Transcript ppt

Java Server Pages
• A Java Server Page is a file consisting of HTML
or XML markup into which special tags and code
blocks are inserted
• When the page is first requested, a JSP is parsed
into a java source file which is then compiled into
a servlet class and run under the container JVM
• Initially, there is a performance hit
• However, there is a “build” mechanism to avoid
unneeded parsing and compilation based on the
date of the JSP page relative to the class file
1
Java Server Page Tags
•
•
•
•
•
•
Directives
Hidden Comments
Declarations
Expressions
Scriptlets
There are also a number of XML-type tags
that begin with “<jsp:’ called “actions”
2
Directives
• Directives are compiler instructions that
are processed when the page is compiled
• The format is <%@ and end with %>
• Examples:
<%@ page %>
<%@ include %>
3
Directives
• <%@ page %>
• At the top of each JSP is a page declaration
<%@ page
language=“java”
import=“. . .”
errorPage=“. . .”
contentType=“. . .”
%>
language (see below)
list of packages to import
substitute error page
usually “text/html”
• At present only Java can be used in a JSP
4
Directives
• <%@ include %>
• This directive inserts the “static” contents
of a file into the JSP at compile time
• The text becomes part of the JSP page
• It is useful for including code that is
common to a number of pages, but for
which you do not want to use a bean
• Example:
<%@ include file="relativeURL" %>
5
Hidden Comments
• These are used to document the page and
are not sent to the client
• The format is <%-- comment --%>
• Example:
<%-- This is a comment about the code --%>
• Any characters may be used in the body of a
comment except the closing "--%>" marker
which should be escaped as "--%\>".
6
Declarations
• These are used to declare variables or methods
that have scope throughout the page
• The format is <%! declaration or method %>
• Examples:
<%! String myString = "hello";
private String getData() {
// Java code for the method goes here
}
%>
7
Declarations
• Every JSP contains implicit references to API
objects that do not need to be declared:
–
–
–
–
–
–
–
–
–
request
response
pageContext
session
application
out
config
page
exception
8
Expressions
• The result of an expression is converted to a
String and inserted into the output stream at the
place where it occurs
• The format is <%= expression %>
• Examples:
<%= myString %>
<%= getData() %>
• Note that the expression is not terminated with a
semicolon
• The parser simply wraps an out.print() or similar
method around the expression as its argument
9
Scriptlets
• Scriptlets contain fragments of Java code
• The format is <% Java code here %>
• Scriptlet code can access implicit references and
declared variables or methods
• Use a scriptlet to wrap a conditional or a loop
around a block of HTML
• Examples:
<% if(request.getParameter("user").equals("new")) { %>
<B>Please sign up!</B>
<% } else { %>
<B>Welcome back!</B>
10
<% } %>
Scriptlets
• The output HTML stream will vary depending on
the value of the request parameter named “user”
• Note the use of the implicit request object which
does not need to be declared with “<%! %>”
• Example of scriptlets with an expression:
• <% for(int i=1; i<11; i++) { %>
The current number is: <%= i %><BR>
<% } %>
11
Action
• <jsp:include>
• This tag is used to include either static or
dynamic content in the output stream
• If the file is dynamic, you can use
<jsp:param> to pass parameters to it
• Examples:
<jsp:include page="/login.jsp">
<jsp:param name="username" value="Fred"/>
</jsp:include>
12
Action
• <jsp:forward>
• This tag takes the implicit request object (which
contains the client request parameters and other
CGI-type data) and forwards it to a target file - an
HTML page, a servlet, or another JSP file
• Example:
<jsp:forward page="relativeURL|<%= expression %>">
<jsp:param name=". . ." value=". . ."/>
</jsp:forward>
• The <jsp:param> tag is used to pass additional
parameters to the target
13
Action: Java Beans
• JavaBeans are the component model for Java
- the equivalent of all those fancy components
you can obtain and use in the .NET world
• In a component model / market, developers
go to the marketplace, pay for the component
library they need, and wire it all together in a
JSP using their IDE
• This has worked for other languages (e.g.
Visual Basic), but has never developed for the
Java market
14
Action: Java Beans
• A Java Bean is a class with the following
– A default constructor (with no argument list)
– A Set and Get method for each attribute
(called a property in Java Bean terms)
• A JSP can use an action to instantiate and
access an instance of the Java Bean class
• A JSP can use actions to access the other
methods of an instance of the Java Bean
• A JavaBean can be monitored by listeners
for changes to its parameters from the JSP
15
Java Bean
public class MyJavaBean
{
private String propertyName;
public MyJavaBean() { … }
// Default Constructor
public void setPropertyName(String theValue)
{ this.propertyName = theValue; }
public String getPropertyName()
{ return this.propertyName; }
}
16
Action: Java Beans
• <jsp:useBean> and <jsp:setProperty>
• Example of how to set up a bean instance
<jsp:useBean
id="beanInstanceName"
scope="page|request|session|application"
class=“MyJavaBean"
>
<jsp:setProperty
name="beanInstanceName"
property="propertyName" value="theValue"
/>
</jsp:useBean>
17
Action: Java Beans
• <jsp:getProperty>
• This tag retrieves the value of a bean property and
converts it to a String to display it in the page
• The format is:
<jsp:getProperty name="beanInstanceName“
property="propertyName"/>
• The name attribute points to the bean with the
same id attribute used in the <jsp:useBean> tag
• The property attribute is the name of the bean
property you wish to display (there must be a
corresponding Get method in the bean)
18
Java Beans in Scriptlets / Expressions
• Once a Java Bean has been instantiated, its
instance name and its methods can be used
in scriptlets:
<% beanInstanceName.setPropertyName
(“New_value”) %>
• or expressions:
<%= beanInstanceName.toString() %>
19
Java Server Pages
• You can view the Java source code generated by
the parser, but it's not a good idea to modify it
• The generated Java code is found in:
Tomcat 6.0\work\Catalina\localhost\myapp\org\apache\jsp
• The class file for any Java Beans used must be in
this directory for it to be found while compiling the
generated JSP source code
• A copy of the class file for any Java Beans must
also be located in the WEB-INF/classes directory
for Tomcat to find it at run time
(Proper classpath setting would probably fix this)20
Model-View-Controller
• Multiple views of enterprise application and
information is required – one for each type of
user
• Leads to MVC Architecture – separation of
functions
• Java Server Pages, Servlets, and Java Beans
can be used to implement the MVC
architecture for access to common application
and/or information
Model-View-Controller
• The MVC Solution
Classic
Web Client
Administrator
Supplier
B2B Agent
HTML
View
Swing
View
XML Web
Service
Enterprise Information System
Model-View-Controller
User gestures
Controller (Servlets)
-Defines application behavior
-Maps user actions to model updates
-Selects views for response
-One for each functionality
View
Selection
State
Change
State Query
View (HTML/JSP)
Model (Java Beans)
-Renders the Model
-Requests updates from model(s)
-Sends user gestures to controller
-Allows controller to select view
-Encapsulates application state
-Responds to state queries
-Exposes application functionality
-Notifies view(s) of changes
Change
Notification