socket长连接的维持

长连接的维持，是要客户端程序，定时向服务端程序，发送一个维持连接包的。
如果，长时间未发送维持连接包，服务端程序将断开连接。

客户端：
通过持有Client对象，可以随时（使用sendObject方法）发送Object给服务端。
如果keepAliveDelay毫秒（程序中是2秒）内未发送任何数据，则，自动发送一个KeepAlive对象给服务端，
用于维持连接。
由于，我们向服务端，可以发送很多不同的对象， 服务端也可以返回不同的对象 。
所以，对于返回对象的处理，要编写具体的ObjectAction实现类进行处理。
通过Client.addActionMap方法进行添加。这样，程序会回调处理。

服务端：
由于客户端会定时（keepAliveDelay毫秒）发送维持连接的信息过来，所以，服务端要有一个检测机制。
即当服务端receiveTimeDelay毫秒（程序中是3秒）内未接收任何数据，则，自动断开与客户端的连接。
ActionMapping的原理与客户端相似（相同）。

通过添加相应的ObjectAction实现类，可以实现不同对象的响应、应答过程。

import  java.io.Serializable;

import  java.text.SimpleDateFormat;

import  java.util.Date;

 

/**

  * 维持连接的消息对象。

  * <p>

  * 创建时间：2010-7-18 上午12:22:09

  * @author HouLei

  * @since 1.0

  */

public  class  KeepAlive  implements  Serializable{

 

     private  static  final  long  serialVersionUID = -2813120366138988480L;

 

     /* 覆盖该方法，仅用于测试使用。

      * @see java.lang.Object#toString()

      */

     @Override

     public  String toString() {

         return  new  SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ).format( new  Date())+ "\t维持连接包" ;

     }

 

}

import  java.io.IOException;

import  java.io.InputStream;

import  java.io.ObjectInputStream;

import  java.io.ObjectOutputStream;

import  java.net.Socket;

import  java.net.UnknownHostException;

import  java.util.concurrent.ConcurrentHashMap;

 

/**

  *    C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。

  * <p>

  * 创建时间：2010-7-18 上午12:17:25

  * @author HouLei

  * @since 1.0

  */

public  class  Client {

 

     /**

      * 处理服务端发回的对象，可实现该接口。

      */

     public  static  interface  ObjectAction{

         void  doAction(Object obj,Client client);

     }

     public  static  final  class  DefaultObjectAction  implements  ObjectAction{

         public  void  doAction(Object obj,Client client) {

             System.out.println( "处理：\t" +obj.toString());

         }

     }

     public  static  void  main(String[] args)  throws  UnknownHostException, IOException {

         String serverIp =  "127.0.0.1" ;

         int  port =  65432 ;

         Client client =  new  Client(serverIp,port);

         client.start();

     }

     

     private  String serverIp;

     private  int  port;

     private  Socket socket;

     private  boolean  running= false ;

     private  long  lastSendTime;

     private  ConcurrentHashMap<Class, ObjectAction> actionMapping =  new  ConcurrentHashMap<Class,ObjectAction>();

     

     public  Client(String serverIp,  int  port) {

         this .serverIp=serverIp; this .port=port;

     }

     

     public  void  start()  throws  UnknownHostException, IOException {

         if (running) return ;

         socket =  new  Socket(serverIp,port);

         System.out.println( "本地端口：" +socket.getLocalPort());

         lastSendTime=System.currentTimeMillis();

         running= true ;

         new  Thread( new  KeepAliveWatchDog()).start();

         new  Thread( new  ReceiveWatchDog()).start();

     }

     

     public  void  stop(){

         if (running)running= false ;

     }

     

     /**

      * 添加接收对象的处理对象。

      * @param cls 待处理的对象，其所属的类。

      * @param action 处理过程对象。

      */

     public  void  addActionMap(Class<Object> cls,ObjectAction action){

         actionMapping.put(cls, action);

     }

 

     public  void  sendObject(Object obj)  throws  IOException {

         ObjectOutputStream oos =  new  ObjectOutputStream(socket.getOutputStream());

         oos.writeObject(obj);

         System.out.println( "发送：\t" +obj);

         oos.flush();

     }

     

     class  KeepAliveWatchDog  implements  Runnable{

         long  checkDelay =  10 ;

         long  keepAliveDelay =  2000 ;

         public  void  run() {

             while (running){

                 if (System.currentTimeMillis()-lastSendTime>keepAliveDelay){

                     try  {

                         Client. this .sendObject( new  KeepAlive());

                     }  catch  (IOException e) {

                         e.printStackTrace();

                         Client. this .stop();

                     }

                     lastSendTime = System.currentTimeMillis();

                 } else {

                     try  {

                         Thread.sleep(checkDelay);

                     }  catch  (InterruptedException e) {

                         e.printStackTrace();

                         Client. this .stop();

                     }

                 }

             }

         }

     }

     

     class  ReceiveWatchDog  implements  Runnable{

         public  void  run() {

             while (running){

                 try  {

                     InputStream in = socket.getInputStream();

                     if (in.available()> 0 ){

                         ObjectInputStream ois =  new  ObjectInputStream(in);

                         Object obj = ois.readObject();

                         System.out.println( "接收：\t" +obj);

                         ObjectAction oa = actionMapping.get(obj.getClass());

                         oa = oa== null ? new  DefaultObjectAction():oa;

                         oa.doAction(obj, Client. this );

                     } else {

                         Thread.sleep( 10 );

                     }

                 }  catch  (Exception e) {

                     e.printStackTrace();

                     Client. this .stop();

                 } 

             }

         }

     }

     

}

import  java.io.IOException;

import  java.io.InputStream;

import  java.io.ObjectInputStream;

import  java.io.ObjectOutputStream;

import  java.net.ServerSocket;

import  java.net.Socket;

import  java.util.concurrent.ConcurrentHashMap;

 

/**

  * C/S架构的服务端对象。

  * <p>

  * 创建时间：2010-7-18 上午12:17:37

  * @author HouLei

  * @since 1.0

  */

public  class  Server {

 

     /**

      * 要处理客户端发来的对象，并返回一个对象，可实现该接口。

      */

     public  interface  ObjectAction{

         Object doAction(Object rev);

     }

     

     public  static  final  class  DefaultObjectAction  implements  ObjectAction{

         public  Object doAction(Object rev) {

             System.out.println( "处理并返回：" +rev);

             return  rev;

         }

     }

     

     public  static  void  main(String[] args) {

         int  port =  65432 ;

         Server server =  new  Server(port);

         server.start();

     }

     

     private  int  port;

     private  volatile  boolean  running= false ;

     private  long  receiveTimeDelay= 3000 ;

     private  ConcurrentHashMap<Class, ObjectAction> actionMapping =  new  ConcurrentHashMap<Class,ObjectAction>();

     private  Thread connWatchDog;

     

     public  Server( int  port) {

         this .port = port;

     }

 

     public  void  start(){

         if (running) return ;

         running= true ;

         connWatchDog =  new  Thread( new  ConnWatchDog());

         connWatchDog.start();

     }

     

     @SuppressWarnings ( "deprecation" )

     public  void  stop(){

         if (running)running= false ;

         if (connWatchDog!= null )connWatchDog.stop();

     }

     

     public  void  addActionMap(Class<Object> cls,ObjectAction action){

         actionMapping.put(cls, action);

     }

     

     class  ConnWatchDog  implements  Runnable{

         public  void  run(){

             try  {

                 ServerSocket ss =  new  ServerSocket(port, 5 );

                 while (running){

                     Socket s = ss.accept();

                     new  Thread( new  SocketAction(s)).start();

                 }

             }  catch  (IOException e) {

                 e.printStackTrace();

                 Server. this .stop();

             }

             

         }

     }

     

     class  SocketAction  implements  Runnable{

         Socket s;

         boolean  run= true ;

         long  lastReceiveTime = System.currentTimeMillis();

         public  SocketAction(Socket s) {

             this .s = s;

         }

         public  void  run() {

             while (running && run){

                 if (System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){

                     overThis();

                 } else {

                     try  {

                         InputStream in = s.getInputStream();

                         if (in.available()> 0 ){

                             ObjectInputStream ois =  new  ObjectInputStream(in);

                             Object obj = ois.readObject();

                             lastReceiveTime = System.currentTimeMillis();

                             System.out.println( "接收：\t" +obj);

                             ObjectAction oa = actionMapping.get(obj.getClass());

                             oa = oa== null ? new  DefaultObjectAction():oa;

                             Object out = oa.doAction(obj);

                             if (out!= null ){

                                 ObjectOutputStream oos =  new  ObjectOutputStream(s.getOutputStream());

                                 oos.writeObject(out);

                                 oos.flush();

                             }

                         } else {

                             Thread.sleep( 10 );

                         }

                     }  catch  (Exception e) {

                         e.printStackTrace();

                         overThis();

                     } 

                 }

             }

         }

         

         private  void  overThis() {

             if (run)run= false ;

             if (s!= null ){

                 try  {

                     s.close();

                 }  catch  (IOException e) {

                     e.printStackTrace();

                 }

             }

             System.out.println( "关闭：" +s.getRemoteSocketAddress());

         }

         

     }

     

}