Download Sequence and Collaboration Diagrams

The Rest of Java (and Java
Server Pages)
CSE301
University of Sunderland
Harry R Erwin, PhD
Resources
You should read further if you intend to program
in Java professionally. Resources include:
• D. Flanagan, 2005, Java in a Nutshell, fifth
edition, O’Reilly.
• Other texts in the O’Reilly Nutshell series ({Java
Foundation Classes|Java Enterprise|Java
Examples} in a Nutshell).
• Many other good books, mostly published by
O’Reilly, Addison-Wesley, and Manning.
Client/Server Processing
• Java provides a large number of facilities to support
network and client/server processing. These include:
–
–
–
–
–
–
–
–
–
–
–
Threads
Serialization
RMI
Corba
TCP/IP libraries
Java Beans
Applets
Servlets
JDBC
JNDI
JSP
Threads and Parallel Processing
• Java supports multiple threads of execution within
a program.
• There are two ways to create a thread object:
– Subclass Thread and instantiate the subclass
– Implement the Runnable interface and pass to Thread()
• You can control:
– Priorities, sleep/wake, timers, synchronization,
interrupts
• The javax.swing package uses threads, so they’re
unavoidable.
Multi-Threading
If you run multiple threads or use javax.swing,
you must consider:
– Deadlock (where two threads wait for each other to
release a resource)
– Data sanity (i.e., two threads may each change the state
of an object or variable at the same time. The last
change wins.)
– Priorities (a thread should not delay more important
activity longer than necessary)
– Clean-up (a program cannot just terminate suddenly,
leaving persistent data half-written).
Serialization
• Objects can be serialized—converted to a byte
stream that can later be converted back to the
object.
• Serialization can be over a network or pipe, to a
file, or to a byte array.
• Used by RMI
• Can be used to allow agents to migrate from
machine to machine.
• Supports persistent storage on disk of objects.
RMI
(Remote Method Invocation)
• Allows you to create and use remote objects in
Java. To work outside of Java, you need to use
CORBA or the Java Native Interface (JNI).
• The following elements are provided:
–
–
–
–
–
Remote object classes
Client interfaces to remote objects
A remote object registry
A network protocol for communication
The ability to create remote objects
CORBA
• Java interfaces to CORBA (Common Object Request
Broker Architecture) via the Java IDL API. This is
language-agnostic.
• This allows you to interface to remote objects and make
your objects accessible to other CORBA clients.
• RMI is easier to use from Java, while CORBA gives
you access to more services.
• We use this in our robotics work.
TCP/IP
• The java.net package makes network access very simple.
• The URL class gives you direct access to resources on the
network. You open a stream on a URL to read it.
• If you want to connect to a TCP/IP port on a host, you can
create a Socket object. If necessary, you can use SSL.
• If you want to deploy a server, you create ServerSocket
class objects for each port you will be listening to.
• Finally, you can create DatagramSocket and
DatagramPacket class instances to use the UDP protocol.
• I have seen a COM379 student write and fully debug an
IRC client in 15 minutes using this package.
Java Beans
• A framework for software components in Java.
• Designed for compatibility with visually-oriented builder
tools.
• Most beans are GUI components, including many in the
awt and Swing packages.
• Can be used as COM or ActiveX components.
• Found in the java.beans and java.beans.beancontext
packages.
• There is no superclass, Bean—any class that meets the
basic rules can be used as a bean. See the resources for the
rules (several pages!).
Applets
• Applets are miniapplications, downloadable over the web
to be run in a web browser.
<APPLET code =“Name.class”>
<PARAM name=“message” value=“string”>
</APPLET>
• Allows you to deliver Java programs to end users.
• Subclasses the java.applet.Applet class. No main method().
Arguments are provided by <PARAM> tags. Applet is a
subclass of java.awt.Panel, an AWT Component. You can
also use javax.swing.JApplet.
• Strict security restrictions.
• The applet is allowed to create threads to handle timeconsuming actions.
Servlets
• Primarily a Java-based replacement for CGI
scripts, but can be used in a request/response
context in any server.
• Persistent between invocations; hence provide
better performance.
• Portable between operating systems and
computers
• Can access the Java APIs.
• Much more secure than scripts.
• Can interface to JSP pages (later).
JDBC
• The Java version of ODBC.
• Supports the following:
– Loading a driver
• Class.forName(“drivername”); // loads a class
–
–
–
–
Connecting to a database
Executing SQL statements
Retrieving results
Detecting database errors
• There is a JDBC-ODBC bridge available. Inefficient but a
useful work-around for development.
• Can work with database metadata.
• Supports transaction processing and batch updates.
JNDI
• Supports access to directory and naming services
in Java programs.
• Allows you to access objects by name rather than
by reference.
• A solution to the same problem addressed by the
Singleton pattern (later) and CORBA.
• Directory services associate attributes with names.
• Provides a standard protocol-independent API for
vendor implementations.
Java Server Page (JSP) Basics
• HTTP
• Servlets
HTTP
•
A Communications Model:
–
–
•
A client, often but not always a web browser, sends a
request for a resource to a server.
The server returns a response or an error message.
Points to remember:
1. Stateless protocol.
2. Delayed feedback.
3. Server cannot tell how the request was made. No
client-side processing can be invoked. (If it could be,
it would be a security nightmare.)
Examples of HTTP Clients
• Web browsers (many, including specialized ones for
console interfaces—lynx—and handicapped users)
• Search utilities (Sherlock on MacOS X)
• Help utilities
• FTP clients (e.g., interarchy on MacOS X)
• Software registration programs
• telnet (a hacker can emulate a web browser by connecting
to port 80)
• Specialized programs (e.g., curl)
• Cracker toolkits (generating malformed http requests)
HTTP Requests
• Information is specified by an HTTP Uniform
Resource Locator (URL, see RFC-2396 and RFC2616).
http://www.cet.sunderland.ac.uk:80/~cs0her/index.html
• Consists of:
– Protocol designation (http and https)
– Server name:port number (port number defaults to 80
for http and 443 for https)
– Name of the resource being requested. Need not be a
file. Here it is: /~cs0her/index.html
HTTP Request Message
• Consists of:
– Request line
• GET resource_name protocol_in_use
• POST (provides parameters in the request body, see below)
– Request headers
• Host (server name)
• User-Agent (browser type)
• Various Accept headers describing formats and languages
– Request body (optional)
Java Servlets
• Currently, Java is the predominant language for
SSP. This is due to the Java Servlet API.
• Advantages over other SSP technologies:
– Persistent between invocations, avoiding process
instantiations.
– Portable across operating systems and servers.
– Good security.
– Can use the Java APIs, particularly JDBC.
– Integrated closely with the J2EE environment.
Servlets
• A servlet runs in a servlet container within a Java
Virtual Machine.
• Servlet containers:
–
–
–
–
Apache/Jserv, which supports Servlets 2.0.
Mortbay.com/Jetty
IBM/WebSphere
Jakarta/Tomcat 4.0 (reference implementation for the
Servlet 2.3 API). Available from
http://jakarta.apache.org.
Servlet Basics
• The Servlet API consists of two Java
packages:
– javax.servlet
– javax.servlet.http
• Required for J2EE 1.3
Servlet Lifecycle
• A client makes a request involving a servlet
running on the server.
• The servlet is responsible for loading and
executing the Java classes that generate the HTML
content.
• To the client, this looks like standard HTML
processing, except faster.
• The servlet then need not shut down. Instead, it
can handle subsequent requests without restarting.
Servlet Methods
• init(), to handle startup. Once init() runs, the
servlet is available.
• service() is called to process each request. Disk
writes are only needed to preserve state.
Arguments to service() are ServletRequest and
ServletResponse objects.
• destroy() is called to clean up resources when the
server shuts down (if it ever shuts down).
Core of the API
• javax.servlet.Servlet interface.
• javax.servlet.http.Servlet class, implementing the
interface. Designed to work with the HTTP
protocol.
• javax.servlet.GenericServlet class, implementing
the interface. This class is communication
protocol agnostic. Can implement a filtering
servlet to adapt output from some other source.
This can provide other protocol services (e.g., ftp).
A Web Application
• A set of resources (servlets, static content,
.jsp files, class libraries) installed in a
specific path, making up a directory.
• Organized as a chroot ‘jail.’
• Multiple servlets can exist concurrently.
Run in a common ServletContext.
• Be careful—the path to the application can
change from machine to machine.
Supporting JSP
• Requirements:
– Workstation or PC with an internet connection.
– Java SDK (available from Sun, links on the
handbook page)
– JSP-enabled web server such as Apache
Tomcat (Jakarta Project). This is available here
at the Informatics Centre.
Summary
• Consult the reference documentation if you
need these services.