Java Server Pages (JSP)

11-11-2013

Review for Exam#2

JSP & JavaBeans

Introduction to Java WebStart

Read:

Doing More with Rich Internet Applications

Java Web Start guide

Exam#2 is scheduled for Tues., Nov. 19, 7:00 pm, Snell 213

review session: today, 11/11, 5:30 to 7:00 pm, ITL

no class on Friday, 11/15

PR#2 due: Wednesday, 12/04/13

Safe copies cloning – take a second look at the contract copy constructor

Collections & Iterators Interfaces: List, Map, Set, … Implementations: ArrayList, LinkedList, HashMap, … use of for-each as an iterator

I/O Reader/Writer vs. Stream Scanner & Parsing a line of text into tokens Serialization

JavaFX GUIs and Design Patterns Event Handling Model

MVC, Observer, Strategy, Iterator, Composite

Review Session: 5:30 – 7:00 pm in the ITL

Practice problems

Understanding the Cloneable interface

no clone() method in the interface

the clone() method in Object is protected

A class must both implement Cloneable plus override the clone() method

essentially creates an object without using a constructor (although non-primitive fields within the object may be copied by calling their constructors)

the contract for clone is weak

must correct fields containing mutable objects, so final fields referring to mutable objects are a problem

A field that is a collection must be corrected (even if final)

There are cases where cloning is not a good design

… Complete this list Example?

A copy constructor for class X is of the form:

public X( X source )

i.e. the constructor has one argument which is an object of type X itself // Example: Copy constructor for class Swimmer

public Swimmer(Swimmer original) { this.name = original.name; this.swimTime = original.swimTime; this.eventDate = new Date(original.eventDate); // Date has copy ctr

}

Item 39: Make defensive copies when needed

What is a defensive copy?

Why is it important?

Key idea: separate Interfaces (ADT), Implementation (concrete code), Algorithms (polymorphic)

Collection of individual elements:

java.util Interface Collection<E> Subinterfaces: List, Set, Queue, Deque, SortedSet, etc.

Implementations: LinkedList, ArrayList, HashSet, etc.

Mapping: pairs <key, value>

java.util Interface Map<K,V> Implementations: HashMap, Hashtable, TreeMap etc.

Chapter 8, Item 52: Refer to objects by their interfaces

Why?

List<Student> roster = new ArrayList<Student>();

roster.add( new Student(“Jim”, … ) ); // adds to the end

traversing a collection

// when to use an interator?

for (Iterator itr = c.iterator(); itr.hasNext(); )

doSomethingWith(itr.next());

// preferred for most uses

for (Object o : collection)

doSomethingWith(o);

Suppose that compareTo() is inconsistent w/ equals() in some class X.

Sorted collections use compareTo(), but Collection/Set/Map use equals()

TreeSet of X will behave differently than HashSet of X if X.equals() is not consistent with X.compareTo()

(cf. Effective Java 2, pp. 63-64)

try {

Scanner scan = new Scanner(new File(“sample.txt”));

int val = scan.nextInt();

System.out.println(“Integer value is: “ + val);

} catch (InputMismatchException e) {

System.err.println(“Next token is not an int”);

} catch (FileNotFoundException e) {

System.err.println(“Could not open file for reading”);

} catch (IOException e) {

System.err.println(“Unexpected IO error: “ + e);

}

// Read and echo lines, using Scanner

try {

Scanner scan = new Scanner(new File(“MyData.txt”) );

scan.useDelimiter(

System.getProperty(“line.separator”));

while ( scan.hasNext() )

System.out.println( scan.next() );

scan.close();

} catch // appropriate exceptions

Any object that implements the serializable interface can be converted into a sequence of bytes

Implements “lightweight persistence”;

persistance – object’s lifetime is independent of program execution (lives even when the program terminates)

Serializable interface – no methods, just tagging

// what are the issues and potential problems?

Item 74: Implement Serializable judiciously

Effective Java 2, pp. 289 – 294

Major cost – decreases flexibility to change a class’s implementation once it has been released

Potential for bugs and security holes (deserialization is another way to create an object)

Increases testing associated with releasing a new version of a class

revisited

cf. Head First Servlets & JSP, 2nd Edition, 2008

cf. Head First Servlets & JSP, 2nd Edition, 2008

Write a servlet class (extends HttpServlet)

Create a deployment descriptor (DD) web.xml

one DD per web application

a single DD can declare many servlets

a <servlet-name> ties the <servlet> element to the <servlet-mapping> element

a <servlet-class> is the Java class name

a <url-pattern> is the name the client uses for the request

Build a directory tree under tomcat/webapps

the web.xml file goes in WEB-INF

the Java class file goes in WEB-INF/classes

Client-known URL name

e.g. click a link to a servlet

Deployer-known internal name

known only to the deployer

doesn’t have to match the public URL used by the client, or the real file and path to the servlet class

Actual file name developer’s servlet class file

Note: mapping servlet names improves flexibility and security

web.xml

a single DD can declare many servlets

the <servlet-name> is used only by the deployer

end-users don’t see it;

<servlet-name> ties the <servlet> element to the <servlet-mapping> element

<servlet-class> is the fully-qualified Java class name (without the .class extension)

<url-pattern> is what the client uses for the request

<servlet-mapping> is what the Container uses at

runtime when a request comes in

web.xml

the DD can also customize security roles, error pages, tag libraries, initial configuration information

If using a full J2EE server, the DD can also specify specific enterprise javabeans that will be used

lets you adapt your application to different resources, such as databases, without having to re-compile and test any code

makes it easier to maintain dynamic security info like access control lists and security roles

MVC takes the business logic out of the servlet and puts it in a “Model” – a reusable Java class

cf. Head First Servlets & JSP, 2nd Edition, 2008

specifies the static HTML code and the dynamic information that the user of the web application sees in a browser

provides a connection to JavaBeans that carry out computations

each JSP page is automatically translated into a servlet

servlet/CGI tightly interleaves programming logic with HTML generation

related technologies (used with XML) include: ASP (Microsoft Active Server Pages) & ASP.NET (JScript,

VBScript and C#) PHP – perl-like scripting language

Python (with a Web Framework like DJANGO)

idea: separate programming & presentation embed code related to presentation within a web document

A JavaBean is a Java class with the following properties:

By convention the name of the bean ends in Bean

It must have a default constructor

A JavaBean exposes its properties through get and set

methods, which follow a naming convention

If the property name is propertyName and the type is Type accessor method: Type getPropertyName()

mutator method: void setpropertyName(Type newValue)

A boolean property uses a different convention boolean isPropertyName() void setPropertyName(boolean newValue)

To use a bean in a JSP page, use the jsp:useBean directive

The following directive invokes the default constructor of

StudentBean, and makes an object with the name user

<jsp:useBean id ="user" class=“StudentBean"/>

To set a property in the bean, use the setProperty directive

<jsp:setProperty name="user" property=“major" value=“36"/>

To get a property in the bean, use the getProperty directive

<jsp:getProperty name="user" property="major"/>

This returns a string that becomes part of the HTML page

Display just the current time, not the whole date, on a page

Get the time with the getTimeInstance method of the

DateFormat class

Put this code in a bean class: TimeFormatter.java

File: TimeFormatterBean.Java

import java.text.DateFormat;

import java.util.Date;

/**

This bean formats the time of day from a given date.

*/

public class TimeFormatterBean {

private DateFormat timeFormatter;

private Date theDate;

/**

Initializes the formatter.

*/

public TimeFormatterBean() {

timeFormatter = DateFormat.getTimeInstance();

}

/** Write-only data property */

public void setDate(Date aDate) {

theDate = aDate;

}

/** Read-only time property */

public String getTime()

{

String timeString = timeFormatter.format(theDate);

return timeString;

}

} // end TimeFormatterBean

TimeFormatterBean, continued

File: time.jsp

<jsp:useBean id="formatter" class="TimeFormatterBean"/>

<jsp:setProperty name="formatter" property="date"

value="<%= new java.util.Date() %>"/>

<html>

<head>

<title>Time JSP</title>

</head>

<body>

<h1>Time JSP</h1>

<p>The current time is:

<jsp:getProperty name="formatter" property="time"/>

</p>

</body>

</html>

It is a good idea to put the bean directive at the beginning of

the JSP file, before the HTML

Both time.jsp and TimeFormatterBean must be

deployed to the proper directories

time.jsp into $CATALINA\webapps\cs242

TimeFormatterBean into $CATALINA\webapps\cs242\WEB-INF\classes

Executable Jar

Web Start RMI app Servlets

100% Local 100% Remote

■ Executable JAR

■ Web Start

■ RMI

■ Java Server Faces, JSP & Servlets

Note: “thin” (web) clients run mostly on the server; “rich” clients run mainly on the client machine

The client runs a web browser. The client also needs Java and the Java Web Start “helper app”.

client can easily download JWS client can easily download Java or update the

version

The server has a web page with a link to a file which can “launch” the executable JAR (more on this later)

When the client clicks on that link, JWS downloads and launches the app on the client machine by invoking the main() method

Once downloaded, the app runs on the client machine, as a stand-alone application

Since the app has been downloaded to the client, it can run from the JWS helper app independently of the browser.

If the code is changed on the server side, JWS automatically downloads and integrates the updated code