socketlistclient.java

JAVA网络编程技术内幕一书的源代码

/*
 * Java Network Programming, Second Edition
 * Merlin Hughes, Michael Shoffner, Derek Hamner
 * Manning Publications Company; ISBN 188477749X
 *
 * http://nitric.com/jnp/
 *
 * Copyright (c) 1997-1999 Merlin Hughes, Michael Shoffner, Derek Hamner;
 * all rights reserved; see license.txt for details.
 */

import java.io.*;
import java.net.*;
import java.util.*;

public class SocketListClient implements DistributedList, Runnable {
  protected String host;
  protected int port;
  protected IDList idList;
  
  public SocketListClient (String host, int port) {
    this.host = host;
    this.port = port;
    idList = new IDList ();
  }

  protected Thread listener;
  protected ObjectInputStream objectIn;
  protected ObjectOutputStream objectOut;
  
  public synchronized void start () throws IOException {
    if (listener == null) {
      Socket socket = new Socket (host, port);
      try {
        objectOut = new ObjectOutputStream
          (new BufferedOutputStream (socket.getOutputStream ()));
        objectOut.flush ();
        objectIn = new ObjectInputStream (
          new BufferedInputStream (socket.getInputStream ()));
      } catch (IOException ex) {
        socket.close ();
        throw ex;
      }
      listener = new Thread (this);
      listener.start ();
    }
  }

  public synchronized void stop () throws IOException {
    if (listener != null) {
      if (listener != Thread.currentThread ())
        listener.interrupt ();
      listener = null;
      try {
        objectOut.writeObject (new QuitMsg ());
        objectOut.flush ();
      } finally {
        objectOut.close ();
      }
    }
  }

  public void run () {
    try {
      execute ();
    } catch (IOException ex) {
      if (listener == Thread.currentThread ())
        ex.printStackTrace ();
    } catch (ClassNotFoundException ex) {
      ex.printStackTrace ();
    } finally {
      try {
        stop ();
      } catch (IOException ignored) {
      }
    }
  }

  protected void execute () throws IOException, ClassNotFoundException {
    Thread myself = Thread.currentThread ();
    while (listener == myself) {
      IDListMsg msg = (IDListMsg) objectIn.readObject ();
      if (msg instanceof InitMsg) {
        InitMsg initMsg = (InitMsg) msg;
        idList = initMsg.getIDList ();
        fireChangeEvent (new ChangeEvent (this));
      } else if (msg instanceof ElementAddedMsg) {
        ElementAddedMsg addedMsg = (ElementAddedMsg) msg;
        idList.addElement (addedMsg.getID (), addedMsg.getElement ());
        fireChangeEvent (new ChangeEvent (this));
      } else if (msg instanceof ElementUpdatedMsg) {
        ElementUpdatedMsg updatedMsg = (ElementUpdatedMsg) msg;
        idList.replaceElement (updatedMsg.getOldID (), updatedMsg.getID (),
                               updatedMsg.getElement ());
        fireChangeEvent (new ChangeEvent (this));
      } else if (msg instanceof ElementReplacedMsg) {
        ElementReplacedMsg replacedMsg = (ElementReplacedMsg) msg;
        idList.replaceElement (replacedMsg.getOldID (), replacedMsg.getID (),
                               replacedMsg.getElement ());
        fireChangeEvent (new ChangeEvent (this));
      } else if (msg instanceof ElementRemovedMsg) {
        ElementRemovedMsg removedMsg = (ElementRemovedMsg) msg;
        idList.removeElement (removedMsg.getID ());
        fireChangeEvent (new ChangeEvent (this));
      } else {
        throw new IOException ("Unknown message " + msg);
      }
    }
  }

  public synchronized void addElement (Object element) {
    if (listener != null) {
      try {
        objectOut.writeObject (new AddElementMsg (element));
        objectOut.flush ();
      } catch (IOException ignored) {
        try {
          stop ();
        } catch (IOException ignored2) {
        }
      }
    }
  }

  public synchronized void updateElement
  (Object oldElement, Object newElement) {
    if (listener != null) {
      ID id = idList.getID (oldElement);
      if (id != null) {
        try {
          objectOut.writeObject (new UpdateElementMsg (id, newElement));
          objectOut.flush ();
        } catch (IOException ignored) {
          try {
            stop ();
          } catch (IOException ignored2) {
          }
        }
      }
    }
  }

  public synchronized void replaceElement
  (Object oldElement, Object newElement) {
    if (listener != null) {
      ID id = idList.getID (oldElement);
      if (id != null) {
        try {
          objectOut.writeObject (new ReplaceElementMsg (id, newElement));
          objectOut.flush ();
        } catch (IOException ignored) {
          try {
            stop ();
          } catch (IOException ignored2) {
          }
        }
      }
    }
  }

  public synchronized void removeElement (Object element) {
    if (listener != null) {
      ID id = idList.getID (element);
      if (id != null) {
        try {
          objectOut.writeObject (new RemoveElementMsg (id));
          objectOut.flush ();
        } catch (IOException ignored) {
          try {
            stop ();
          } catch (IOException ignored2) {
          }
        }
      }
    }
  }

  public Enumeration getElements () {
    return idList.getElements ();
  }

  protected Vector listeners = new Vector ();
  
  public void addChangeListener (ChangeListener listener) {
    listeners.addElement (listener);
  }

  public void removeChangeListener (ChangeListener listener) {
    listeners.removeElement (listener);
  }

  protected void fireChangeEvent (ChangeEvent changeEvent) {
    Vector listeners = (Vector) this.listeners.clone ();
    for (int i = 0; i < listeners.size (); ++ i)
      ((ChangeListener) listeners.elementAt (i)).changeOccurred (changeEvent);
  }
}