1 Java Server Pages A Java Server Page is a file consisting of HTML or XML markup into which special...
-
Upload
allan-walker -
Category
Documents
-
view
225 -
download
0
description
Transcript of 1 Java Server Pages A Java Server Page is a file consisting of HTML or XML markup into which special...
1
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
2
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”
3
Directives
• Directives are compiler instructions that are processed when the page is compiled
• The format is <%@ and end with %>• Examples:
<%@ page %><%@ include %>
4
Directives
• <%@ page %>• At the top of each JSP is a page declaration
<%@ page language=“java” language (see below)import=“. . .” list of packages to importerrorPage=“. . .” substitute error pagecontentType=“. . .” usually “text/html”%>
• At present only Java can be used in a JSP
5
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" %>
6
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 "--%\>".
7
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}%>
8
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
9
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
10
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><% } %>
11
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><% } %>
12
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>
13
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
14
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
15
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
Java Beanpublic class MyJavaBean{ private String propertyName; public MyJavaBean() { … } // Default Constructor
public void setPropertyName(String theValue) { this.propertyName = theValue; }
public String getPropertyName() { return this.propertyName; }}
16
17
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>
18
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)
19
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() %>
20
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)
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
Enterprise Information System
HTMLView
ClassicWeb Client Administrator
SwingView
XML WebService
SupplierB2B Agent
Model-View-Controller
View (HTML/JSP)-Renders the Model-Requests updates from model(s)-Sends user gestures to controller-Allows controller to select view
Controller (Servlets)-Defines application behavior-Maps user actions to model updates-Selects views for response-One for each functionality
Model (Java Beans)-Encapsulates application state-Responds to state queries-Exposes application functionality-Notifies view(s) of changes
ChangeNotification
State Query
StateChange
View Selection
User gestures