Section 10.4
Networking
AS FAR AS A PROGRAM IS CONCERNED,
A NETWORK is just another possible source of input data,
and another place where data can be output. That does
oversimplify things, because networks are still not
quite as easy to work with as files are. But in Java,
you can do network communication using input streams and
output streams, just as you can use such streams to
communicate with the user or to work with files.
Nevertheless, opening a network connection between two computers
is a bit tricky, since there are two computers involved
and they have to somehow agree to open a connection.
And when each computer can send data to the other,
synchronizing communication can be a problem. But the
fundamentals are the same as for other forms of I/O.
One of the standard Java packages is called java.net.
This package includes several classes that can be
used for networking. Two different styles of network I/O
are supported. One of these, which is fairly high-level, is
based on the World-Wide Web, and provides the sort of
network communication capability that is used by a Web
browser when it downloads pages for you to view. The main
classes for this style of networking are java.net.URL and java.net.URLConnection.
An object of type URL is an abstract representation
of a Universal Resource Locator,
which is an address for an HTML document or other resource on
the Web. A URLConnection represents a network connection
to such a resource.
The second style of I/O views the network at a lower level. It is
based on the idea of a socket.
A socket is used by a program to establish a connection with
another program on a network. Communication over a network
involves two sockets, one on each of the computers involved in
the communication. Java uses a class called java.net.Socket
to represent sockets that are used for network communication.
The term "socket" presumably comes from an image of physically
plugging a wire into a computer to establish a connection to
a network, but it is important to understand that a socket,
as the term is used here, is simply an object belonging to
the class Socket. In particular, a program can
have several sockets at the same time, each connecting it
to another program running on some other computer on the
network. All these connections use the same physical network
connection.
This section gives a brief introduction to these
basic networking classes, and shows how they relate
to input and output streams and to exceptions.
URLs and URLConnections
The URL class is used to represent resources on the
World-Wide Web. Every resource has an address, which identifies
it uniquely and contains enough information for a Web browser
to find the resource on the network and retrieve it. The address
is called a "url" or "universal resource locator." See
Section 6.2 for more information.
An object belonging to the URL class represents
such an address. Once you have a URL object, you can
use it to open a URLConnection to the resource at that
address.
A url is ordinarily specified as a string, such as
"https://math.hws.edu/eck/index.html". There are also
relative url's. A relative url specifies the
location of a resource relative to the location of another url,
which is called the base or
context for the relative url.
For example, if the context is given by the url
https://math.hws.edu/eck/, then the incomplete,
relative url "index.html" would really refer to
https://math.hws.edu/eck/index.html.
An object of the class URL is not simply a string, but
it can be constructed from a string representation of a url.
A URL object can also be constructed from another URL
object, representing a context, and a string that specifies a url
relative to that context. These constructors have prototypes
public URL(String urlName) throws MalformedURLException
and
public URL(URL context, String relativeName)
throws MalformedURLException
Note that these constructors will throw an exception of type
MalformedURLException if the specified strings don't represent
legal url's. The MalformedURLException class is a subclass
of IOException, and it requires mandatory exception handling.
That is, you must call the
constructor inside a try...catch statement that handles the exception or in a
subroutine that is declared to throw the exception.
The second constructor is especially convenient when writing applets.
In an applet, two methods are available
that provide useful URL contexts. The method getDocumentBase(),
defined in the Applet class, returns an object of type
URL. This URL represents the location from which
the HTML page that contains the applet was downloaded. This allows
the applet to go back and retrieve other files that are stored
in the same location as that document. For example,
URL url = new URL(getDocumentBase(), "data.txt");
constructs a URL that refers to a file named data.txt
on the same computer and in the same directory as the web page on which
the applet is running. Another method, getCodeBase(), returns
a URL that gives the location of the applet class file (which is not
necessarily the same as the location of the document).
Once you have a valid URL object, you can call its openConnection()
method to set up a connection. This method returns a URLConnection.
The URLConnection object can, in turn, be used to create an
InputStream for reading data from the resource represented by the URL.
This is done by calling its getInputStream() method. For example:
URL url = new URL(urlAddressString);
URLConnection connection = url.openConnection();
InputStream in = connection.getInputStream();
The openConnection() and getInputStream() methods can both
throw exceptions of type IOException. Once the InputStream has
been created, you can read from it in the usual way, including wrapping
it in another input steam type, such as TextReader. Reading from
the stream can, of course, generate exceptions.
One of the other useful instance methods in the URLConnection class
is getContentType(), which returns a String that describes the
type of information available from the URL. The return value can be null
if the type of information is not yet known or if it is not possible to determine the type.
The type might not be available until after the input stream has been created, so
you should generally call getContentType() after getInputStream().
The string returned by getContentType() is in a format called a
mime type. Mime types include "text/plain", "text/html",
"image/jpeg", "image/gif", and many others. All mime types contain two parts:
a general type, such as "text" or "image", and a more specific type within that
general category, such as "html" or "gif". If you are only interested in
text data, for example, you can check whether the string returned by
getContentType() starts with "text". (Mime types were first introduced to
describe the content of email messages. The name stands for "Multipurpose
Internet Mail Extensions." They are now used almost universally
to specify the type of information in a file or other resource.)
Let's look at a short example that uses all this to read the data from
a URL. This subroutine opens a connection to a specified URL,
checks that the type of data at the URL is text, and the copies the
text onto the screen. Many of the operations in this subroutine can
throw exceptions. They are handled by declaring that the
subroutine "throws Exception" and leaving it up to the main program to
decide what to do when an error occurs.
static void readTextFromURL( String urlString ) throws Exception {
// This subroutine attempts to copy text from the
// specified URL onto the screen. All errors must
// be handled by the caller of this subroutine.
/* Open a connection to the URL, and get an input stream
for reading data from the URL. */
URL url = new URL(urlString);
URLConnection connection = url.openConnection();
InputStream urlData = connection.getInputStream();
/* Check that the content is some type of text. */
String contentType = connection.getContentType();
if (contentType == null || contentType.startsWith("text") == false)
throw new Exception("URL does not refer to a text file.");
/* Copy characters from the input stream to the screen, until
end-of-file is encountered (or an error occurs). */
while (true) {
int data = urlData.read();
if (data < 0)
break;
System.out.print((char)data);
}
} // end readTextFromURL()
A complete program that uses this subroutine can be found in the file
ReadURL.java. Here is an applet
that does much the same thing (although it is more complex and uses some
techniques that won't be covered until the next section).
The applet lets you enter a URL. It can be a relative URL, which will be interpreted
relative to the document base of the applet. Error messages or text loaded from
the URL will be displayed in the text area of the applet. (The amount of text
is limited to 10000 characters.) When the applet starts up, it is configured
to load the file ReadURL.java. Just click the "Load" button:
You can also try to use this applet to look at the HTML source code for this
very page. Just type s4.html into the input box at the
bottom of the applet and then click on the Load button.
You might want to experiment with other urls to see
what types of errors can occur. For example,
entering "bogus.html" is likely to generate a FileNotFoundException,
since no document of that name exists in the directory that contains
this page. As another example, you can probably generate
a SecurityException by trying to connect to
https://www.whitehouse.gov. (Not because it's an official secret --
any url that does not lead back to the same computer from which the applet
was loaded will generate a security exception. To protect you from malicious applets,
an applet is allowed to open network connections only back to the
computer from which it came.) The source code for the applet is in the
file ReadURLApplet.java
Sockets, Clients, and Servers
Communication over the Internet is based on a pair of protocols called
the Internet Protocol and the
Transmission Control Protocol, which are
collectively referred to as TCP/IP. (In fact, there is a more basic
communication protocol called UDP that can be used instead of TCP in
certain applications. UDP is supported in Java, but
for this discussion, I'll stick to the full TCP/IP, which provides reliable
two-way communication between networked computers.)
For two programs to communicate using
TCP/IP, each program must create a socket, as discussed earlier in
this section, and those sockets must be connected. Once such a connection
is made, communication takes place using input streams and output streams.
Each program has its own input stream and its own output stream.
Data written by one program to its output stream is transmitted to
the other computer. There, it enters the input stream of the program
at the other end of the network connection. When that program reads
data from its input stream, it is receiving the data that was transmitted
to it over the network.
The hard part, then, is making a network connection in the first
place. Two sockets are involved. To get things started, one program
must create a socket that will wait passively until a connection request
comes in from another socket. The waiting socket is said to be
listening for a connection. On the other
side of the connection-to-be, another program creates a socket that
sends out a connection request to the listening socket. When the listening
socket receives the connection request, it responds, and the connection is
established. Once that is done, each program can obtain an input stream
and an output stream for the connection. Communication takes place through
these streams until one program or the other closes
the connection.
A program that creates a listening socket is sometimes said to be
a server, and the socket is called a
server socket. A program that connects to
a server is called a client, and the socket that
it uses to make a connection is called a client socket.
The idea is that the server is out there somewhere on the network, waiting
for a connection request from some client. The server can be thought of
as offering some kind of service, and the client gets access to that service
by connecting to the server. This is called the
client/server model of network communication.
In many actual applications, a server program can provide connections to several
clients at the same time. When a client connects to a server's listening socket,
that socket does not stop listening. Instead, it continues listening for
additional client connections at the same time that the first client is
being serviced. (To do this, it is necessary to use "threads". We'll
look at how it works in the next section.)
The URL class that was discussed at the beginning of this section
uses a client socket behind the scenes to do any necessary network communication.
On the other side of that connection is a server program that accepts a
connection request from the URL object, reads a request from that
object for some particular file on the server computer, and responds by
transmitting the contents of that file over the network back to the URL
object. After transmitting the data, the server closes the connection.
To implement TCP/IP connections, the java.net package provides
two classes, ServerSocket and Socket. A ServerSocket
represents a listening socket that waits for connection requests from
clients. A Socket represents one endpoint of an actual
network connection. A Socket, then, can be a client
socket that sends a connection request to a server. But a Socket
can also be created by a server to handle a connection request from a client.
This allows the server to create multiple sockets and handle multiple
connections. (A ServerSocket does not itself participate in
connections; it just listens for connection requests and creates Sockets
to handle the actual connections.)
To use Sockets and ServerSockets, you need to know
about Internet addresses. After all, a client program has to have some
way to specify which computer, among all those on the network, it wants to
communicate with. Every computer on the Internet has an IP
address which identifies it uniquely among all the computers on the net.
Many computers can also be referred to by domain
names such as math.hws.edu or www.whitehouse.gov. (See
Section 1.7.) Now, a single computer might
have several programs doing network communication at the same time,
or one program communicating with several other computers. To allow for
this possibility, a socket is actually identified by
a port number in combination with
an IP address. A port number is just a 16-bit integer. A server
does not simply listen for connections -- it listens for connections on
a particular port. A potential client must know both the Internet
address of the computer on which the server is running and the port number
on which the server is listening. A Web server, for example, generally
listens for connections on port 80; other standard Internet services also
have standard port numbers. (The standard port numbers are all less than
1024. If you create your own server programs, you should use port numbers
greater than 1024.)
When you construct a ServerSocket object, you have to
specify the port number on which the server will listen. The specification
for the constructor is
public ServerSocket(int port) throws IOException
As soon as the ServerSocket is established, it starts listening
for connection requests. The accept() method in the
ServerSocket class accepts such a request, establishes
a connection with the client, and returns a Socket that can
be used for communication with the client. The accept()
method has the form
public Socket accept() throws IOException
When you call the accept() method, it will not return
until a connection request is received (or until some error occurs).
The method is said to block while
waiting for the connection. (While the method is blocked, the thread
that called the method can't do anything else. However, other threads
in the same program can proceed.) The
ServerSocket will continue listening for connections
until it is closed, using its close() method, or until
some error occurs.
Suppose that you want a server to listen on port 1728, and
suppose that you've written
a method provideService(Socket) to handle the communication with
one client. Then the basic form of the server program
would be:
try {
ServerSocket server = new ServerSocket(1728);
while (true) {
Socket connection = server.accept();
provideService(connection);
}
}
catch (IOException e) {
System.out.println("Server shut down with error: " + e);
}
On the client side, a client socket is created using a constructor
in the Socket class. To connect to a server on a known computer
and port, you would use the constructor
public Socket(String computer, int port) throws IOException
The first parameter can be either an IP number or a domain name.
This constructor will block until the connection is established or
until an error occurs. Once the connection is established,
you can use the Socket methods getInputStream() and getOutputStream()
to obtain streams that can be used for communication over the connection.
Keeping all this in mind, here is the outline of a method for working
with a client connection:
void doClientConnection(String computerName, int listeningPort) {
// ComputerName should give the name or ip number of the
// computer where the server is running, such as
// math.hws.edu. ListeningPort should be the port
// on which the server listens for connections, such as 1728.
Socket connection;
InputStream in;
OutputStream out;
try {
connection = new Socket(computerName,listeningPort);
in = connection.getInputStream();
out = connection.getOutputStream();
}
catch (IOException e) {
System.out.println(
"Attempt to create connection failed with error: " + e);
return;
}
.
. // Use the streams, in and out, to communicate with server.
.
try {
connection.close();
// (Alternatively, you might depend on the server
// to close the connection.)
}
catch (IOException e) {
}
} // end doClientConnection()
All this makes network communication sound easier than it really is.
(And if you think it sounded hard, then it's even harder.) If networks
were completely reliable, things would be almost as easy as I've described.
The problem, though, is to write robust programs that can deal with network
and human error. I won't go into detail here -- partly because I don't
really know enough about serious network programming in Java myself.
However, what I've covered here should give you the basic ideas of
network programming, and it is enough to write some simple network
applications. (Just don't try to write a replacement for Netscape.)
Let's look at a few working examples of client/server programming.
Programming Examples
The first example consists of two programs. One is a simple client
and the other is a matching server. The client makes a connection to
the server, reads one line of text from the server, and displays that
text on the screen. The text sent by the server consists of the
current date and time on the computer where the server is running.
In order to open a connection, the client must know the computer
on which the server is running and the port on which it is listening.
The server listens on port number 32007. The port number could be anything
between 1025 and 65535, as long the server and the client use the same port.
Port numbers between 1 and 1024 are reserved for standard services and
should not be used for other servers. The name or IP number of the
computer on which the server is running must be specified as a
command-line parameter. For example, if the server is running
on a computer named math.hws.edu, then you would typically run
the client with the command "java DateClient math.hws.edu". Here is
the complete client program:
import java.net.*;
import java.io.*;
public class DateClient {
static final int LISTENING_PORT = 32007;
public static void main(String[] args) {
String computer; // Name of the computer to connect to.
Socket connection; // A socket for communicating with
// that computer.
Reader incoming; // Stream for reading data from
// the connection.
/* Get computer name from command line. */
if (args.length > 0)
computer = args[0];
else {
// No computer name was given. Print a message and exit.
System.out.println("Usage: java DateClient <server>");
return;
}
/* Make the connection, then read and display a line of text. */
try {
connection = new Socket( computer, LISTENING_PORT );
incoming = new InputStreamReader( connection.getInputStream() );
while (true) {
int ch = incoming.read();
if (ch == -1 || ch == '\n' || ch == '\r')
break;
System.out.print( (char)ch );
}
System.out.println();
incoming.close();
}
catch (IOException e) {
TextIO.putln("Error: " + e);
}
// end main()
} // end class DateClient
Note that all the communication with the server is
done in a try...catch. This will catch the IOExceptions
that can be generated when the connection is opened or closed and
when characters are read from the stream. The stream that is used
for input is a basic Reader, which includes the
input operation incoming.read(). This function reads one
character from the stream and returns its Unicode code number.
If the end-of-stream has been reached, then the value -1 is returned instead.
The while loop reads characters and
copies them to standard output until an end-of-stream or end-of-line
is seen. An end of line is marked by one of the characters '\n'
or '\r', depending on the type of computer on which the server is running.
In order for this program to run without error, the server program
must be running on the computer to which the client tries to connect.
By the way, it's possible to run the client and the server program
on the same computer. For example, you can open two command windows,
start the server in one window and then run the client in the other
window. To make things like this easier, most computers will
recognize the IP number 127.0.0.1 as referring to "this computer".
That is, the command "java DateClient 127.0.0.1" will tell
the DateClient program to connect to a server running on
the same computer. Most computers will also recognize the name
"localhost" as a name for "this computer".
The server program that corresponds to the DateClient
client program is called DateServe. The DateServe program creates a
ServerSocket to listen for connection requests on port 32007.
After the listening socket is created, the
server will enter an infinite loop in which it accepts and processes
connections. This will continue until the program is killed in
some way -- for example by typing a CONTROL-C in the command
window where the server is running. When a connection is received from a client,
the server calls a subroutine to handle the connection. In the subroutine, any
Exception that occurs is caught, so that it will not crash
the server. The subroutine creates a PrintWriter stream
for sending data over the connection. It writes the current
date and time to this stream and then closes the connection.
(The standard class java.util.Date is used to obtain the
current time. An object of type Date represents a particular
date and time. The default constructor, "new Date()", creates
an object that represents the time when the object is created.)
The complete server program is as follows:
import java.net.*;
import java.io.*;
import java.util.Date;
public class DateServe {
static final int LISTENING_PORT = 32007;
public static void main(String[] args) {
ServerSocket listener; // Listens for incoming connections.
Socket connection; // For communication with the
// connecting program.
/* Accept and process connections forever, or until
some error occurs. (Note that errors that occur
while communicating with a connected program are
caught and handled in the sendDate() routine, so
they will not crash the server.)
*/
try {
listener = new ServerSocket(LISTENING_PORT);
TextIO.putln("Listening on port " + LISTENING_PORT);
while (true) {
connection = listener.accept();
sendDate(connection);
}
}
catch (Exception e) {
TextIO.putln("Sorry, the server has shut down.");
TextIO.putln("Error: " + e);
return;
}
} // end main()
static void sendDate(Socket client) {
// The parameter, client, is a socket that is
// already connected to another program. Get
// an output stream for the connection, send the
// current date, and close the connection.
try {
System.out.println("Connection from " +
client.getInetAddress().toString() );
Date now = new Date(); // The current date and time.
PrintWriter outgoing; // Stream for sending data.
outgoing = new PrintWriter( client.getOutputStream() );
outgoing.println( now.toString() );
outgoing.flush(); // Make sure the data is actually sent!
client.close();
}
catch (Exception e){
System.out.println("Error: " + e);
}
} // end sendDate()
} //end class DateServe
If you run DateServe in a command-line interface, it will
sit and wait for connection requests and report them as they are received.
To make the DateServe service permanently available on
a computer, the program really should be run as a daemon.
A daeman is a program that runs continually on a computer, independently
of any user. The computer can be configured to start the daemon
automatically as soon as the computer boots up. It then runs in
the background, even while the computer is being used for other
purposes. For example, a computer that makes pages available on
the World Wide Web runs a daemon that listens for requests for pages
and responds by transmitting the pages. It's just a souped-up analog
of the DateServe program! However, the question of how
to set up a program as a daemon is not one I want to go into here.
For testing purposes, it's easy enough to start the program by hand,
and, in any case, my examples are not really robust enough or full-featured
enough to be run as serious servers. (By the way, the word
"daemon" is just an alternative spelling of "demon" and is usually
pronounced the same way.)
Note that after calling out.println() to send a line of
data to the client, the server program calls out.flush().
The flush() method is available in every output stream class.
Calling it ensures that data that has been written to the stream
is actually sent to its destination. You should call this function
every time you use an output stream to send data over a network
connection. If you don't do so, it's possible that the
stream will collect data until it has a large batch of data to
send. This is done for efficiency, but it can impose unacceptable
delays when the client is waiting for the transmission.
It is even possible that some of the data might remain untransmitted
when the socket is closed, so it is especially important to call
flush() before closing the connection. This is one of those
unfortunate cases where different implementations of Java can
behave differently. If you fail to flush your output streams, it
is possible that your network application will work on some types
of computers but not on others.
In the DateServe example, the server transmits information
and the client reads it. It's also possible to have two-way communication
between client and server. As a first example, we'll look at
a client and server that allow a user on each end of the connection
to send messages to the other user. The program works in a
command-line interface where the users type in their messages.
In this example, the server waits for a connection from a single client
and then closes down its listener so that no other clients can connect.
After the client and server are connected,
both ends of the connection work in much the same way. The user on the
client end types a message, and it is transmitted to the server, which
displays it to the user on that end. Then the user of the server types
a message that is transmitted to the client. Then the client user types
another message, and so on. This continues until one user or the other
enters "quit" when prompted for a message. When that happens,
the connection is closed and both programs terminate.
The client program
and the server program are very similar. The techniques for opening
the connections differ, and the client is programmed to send
the first message while the server is programmed to receive the
first message. Here is the server program. You can find the
client program in the file CLChatClient.java.
(The name "CLChat" stands for command-line chat.)
import java.net.*;
import java.io.*;
public class CLChatServer {
static final int DEFAULT_PORT = 1728; // Port to listen on,
// if none is specified
// on the command line.
static final String HANDSHAKE = "CLChat"; // Handshake string.
// Each end of the connection sends this string
// to the other just after the connection is
// opened. This is done to confirm that the
// program on the other side of the connection
// is a CLChat program.
static final char MESSAGE = '0'; // This character is added to
// the beginning of each message
// that is sent.
static final char CLOSE = '1'; // This character is sent to
// the connected program when
// the user quits.
public static void main(String[] args) {
int port; // The port on which the server listens.
ServerSocket listener; // Listens for a connection request.
Socket connection; // For communication with the client.
TextReader incoming; // Stream for receiving data from client.
PrintWriter outgoing; // Stream for sending data to client.
String messageOut; // A message to be sent to the client.
String messageIn; // A message received from the client.
/* First, get the port number from the command line,
or use the default port if none is specified. */
if (args.length == 0)
port = DEFAULT_PORT;
else {
try {
port = Integer.parseInt(args[0]);
if (port < 0 || port > 65535)
throw new NumberFormatException();
}
catch (NumberFormatException e) {
TextIO.putln("Illegal port number, " + args[0]);
return;
}
}
/* Wait for a connection request. When it arrives, close
down the listener. Create streams for communication
and exchange the handshake. */
try {
listener = new ServerSocket(port);
TextIO.putln("Listening on port " + listener.getLocalPort());
connection = listener.accept();
listener.close();
incoming = new TextReader(connection.getInputStream());
outgoing = new PrintWriter(connection.getOutputStream());
outgoing.println(HANDSHAKE);
outgoing.flush();
messageIn = incoming.getln();
if (! messageIn.equals(HANDSHAKE) ) {
throw new IOException("Connected program is not CLChat!");
}
TextIO.putln("Connected. Waiting for the first message.\n");
}
catch (Exception e) {
TextIO.putln("An error occurred while opening connection.");
TextIO.putln(e.toString());
return;
}
/* Exchange messages with the other end of the connection
until one side or the other closes the connection.
This server program waits for the first message from
the client. After that, messages alternate strictly
back and forth. */
try {
while (true) {
TextIO.putln("WAITING...");
messageIn = incoming.getln();
if (messageIn.length() > 0) {
// The first character of the message is a command.
// If the command is CLOSE, then the connection
// is closed. Otherwise, remove the command
// character from the message and proceed.
if (messageIn.charAt(0) == CLOSE) {
TextIO.putln("Connection closed at other end.");
connection.close();
break;
}
messageIn = messageIn.substring(1);
}
TextIO.putln("RECEIVED: " + messageIn);
TextIO.put("SEND: ");
messageOut = TextIO.getln();
if (messageOut.equalsIgnoreCase("quit")) {
// User wants to quit. Inform the other side
// of the connection, then close the connection.
outgoing.println(CLOSE);
outgoing.flush(); // Make sure the data is sent!
connection.close();
TextIO.putln("Connection closed.");
break;
}
outgoing.println(MESSAGE + messageOut);
outgoing.flush(); // Make sure the data is sent!
if (outgoing.checkError()) {
throw new IOException(
"Error occurred while transmitting message.");
}
}
}
catch (Exception e) {
TextIO.putln("Sorry, an error has occurred. Connection lost.");
TextIO.putln(e.toString());
System.exit(1);
}
} // end main()
} //end class CLChatServer
This program is a little more robust than DateServe.
For one thing, it uses a handshake
to make sure that a client who is trying to connect is really
a CLChatClient program. A handshake is simply information
sent between client and server as part of setting up the connection.
In this case, each side of the connection sends a string to
the other side to identify itself. The handshake is part of
the protocol that I made up for
communication between CLChatClient and CLChatServer.
When you design a client/server application, the design of the
protocol is an important consideration. Another aspect of
the CLChat protocol is that every line of text that
is sent over the connection after the handshake begins with
a character that acts as a command. If the character is 0,
the rest of the line is a message from one user to the other.
If the character is 1, the line indicates that a user has entered
the "quit" command, and the connection is to be shut down.
Remember that if you want to try out this program on a
single computer, you can use two command-line windows.
In one, give the command "java CLChatServer" to start the
server. Then, in the other, use the command
"java CLChatClient 127.0.0.1" to connect to the server
that is running on the same machine.
