JavaBeans

JSP Standard Actions

Dispatching Mechanisms
Expression Language
JSPs in XML

#StandardAction #EL #MVC1

 Review
• Session Tracking Mechanism
– Client must be stored the value that transfer to server in each its request

Store data/object at
server site Session object
Tracking But, SessionID is
Session stored at client
Mechanism
Located
at client’s Cookies
system fie
Store
data/object at
client site Located
URL rewriting
at query
string

Located on web page

and pass via form’s Hidden form fields
parameter
• Error Handling
– Reporting Error: create the friendly UI to user when the system’s errors occur.
– Logging Error: store the errors (users or/and app) to the file to improve the
application and get users’ behaviors
 Objectives
• How to build the Web Application using MVC1?
– Standard Actions
– Dispatching Mechanisms
• How to remove the scripting element (Java Code) in
the jsp (view)?
– Expression Language
 Objectives
Day 1, 2, 3, 4, 5, 6 – Login
Servlet, JDBC

Day 7, 8, 9 – Search
Break Down

Day 10, 11 – MVC2

JSP
Web Day 12, 13, 14, 15 – CUD, Shopping Carts
Web based
App - PBL Sessions

Day 16, 17 – Login

JavaBeans

Day 18, 19, 20 – CRUD

MVC 2 Complete - JSTL - Taglib

Day 21, 22, 23 – Filter

MVC2 Using Filter as Controller
 MVC 1
Requirements
• Building the web application with authentication functions
– The GUI is shown as
 MVC 1
Expectation
 MVC1
Interactive Server Model
1. Send request

Web/App JSP
Server
1. Click Login
2. Check Login
4. Response the
result page
Java
Beans/
Welcome page/ BLO
invalid page 3. Call

4. Query DB
DAO
DB

Client Server
 JSP Standard Actions
Java Beans
• JavaBeans technology is the component architecture for the Java 2
Platform, Standard Edition (J2SE).
• JavaBeans technology is based on the JavaBeans specification.
• Components (JavaBeans) are reusable software programs that you
can develop and assemble easily to create sophisticated applications.
– Are reusable components which define the interactivity of Java objects
– Are reusable software components that work independently on a workstation
and with a set of other distributed components.
• Encapsulate state and behavior of software component
• The different point between Java Bean and Java class
– Java Bean implemented from Serializable
• The process of create a copy of an object suitable for passing to another
object/ package classes into streams of bytes that are transmitted
through networks or saved to the disk
 JSP Standard Actions
Java Beans
• In order to function as a JavaBean class, an object class must obey
certain conventions about method naming, construction, and
behavior.
– These conventions make it possible to have tools that can use, reuse, replace,
and connect JavaBeans.
• A Bean a simple Java Class that follows certain coding conventions
– Bean class should always use a package name
– Bean class must have a public no-argument constructor
– The properties of bean (persistence) is not declared “public”. They are
accessed through getter and setter methods.
– Public getter method is used to retrieve the properties of a bean class
– Public setter method is used to set the properties of a bean class
• Notes:
– The first character of each property should name in lower case then the
accessor methods are used along with property name with the first character
of each word in upper case (Ex: length – getLength and setLength)
– The dataType of properties is boolean then the getter method is isXxx instead of
getXxx
 JSP Standard Actions
Java Beans
• A JSP page accesses Java Beans using tag action and
gets the result of processing without how to JavaBeans
implementation and process
• Java Bean tags are combined with JSP elements
• Java Bean tags are translated into single java Servlet
classes on the server
• JSP technology directly supports using JavaBeans
components with JSP language elements
 JSP Standard Actions
Standard Actions
• An alternative to inserting java code into designed presentation
page
• Are performed when a browser requests for a JSP page
• Are used for
– Forwarding requests and performing includes in page
– Embedding the appropriate HTML on pages
– Interacting between pages and JavaBeans
– Providing additional functionality to tag libraries
• Syntax: <prefix:actionName att=“…”>...</prefix:actionName>
• Some properties
– It use “jsp” prefix
– The attributes are case sensitive
– Value in the attributes must be enclosed in double quotes
– Standard actions can be either an empty or a container tag
• A JSP provides 03 tags that use interact with JavaBean
– jsp:useBean, jsp:setProperty, jsp:getProperty
 JSP Standard Actions
The <jsp:useBean> tag
• Is used to locate or instantiate a JavaBeans component
• First tries to locate an instance of the Bean otherwise it instantiates
the Bean from a class
• To locate or instantiate the Bean, the <jsp:useBean> follows the
following steps:
– Attempts to locate a Bean (means attribute containing object) within the scope
– Defines an object reference variable with the name
– Stores a reference to it in the variable, if it retrieves the Bean
– Instantiates it from the specified class, if it cannot retrieve the Bean
• Syntax
<jsp:useBean id=“<identifier>” class=“<class name>” [scope = “scope name”]/>
– id: is used to name the attribute name, to refer to the Bean instance in specify
scope
– class: a class name implementing a Bean processing.
– scope: the lifespan of a bean (sharable). Default value is page
 JSP Standard Actions
The <jsp:useBean> tag
• Use scriptlet element to declare Java Bean:
<%
className id = (className) scope.getAttribute(“identifier”);
if (id == null) {
id = new className();
scope.setAttribute (“identifier”, id);
}
%>
• Ex
– <jsp:useBean id=“book1” class=“store.book”/>
– similar to
<%
store.book book1 = (store.book) pageContext.getAttribute(“book1”);
if (book1 == null) {
book1 = new store.book();
pageContext.setAttribute(“book1”, book1);
}
%>
 JSP Standard Actions
• Casting The <jsp:useBean> tag
<jsp:useBean id=“<identifier>” class=“<class name>” type = “<dataType>”
[scope = “scope type”]/>
– type: Java – DataType
• JSP Scriptlet element
<%
dataType id = (dataType) scope.getAttribute(“identifier”);
if (id == null) {
id = (dataType) (new className());
scope.setAttribute (“identifier”, id);
}
%>
• Ex
– <jsp:useBean id=“book1” class=“store.book” type=“library.magazine” />
– Similar to
<% library.magazine book1 = (library.magazine) pageContext.getAttribute(“book1”);
if (book1 == null) {
book1 = (library.magazine) (new store.book());
pageContext.setAttribute(“book1”, book1);
} %>
 JSP Standard Actions
The <jsp:useBean> tag
• Other syntax
<jsp:useBean …> statement </jsp:useBean>
– Ex
<jsp:useBean id="count" class="ABean.AccessBean" scope="application">
<jsp:setProperty name="count" property="firstPage" value="ATest.jsp" />
</jsp:useBean>
• Notes:
– If using some specified symbol in command, the symbol “\” should put such as ‘
(\’); “ (\”), \ (\\), % (\%), ...
– The JSP scriptlets use id as a variable.
 JSP Standard Actions
The <jsp:getProperty> tag
• Retrieves a bean property value using the getter methods and
displays the output in a JSP page
• Before using <jsp:getProperty> you must create or locate a bean
with <jsp:useBean>
• Drawback
– Fails to retrieve the values of an indexed property
– Fails to directly access enterprise beans components
• Syntax
<jsp:getProperty name=“<identifier>” property=“<attr name>” />
– name: the identifier declared in jsp:useBean
– property: the property name is implemented in Java Bean
• Use scriptlet command
<%= <identifier>.getXxx() %>
• Ex
<jsp:getProperty name=“book1” property=“title”/>
Similar to <%= book1.getTitle()%>
 JSP Standard Actions
The <jsp:setProperty> tag
• Sets the value of the properties in a bean, using the bean’s setter
methods
• Before using <jsp:setProperty> you must create or locate a bean
with <jsp:useBean>
• Syntax
<jsp:setProperty name=“<identifiers>” property=
“<attr name>” value=“<const/ expression>” />
• Use scriptlet command:
<%
id.setXxx(<value>);
scope.setAttribute(“identifier”, id);
%>
• Ex: <jsp:setProperty name=“book1” property=“title” value=“JSP Book” />
Similar to <% book1.setTitle(“JSP Book”);
pageContext.setAttribute(“book1”, book1);
%>
 JSP Standard Actions
The <jsp:setProperty> tag
• Assign a expression to action setProperty
– String sMsg = request.getParameter("sms");
– <jsp:setProperty name="msg" property="message" value="<%= sMsg %>" />
• Use param properties in setProperty: receive an inputted value
from a request (from other JSP page, application, or URL)
– <jsp:setProperty name="msg" property="message" param=“message” />
• To set values to whole bean properties, the symbol “*” is assigned
to setProperty
<jsp:setProperty name="msg" property=“*" />
• Notes:
– The Bean Action is executed only if all of properties is assigned values
because the engine does not assign a null value with lacked properties.
– In some web server, the exceptions are thrown if a property value is assigned
to double
– The converted mechanism does not ensure a valid value for property
(instead of manual casting)
– The parameters name should similar to properties name implemented in
Bean
 JSP Standard Actions
Steps in design Web Application
following MVC patterns
• Step 1
– create View
• Step 2
– Depends on View, determine some persistence controls that are
implemented as the Java Bean (Model) ‘s properties
– Implement the Java Bean with accessor methods and some
utilitie methods that are used to query the properties of Java Bean
• The methods are designed following the OO standard
• Step 3
– Create servlet (Controller)/JSP page combining View & Model
 MVC1
Requirements
 JSP Standard Actions
• page
Scope of JavaBeans
– Accessible for current page. The life span tills the current page displayed
– The information is stored in pageContext (get values through the getAttribute
method) – default scope
• application
– Current and any successive request from the same Web Application. Global to
all JSP and servlet.
– The information is stored in ServletContext.
– The life span is Application
• session
– The information is stored in HttpSession combined current request (get
values through the getValues method of Session interface (Implicit Object)).
– The life span tills the session destroyed, time out, or Web browser closed.
• request
– Accessible for current request (get values through the getAttribute methods)
– The information is stored in ServletRequest
– The life Span tills the request processed and the response is sent back to the Web
browser
 JSP Standard Actions
Scope of JavaBeans
• Notes:
– Using JavaBeans with Session or Application scope, a
JSP page must declare a tag action jsp:useBean with a
same id and class name.
– JSP, JSP/ Servlet engine defines scope in executing Web
application, if the instance bean existed, the engine does
not instantatiate new one (the tag jsp:useBean is
omited) to execute Bean’s methods. Otherwise, the
engine create a new instance.
 Dispatching Mechanisms
The <jsp:include> tag
• Can be used to include the response from another
file within the JSP page output.
• To incorporate the content or insert a file from
another page into current page
• Syntax
<jsp:include page=“…” flush=“true” />
• The file whose response should be included has to
reside somewhere in your web application but
doesn’t have to be present until the page is
actually requested
 Dispatching Mechanisms
The <jsp:include> tag – Example
 Dispatching Mechanisms
The <jsp:include> tag – Example
 Dispatching Mechanisms
The <jsp:include> tag – Example
 Dispatching Mechanisms
The <jsp:include> tag – Example
 Dispatching Mechanisms
<jsp:include> vs. <%@ include …%>

<jsp:include>
 Dispatching Mechanisms
<jsp:include> vs. <%@ include …%>

<%@ include %>

 Dispatching Mechanisms
The <jsp:forward> tag
• Forwards processing to another resource within the web
application
• To permanently transfer control from a JSP page to
another location on the local server
• Is used to redirect the request object containing the client
request from one JSP file to another file. The target file
can be an HTML file, another JSP file or a servlet
• The code after the <jsp:forward> element is not
processed
• Syntax
<jsp:forward page=“…” /> or
<jsp:forward page=“…” >
<jsp:param name=“…” value=“…”/>
</jsp:forward>
 Dispatching Mechanisms
The <jsp:param> tag
• Pass one or more name and value pairs as parameters to
an included or forwarded resource like a JSP page, servlet
or other resource that can process the parameter (such as
jsp:forward and jsp:include)
• Syntax
<jsp:param name=“…” value=“{parValue|<%=exp%>}” />
 Expression Languages
EL Language Basics
• New feature of JSP 2.0
• Allows JSP developers to access and manipulating java objects
via a compact, easy-to-use shorthand style (similar to JavaScript)
• It can handle both expressions and literals
• Can be used to display the generated dynamic content in a table on
the web page and can also be used in HTML tags
• Developed by two groups
– JSP Standard Tag Library expert group
– JSP 2.0 expert group
• Syntax: ${EL Expression}
• JSP EL expressions are used in
– Static text
– Standard and Custom tags
• Advantages
– Clear syntax
– Simple & robust
– Easy access application data stored (in JavaBeans)
 Expression Languages
EL Operators
Operators

Arithmetic Relational Logical Others

* < or lt && or and empty

/ or div > or gt
|| or or ?:
+ < = or le
! or not null
> = or ge
- true
= = or eq
% or mod false
!= or ne
Expression Languages
EL Operators – Example
Expression Languages
EL Operators – Example
 Expression Languages
• Are a standard set of classes. EL Implicit Objects
• The user creates an instance
of an implicit object to use to
use available methods and
variables, that are provided by Implicit Objects
JSP container, through EL
Expressions

pageContext param paramValues initParam cookie

servletContext
scopeObj header headerValues
request
pageScope
response requestScope

sessionScope
session
applicationScope
 EL Implicit Objects
Objects Descriptions

- Can be used without creating an instance of the object

pageContext - Provides access to page attributes
- Can be used to access different page attributes
- Specifies the JSP page, servlet and Web components contained in the same
servletContext
application. Communication with servlet container
session - Represents the session created for the client sending a request
request - Represents the request accepted by the JSP page from client
- Represents the response sent to the client by the JSP page. The response
response
contains the data passed between a client and servlet
param - Returns a value that maps a request parameter name to a single string value
- Returns and array of values, which is mapped to the request parameters
paramValues
from client
header - Returns a request header name & maps the value to single string value
headerValues - Returns an array of values that is mapped to the request header
cookie - Returns the cookie name mapped to a single cookie object
- Returns a context initialization parameter name, which is mapped to a
initParam
single value
 Expression Languages
EL Implicit Objects
• getParameter
– ${param.param_Name}
– Similar to: request.getParameter(“param_Name”)
• Get Properties in Java Beans
– ${bean_id.property_name} or ${bean_id[“property_name”]}
• Similar to: <%= bean_id.getProperty_name %>
• Or, <jsp:getProperty name=“bean_id” property=“prop_name”/>
 Expression Languages
• Variables Scoped Variables
– Are used to store and access values in JSP program
– Refers as a attributes that are stored in standard scope such as page, request,
session and application
• Ex: <% xxxContext.setAttribute(“info”, “att”) %>
${info} or ${xxxScope.info}
– Dot operator “.” or square brackets [ ] can be used to access value of
variable
• The “.” and [] is used to display a property of java bean (getter method)
• They are not limited one level
• They support accessing the arrays, lists, and map element (e.g. a[i], list.get(i),
map.getValue(key)
– Ex
• ${pageScope.color}
• ${pageScope[“color”]}
• The term scoped variable means that the variable confined to the
mentioned context only.
• The EL enhances supporting the retrieval of the stored objects as
scoped variables
 Expression Languages
Scoped Variables
Scopes Descriptions

- Returns page-scoped variable names, which are mapped to

pageScope their values
- Is accessible from the JSP page that creates the object
- Provides access to the attributes of request object
- Returns requests coped variable names, which are mapped
requestScope to their values
- Is accessible from web components handling a request that
belongs to the session
- Returns session-scoped variable names, which are mapped
to their values
sessionScope
- Is accessible from Web components handling a request that
belong to the session
- Returns application-scoped variable and maps the variable
applicationScope
name to their values
Expression Languages
Example
Expression Languages
Example
Expression Languages
Example
 Summary
• How to build the Web Application using MVC1?
How to remove the java code in the jsp (view)?
– Standard Actions
– Dispatching Mechanisms
– Expression Language

Q&A
 Next Lecture
• How to remove completed Scripting Element
(Java Code) in JSP (View)? Complete the
View of MVC 2 Design Pattern
– JSTL
• How to build the data grid tag library using
in JSP?
– Tag Libraries
• Model
• Classical, Simple, and Handles
• How to implement the custom Tag Lib and use it in JSP
 Next Lecture
Day 1, 2, 3, 4, 5, 6 – Login
Servlet, JDBC

Day 7, 8, 9 – Search
Break Down

Day 10, 11 – MVC2

JSP
Web Day 12, 13, 14, 15 – CUD, Shopping Carts
Web based
App - PBL Sessions

Day 16, 17 – Login

JavaBeans

Day 18, 19, 20 – CRUD

MVC 2 Complete - JSTL - Taglib

Day 21, 22, 23 – Filter

MVC2 Using Filter as Controller
Appendix - MVC1
Login page
 MVC1
Login Beans
 MVC1
Process Login JSP
 MVC1
Process Login JSP
 MVC1
Welcome page
 MVC1
Optimizing
Appendix – JSP Standard Actions
Scope of JavaBeans – Example
 JSP Standard Actions
Scope of JavaBeans – Example
 JSP Standard Actions
Scope of JavaBeans, accessing on Servlet
via HttpSession– Example
 JSP Standard Actions
Scope of JavaBeans, accessing on Servlet
via HttpSession– Example
 JSP Standard Actions
Scope of JavaBeans, accessing on Servlet
via HttpSession– Example
Appendix – Dispatching Mechanisms
Example
Dispatching Mechanisms
Example
Dispatching Mechanisms
Example
 Appendix
XML for JSPs
• HTML is narrowly focused on marking up take
• XML can be defined by users and can used for making up
text (as in XHTML), but it has a pretty much infinite set of
the other possible uses
• The tag in jsp has
– Opening tag
– Closing tag
– Data content between the opening and closing tags (called as the
body)
– The opening tag can have a prefix and can contain many
attributes
– Contain the nested tag
 Appendix
XML-Friendly Syntax
• JSP documents
– Are JSP source files written entirely in XML syntax
– Have a .jspx extension
– Can be also be identified by setting in web deployment
descriptor
<jsp-config>
<jsp-property-group>
<url-pattern>/jspx/*</url-pattern>
<is-xml>true</is-xml>
</jsp-property-group>
</jsp-config>
• Or, Define in a JSP document as form
<jsp:root xmlns:jsp=“http://java.sun.com/JSP/Page”>
 Appendix
XML-Friendly Syntax
• JSP document syntax provides replacements for all <%-
type scripting element syntax
– <jsp:scriptlet>…</jsp:scriptlet> replace <%...%>
– <jsp:expression>…</jsp:expression> replace <%= … %>
– <jsp:declaration>…</jsp:declaration> replace <%! … %>
– <jsp:directive.page …/> replace <%@page ...%>
– <jsp:directive.include …/> replace <%@ include …%>
– <!-- … --> replace <%-- … --%>
– There are some things within the Java language itself that are
anathema to XML validators (ex: “<“ symbol looks like the
beginning of an opening or closing tag, and an XML validator will
assuredly treat it as such)
• Using as an entity in XML that begin with an ampersand (&) and end on
a semicolon (;). Ex: &lt;
• Using <![CDATA[symbol]]> or <![CDATA[command]]>
– Ex: <![CDATA[for(int i=0; i<10; i++)]]> or i <![CDATA[<]]> 10
 Appendix
XML-Friendly Syntax
 Appendix
XML-Friendly Syntax – Sample
 Appendix
XML-Friendly Syntax – Sample
 Appendix
Functions using EL
• Supports using of the Java function within
the JSP page is an easy as using a tag
• The following steps to set up EL to Java
functions
– Step 1: Creating “static” method
– Step 2: Creating Tag Library Descriptor
– Step 3: Modifying Deployment Descriptor and
locating the TLD file in web deployment
descriptor (if necessary)
– Step 4: Access EL functions within JSP
 Appendix
Creating “static” method
• The static java methods can be called within the EL
expression
• Ex:
 Appendix
Creating Tag Library Descriptor
• After defining the functions, the function name should be mapped
with EL using a Tag Library Descriptor (TLD) file
• A defined in a class with EL. TLD file uses XML syntax to map
the name of functions
• Save this TLD file in the /WEB-INF/tlds folder, where tlds is a
user-created folder
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-
jsptaglibrary_2_0.xsd">
<tlib-version>1.0</tlib-version>
<function>
<description>information description</description>
<name>functionName</name>
<function-class>Java class</function-class>
<function-signature>declared method with parameters</function-signature>
</function>
</taglib>
 Appendix
Creating Tag Library Descriptor

• Click Next button

 Appendix
Creating Tag Library Descriptor

Fill taglib name

Browse to directory
containing taglib.
Should not be
changed

• Click Finish button

• The taglig file with extension is tld located at the WEB-INF/tlds
directory
 Appendix
Creating Tag Library Descriptor
• Modified the .tld file
 Appendix
Modifying the Deployment Descriptor
• The default mode for JSP pages delivered with JSP version
2.0 technology is to evaluate EL expressions
• JSP EL expression can be enabled or disabled with 02
ways
– Using isELIgnored attribute in the JSP page directive
<%@ page isELIgnored= “true | false” %>
– Modifing in web.xml
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<el-ignored>false</el-ignored>
</jsp-property-group>
</jsp-config>
 Appendix
Accessing EL functions within JSP
• To access the function created in a TLD file using a JSP file,
developer need to import the TLD file using the taglib directive.
In the directive statement, developer need to mention a prefix for
the tags and location of the TLD file
<%@taglib prefix=“prefix” uri=“path” %>
• After importing the TLD file, developer can access the function
using an EL expression
${prefix:funcName(args)}
Appendix
Example
 Appendix
Coersion
• Means that the parameters are converted to the appropriate
objects or primitives automatically
• EL defines appropriate conversion with default values
– For example, a string parameter from a request will be coerced to the
appropriate object or primitive.
• There is a difference between type coercion and type conversion.
– Coercion is implicit type conversion and its usually performed
automatically by the compiler
– Type conversion is an explicit type conversion inserted by the programmer.

Coercion

Boxing and Coercion to Coercion to

Unboxing String Number
 Appendix
Coersion
• Boxing an Unboxing
– Boxing converts values of primitive type to corresponding
values of reference type.
• If i is a boolean value, then boxing conversion converts i into a reference
r or class and type Boolean, such that r.value() = i.
• If i is a byte value, then boxing conversion converts i info a reference r
of class and type Byte, such that r.value() = i
– Unboxing converts values of reference type to corresponding
values of primitive type
• If r is a Boolean reference, then unboxing conversion converts r into v of
type boolean, such that r.value() = v.
• If r is a Byte reference, then unboxing convertion converts r into a value
v of type byte, such that r.value() = v.
• Coercion to String
– A is String, return A
– A is null, return “”
– A.toString() throws exception, return error. Otherwise return
A.toString()
 Appendix
• Coercion to Number
Coersion
– The rule to coerce a value to number type are If A is null or “”, return 0
– A is character and is converted to short, developer apply following rules:
• If A is Boolean, return error
• If A is number type, return A
– A is number, coerce occurs quietly to type N using the following algorithm:
• If N is BigInteger
– If A is BigDecimal, return A.toBigInteger()
– Otherwise, return BigInteger.valueOf(A.longValue())
• If N is BigDecimal
– If A is a BigInteger, return new BigDecimal(A)
– Otherwise, return new BigDecimal (A.doubleValue())
• If N is Byte, return new Byte (A.byteValue())
• If N is Short, return new Short (A.shortValue())
• If N is Integer, return new Integer(A.integerValue())
• If N is Long, return new Long(A.longValue())
• If N is Float, return new Float(A.floatValue())
• If N is Double, return new Double(A.doubleValue())
• Otherwise return error
 Appendix
Coersion – Example
 Appendix
• Notes:
Coersion
– Variables declared in JSP page (in scriptlet or declaration) cannot be accessed
in JSP page or all of them can be presented with ${variable_name}
– Therefore, if these variables are forced in expression with EL, the value of
these variables are converted to 0 (number) or false (boolean)
– The EL operators’ arithmetic or logical is only applied to arithmetic or logic. If
the value is not same type, the exception is thrown
– The EL can access the attribute in particular scope (page, request, session,
application)
– The coersion is applied on the used operator in expression
 Appendix
Coersion – Example
 Appendix
Coersion – Example
 Appendix
Coersion – Example
 Appendix
Coersion – Example