socketmessagemanager2.java

这是java的一本书上的源代码

// SocketMessageManager2.java
// SocketMessageManager2 is a class for objects capable of managing
// communications with a message server.
package com.deitel.messenger.sockets.client;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.net.*;
import java.util.*;

import com.deitel.messenger.*;

public class SocketMessageManager2 implements MessageManager {   
   private SocketChannel socketChannel;
   private MessageListener messageListener;
   private String serverAddress;
   private ReceivingThread receiveMessage;
   private boolean connected;
   private Charset charSet = Charset.forName( "UTF-8" );
   private ByteBuffer writeBuffer;
   private ByteBuffer readBuffer = ByteBuffer.allocate( 512 );

   public SocketMessageManager2( String host )
   {
      serverAddress = host;
      connected = false;
   }
   
   // connect to message server and start receiving message
   public void connect( MessageListener listener )
   {
      messageListener = listener;

      // connect to server and start thread to receive message
      try {

         // create SocketChannel to make connection to server
         socketChannel = SocketChannel.open();
         socketChannel.connect( new InetSocketAddress(
               InetAddress.getByName( serverAddress ), 12345 ) );

         // start ReceivingThread to receive messages sent by server
         receiveMessage = new ReceivingThread();
         receiveMessage.start();

         connected = true;
      }
	  catch ( Exception exception ) {
         exception.printStackTrace();
      }
   }
   
   // disconnect from message server and stop receiving message
   public void disconnect( MessageListener listener )
   {
      if ( connected ) {

         // send disconnect request and stop receiving
         try {
            sendMessage( "", "Disconnect" );

            connected = false;

            // send interrupt signal to receiving thread
            receiveMessage.interrupt();
         }
	     catch ( Exception exception ) {
            exception.printStackTrace();
         }
      }
   }
   
   // send message to message server
   public void sendMessage( String userName, String messageBody ) 
   {
      String message = userName + "> " + messageBody;

      // send message to server
      try {
         writeBuffer = charSet.encode( message );
         socketChannel.write( writeBuffer );
      }
      catch ( IOException ioException ) {
         ioException.printStackTrace();

         try {
            socketChannel.close();
         }
         catch ( IOException exception ) {
            exception.printStackTrace();
         }
      }

   } // end method sendMessage

   public class ReceivingThread extends Thread 
   {
      public void run() 
      {
         int messageLength = 0;
         String message = "";

         // read messages until server close the connection
         try {

            // process messages sent from server
            do {
               readBuffer.clear();
               socketChannel.read( readBuffer );
               readBuffer.flip();
               CharBuffer charMessage = charSet.decode( readBuffer );
               message = charMessage.toString().trim();

               // tokenize message to retrieve user name and message body
               StringTokenizer tokenizer = 
                  new StringTokenizer( message, ">" );

               // ignore messages that do not contain a user 
               // name and message body
               if ( tokenizer.countTokens() == 2 ) 

                  // send message to MessageListener
                  messageListener.messageReceived( 
                     tokenizer.nextToken(),   // user name
                     tokenizer.nextToken() ); // message body

            } while ( true );  // keep receiving messages

         } // end try

         // catch problems reading from server
         catch ( IOException ioException ) {
            if ( ioException instanceof ClosedByInterruptException )
               System.out.println( "socket channel closed" );
            else {
               ioException.printStackTrace();

               try {
                  socketChannel.close();
                  System.out.println( "socket channel closed" );
               }
               catch ( IOException exception ) {
                  exception.printStackTrace();
               }
            }

         } // end catch

      } // end method run

   } // end inner class ReceivingThread

} // end class SocketMessageManager2


/**************************************************************************
 * (C) Copyright 1992-2003 by Deitel & Associates, Inc. and               *
 * Prentice Hall. All Rights Reserved.                                    *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/