Title: Advanced Java Applications
1Advanced JavaApplications
2Networking
- Using the networking capabilities provided in the
Java environment is quite easy - We will see how to use Sockets
3Sockets
- 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
4What 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.
5How 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
6Connection 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
7How 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
8Echo Echo Echo
import 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 //
9Establish the Socket connection
Output
Port
Host
try echoSocket new Socket(avatar ",
7777) out new PrintWriter(echoSocket.getOutp
utStream(), true) in new
BufferedReader(new
InputStreamReader(echoSocket.getInputStream()))
catch
Input
10Need 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)
11Simple Socket Example
Set up a mechanism to read from standard input
BufferedReader stdIn new
BufferedReader(
new InputStreamReader(System.in))
String userInput
while ((userInput stdIn.readLine()) ! null)
out.println(userInput)
System.out.println("echo "
in.readLine())
Read from standard input
Write to Server
Output whats read back from Server
12Close up Shop on Client side
out.close( ) in.close( ) stdIn.close(
) echoSocket.close( )
13Basic 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.
14Same 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
15Server
- A server must open a SeverSocket
- ServerSocket server new ServerSocket( 7777 )
- Call accept on that socket creating a new socket
- Socket socket server.accept()
- Socket acts as socket from client
16If a socket is a pipe
- We could conceptualize this like so
Ports
Client
Server
The things flowing through the Plumbing
The Socket Plumbing
17The Answer Is ..
- A Number of things can conceptually flow through
the pipe - We will focus on two
- Objects
- Characters from a String
- We looked at several examples last time
- The 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)
18Objects 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 server
- Objects to be read by the client
19The newprotocol Client
public 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()
20The newprotocol Server
class 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 )
21Reading 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 Mechanism
- This works for the sockets as was just shown but
is actually more general - Persistent storage of objects can be accomplished
by using a file for the stream.
22File example
- For example to write an object that can be read
by the example in ObjectInputStream
FileOutputStream ostream new FileOutputStream(f
oo.bar") ObjectOutputStream p new
ObjectOutputStream(ostream) p.writeInt(12345) p.
writeObject("Today") p.writeObject(new
Date()) p.flush() ostream.close()
23The read counterpart
FileInputStream istream new
FileInputStream(" foo.bar ")
ObjectInputStream p new ObjectInputStream(istrea
m) int i p.readInt() String
today (String)p.readObject() Date date
(Date)p.readObject() istream.close()
24The Needed Java Framework
- Only 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
25More 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)
26Deserialization 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
27Reflection 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
28Reflection 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.
29Examining 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
30Retrieving 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()
31Other 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)
32Getting 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
33An Example
import 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 Reflection Package To Do this
34Selected References
- Advanced Techniques for Java Developers,Berg
Fritzinger, Wiley, 1999 Chapter 4 - http//java.sun.com/docs/books/tutorial/networking
/index.html - The Java Programming Language , K.Arnold and J.
Gosling , Addison-Wesley , 1996 - Java in a Nutshell , D. Flanagan, O'Reilly and
Associates - http//java.sun.com/products/jdk/1.2/docs/
35More References
- The Java Programming Language , K.Arnold and J.
Gosling , Addison-Wesley , 1996 - Java in a Nutshell , D. Flanagan, O'Reilly and
Associates - http//java.sun.com/products/jdk/1.2/docs/