• 心跳包的长连接

    网上有用实例小文章！

    心跳： 
    socket模拟网页的报文连接某个网站，创建tcp的socket后，当我socket.connect后，如果在5到7秒钟不socket.send，那么这个链接就失效了。 请问如何长时间的保持这个链接 
    这是在服务器端的设置的，客户端没法设置,可以发送心跳包。 
    socket.connect后，每3-4秒用socket.send发送一字节数据（内容随便），然后观查这个连接是否保持。 

    lientSocket=serverSocket.accept(); 
    OutputStream os = clientSocket.getOutputStream();           
    ObjectOutputStream oos=new ObjectOutputStream(os); 
    oos.writeObject(al); 
    oos.flush(); 
    oos.close()//socket会关闭 

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

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

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


    Java代码  收藏代码
    1. package houlei.csdn.keepalive;  
    2.   
    3. import java.io.Serializable;  
    4. import java.text.SimpleDateFormat;  
    5. import java.util.Date;  
    6.   
    7. /** 
    8.  * 维持连接的消息对象。 
    9.  */  
    10. public class KeepAlive implements Serializable{  
    11.   
    12.     private static final long serialVersionUID = -2813120366138988480L;  
    13.   
    14.     /* 覆盖该方法，仅用于测试使用。 
    15.      * @see java.lang.Object#toString() 
    16.      */  
    17.     @Override  
    18.     public String toString() {  
    19.         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" 维持连接包";  
    20.     }  
    21.   
    22. }  



    client: 

    Java代码  收藏代码
    1. package houlei.csdn.keepalive;  
    2.   
    3. import java.io.IOException;  
    4. import java.io.InputStream;  
    5. import java.io.ObjectInputStream;  
    6. import java.io.ObjectOutputStream;  
    7. import java.net.Socket;  
    8. import java.net.UnknownHostException;  
    9. import java.util.concurrent.ConcurrentHashMap;  
    10.   
    11. /** 
    12.  *  C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。 
    13.  */  
    14. public class Client {  
    15.   
    16.     /** 
    17.      * 处理服务端发回的对象，可实现该接口。 
    18.      */  
    19.     public static interface ObjectAction{  
    20.         void doAction(Object obj,Client client);  
    21.     }  
    22.     public static final class DefaultObjectAction implements ObjectAction{  
    23.         public void doAction(Object obj,Client client) {  
    24.             System.out.println("处理： "+obj.toString());  
    25.         }  
    26.     }  
    27.     public static void main(String[] args) throws UnknownHostException, IOException {  
    28.         String serverIp = "127.0.0.1";  
    29.         int port = 65432;  
    30.         Client client = new Client(serverIp,port);  
    31.         client.start();  
    32.     }  
    33.       
    34.     private String serverIp;  
    35.     private int port;  
    36.     private Socket socket;  
    37.     private boolean running=false;  
    38.     private long lastSendTime;  
    39.     private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();  
    40.       
    41.     public Client(String serverIp, int port) {  
    42.         this.serverIp=serverIp;this.port=port;  
    43.     }  
    44.       
    45.     public void start() throws UnknownHostException, IOException {  
    46.         if(running)return;  
    47.         socket = new Socket(serverIp,port);  
    48.         System.out.println("本地端口："+socket.getLocalPort());  
    49.         lastSendTime=System.currentTimeMillis();  
    50.         running=true;  
    51.         new Thread(new KeepAliveWatchDog()).start();  
    52.         new Thread(new ReceiveWatchDog()).start();  
    53.     }  
    54.       
    55.     public void stop(){  
    56.         if(running)running=false;  
    57.     }  
    58.       
    59.     /** 
    60.      * 添加接收对象的处理对象。 
    61.      * @param cls 待处理的对象，其所属的类。 
    62.      * @param action 处理过程对象。 
    63.      */  
    64.     public void addActionMap(Class<Object> cls,ObjectAction action){  
    65.         actionMapping.put(cls, action);  
    66.     }  
    67.   
    68.     public void sendObject(Object obj) throws IOException {  
    69.         ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());  
    70.         oos.writeObject(obj);  
    71.         System.out.println("发送： "+obj);  
    72.         oos.flush();  
    73.     }  
    74.       
    75.     class KeepAliveWatchDog implements Runnable{  
    76.         long checkDelay = 10;  
    77.         long keepAliveDelay = 2000;  
    78.         public void run() {  
    79.             while(running){  
    80.                 if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){  
    81.                     try {  
    82.                         Client.this.sendObject(new KeepAlive());  
    83.                     } catch (IOException e) {  
    84.                         e.printStackTrace();  
    85.                         Client.this.stop();  
    86.                     }  
    87.                     lastSendTime = System.currentTimeMillis();  
    88.                 }else{  
    89.                     try {  
    90.                         Thread.sleep(checkDelay);  
    91.                     } catch (InterruptedException e) {  
    92.                         e.printStackTrace();  
    93.                         Client.this.stop();  
    94.                     }  
    95.                 }  
    96.             }  
    97.         }  
    98.     }  
    99.       
    100.     class ReceiveWatchDog implements Runnable{  
    101.         public void run() {  
    102.             while(running){  
    103.                 try {  
    104.                     InputStream in = socket.getInputStream();  
    105.                     if(in.available()>0){  
    106.                         ObjectInputStream ois = new ObjectInputStream(in);  
    107.                         Object obj = ois.readObject();  
    108.                         System.out.println("接收： "+obj);  
    109.                         ObjectAction oa = actionMapping.get(obj.getClass());  
    110.                         oa = oa==null?new DefaultObjectAction():oa;  
    111.                         oa.doAction(obj, Client.this);  
    112.                     }else{  
    113.                         Thread.sleep(10);  
    114.                     }  
    115.                 } catch (Exception e) {  
    116.                     e.printStackTrace();  
    117.                     Client.this.stop();  
    118.                 }   
    119.             }  
    120.         }  
    121.     }  
    122.       
    123. }  



    server: 

    Java代码  收藏代码
      1. package houlei.csdn.keepalive;  
      2.   
      3.   
      4. import java.io.IOException;  
      5. import java.io.InputStream;  
      6. import java.io.ObjectInputStream;  
      7. import java.io.ObjectOutputStream;  
      8. import java.net.ServerSocket;  
      9. import java.net.Socket;  
      10. import java.util.concurrent.ConcurrentHashMap;  
      11.   
      12. /** 
      13.  * C/S架构的服务端对象。 
      14.  */  
      15. public class Server {  
      16.   
      17.     /** 
      18.      * 要处理客户端发来的对象，并返回一个对象，可实现该接口。 
      19.      */  
      20.     public interface ObjectAction{  
      21.         Object doAction(Object rev);  
      22.     }  
      23.       
      24.     public static final class DefaultObjectAction implements ObjectAction{  
      25.         public Object doAction(Object rev) {  
      26.             System.out.println("处理并返回："+rev);  
      27.             return rev;  
      28.         }  
      29.     }  
      30.       
      31.     public static void main(String[] args) {  
      32.         int port = 65432;  
      33.         Server server = new Server(port);  
      34.         server.start();  
      35.     }  
      36.       
      37.     private int port;  
      38.     private volatile boolean running=false;  
      39.     private long receiveTimeDelay=3000;  
      40.     private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();  
      41.     private Thread connWatchDog;  
      42.       
      43.     public Server(int port) {  
      44.         this.port = port;  
      45.     }  
      46.   
      47.     public void start(){  
      48.         if(running)return;  
      49.         running=true;  
      50.         connWatchDog = new Thread(new ConnWatchDog());  
      51.         connWatchDog.start();  
      52.     }  
      53.       
      54.     @SuppressWarnings("deprecation")  
      55.     public void stop(){  
      56.         if(running)running=false;  
      57.         if(connWatchDog!=null)connWatchDog.stop();  
      58.     }  
      59.       
      60.     public void addActionMap(Class<Object> cls,ObjectAction action){  
      61.         actionMapping.put(cls, action);  
      62.     }  
      63.       
      64.     class ConnWatchDog implements Runnable{  
      65.         public void run(){  
      66.             try {  
      67.                 ServerSocket ss = new ServerSocket(port,5);  
      68.                 while(running){  
      69.                     Socket s = ss.accept();  
      70.                     new Thread(new SocketAction(s)).start();  
      71.                 }  
      72.             } catch (IOException e) {  
      73.                 e.printStackTrace();  
      74.                 Server.this.stop();  
      75.             }  
      76.               
      77.         }  
      78.     }  
      79.       
      80.     class SocketAction implements Runnable{  
      81.         Socket s;  
      82.         boolean run=true;  
      83.         long lastReceiveTime = System.currentTimeMillis();  
      84.         public SocketAction(Socket s) {  
      85.             this.s = s;  
      86.         }  
      87.         public void run() {  
      88.             while(running && run){  
      89.                 if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){  
      90.                     overThis();  
      91.                 }else{  
      92.                     try {  
      93.                         InputStream in = s.getInputStream();  
      94.                         if(in.available()>0){  
      95.                             ObjectInputStream ois = new ObjectInputStream(in);  
      96.                             Object obj = ois.readObject();  
      97.                             lastReceiveTime = System.currentTimeMillis();  
      98.                             System.out.println("接收： "+obj);  
      99.                             ObjectAction oa = actionMapping.get(obj.getClass());  
      100.                             oa = oa==null?new DefaultObjectAction():oa;  
      101.                             Object out = oa.doAction(obj);  
      102.                             if(out!=null){  
      103.                                 ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());  
      104.                                 oos.writeObject(out);  
      105.                                 oos.flush();  
      106.                             }  
      107.                         }else{  
      108.                             Thread.sleep(10);  
      109.                         }  
      110.                     } catch (Exception e) {  
      111.                         e.printStackTrace();  
      112.                         overThis();  
      113.                     }   
      114.                 }  
      115.             }  
      116.         }  
      117.           
      118.         private void overThis() {  
      119.             if(run)run=false;  
      120.             if(s!=null){  
      121.                 try {  
      122.                     s.close();  
      123.                 } catch (IOException e) {  
      124.                     e.printStackTrace();  
      125.                 }  
      126.             }  
      127.             System.out.println("关闭："+s.getRemoteSocketAddress());  
      128.         }  
      129.           
      130.     }  
      131.       
      132. } 
  • 相关阅读:
    Python
    Linux, Nginx
    Python
    C#图像处理(各种旋转、改变大小、柔化、锐化、雾化、底片、浮雕、黑白、滤镜效果)
    堆——神奇的优先队列（下）
    堆——神奇的优先队列（上）
    二叉树
    开启“树”之旅
    巧妙的邻接表（数组实现）
    Dijkstra最短路算法
  • 原文地址：https://www.cnblogs.com/atongmyuxiaowanzi/p/5421753.html
Copyright © 2020-2023  润新知