SECTION 8: THE JAVA SERVER PAGES (JSP) TECHNOLOGY MODEL

Section 8
8.1 Write the opening and closing tags for the following JSP tag types: Directive Declaration Scriptlet Expression
8.2 Given a type of JSP tag, identify correct statements about its purpose or use.
8.3 Given a JSP tag type, identify the equivalent XML-based tags.
8.4 Identify the page directive attribute, and its values, that: Import a Java class into the JSP page Declare that a JSP page exists within a session Declare that a JSP page uses an error page Declare that a JSP page is an error page
8.5 Identify and put in sequence the following elements of the JSP page lifecycle: Page translation JSP page compilation Load class Create instance Call jspInit Call _jspService Call jspDestroy
8.6 Match correct descriptions about purpose, function, or use with any of the following implicit objects: request response out session config application page pageContext exception
8.7 Distinguish correct and incorrect scriptlet code for: A conditional statement; An iteration statement

Section 8 - The Java Server Pages (JSP) Technology Model

8.1 Write the opening and closing tags for the following JSP tag types:

1. Directive
2. Declaration
3. Scriptlet
4. Expression

Directives

• JSP Directives (Directives are used during the translation phase; all other elements are used during request processing phase)
• <%@ include file={static hltml file or regular jsp file} %> includes file as part of the translation unit, which is compiled into a servlet; a page may include multiple include directives
• <%@ page {…} %> assigns various page-dependent attributes; defaults are given below:
  1. language= "java"
  2. contentType= "text/html"
  3. import= "java.util.Date, java.util.DateFormat" {may have more than one import assignments via multiple page directives}
  4. session= "true" (if set to false, the implicit session variable is not available to scripting elements)
  5. isErrorPage= "false" (set to true if this page is used as an error page, and it will have the implicit exception variable available to scripting elements)
  6. errorPage= "…" (no default; page-relative or context-relative URI to redirect to in case exception thrown)
  7. autoFlush= "true" (if false, throws exception when buffer is full)
  8. buffer= "8kb" (defines size of buffer; "none" to disable buffering)
  9. info= "…" (no default; used by server administrative tool as a description of the jsp page)
  10. isThreadSafe= "true" (if set to false, then will use SingleThreadModel)
  11. extends= "…" (no default; fully qualified classname to extend; class must implement JspPage or HttpJspPage interface)
  
• <%@ taglib {…} %> declares a tag library, containing custom actions, that is used in the page
  1. prefix= "…" (mandatory; no default; specifies prefix to use in the action element names for all actions in the library)
  2. uri= "…" (mandatory; no default; either a symbolic name for the tag library in the web.xml file or a page- or context-relative uri for the library's TLD or JAR file)

  Declaration

• <%! String mystring = new String("hello"); %>
• must be a valid java variable declaration; declares instance variables of the JSP implementation class; thread-safe alternative is to declare variables in scriptlets, so they are local variables
• may also declare methods within a Declaration element
• JSP implicit variables are not visible in a declaration element, since they are declared within the _jspService() method.

  Scriptlet

• <% if (1+2==true) { %> yippee!! <% } else { %> boohoo!! <% } %>
• scriptlet code fragments are combined with code for sending template data between them to the browser; the combination of all scriptlets in a page must form valid java code
• all JSP implicit variables are visible in a scriptlet element

  Expresson

• <%= 1+2 %> or <%= mystring %>
• must be complete valid java expression that results in or can be converted to a string.
• all JSP implicit variables are visible in an expression element

8.2 Given a type of JSP tag, identify correct statements about its purpose or use.

• Directive - controls translation and compilation phase.
• Declaration - declare a java variable or method. No output produced. Class level declarations.
• Scriptlet - valid java statements. No output produced unless out is used
• Expression - evaluation of expression to a String and then included in the output

8.3 Given a JSP tag type, identify the equivalent XML-based tags.

• <%@ page …%> == <jsp:directive.page …/>
• <%! …%> == <jsp:declaration> … </jsp:declaration>
• <% …%> == <jsp:scriptlet>> … </jsp:scriptlet>
• <%= …%> == <jsp:expression>> … </jsp:expression>

taglib directive doesn't have XML equivalent, it is included in <jsp:root> element as a xmlns element. <%@taglib uri=http://my.com/my.tld prefix="my" %> will become <jsp:root xmlns:my=http://my.com/my.tld> </jsp:root> Template text should use <jsp:text> element.

8.4 Identify the page directive attribute, and its values, that:

1. Import a Java class into the JSP page
   <%@ page import="java.util.Date" %> (Multiple declarations are separated by comma)
2. Declare that a JSP page exists within a session
   <%@ page session="true"%>
3. Declare that a JSP page uses an error page
   <%@ page errorPage="errorPage.jsp" %>
4. Declare that a JSP page is an error page
   <%@ page isErrorPage="true" %>

8.5 Identify and put in sequence the following elements of the JSP page lifecycle:

1. Page translation
   
2. JSP page compilation
   
3. Load class
   
4. Create instance
   
5. Call jspInit
   
6. Call _jspService
   
7. Call jspDestroy
   

The above order is already correct.

Basically there are two phases, translation and execution. During the translation phase the container locates or creates the JSP page implementation class that corresponds to a given JSP page. This process is determined by the semantics of the JSP page. The container interprets the standard directives and actions, and the custom actions referencing tag libraries used in the page. A tag library may optionally provide a validation method to validate that a JSP page is correctly using the library. A JSP container has flexibility in the details of the JSP page implementation class that can be used to address quality-of-service --most notably performance--issues.

During the execution phase the JSP container delivers events to the JSP page implementation object. The container is responsible for instantiating request and response objects and invoking the appropriate JSP page implementation object. Upon completion of processing, the response object is received by the container for communication to the client.

8.6 Match correct descriptions about purpose, function, or use with any of the following implicit objects:

1. request
2. response
3. out
4. session
5. config
6. application
7. page
8. pageContext
9. exception

PageContext provides a number of facilities to the page/component implementor including

• a single API to manage the various scoped namespaces
• a number of convenience API's to access various public objects
• a mechanism to obtain the JspWriter for output
• a mechanism to manage session usage by the page
• a mechanism to expose page directive attributes to the scripting environment
• mechanisms to forward or include the current request to other active components in the application
• a mechanism to handle errorpage exception processing

The methods related to attributes are:

setAttribute(), 
getAttribute(), 
removeAttribute() - deals page scope
findAttribute(), - looks in all scopes 
int getAttributesScope()
getAttributeNamesInScope(int scope)

The following methods provide convenient access to implicit objects:

getOut(), 
getException(), 
getPage() 
getRequest(), 
getResponse(), 
getSession(), 
getServletConfig() 
getServletContext()

The following methods provide support for forwarding, inclusion and error handling:

forward(relativeURl), 
include(relativeURl), 
handlePageException(Exception/Throwable).

8.7 Distinguish correct and incorrect scriptlet code for:

1. A conditional statement;
2. An iteration statement

Conditional Statement

<% if (event.equals("ENTER_RECORD")) { %>
<jsp:include page="enterRecord.jsp" flush=true"/>
<% } else if (event.equals ("NEW_RECORD")) { %>
<jsp:include page="newRecord.jsp" flush="true/>
<% } else { %>
<jsp:include page="default.jsp" flush = true"/>
<% } %>

Iterative Statement

<% Hashtable h = (Hashtable) session.getAttribute("charges");
if (h != null) { %>
<ul>
<%
Enumeration charges = h.keys();
While (charges.hasMoreElements()) {
    String proj = (String) charges.nextElement();
    Charge ch = (Charge) h.get(proj);
%>
<li>
    name = <%= ch.getName() %>
  , project = <%= proj %>
  , hours = <%= ch.getHours() %>
  , date = <%= ch.getDate() %>
<% } %>
</ul>
<% } %>