Case Study: DeitelMessenger Server and Client

Case Study DeitelMessenger Server and Client

Chat rooms have become common on the Internet. They provide a central location where users can chat with each other via short text messages. Each participant can see all messages that the other users post, and each user can post messages. This section presents our capstone networking case study, which integrates many of the Java networking, multithreading and Swing GUI features we have learned thus far to build an online chat system. We also introduce multicasting, which enables an application to send DatagramPackets to groups of clients. After reading this section, you will be able to build more significant networking applications.

24.10.1. DeitelMessengerServer and Supporting Classes

DeitelMessengerServer (Fig. 24.18) is the heart of the online chat system. This class appears in package com.deitel.messenger.sockets.server. Chat clients can participate in a chat by connecting to the DeitelMessengerServer. Method startServer (lines 2053) launches DeitelMessengerServer. Lines 2829 create a ServerSocket to accept incoming network connections. Recall that the ServerSocket constructor takes as its first argument the port on which the server should listen for incoming connections. Interface SocketMessengerConstants (Fig. 24.20) declares the port number as the constant SERVER_PORT to ensure that the server and the clients use the correct port number.

Figure 24.18. DeitelMessengerServer for managing a chat room.

(This item is displayed on pages 1155 - 1156 in the print version)

Lines 3547 listen continuously for new client connections. Line 38 invokes ServerSocket method accept to wait for and accept a new client connection. Lines 4142 create and start a new MessageReceiver for the client. Class MessageReceiver (Fig. 24.22) of package com.deitel.messenger.sockets.server implements Runnable and listens for incoming messages from a client. The first argument to the MessageReceiver constructor is a MessageListener (Fig. 24.21), to which messages from the client should be delivered. Class DeitelMessengerServer implements interface MessageListener (line 15) of package com.deitel.messenger and therefore can pass the this reference to the MessageReceiver constructor.

When each MessageReceiver receives a new message from a client, the MessageReceiver passes the message to a MessageListener through method messageReceived (lines 5664). Line 59 concatenates the from string with the separator >>> and the message body. Lines 6263 create and start a new MulticastSender to deliver completeMessage to all clients. Class MulticastSender (Fig. 24.23) of package com.deitel.messenger.sockets.server uses multicasting as an efficient mechanism for sending one message to multiple clients. We discuss the details of multicasting shortly. Method main (lines 711 of Fig. 24.19) creates a new DeitelMessengerServer instance and starts the server.

Figure 24.19. Test class for DeitelMessengerServer.

Interface SocketMessengerConstants (Fig. 24.20) declares constants for use in the various classes that make up the Deitel messenger system. Classes can access these static constants by using a static import as shown in Fig. 24.22.

Figure 24.20. SocketMessengerConstants declares constants for use in the DeitelMessengerServer and DeitelMessenger.

Line 9 declares the String constant MULTICAST_ADDRESS, which contains the address to which a MulticastSender (Fig. 24.23) should send messages. This address is one of the addresses reserved for multicast, which we describe in the discussion of Fig. 24.23. Line 12 declares the integer constant MULTICAST_LISTENING_PORTthe port on which clients should listen for new messages. Line 15 declares the integer constant MULTICAST_SENDING_PORTthe port to which a MulticastSender should post new messages at the MULTICAST_ADDRESS. Line 18 declares the integer constant SERVER_PORTthe port on which DeitelMessengerServer listens for incoming client connections. Line 21 declares String constant DISCONNECT_STRING, which is the String that a client sends to DeitelMessengerServer when the user wishes to leave the chat room. Line 24 declares String constant MESSAGE_SEPARATOR, which separates the user name from the message body. Line 27 specifies the maximum message size in bytes.

Many different classes in the Deitel messenger system receive messages. For example, DeitelMessengerServer receives messages from clients and delivers them to all chat room participants. As we will see, the user interface for each client also receives messages and displays them to the users. Each class that receives messages implements interface MessageListener (Fig. 24.21). The interface (from package com.deitel.messenger) declares method messageReceived, which allows an implementing class to receive chat messages. Method messageReceived takes two string arguments representing the name of the sender and the message body, respectively.

Figure 24.21. MessageListener interface that declares method messageReceived for receiving new chat messages.

DeitelMessengerServer uses instances of class MessageReceiver (Fig. 24.22) from package com.deitel.messenger.sockets.server to listen for new messages from each client. Class MessageReceiver implements interface Runnable. This enables DeitelMessengerServer to create an object of class MessageReceiver to run in a separate thread for each client, so that messages from multiple clients can be handled concurrently. When DeitelMessengerServer receives a new client connection, DeitelMessengerServer creates a new MessageReceiver for the client, then continues listening for new client connections. The MessageReceiver listens for messages from a single client and passes them back to the DeitelMessengerServer through method messageReceived.

Figure 24.22. MessageReceiver for listening for new messages from DeitelMessengerServer clients in separate threads.

(This item is displayed on pages 1159 - 1161 in the print version)

The MessageReceiver constructor (lines 2341) takes a MessageListener as its first argument. The MessageReceiver will deliver new messages to this listener by invoking its messageReceived method. The MessageReceiver constructor's Socket argument is the connection to a particular client. Line 26 sets the MessageListener to which the MessageReceiver should deliver new messages. Line 31 invokes Socket method setSoTimeout with an integer argument of 5000 milliseconds. Reading data from a Socket is a blocking callthe current thread does not execute until the read operation completes. Method setSoTimeout specifies that if no data is received in the given number of milliseconds, the Socket should issue a SocketTimeoutException, which the current thread can catch, then continue executing. This technique prevents the current thread from dead-locking if no more data is available from the Socket. Lines 3435 create a new BufferedReader for the clientSocket's InputStream. The MessageReceiver uses this BufferedReader to read new messages from the client.

Method run (lines 4499) listens continuously for new messages from the client. Lines 4989 loop as long as the boolean variable keepListening is TRue. Line 53 invokes BufferedReader method readLine to read a line of text from the client. If more than 5000 milliseconds pass without any data being read, method readLine tHRows an InterruptedIOException, which indicates that the time-out set on line 31 has expired. Line 57 uses a continue statement to go to the next iteration of the while loop to continue listening for messages. Lines 5963 catch an IOException, which indicates a more severe problem from method readLine. In this case, line 61 prints a stack trace to aid in debugging the application, and line 62 uses keyword break to terminate the loop.

When sending a message to the server, the client separates the user's name from the message body with MESSAGE_SEPARATOR declared in interface SocketMessengerConstants. If no exceptions are thrown when reading data from the client and the message is not null (line 66), lines 6970 create a new StringTokenizer that uses delimiter MESSAGE_SEPARATOR to separate each message into two tokensthe sender's user name and the message. Line 74 checks for the proper number of tokens (using StringTokenizer method countTokens), and lines 7779 invoke method messageReceived of interface MessageListener to deliver the new message to the registered MessageListener. If the StringTokenizer does not produce two tokens, lines 8485 check the message to see whether it matches the constant DISCONNECT_STRING, which would indicate that the user wishes to leave the chat room. Line 84 uses String method equalsIgnoreCase to test whether the input String equals the disconnect string. This method is equivalent to String method equals, but it does not consider the case of the letters. This allows the user to type DISCONNECT, disconnect or even dIscoNNEcT to terminate the connection. If the strings match, line 86 invokes MessageReceiver method stopListening to terminate the MessageReceiver.

Method stopListening (lines 102105) sets boolean variable keepListening to false. This causes the while loop condition that starts at line 49 to fail and causes the MessageReceiver to close the client Socket (line 93). Then method run returns, which terminates the MessageReceiver's execution.

MulticastSender (Fig. 24.23) delivers DatagramPackets containing chat messages to a group of clients. Multicast is an efficient way to send data to many clients without the overhead of broadcasting it to every host on the Internet. To understand multicast, let us look at a real-world analogythe relationship between a magazine's publisher and its subscribers. The publisher produces a magazine and provides it to a distributor. Customers obtain a subscription and begin receiving the magazine in the mail from the distributor. This communication is quite different from a television broadcast. When a television station produces a television show, the station broadcasts the show throughout a geographical region or perhaps throughout the world by using satellites. Broadcasting a show for 1,000,000 viewers costs no more than broadcasting one for 100 viewersthe signal carrying the broadcast reaches a wide area. However, printing and delivering a magazine to 1,000,000 readers would be much more expensive than for 100 readers. Most publishers could not stay in business if they had to broadcast their magazines to everyone, so they multicast them to a group of subscribers instead.

Figure 24.23. MulticastSender for delivering outgoing messages to a multicast group via DatagramPackets.

(This item is displayed on pages 1162 - 1163 in the print version)

Using multicast, an application can "publish" DatagramPackets to "subscriber" applications by sending them to a multicast address, which is an IP address reserved for multicast. Multicast addresses are in the range from 224.0.0.0 to 239.255.255.255. Addresses starting with 239 are reserved for intranets, so we use one of these (239.0.0.1) in our case study. Clients that wish to receive these DatagramPackets can connect to the appropriate multicast address to join the group of subscribersthe multicast group. When an application sends a DatagramPacket to the multicast address, each client in the group receives it. Multicast DatagramPackets, like unicast DatagramPackets (Fig. 24.7), are not reliablepackets are not guaranteed to reach any destination or arrive in any particular order.

Class MulticastSender implements interface Runnable to enable DeitelMessengerServer to send multicast messages in a separate thread. The DeitelMessengerServer creates a MulticastSender with the contents of the message and starts the thread. The MulticastSender constructor (lines 1619) takes as an argument an array of bytes containing the message.

Method run (lines 2244) delivers the message to the multicast address. Lines 2728 create a new DatagramSocket. Recall from Section 24.7 that we use DatagramSockets to send unicast DatagramPacketspackets sent from one host directly to another host. Multicast DatagramPackets are sent the same way, except that the address to which they are sent is a multicast address. Line 31 create an InetAddress object for the multicast address, which is declared as a constant in interface SocketMessengerConstants. Lines 3435 create the DatagramPacket containing the message. The first argument to the DatagramPacket constructor is the byte array containing the message. The second argument is the length of the byte array. The third argument specifies the InetAddress to which the packet should be sent, and the last specifies the port number at which the packet should be delivered to the multicast address. Line 37 sends the packet with DatagramSocket method send. All clients listening to the multicast address on the proper port will receive this DatagramPacket. Line 38 closes the DatagramSocket, and the run method returns, terminating the MulticastSender.

Executing the DeitelMessengerServerTest

To execute the DeitelMessengerServerTest, open a Command Prompt window and change directories to the location in which package com.deitel.messenger.sockets.server resides (i.e., the directory in which com is located). Then type

java com.deitel.messenger.sockets.server.DeitelMessengerServerTest

to execute the server.

24.10.2. DeitelMessenger Client and Supporting Classes

The client for the DeitelMessengerServer has several components. A class that implements interface MessageManager (Fig. 24.24) manages communication with the server. A Runnable subclass listens for messages at DeitelMessengerServer's multicast address. Another Runnable subclass sends messages from the client to the server. A JFrame subclass provides the client's GUI.

Figure 24.24. MessageManager interface that declares methods for communicating with a DeitelMessengerServer.

Interface MessageManager (Fig. 24.24) declares methods for managing communication with DeitelMessengerServer. We declare this interface to abstract the base functionality a client needs to interact with a chat server from the underlying communication mechanism. This abstraction enables us to provide MessageManager implementations that use other network protocols to implement the communication details. For example, if we wanted to connect to a different chat server that did not use multicast DatagramPackets, we could implement the MessageManager interface with the appropriate network protocols for this alternative messaging server. We would not need to modify any other code in the client, because the client's other components refer only to interface MessageManager, not a particular MessageManager implementation. Similarly, MessageManager methods refer to other components of the client only through interface MessageListener, so other client components can change without requiring changes in the MessageManager or its implementations. Method connect (line 10) connects a MessageManager to DeitelMessengerServer and routes incoming messages to the appropriate MessageListener. Method disconnect (line 14) disconnects a MessageManager from the DeitelMessengerServer and stops delivering messages to the given MessageListener. Method sendMessage (line 17) sends a new message to DeitelMessengerServer.

Class SocketMessageManager (Fig. 24.25) implements MessageManager (line 18), using Sockets and MulticastSockets to communicate with DeitelMessengerServer and receive incoming messages. Line 20 declares the Socket used to connect to and send messages to DeitelMessengerServer. Line 22 declares a PacketReceiver (Fig. 24.27) that listens for new incoming messages. The connected flag (line 23) indicates whether the SocketMessageManager is currently connected to DeitelMessengerServer.

Figure 24.25. SocketMessageManager implementation of interface MessageManager for communicating via Sockets and multicast DatagramPackets.

(This item is displayed on pages 1165 - 1167 in the print version)

The SocketMessageManager constructor (lines 2630) receives the address of the DeitelMessengerServer to which SocketMessageManager should connect. Method connect (lines 3352) connects SocketMessageManager to DeitelMessengerServer. If it was connected previously, line 36 returns from method connect. Lines 4041 create a new Socket to communicate with the server. Line 41 creates an InetAddress object for the server's address and uses the constant SERVER_PORT to specify the port on which the client should connect. Line 44 creates a new PacketReceiver, which listens for incoming multicast messages from the server, and line 45 executes the Runnable. Line 46 updates boolean variable connected to indicate that SocketMessageManager is connected to the server.

Method disconnect (lines 5584) terminates the SocketMessageManager's connection to the server. If SocketMessageManager is not connected, line 58 returns from method disconnect. Lines 6364 create a new MessageSender (Fig. 24.26) to send DISCONNECT_STRING to DeitelMessengerServer. Class MessageSender delivers a message to DeitelMessengerServer over the SocketMessageManager's Socket connection. Line 65 starts the MessageSender to deliver the message using method submit of the ExecutorService. This method returns a Future which represents the executing Runnable. Line 66 invokes Future method get to wait for the disconnect message to be delivered and the Runnable to terminate. Once the disconnect message has been delivered, line 67 invokes PacketReceiver method stopListening to stop receiving incoming chat messages. Line 68 closes the Socket connection to DeitelMessengerServer.

Figure 24.26. MessageSender for delivering outgoing messages to DeitelMessengerServer.

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

Method sendMessage (lines 8795) sends an outgoing message to the server. If SocketMessageManager is not connected, line 90 returns from method sendMessage. Lines 9394 create and start a new MessageSender (Fig. 24.26) to deliver the new message in a separate thread of execution.

Class MessageSender (Fig. 24.26), which implements Runnable, delivers outgoing messages to the server in a separate thread of execution. MessageSender's constructor (lines 1622) takes as arguments the Socket over which to send the message, the userName from whom the message came and the message. Line 21 concatenates these arguments to build messageToSend. Constant MESSAGE_SEPARATOR enables the message recipient to parse the message into two partsthe sending user's name and the message bodyby using a StringTokenizer.

Method run (lines 2538) delivers the complete message to the server, using the Socket provided to the MessageSender constructor. Lines 2930 create a new Formatter for the clientSocket's OutputStream. Line 31 invokes Formatter method format to send the message. Line 32 invokes method flush of class Formatter to ensure that the message is sent immediately. Note that class MessageSender does not close the clientSocket. Class SocketMessageManager uses a new object of class MessageSender for each message the client sends, so the clientSocket must remain open until the user disconnects from DeitelMessengerServer.

Class PacketReceiver (Fig. 24.27) implements interface Runnable to enable SocketMessageManager to listen for incoming messages in a separate thread of execution. Line 18 declares the MessageListener to which PacketReceiver will deliver incoming messages. Line 19 declares a MulticastSocket for receiving multicast DatagramPackets. Line 20 declares an InetAddress reference for the multicast address to which DeitelMessengerServer posts new chat messages. The MulticastSocket connects to this InetAddress to listen for incoming chat messages.

Figure 24.27. PacketReceiver for listening for new multicast messages from DeitelMessengerServer in a separate thread.

(This item is displayed on pages 1169 - 1171 in the print version)

The PacketReceiver constructor (lines 2346) takes as an argument the MessageListener to which the PacketReceiver is to deliver incoming messages. Recall that interface MessageListener declares method messageReceived. When the PacketReceiver receives a new chat message over the MulticastSocket, PacketReceiver invokes messageReceived to deliver the new message to the MessageListener.

Lines 3031 create a new MulticastSocket and pass to the MulticastSocket constructor the constant MULTICAST_LISTENING_PORT from interface SocketMessengerConstants. This argument specifies the port on which the MulticastSocket will listen for incoming chat messages. Line 34 creates an InetAddress object for the MULTICAST_ADDRESS, to which DeitelMessengerServer multicasts new chat messages. Line 37 invokes MulticastSocket method joinGroup to register the MulticastSocket to receive messages sent to MULTICAST_ADDRESS. Line 40 invokes MulticastSocket method setSoTimeout to specify that if no data is received in 5000 milliseconds, the MulticastSocket should issue an InterruptedIOException, which the current thread can catch, then continue executing. This approach prevents PacketReceiver from blocking indefinitely when waiting for incoming data. Also, if the MulticastSocket never timed out, the while loop would not be able to check the keepListening variable and would therefore prevent PacketReceiver from stopping if keepListening were set to false.

Method run (lines 49104) listens for incoming multicast messages. Lines 5859 create a DatagramPacket to store the incoming message. Line 63 invokes MulticastSocket method receive to read an incoming packet from the multicast address. If 5000 milliseconds pass without receipt of a packet, method receive throws an InterruptedIOException, because we previously set a 5000-millisecond time-out (line 40). Line 67 uses continue to proceed to the next loop iteration to listen for incoming messages. For other IOExceptions, line 72 breaks the while loop to terminate the PacketReceiver.

Line 76 invokes DatagramPacket method getdata to retrieve the message data. Line 78 invokes method trim of class String to remove extra white space from the end of the message. Recall that DatagramPackets are of a fixed size512 bytes in this exampleso, if the message is shorter than 512 bytes, there will be extra white space after it. Lines 8182 create a StringTokenizer to separate the message body from the name of the user who sent the message. Line 86 checks for the correct number of tokens. Lines 8991 invoke method messageReceived of interface MessageListener to deliver the incoming message to the PacketReceiver's MessageListener.

If the program invokes method stopListening (lines 107110), the while loop in method run (lines 49104) terminates. Line 97 invokes MulticastSocket method leaveGroup to stop receiving messages from the multicast address. Line 98 invokes MulticastSocket method close to close the MulticastSocket. When method run completes execution, the PacketReceiver terminates.

Class ClientGUI (Fig. 24.28) extends class JFrame to create a GUI for a user to send and receive chat messages. The GUI consists of a JTextArea for displaying incoming messages (line 31), a JTextArea for entering new messages (line 32), JButtons and JMenuItems for connecting to and disconnecting from the server (lines 3336) and a JButton for sending messages (line 37). The GUI also contains a JLabel that displays whether the client is connected or disconnected (line 38).

Figure 24.28. ClientGUI subclass of JFrame for presenting a GUI for viewing and sending chat messages.

(This item is displayed on pages 1172 - 1177 in the print version)

ClientGUI uses a MessageManager (line 40) to handle all communication with the chat server. Recall that MessageManager is an interface that enables ClientGUI to use any MessageManager implementation. Class ClientGUI also uses a MessageListener (line 41) to receive incoming messages from the MessageManager.

The ClientGUI constructor (lines 44160) takes as an argument the MessageManager for communicating with DeitelMessengerServer. Line 48 sets the ClientGUI's MessageManager. Line 51 creates an instance of MyMessageListener, which implements interface MessageListener. Lines 5357 create a Server menu that contains JMenuItems for connecting to and disconnecting from the chat server. Lines 6061 create an ImageIcon for connectButton and connectMenuItem.

Lines 6465 create connectButton and connectMenuItem, each with the label "Connect" and the Icon connectIcon. Line 66 invokes method setMnemonic to set the mnemonic character for keyboard access to connectMenuItem. Line 69 creates an instance of inner class ConnectListener (declared at lines 163185), which implements interface ActionListener to handle ActionEvents from connectButton and connectMenuItem. Lines 7071 add connectListener as an ActionListener for connectButton and connectMenuItem.

Lines 7475 create an ImageIcon for the disconnectButton and disconnectMenuItem components. Lines 7879 create disconnectButton and disconnectMenuItem, each with the label "Disconnect" and the Icon disconnectIcon. Line 80 invokes method setMnemonic to enable keyboard access to disconnectMenuItem. Lines 8384 invoke method setEnabled with a false argument on disconnectButton and disconnectMenuItem to disable these components. This prevents the user from attempting to disconnect from the server because the client is not yet connected. Line 87 creates an instance of inner class DisconnectListener (declared at lines 189204), which implements interface ActionListener to handle ActionEvents from disconnectButton and disconnectMenuItem. Lines 8889 add disconnectListener as an ActionListener for disconnectButton and disconnectMenuItem.

Lines 9293 add connectMenuItem and disconnectMenuItem to menu Server. Lines 9698 create a JPanel and add connectButton and disconnectButton to it. Line 100 creates the textarea messageArea, in which the client displays incoming messages. Line 101 invokes method setEditable with a false argument, to disable editing. Lines 102103 invoke JTextArea methods setWrapStyleWord and setLineWrap to enable word wrapping in messageArea. If a message is longer than messageArea's width, the messageArea will wrap the text after the last word that fits on each line, making longer messages easier to read. Lines 106109 create a JPanel for the messageArea and add the messageArea to the JPanel in a JScrollPane.

Line 111 creates the inputArea JTextArea for entering new messages. Lines 112113 enable word and line wrapping, and line 114 disables editing the inputArea. When the client connects to the chat server, ConnectListener enables the inputArea to allow the user to type new messages.

Lines 117118 create an ImageIcon for sendButton. Line 120 creates sendButton, which the user can click to send a message. Line 121 disables sendButtonthe ConnectListener enables the sendButton when the client connects to the chat server. Lines 122133 add an ActionListener to sendButton. Lines 128129 invoke method sendMessage of interface MessageManager with the userName and inputArea text as arguments. This statement sends the user's name and message as a new chat message to DeitelMessengerServer. Line 130 clears the inputArea for the next message.

Lines 135138 use a horizontal Box container to arrange components inputArea and sendButton. Line 136 places inputArea in a JScrollPane to enable scrolling of long messages. Line 138 adds the Box containing inputArea and sendButton to the SOUTH region of messagePanel. Line 141 creates the statusBar JLabel. This label displays whether the client is connected to or disconnected from the chat server. Line 142 invokes method setBorder of class JLabel and creates a new BevelBorder of type BevelBorder.LOWERED. This border makes the label appear recessed, as is common with status bars in many applications. Lines 144146 add buttonPanel, messagePanel and statusBar to the ClientGUI.

Lines 149159 add a WindowListener to the ClientGUI. Line 155 invokes method disconnect of interface MessageManager to disconnect from the chat server in case the user quits while still connected. Then line 156 terminates the application.

Inner class ConnectListener (lines 163185) handles events from connectButton and connectMenuItem. Line 169 invokes MessageManager method connect to connect to the chat server. Line 169 passes as an argument to method connect the MessageListener to which new messages should be delivered. Lines 172173 prompt the user for a user name, and line 175 clears the messageArea. Lines 176181 enable the components for disconnecting from the server and for sending messages and disable the components for connecting to the server. Line 182 invokes inputArea's requestFocus method (inherited from class Component) to place the text-input cursor in the inputArea so that the user can immediately begin typing a message.

Inner class DisconnectListener (lines 189204) handles events from disconnectButton and disconnectMenuItem. Line 195 invokes MessageManager method disconnect to disconnect from the chat server. Lines 196201 disable the components for sending messages and the components for disconnecting, then enable the components for connecting to the chat server.

Inner class MyMessageListener (lines 208217) implements interface MessageListener to receive incoming messages from the MessageManager. When a new message is received, the MessageManager invokes method messageReceived (lines 211216) with the user name of the sender and the message body. Lines 214215 invoke SwingUtilities method invokeLater with a MessageDisplayer object that appends the new message to messageArea. Recall, from Chapter 23, that Swing components should be accessed only from the event-dispatch thread. Method messageReceived is invoked by the PacketReceiver in class SocketMessageManager and therefore cannot append the message text to messageArea directly, as this would occur in PacketReceiver, not the event-dispatch thread.

Inner class MessageDisplayer (lines 221239) implements interface Runnable to provide a thread-safe way to append text to the messageArea. The MessageDisplayer constructor (lines 227231) takes as arguments the user name and the message to send. Method run (lines 234238) appends the user name, "> " and messageBody to messageArea.

Class DeitelMessenger (Fig. 24.29) launches the client for the DeitelMessengerServer. Lines 1520 create a new SocketMessageManager to connect to the DeitelMessengerServer with the IP address specified as a command-line argument to the application (or localhost, if no address is provided). Lines 2326 create a ClientGUI for the MessageManager, set the ClientGUI size and make the ClientGUI visible.

Figure 24.29. DeitelMessenger application for participating in a DeitelMessengerServer chat session.

(This item is displayed on pages 1179 - 1180 in the print version)

Executing the DeitelMessenger Client Application

To execute the DeitelMessenger client, open a command window and change directories to the location in which package com.deitel.messenger.sockets.client resides (i.e., the directory in which com is located). Then type

java com.deitel.messenger.sockets.client.DeitelMessenger

to execute the client and connect to the DeitelMessengerServer running on your local computer. If the server resides on another computer, follow the preceding command with the hostname or IP address of that computer. The preceding command is equivalent to

java com.deitel.messenger.sockets.client.DeitelMessenger localhost

or

java com.deitel.messenger.sockets.client.DeitelMessenger 127.0.0.1

Deitel Messenger Case Study Summary

The Deitel messenger case study is a significant application that uses many intermediate Java features, such as networking with Sockets, DatagramPackets and MulticastSockets, multithreading and Swing GUI. The case study also demonstrates good software engineering practices by separating interface from implementation, enabling developers to build MessageManagers for different network protocols and MessageListeners that provide different user interfaces. You should now be able to apply these techniques to your own, more complex, Java projects.