// This file contains material supporting section 3.8 of the textbook:// "Object Oriented Software Engineering" and is issued under the open-source// license found at www.lloseng.compackage ocsf.server;import java.io.*;import java.net.*;import java.util.*;/*** An instance of this class is created by the server when a client* connects. It accepts messages coming from the client and is* responsible for sending data to the client since the socket is* private to this class. The AbstractServer contains a set of* instances of this class and is responsible for adding and deleting* them.<p>** Project Name: OCSF (Object Client-Server Framework)<p>** @author Dr Robert Lagani&egrave;re* @author Dr Timothy C. Lethbridge* @author Fran&ccedil;ois B&eacute;langer* @author Paul Holden* @version February 2001 (2.12)*/public class ConnectionToClient extends Thread{// INSTANCE VARIABLES ***********************************************  /**  * A reference to the Server that created this instance.  */  private AbstractServer server;  /**  * Sockets are used in the operating system as channels  * of communication between two processes.  * @see java.net.Socket  */  private Socket clientSocket;  /**  * Stream used to read from the client.  */  private ObjectInputStream input;  /**  * Stream used to write to the client.  */  private ObjectOutputStream output;  /**  * Indicates if the thread is ready to stop. Set to true when closing  * of the connection is initiated.  */  private boolean readyToStop;  /**   * Map to save information about the client such as its login ID.   * The initial size of the map is small since it is not expected   * that concrete servers will want to store many different types of   * information about each client. Used by the setInfo and getInfo   * methods.   */  private HashMap savedInfo = new HashMap(10);// CONSTRUCTORS *****************************************************  /**   * Constructs a new connection to a client.   *   * @param group the thread group that contains the connections.   * @param clientSocket contains the client's socket.   * @param server a reference to the server that created   *        this instance   * @exception IOException if an I/O error occur when creating   *        the connection.   */  ConnectionToClient(ThreadGroup group, Socket clientSocket,    AbstractServer server) throws IOException  {    super(group,(Runnable)null);    // Initialize variables    this.clientSocket = clientSocket;    this.server = server;    clientSocket.setSoTimeout(0); // make sure timeout is infinite    //Initialize the objects streams    try    {      input = new ObjectInputStream(clientSocket.getInputStream());      output = new ObjectOutputStream(clientSocket.getOutputStream());    }    catch (IOException ex)    {      try      {        closeAll();      }      catch (Exception exc) { }      throw ex;  // Rethrow the exception.    }    readyToStop = false;    start(); // Start the thread waits for data from the socket  }// INSTANCE METHODS *************************************************  /**   * Sends an object to the client.   *   * @param msg the message to be sent.   * @exception IOException if an I/O error occur when sending the   *    message.   */  final public void sendToClient(Object msg) throws IOException  {    if (clientSocket == null || output == null)      throw new SocketException("socket does not exist");    output.writeObject(msg);  }  /**   * Closes the client.   * If the connection is already closed, this   * call has no effect.   *   * @exception IOException if an error occurs when closing the socket.   */  final public void close() throws IOException  {    readyToStop = true; // Set the flag that tells the thread to stop    try    {      closeAll();    }    finally    {      server.clientDisconnected(this);    }  }// ACCESSING METHODS ------------------------------------------------  /**   * Returns the address of the client.   *   * @return the client's Internet address.   */  final public InetAddress getInetAddress()  {    return clientSocket == null ? null : clientSocket.getInetAddress();  }  /**   * Returns a string representation of the client.   *   * @return the client's description.   */  public String toString()  {    return clientSocket == null ? null :      clientSocket.getInetAddress().getHostName()        +" (" + clientSocket.getInetAddress().getHostAddress() + ")";  }  /**   * Saves arbitrary information about this client. Designed to be   * used by concrete subclasses of AbstractServer. Based on a hash map.   *   * @param infoType   identifies the type of information   * @param info       the information itself.   */  public void setInfo(String infoType, Object info)  {    savedInfo.put(infoType, info);  }  /**   * Returns information about the client saved using setInfo.   * Based on a hash map.   *   * @param infoType   identifies the type of information   */  public Object getInfo(String infoType)  {    return savedInfo.get(infoType);  }// RUN METHOD -------------------------------------------------------  /**   * Constantly reads the client's input stream.   * Sends all objects that are read to the server.   * Not to be called.   */  final public void run()  {    server.clientConnected(this);    // This loop reads the input stream and responds to messages    // from clients    try    {      // The message from the client      Object msg;      while (!readyToStop)      {        // This block waits until it reads a message from the client        // and then sends it for handling by the server        msg = input.readObject();        server.receiveMessageFromClient(msg, this);      }    }    catch (Exception exception)    {      if (!readyToStop)      {        try        {          closeAll();        }        catch (Exception ex) { }        server.clientException(this, exception);      }    }  }// METHODS TO BE USED FROM WITHIN THE FRAMEWORK ONLY ----------------  /**   * Closes all connection to the server.   *   * @exception IOException if an I/O error occur when closing the   *     connection.   */  private void closeAll() throws IOException  {    try    {      // Close the socket      if (clientSocket != null)        clientSocket.close();      // Close the output stream      if (output != null)        output.close();      // Close the input stream      if (input != null)        input.close();    }    finally    {      // Set the streams and the sockets to NULL no matter what      // Doing so allows, but does not require, any finalizers      // of these objects to reclaim system resources if and      // when they are garbage collected.      output = null;      input = null;      clientSocket = null;    }  }  /**   * This method is called by garbage collection.   */  protected void finalize()  {    try    {      closeAll();    }    catch(IOException e) {}  }}// End of ConnectionToClient class