Client/Server Interaction with Stream Socket Connections

Client Server Interaction with Stream Socket Connections

Figure 24.5 and Fig. 24.7 use stream sockets to demonstrate a simple client/server chat application. The server waits for a client connection attempt. When a client connects to the server, the server application sends the client a String object (recall that Strings are Serializable objects) indicating that the connection was successful. Then the client displays the message. The client and server applications each provide textfields that allow the user to type a message and send it to the other application. When the client or the server sends the string "TERMINATE", the connection terminates. Then the server waits for the next client to connect. The declaration of class Server appears in Fig. 24.5. The declaration of class Client appears in Fig. 24.7. The screen captures showing the execution between the client and the server are shown as part of Fig. 24.7.

Figure 24.5. Server portion of a client/server stream-socket connection.

(This item is displayed on pages 1120 - 1123 in the print version)

 1 // Fig. 24.5: Server.java
 2 // Set up a Server that will receive a connection from a client, send
 3 // a string to the client, and close the connection.
 4 import java.io.EOFException;
 5 import java.io.IOException;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 import java.net.ServerSocket;
 9 import java.net.Socket; 
10 import java.awt.BorderLayout;
11 import java.awt.event.ActionEvent;
12 import java.awt.event.ActionListener;
13 import javax.swing.JFrame;
14 import javax.swing.JScrollPane;
15 import javax.swing.JTextArea;
16 import javax.swing.JTextField;
17 import javax.swing.SwingUtilities;
18 
19 public class Server extends JFrame
20 {
21 private JTextField enterField; // inputs message from user
22 private JTextArea displayArea; // display information to user
23 private ObjectOutputStream output; // output stream to client
24 private ObjectInputStream input; // input stream from client
25 private ServerSocket server; // server socket 
26 private Socket connection; // connection to client
27 private int counter = 1; // counter of number of connections
28 
29 // set up GUI
30 public Server()
31 {
32 super ( "Server" );
33 
34 enterField = new JTextField(); // create enterField
35 enterField.setEditable( false );
36 enterField.addActionListener(
37 new ActionListener()
38 {
39 // send message to client
40 public void actionPerformed( ActionEvent event )
41 {
42 sendData( event.getActionCommand() );
43 enterField.setText( "" );
44 } // end method actionPerformed
45 } // end anonymous inner class
46 ); // end call to addActionListener
47 
48 add( enterField, BorderLayout.NORTH );
49 
50 displayArea = new JTextArea(); // create displayArea
51 add( new JScrollPane( displayArea ), BorderLayout.CENTER );
52 
53 setSize( 300, 150 ); // set size of window
54 setVisible( true ); // show window
55 } // end Server constructor
56 
57 // set up and run server
58 public void runServer()
59 {
60 try // set up server to receive connections; process connections
61 {
62 server = new ServerSocket( 12345, 100 ); // create ServerSocket
63 
64 while ( true )
65 {
66 try
67 {
68 waitForConnection(); // wait for a connection
69 getStreams(); // get input & output streams
70 processConnection(); // process connection
71 } // end try
72 catch ( EOFException eofException )
73 {
74 displayMessage( "
Server terminated connection" );
75 } // end catch
76 finally
77 {
78 closeConnection(); // close connection
79 counter++;
80 } // end finally
81 } // end while
82 } // end try
83 catch ( IOException ioException )
84 {
85 ioException.printStackTrace();
86 } // end catch
87 } // end method runServer
88 
89 // wait for connection to arrive, then display connection info
90 private void waitForConnection() throws IOException
91 {
92 displayMessage( "Waiting for connection
" );
93 connection = server.accept(); // allow server to accept connection
94 displayMessage( "Connection " + counter + " received from: " +
95 connection.getInetAddress().getHostName() );
96 } // end method waitForConnection
97 
98 // get streams to send and receive data
99 private void getStreams() throws IOException
100 {
101 // set up output stream for objects
102 output = new ObjectOutputStream( connection.getOutputStream() ); 
103 output.flush(); // flush output buffer to send header information
104 
105 // set up input stream for objects
106 input = new ObjectInputStream( connection.getInputStream() );
107 
108 displayMessage( "
Got I/O streams
" );
109 } // end method getStreams
110 
111 // process connection with client
112 private void processConnection() throws IOException
113 {
114 String message = "Connection successful";
115 sendData( message ); // send connection successful message
116 
117 // enable enterField so server user can send messages
118 setTextFieldEditable( true );
119 
120 do // process messages sent from client
121 {
122 try // read message and display it
123 {
124 message = ( String ) input.readObject(); // read new message
125 displayMessage( "
" + message ); // display message
126 } // end try
127 catch ( ClassNotFoundException classNotFoundException )
128 {
129 displayMessage( "
Unknown object type received" );
130 } // end catch
131 
132 } while ( !message.equals( "CLIENT>>> TERMINATE" ) );
133 } // end method processConnection
134 
135 // close streams and socket
136 private void closeConnection()
137 {
138 displayMessage( "
Terminating connection
" );
139 setTextFieldEditable( false ); // disable enterField
140 
141 try
142 {
143 output.close(); // close output stream
144 input.close(); // close input stream 
145 connection.close(); // close socket 
146 } // end try
147 catch ( IOException ioException )
148 {
149 ioException.printStackTrace();
150 } // end catch
151 } // end method closeConnection
152 
153 // send message to client
154 private void sendData( String message )
155 {
156 try // send object to client
157 {
158 output.writeObject( "SERVER>>> " + message );
159 output.flush(); // flush output to client 
160 displayMessage( "
SERVER>>> " + message );
161 } // end try
162 catch ( IOException ioException )
163 {
164 displayArea.append( "
Error writing object" );
165 } // end catch
166 } // end method sendData
167 
168 // manipulates displayArea in the event-dispatch thread
169 private void displayMessage( final String messageToDisplay )
170 {
171 SwingUtilities.invokeLater(
172 new Runnable()
173 {
174 public void run() // updates displayArea
175 {
176 displayArea.append( messageToDisplay ); // append message
177 } // end method run
178 } // end anonymous inner class
179 ); // end call to SwingUtilities.invokeLater
180 } // end method displayMessage
181 
182 // manipulates enterField in the event-dispatch thread
183 private void setTextFieldEditable( final boolean editable )
184 {
185 SwingUtilities.invokeLater(
186 new Runnable()
187 {
188 public void run() // sets enterField's editability
189 {
190 enterField.setEditable( editable );
191 } // end method run
192 } // end inner class
193 ); // end call to SwingUtilities.invokeLater
194 } // end method setTextFieldEditable
195 } // end class Server

Server Class

Server's constructor (lines 3055) creates the server's GUI, which contains a JTextField and a JTextArea. Server displays its output in the JTextArea. When the main method (lines 712 of Fig. 24.6) executes, it creates a Server object, specifies the window's default close operation and calls method runServer (declared at lines 5887).

Figure 24.6. Test class for Server.

(This item is displayed on page 1124 in the print version)

 1 // Fig. 24.6: ServerTest.java
 2 // Test the Server application.
 3 import javax.swing.JFrame;
 4
 5 public class ServerTest
 6 {
 7 public static void main( String args[] )
 8 {
 9 Server application = new Server(); // create server
10 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 application.runServer(); // run server application
12 } // end main
13 } // end class ServerTest

Method runServer sets up the server to receive a connection and processes one connection at a time. Line 62 creates a ServerSocket called server to wait for connections. The ServerSocket listens for a connection from a client at port 12345. The second argument to the constructor is the number of connections that can wait in a queue to connect to the server (100 in this example). If the queue is full when a client attempts to connect, the server refuses the connection.

Common Programming Error 24.1

Specifying a port that is already in use or specifying an invalid port number when creating a ServerSocket results in a BindException.

Line 68 calls method waitForConnection (declared at lines 9096) to wait for a client connection. After the connection is established, line 69 calls method getStreams (declared at lines 99109) to obtain references to the streams for the connection. Line 70 calls method processConnection (declared at lines 112133) to send the initial connection message to the client and to process all messages received from the client. The finally block (lines 7680) terminates the client connection by calling method closeConnection (lines 136151) even if an exception occurs. Method displayMessage (lines 169180) is called from these methods to use the event-dispatch thread to display messages in the application's JTextArea.

In method waitForConnection (lines 9096), line 93 uses ServerSocket method accept to wait for a connection from a client. When a connection occurs, the resulting Socket is assigned to connection. Method accept blocks until a connection is received (i.e., the thread in which accept is called stops executing until a client connects). Lines 9495 output the host name of the computer that made the connection. Socket method getInetAddress returns an InetAddress (package java.net) containing information about the client computer. InetAddress method getHostName returns the host name of the client computer. For example, there is a special IP address (127.0.0.1) and host name (localhost) that is useful for testing networking applications on your local computer (this is also known as the loopback address). If getHostName is called on an InetAddress containing 127.0.0.1, the corresponding host name returned by the method would be localhost.

Method getStreams (lines 99109) obtains references to the Socket's streams and uses them to initialize an ObjectOutputStream (line 102) and an ObjectInputStream (line 106), respectively. Note the call to ObjectOutputStream method flush at line 103. This statement causes the ObjectOutputStream on the server to send a stream header to the corresponding client's ObjectInputStream. The stream header contains such information as the version of object serialization being used to send objects. This information is required by the ObjectInputStream so that it can prepare to receive those objects correctly.

Software Engineering Observation 24.5

When using an ObjectOutputStream and ObjectInputStream to send and receive data over a network connection, always create the ObjectOutputStream first and flush the stream so that the client's ObjectInputStream can prepare to receive the data. This is required only for networking applications that communicate using ObjectOutputStream and ObjectInputStream.

Performance Tip 24.3

A computer's input and output components are typically much slower than its memory. Output buffers typically are used to increase the efficiency of an application by sending larger amounts of data fewer times, thus reducing the number of times an application accesses the computer's input and output components.

Line 114 of method processConnection (lines 112133) calls method sendData to send "SERVER>>> Connection successful" as a string to the client. The loop at lines 120132 executes until the server receives the message "CLIENT>>> TERMINATE". Line 124 uses ObjectInputStream method readObject to read a String from the client. Line 125 invokes method displayMessage to append the message to the JTextArea.

When the transmission is complete, method processConnection returns, and the program calls method closeConnection (lines 136151) to close the streams associated with the Socket and close the Socket. Then the server waits for the next connection attempt from a client by continuing with line 68 at the beginning of the while loop.

When the user of the server application enters a string in the textfield and presses the Enter key, the program calls method actionPerformed (lines 4044), which reads the string from the textfield and calls utility method sendData (lines 154166) to send the string to the client. Method sendData writes the object, flushes the output buffer and appends the same string to the textarea in the server window. It is not necessary to invoke displayMessage to modify the textarea here, because method sendData is called from an event handlerthus, sendData executes as part of the event-dispatch thread.

Note that Server receives a connection, processes it, closes it and waits for the next connection. A more likely scenario would be a Server that receives a connection, sets it up to be processed as a separate thread of execution, then immediately waits for new connections. The separate threads that process existing connections can continue to execute while the Server concentrates on new connection requests. This makes the server more efficient, because multiple client requests can be processed concurrently. We demonstrate a multithreaded server in Section 24.8.

Client Class

Like class Server, class Client's (Fig. 24.7) constructor (lines 2956) creates the GUI of the application (a JTextField and a JTextArea). Client displays its output in the textarea. When method main (lines 719 of Fig. 24.8) executes, it creates an instance of class Client, specifies the window's default close operation and calls method runClient (declared at lines 5979). In this example, you can execute the client from any computer on the Internet and specify the IP address or host name of the server computer as a commandline argument to the program. For example, the command

 java Client 192.168.1.15

attempts to connect to the Server on the computer with IP address 192.168.1.15.

Figure 24.7. Client portion of a stream-socket connection between client and server.

(This item is displayed on pages 1126 - 1129 in the print version)

 1 // Fig. 24.7: Client.java
 2 // Client that reads and displays information sent from a Server.
 3 import java.io.EOFException;
 4 import java.io.IOException;
 5 import java.io.ObjectInputStream;
 6 import java.io.ObjectOutputStream;
 7 import java.net.InetAddress;
 8 import java.net.Socket; 
 9 import java.awt.BorderLayout;
10 import java.awt.event.ActionEvent;
11 import java.awt.event.ActionListener;
12 import javax.swing.JFrame;
13 import javax.swing.JScrollPane;
14 import javax.swing.JTextArea;
15 import javax.swing.JTextField;
16 import javax.swing.SwingUtilities;
17 
18 public class Client extends JFrame
19 {
20 private JTextField enterField; // enters information from user
21 private JTextArea displayArea; // display information to user
22 private ObjectOutputStream output; // output stream to server
23 private ObjectInputStream input; // input stream from server
24 private String message = ""; // message from server
25 private String chatServer; // host server for this application
26 private Socket client; // socket to communicate with server
27 
28 // initialize chatServer and set up GUI
29 public Client( String host )
30 {
31 super( "Client" );
32 
33 chatServer = host; // set server to which this client connects
34 
35 enterField = new JTextField(); // create enterField
36 enterField.setEditable( false );
37 enterField.addActionListener(
38 new ActionListener()
39 {
40 // send message to server
41 public void actionPerformed( ActionEvent event )
42 {
43 sendData( event.getActionCommand() );
44 enterField.setText( "" );
45 } // end method actionPerformed
46 } // end anonymous inner class
47 ); // end call to addActionListener
48 
49 add( enterField, BorderLayout.NORTH );
50 
51 displayArea = new JTextArea(); // create displayArea
52 add( new JScrollPane( displayArea ), BorderLayout.CENTER );
53 
54 setSize( 300, 150 ); // set size of window
55 setVisible( true ); // show window
56 } // end Client constructor
57 
58 // connect to server and process messages from server
59 public void runClient()
60 {
61 try // connect to server, get streams, process connection
62 {
63 connectToServer(); // create a Socket to make connection
64 getStreams(); // get the input and output streams
65 processConnection(); // process connection
66 } // end try
67 catch ( EOFException eofException )
68 {
69 displayMessage( "
Client terminated connection" );
70 } // end catch
71 catch ( IOException ioException )
72 {
73 ioException.printStackTrace();
74 } // end catch
75 finally
76 {
77 closeConnection(); // close connection
78 } // end finally
79 } // end method runClient
80 
81 // connect to server
82 private void connectToServer() throws IOException
83 {
84 displayMessage( "Attempting connection
" );
85 
86 // create Socket to make connection to server
87 client = new Socket( InetAddress.getByName( chatServer ), 12345 );
88 
89 // display connection information
90 displayMessage( "Connected to: " +
91 client.getInetAddress().getHostName() );
92 } // end method connectToServer
93 
94 // get streams to send and receive data
95 private void getStreams() throws IOException
96 {
97 // set up output stream for objects
98 output = new ObjectOutputStream( client.getOutputStream() ); 
99 output.flush(); // flush output buffer to send header information
100 
101 // set up input stream for objects
102 input = new ObjectInputStream( client.getInputStream() );
103 
104 displayMessage( "
Got I/O streams
" );
105 } // end method getStreams
106 
107 // process connection with server
108 private void processConnection() throws IOException
109 {
110 // enable enterField so client user can send messages
111 setTextFieldEditable( true );
112 
113 do // process messages sent from server
114 {
115 try // read message and display it
116 {
117 message = ( String ) input.readObject(); // read new message
118 displayMessage( "
" + message ); // display message
119 } // end try
120 catch ( ClassNotFoundException classNotFoundException )
121 {
122 displayMessage( "
Unknown object type received" );
123 } // end catch
124 
125 } while ( !message.equals( "SERVER>>> TERMINATE" ) );
126 } // end method processConnection
127 
128 // close streams and socket
129 private void closeConnection()
130 {
131 displayMessage( "
Closing connection" );
132 setTextFieldEditable( false ); // disable enterField
133 
134 try
135 {
136 output.close(); // close output stream
137 input.close(); // close input stream 1
138 client.close(); // close socket 
139 } // end try
140 catch ( IOException ioException )
141 {
142 ioException.printStackTrace();
143 } // end catch
144 } // end method closeConnection
145 
146 // send message to server
147 private void sendData( String message )
148 {
149 try // send object to server
150 {
151 output.writeObject( "CLIENT>>> " + message );
152 output.flush(); // flush data to output 
153 displayMessage( "
CLIENT>>> " + message );
154 } // end try
155 catch ( IOException ioException )
156 {
157 displayArea.append( "
Error writing object" );
158 } // end catch
159 } // end method sendData
160 
161 // manipulates displayArea in the event-dispatch thread
162 private void displayMessage( final String messageToDisplay )
163 {
164 SwingUtilities.invokeLater(
165 new Runnable()
166 {
167 public void run() // updates displayArea
168 {
169 displayArea.append( messageToDisplay );
170 } // end method run
171 } // end anonymous inner class
172 ); // end call to SwingUtilities.invokeLater
173 } // end method displayMessage
174 
175 // manipulates enterField in the event-dispatch thread
176 private void setTextFieldEditable( final boolean editable )
177 {
178 SwingUtilities.invokeLater(
179 new Runnable()
180 {
181 public void run() // sets enterField's editability
182 {
183 enterField.setEditable( editable );
184 } // end method run
185 } // end anonymous inner class
186 ); // end call to SwingUtilities.invokeLater
187 } // end method setTextFieldEditable
188 } // end class Client

Figure 24.8. Class that tests the Client.

(This item is displayed on pages 1130 - 1131 in the print version)

 1 // Fig. 24.8: ClientTest.java
 2 // Test the Client class.
 3 import javax.swing.JFrame;
 4
 5 public class ClientTest
 6 {
 7 public static void main( String args[] )
 8 {
 9 Client application; // declare client application
10
11 // if no command line args
12 if ( args.length == 0 )
13 application = new Client( "127.0.0.1" ); // connect to localhost
14 else
15 application = new Client( args[ 0 ] ); // use args to connect 
16
17 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
18 application.runClient(); // run client application
19 } // end main
20 } // end class ClientTest

 

Client method runClient (lines 5979) sets up the connection to the server, processes messages received from the server and closes the connection when communication is complete. Line 63 calls method connectToServer (declared at lines 8292) to perform the connection. After connecting, line 64 calls method getStreams (declared at lines 95105) to obtain references to the Socket's stream objects. Then line 65 calls method processConnection (declared at lines 108126) to receive and display messages sent from the server. The finally block (lines 7578) calls closeConnection (lines 129144) to close the streams and the Socket even if an exception has occurred. Method displayMessage (lines 162173) is called from these methods to use the event-dispatch thread to display messages in the application's textarea.

Method connectToServer (lines 8292) creates a Socket called client (line 87) to establish a connection. The method passes two arguments to the Socket constructorthe IP address of the server computer and the port number (12345) where the server application is awaiting client connections. In the first argument, InetAddress static method getByName returns an InetAddress object containing the IP address specified as a command-line argument to the application (or 127.0.0.1 if no command-line arguments are specified). Method getByName can receive a string containing either the actual IP address or the host name of the server. The first argument also could have been written other ways. For the localhost address 127.0.0.1, the first argument could be

 InetAddress.getByName( "localhost" )

or

 InetAddress. getLocalHost()

Also, there are versions of the Socket constructor that receive a string for the IP address or host name. The first argument could have been specified as "127.0.0.1" or "localhost". We chose to demonstrate the client/server relationship by connecting between applications executing on the same computer (localhost). Normally, this first argument would be the IP address of another computer. The InetAddress object for another computer can be obtained by specifying the computer's IP address or host name as the argument to InetAddress method getByName. The Socket constructor's second argument is the server port number. This must match the port number at which the server is waiting for connections (called the handshake point). Once the connection is made, lines 9091 display a message in the text area indicating the name of the server computer to which the client has connected.

The Client uses an ObjectOutputStream to send data to the server and an ObjectInputStream to receive data from the server. Method getStreams (lines 95105) creates the ObjectOutputStream and ObjectInputStream objects that use the streams associated with the client socket.

Method processConnection (lines 108126) contains a loop that executes until the client receives the message "SERVER>>> TERMINATE". Line 117 reads a String object from the server. Line 118 invokes displayMessage to append the message to the textarea.

When the transmission is complete, method closeConnection (lines 129144) closes the streams and the Socket.

When the user of the client application enters a string in the textfield and presses the Enter key, the program calls method actionPerformed (lines 4145) to read the string and invoke utility method sendData (147159) to send the string to the server. Method sendData writes the object, flushes the output buffer and appends the same string to the JTextArea in the client window. Once again, it is not necessary to invoke utility method displayMessage to modify the textarea here, because method sendData is called from an event handler.