UMBC

Advanced Java
Applications
Shon Vick
CMSC 331
UMBC
Networking

• Using the networking capabilities provided

in the Java environment is quite easy
• We will see how to use Sockets

2
UMBC
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

3
UMBC
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.

4
UMBC
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
5
UMBC
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

6
UMBC 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
7
UMBC
Echo 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;
// … 8
 UMBC Establish the Socket connection

Output
Host Port
try {
echoSocket = new Socket(“avatar ", 7777);
out = new PrintWriter(echoSocket.getOutputStream(), true);
in = new BufferedReader(new
InputStreamReader(echoSocket.getInputStream()));
}
catch …
Input
9
UMBC
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);
} 10
UMBC
Simple Socket Example

Set up a mechanism to read from standard input

BufferedReader stdIn = new BufferedReader(

new InputStreamReader(System.in));
String userInput;
Read from standard input
while ((userInput = stdIn.readLine()) != null) {
Write to
out.println(userInput); Server
System.out.println("echo: " + in.readLine());
} Output what’s read back from Server 11
UMBC
Close up Shop on Client side

out.close( );
in.close( );
stdIn.close( );
echoSocket.close( );

12
UMBC
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.
13
UMBC
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

14
UMBC
Server

• 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

15
UMBC
If a socket is a pipe …

We could conceptualize this like so:

Ports Client
Server

The Socket Plumbing The things flowing

through the
Plumbing
16
UMBC
The 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)
17
UMBC 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 server
– Objects to be read by the client

18
UMBC
The 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();

19
 UMBC
The 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 );
20
UMBC
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 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.
21
UMBC
File example

• For 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();

22
UMBC
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();

23
UMBC
The 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
24
UMBC
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)

25
UMBC 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 Reflection
reference sharing mechanism.
– New objects are always allocated when deserializing,
which prevents existing objects from being overwritten

26
UMBC
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
27
UMBC
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.

28
UMBC
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

29
UMBC
Retrieving Class Objects

You can retrieve a Class object in several ways:

Class c = foo.getClass() // for some object named foo

Foo
Bar b = new Bar();
Class c = b.getClass();
Class s = c.getSuperclass(); Bar

30
UMBC 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)

31
UMBC
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
32
UMBC
An Example
import java.lang.reflect.*;
import java.awt.*;
class SampleName {
Need Reflection
public static void main(String[] args) { Package
Button b = new Button(); To Do this

printName(b);
}
static void printName(Object o) {
Class c = o.getClass();
String s = c.getName();
System.out.println(s);
33
}}
UMBC
Selected References

• Advanced Techniques for Java Developers,Berg

&Fritzinger, Wiley, 1999 Chapter 4
• http://java.sun.com/docs/books/tutorial/networkin
g/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/

34
UMBC
More 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/

35