jsp – java server pages part 2
DESCRIPTION
JSP – Java Server Pages Part 2. Representation and Management of Data on the Internet. Interacting with other Resources. JSP Cooperation. We will consider several ways in which JSP and other resources cooperate Forwarding the request handling to other resources - PowerPoint PPT PresentationTRANSCRIPT
JSP – Java Server PagesJSP – Java Server PagesPart 2Part 2
Representation and Management of Data on the Internet
Interacting with other Interacting with other ResourcesResources
JSP CooperationJSP Cooperation
• We will consider several ways in which JSP and other resources cooperate- Forwarding the request handling to other resources
- Including the content of other sources
- Including the code of other JSP files
- Forwarding exception handling to other JSPs
ActionsActions
• JSP actions use constructs in XML syntax to control the behavior of the Servlet engine
• Using actions, you can
- forward the request to another resource in the application
- dynamically include a resource content in the response
The The forwardforward Action Action
• jsp:forward - Forwards the requester to a new
resource <jsp:forward page="{relativeURL|<%= expression %>}">
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" /> *
</jsp:forward>
• This action is translated to an invocation of the
RequestDispatcher
The The includeinclude Action Action
• jsp:include - Include a resource content at run
time <jsp:include page="{relativeURL|<%= expression %>}">
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" />*
</jsp:include>
• This action is also translated to an invocation of
the RequestDispatcher
The The includeinclude Directive 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="url" %>
• JSP content can affect main page
• In Tomcat 5.x, generated Servlet is updated when included files change (unlike old versions...)
Include - ActionInclude - Action
File1.jsp
Servlet1
File2.jsp Servlet2
HTMLcontent
HTMLcontent
HTMLcontent
Include DirectiveInclude Directive
File1.jsp
File2.jspServlet
HTMLcontent
includeinclude Action vs. Directive Action vs. Directive
• When a resource is included using the include action, the generated Servlet uses the dispatcher to include its content at runtime
• When a file is included using the include directive, the file itself is included verbatim into the JSP code, prior to the Servlet generation
• Question: in which of the above options can the included element change the HTTP headers or status?
<html>
<head><title>Including JSP</title></head><body>
<h2>Here is an interesting page.</h2>
<p>Bla, Bla, Bla, Bla.</p>
<%@ include file="/AccessCount.jsp" %>
<jsp:include page="/dbimail.jsp"/>
</body></html>
BlaBla.jsp
<%! private int accessCount = 0; %>
<hr><p>Accesses to page since Servlet init:
<%= ++accessCount %></p>
<hr><p>
Page Created for Dbi Course at <%= new java.util.Date() %>. Email us <a href="mailto:[email protected]">here</a>. </p>
AccessCount.jsp
dbimail.jsp
out.write("<html>\r\n");
out.write(" <head><title>Including JSP</title></head>\r\n");
out.write(" <body>\r\n");
out.write(" <h2>Here is an interesting page.</h2>\r\n");
out.write(" <p>Bla, Bla, Bla, Bla.</p>\r\n");
out.write("<hr>\r\n");
out.write("<p> \r\n");
out.write(" Accesses to page since Servlet init: \r\n");
out.print( ++accessCount );
out.write("</p>\r\n");
org.apache.jasper.runtime.JspRuntimeLibrary.
include(request, response, "/dbimail.jsp", out, false);
out.write(" </body>\r\n");
out.write("</html>\r\n");
BlaBla_jsp.java
Included CounterIncluded Counter
• Suppose that the file BlaBla2.jsp is similar the BlaBla.jsp
• How will the counter of BlaBla2.jsp act?
• What if we used a JSP action instead of a JSP directive for the counter?
Error PagesError Pages
• We can set one JSP page to be the handler of uncaught
exceptions of another JSP page, using JSP directives
• <%@ page errorPage="url " %>
- Defines a JSP page that handles uncaught exceptions
- The page in url must have true in the page-directive:
• <%@ isErrorPage="true|false" %>
- The variable exception holds the exception thrown
by the calling JSP
<html>
<head><title>Reading From Database </title></head>
<body>
<%@ page import="java.sql.*" %>
<%@ page errorPage="errorPage.jsp" %>
<%
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con = DriverManager.getConnection
("jdbc:oracle:thin:" + "snoopy/snoopy@sol4:1521:stud");
%>
<h2>Connection Established!!</h2>
</body>
</html>
connect.jsp
<html>
<head><title>Connection Error</title></head>
<body>
<%@ page import="java.io.*" %>
<%@ page isErrorPage="true" %>
<h1>Oops. There was an error when you accessed the
database.</h1>
<h2>Here is the stack trace:</h2>
<pre style="color:red">
<% exception.printStackTrace(new PrintWriter(out)); %>
</pre>
</body>
</html>
errorPage.jsp
Custom JSP TagsCustom JSP Tags
Custom JSP TagsCustom JSP Tags
• JSP code may use custom tags - tags that are defined and implemented by the programmer
• The programmer defines how each of the custom tags is translated into Java code
• There are two methods to define custom tags:- Tag libraries - used in old versions of JSP
- Tag files - much simpler, introduced in JSP 2.0
Tag LibrariesTag Libraries
• A tag library consists of:- Tag handlers - Java classes that define how each of
the new tags is translated into Java code
- A TLD (Tag Library Descriptor) file, which is an XML file that defines the structure and the implementing class of each tag
package dbi;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
public class DateTag extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
getJspContext().getOut().print(new java.util.Date());
}
}
DateTag.java
A Simple TagLib ExampleA Simple TagLib Example
<taglib>
<tlib-version>1.0</tlib-version><jsp-version>2.0</jsp-version>
<tag>
<name>date</name>
<tagclass>dbi.DateTag</tagclass>
<body-content>empty</body-content>
</tag>
</taglib> dbi-taglib.tld
<%@ taglib prefix="dbitag" uri="/WEB-INF/tags/dbi-taglib.tld" %>
<html><body>
<h1>Hello. The time is: <dbitag:date/></h1>
</body></html> taglibuse.jsp
Tag FilesTag Files
• JSP 2.0 provides an extremely simplified way of defining tags
• The idea: for each custom tag, write a tag file tagName.tag that implements the tag translation using JSP code
• This way, the programmer can avoid creating tag handlers and TLD files
<%= new java.util.Date() %>
The Simplified ExampleThe Simplified Example
<%@ taglib prefix="dbitag" tagdir="/WEB-INF/tags/" %>
<html>
<body>
<h1>Hello. The time is: <dbitag:date/></h1>
</body>
</html>
date.tag
taguse.jsp
Other Capabilities of Custom TagsOther Capabilities of Custom Tags
• Attributes- You can define the possible attributes of the Tags
- These can be accessed during the Tag translation
• Tag Body- Tag translation may choose to ignore, include or
change the tag body
Java Beans in JSPJava Beans in JSP
MotivationMotivation
• Software components (e.g. objects, data structures, primitives) are extensively used in Web applications
• For example:
- Service local variables
- Attributes forwarded in requests
- Session attributes, like users information
- Application attributes, like access counters
MotivationMotivation
• Standard actions are used to manipulate
components: declaration, reading from the
suitable context, setting of new values (according
to input parameters), storing inside the suitable
context, etc.
• Java Beans provide a specification for automatic
handling and manipulation of software
components in JSP (and other technologies...)
Java Beans: The IdeaJava Beans: The Idea
• Java Beans are simply objects of classes that follow some (natural) coding convention:- An empty constructor
- A readable property has a matching getter
- A writable property has a matching setter
• Use JSP actions to access and manipulate the bean, and special action attributes to specify the properties of the bean, like its scope
Example 1: Access CounterExample 1: Access Counter
In the following example, we use a Bean to maintain an access counter for requests to the
pages
package dbi;
public class CounterBean {
private int counter;
public CounterBean() { counter = 0; }
public int getCounter() { return counter; }
public void setCounter(int i) { counter = i; }
public void increment() { ++counter; }
}
Bean must reside in a package
Bean is created by an empty constructor
counter is readable and writable
other methods can be used
Counter BeanCounter Bean
CounterBean.java
<html>
<head><title>Bean Example</title></head><body>
<jsp:useBean id="accessCounter"
class="dbi.CounterBean" scope="application"/>
<% accessCounter.increment(); %>
<h1> Welcome to Page A</h1>
<h2>Accesses to this application:
<jsp:getProperty name="accessCounter" property="counter"/>
</h2>
<a href="pageB.jsp">Page B</a></body>
</html> invokes getCounter() pageA.jsp
<html>
<head><title>Bean Example</title></head><body>
<jsp:useBean id="accessCounter"
class="dbi.CounterBean" scope="application"/>
<% accessCounter.increment(); %>
<h1> Welcome to Page B</h1>
<h2>Accesses to this application:
<jsp:getProperty name="accessCounter" property="counter"/>
</h2>
<a href="pageA.jsp">Page A</a></body>
</html> pageB.jsp
dbi.CounterBean accessCounter = null;
synchronized (application) {
accessCounter = (dbi.CounterBean) _jspx_page_context.getAttribute("accessCounter",
PageContext.APPLICATION_SCOPE);
if (accessCounter == null) {
accessCounter = new dbi.CounterBean();
_jspx_page_context.setAttribute("accessCounter",
accessCounter, PageContext.APPLICATION_SCOPE);
}
}
From the Generated ServletFrom the Generated Servlet
Example 2: Session DataExample 2: Session Data
In the following example, we use a Bean in order to keep a user's details throughout the session
package dbi;
public class UserInfoBean {
private String firstName;
private String lastName;
public UserInfoBean() { firstName = lastName = null;}
public String getFirstName() {return firstName;}
public String getLastName() { return lastName;}
public void setFirstName(String string) {firstName = string;}
public void setLastName(String string) {lastName = string;}
} UserInfoBean.java
<html>
<head><title>Information Form</title></head>
<body>
<h1>Fill in your details:</h1>
<form action="infoA.jsp" method="get"><p>
Your First Name:
<input type="text" name="firstName" /> <br/>
Your Last Name:
<input type="text" name="lastName" /><br/>
<input type="submit" /></p>
</form>
</body></html> infoForm.html
<jsp:useBean id="userInfo" class="dbi.UserInfoBean"
scope="session"/>
<jsp:setProperty name="userInfo" property="*"/>
<html>
<head><title>Page A</title></head><body>
<h1>Hello
<jsp:getProperty name="userInfo" property="firstName"/>
<jsp:getProperty name="userInfo" property="lastName"/>,
</h1>
<h1>Have a nice session!</h1>
<h2> <a href="infoB.jsp">User Info B</a></h2>
</body></html>
Match parameters to corresponding properties
infoA.jsp
<jsp:useBean id="userInfo" class="dbi.UserInfoBean"
scope="session"/>
<jsp:setProperty name="userInfo" property="*"/>
<html>
<head><title>Page B</title></head><body>
<h1>Hello
<jsp:getProperty name="userInfo" property="firstName"/>
<jsp:getProperty name="userInfo" property="lastName"/>,
</h1>
<h1>Have a nice session!</h1>
<h2> <a href="infoA.jsp">User Info A</a></h2>
</body></html> infoB.jsp
Advantages of Java BeansAdvantages of Java Beans
• Easy and standard management of data
- Automatic management of bean sharing and lots more
• Good programming style
- Allow standard but not direct access to members
- You can add code to the setters and getters (e.g. constraint
checks) without changing the client code
- You can change the internal representation of the data without
changing the client code
• Increase of separation between business logic (written
by programmers) and HTML (written by GUI artists)
JSP Expression LanguageJSP Expression Language
JSP Expression LanguageJSP Expression Language
• JSP expression language is a comfortable tool to access useful objects in JSP
• This language provides shortcuts in JavaScript-like syntax
• An expression in EL is written as ${expr}
• For example:
Hi, ${user}. <em style="${style}">Welcome</em>
EL VariablesEL Variables
• JSP EL does not recognize JSP's implicit objects, but rather has its own set:
param, paramValues, header ,headerValues, cookie, initParam, pageScope, requestScope, sessionScope, applicationScope
• Each of these objects maps names to values
• For example, use param["x"] or param.x to get the value of the parameter x
EL Variables (cont)EL Variables (cont)
• A variable that is not an EL implicit object is looked up at the page, request, session (if valid) and application scopes
• That is, x is evaluated as the first non null element obtained by executing pageContext.getAttribute("x"), request.getAttribute("x"), etc.
Object PropertiesObject Properties
• In JSP EL, Property p of Object o is referred to as o[p]
• Property p of Object o is evaluated as follows:- If o is a Map object, then o.get(p) is returned
- If o is a List or an array, then p is converted into an integer and o.get(p) or o[p] is returned
- Otherwise, treat o as a bean, convert p to a string, and return apply the corresponding getter of o
• The term o.p is equivalent to o["p"]
An ExampleAn Example
<% response.addCookie(new Cookie("course","dbi"));
session.setAttribute("dbiurl",new
java.net.URL("http://www.cs.huji.ac.il/~dbi/index.html"));
String[] strs = {"str1","str2"};
session.setAttribute("arr", strs); %>
<html><head><title>JSP Expressions</title></head><body>
<form method="get" action="el.jsp">
<h2>Write the parameter x: <input name="x" type="text" />
<input type="submit" value="send" /></h2>
</form>
</body></html> elcall.jsp
<%@ page isELIgnored="false" %>
<html>
<head><title>EL Examples</title></head>
<h1>Expression-Language Examples</h1>
<h2>Parameter <code>x</code>: ${param["x"]} </h2>
<h2>Cookie <code>course</code>:
${cookie.course.value}</h2>
<h2>Header <code>Connection</code>:
${header.Connection} </h2>
<h2>Path of session attr. <code>dbiurl</code>:
${sessionScope.dbiurl.path}</h2>
<h2>Element <code>arr[${param.x}]</code>:
${arr[param.x]} </h2>
</body></html> el.jsp