advance java
TRANSCRIPT
Advanced JavaApplications
Overview
We will see some advanced techniques and applications of Java
We will take a quick look at some data structures built into the language
Next will show be how Java and Object Orientation can be applied to networking
Finally we will be to show Reflection in Java
Hashtable Example
Hashtable numbers = new Hashtable();
numbers.put("one", new Integer(1));numbers.put("two", new Integer(2));numbers.put("three", new Integer(3));
key value
Hashtable Example
Integer n = (Integer)numbers.get("two"); if (n != null) { System.out.println("two = " + n); }
ObjectSpecificObject
Many Other Collections
VectorStackLinkedListDictionary ArrayListhttp://www.javasoft.com/products/jdk/1.2/docs/api/
index.html for a complete list
Networking
Using the networking capabilities provided in the Java environment is quite easy
We will see how to use Sockets
Sockets
Lower-level network communication- Client – uses some service- Server - provides some service
TCP provides a reliable, point-to-point communication channel for client-server apps
What Is a Socket?
A socket is one endpoint of a two-way communication link between two programs running on the network.
A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent.
How do Sockets work?
A server runs on a specific computer and has a socket that is bound to a specific port number.
Client knows the hostname and port of server and tries to make a connection request
Connection established
If the server accepts the connection it gets a new socket bound to a different port.
It needs a new socket (and consequently a different port number) so that it can continue to listen to the original socket
How does Java support Sockets
The java.net package provides a class, Socket, that implements one side of a two-way connection between your Java program and another program on the network
It also includes the ServerSocket class, which implements a socket that servers can use to listen for and accept connections to client
Echo Echo Echoimport java.io.*;import java.net.*;
public class EchoClient { public static void main(String[] args) throws IOException {
Socket echoSocket = null; PrintWriter out = null; BufferedReader in = null;// …
Establish the Socket connection
try { echoSocket = new Socket(“image ", 7777); out = new PrintWriter(echoSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream())); } catch …
Host Port Output
Input
Need to Catch Exceptions
} catch (UnknownHostException e) { System.err.println("Don't know about host: avatar."); System.exit(1); } catch (IOException e) { System.err.println("Couldn't get I/O for " + "the connection to: avatar."); System.exit(1);}
Simple Socket Example
BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in)); String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("echo: " + in.readLine()); }
Set up a mechanism to read from standard input
Output what’s read back from Server
Write to Server
Read from standard input
Close up Shop on Client side
out.close( );
in.close( );
stdIn.close( );
echoSocket.close( );
Basic Steps
Open a socket. Open an input stream and output stream to the
socket. Read from and write to the stream according to the
server's protocol. Close the streams. Close the socket.
Same Basic Steps
This client program is straightforward and simple because the Echo server implements a simple protocol
Even with more complicated protocols such as HTTP server, your client program while more complicated will follow the same basics as this simple example
Server
A server must open a SeverSocket ServerSocket server = new ServerSocket( 7777 );
Call accept on that socket creating a new socketSocket socket = server.accept();
Socket acts as socket from client
If a socket is a pipe …
We could conceptualize this like so:
ClientServer
Ports
The Socket Plumbing The things flowing throughthe Plumbing
The Answer Is ..A Number of things can conceptually flow through the
pipeWe will focus on two:
Objects Characters from a String
We looked at several examples last timeThe first was a simple echo program – a very simple
protocol – give me back what I gave you (Strings)We also looked at simpleprotocol example (Protocol
Objects)
Objects flow through the Pipe
Let first address the case where we want to have objects flowing over the pipe
Must have at least the following mechanisms for Objects to be written by the serverObjects to be read by the client
The newprotocol Clientpublic class Client { Socket socket = new Socket( "127.0.0.1", 9999 ); // ObjectInputStream input = new ObjectInputStream(socket.getInputStream() );
// read using serialization NewProtocol protocol = (NewProtocol)(input.readObject() ); System.out.println(“Protocol: “ + protocol); socket.close();
The newprotocol Serverclass ThreadedSocket extends Thread {// here is where all the real work is done. private Socket socket; ThreadedSocket( Socket socket ) { this.socket = socket; //… ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream() ); output.writeObject( protocol );
Reading and Writing Objects
An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.
The objects can be read (reconstituted) using an ObjectInputStream.
General MechanismThis works for the sockets as was just shown but is
actually more generalPersistent storage of objects can be accomplished by
using a file for the stream.
File exampleFor example to write an object that can be read by
the example in ObjectInputStream
FileOutputStream ostream = new FileOutputStream(“foo.bar");ObjectOutputStream p = new ObjectOutputStream(ostream);p.writeInt(12345);p.writeObject("Today");p.writeObject(new Date());p.flush();ostream.close();
The read counterpart
FileInputStream istream = new FileInputStream(" foo.bar ");
ObjectInputStream p = new ObjectInputStream(istream);
int i = p.readInt();
String today = (String)p.readObject();
Date date = (Date)p.readObject();
istream.close();
The Needed Java FrameworkOnly objects that support the java.io.Serializable
interface can be written to streams.
The class of each serializable object is encoded including the class name and signature of the class, the values of the object's fields and arrays, and the closure of any other objects referenced from the initial objects
This relates to introspection/reflection which we will discuss shortly
More about the Framework
The default deserialization mechanism for objects restores the contents of each field to the value and type it had when it was written.
Marshalling of Objects (Serialize)Un marshaling of Object (Serialize)
Deserialization& Object Reflection
Fields declared as transient or static are ignored by the deserialization process.
References to other objects cause those objects to be read from the stream as necessary. Graphs of objects are restored correctly using a
reference sharing mechanism. New objects are always allocated when deserializing,
which prevents existing objects from being overwritten
Reflection
Reflection Allows
Determination of the class of an object.
Creation of an instance of a class whose name is not known until runtime.
Obtaining information about a class's modifiers, fields, methods, constructors, and superclasses.
Determination of constants and method declarations that belong to an interface
Reflection Also Allows
• Allows one to get and set the value of an object's field, even if the field name is unknown to your program until runtime.
• Allows one to invoke a method on an object, even if the method is not known until runtime.
• Create a new array, whose size and component type are not known until runtime, and then modify the array's components.
Examining Classes
A way to get information about classes at runtime
For each class, the Java Runtime Environment (JRE) maintains an immutable Class object that contains information about the class. A Class object represents, or reflects, the class
To get this information you need to get the Class object that reflects the class
Retrieving Class Objects
You can retrieve a Class object in several ways: Class c = foo.getClass() // for some object named foo
Bar b = new Bar(); Class c = b.getClass(); Class s = c.getSuperclass();
Foo
Bar
Other Ways of Retrieving Class Objects
If you know the name of the class at compile time, you can retrieve its Class object by appending .class to its name:
Class c = java.awt.Button.class;
You can also use the Class.forName static method:
Class c = Class.forName(commandNameToken)
Getting the Class Name Every class in the Java programming language has a
name. When you declare a class, the name immediately follows the class keyword
At runtime, you can determine the name of a Class object by invoking the getName method. The String returned by getName is the fully-qualified name of the class.
A good home study question: Given an instance prints the names of the classes its inheritance hierarchy from least specific to most specific excluding Object
An Exampleimport java.lang.reflect.*;
import java.awt.*;
class SampleName {
public static void main(String[] args) {
Button b = new Button();
printName(b);
}
static void printName(Object o) {
Class c = o.getClass();
String s = c.getName();
System.out.println(s);
}}
Need ReflectionPackage
To Do this