码迷，mamicode.com
首页 > 编程语言 > 详细

JAVA长连接demo

时间：2016-03-13 17:32:10      阅读：287      评论：0      收藏：0      [点我收藏+]

标签：

http://blog.csdn.net/caomiao2006/article/details/38830475

 

JAVA长连接demo

2014-08-25 23:20 4767人阅读 评论(2) 收藏 举报
技术分享 分类：
 

 

[java] view plain copy
 
  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.  * <p> 
  10.  * 创建时间：2010-7-18 上午12:22:09 
  11.  * @author HouLei 
  12.  * @since 1.0 
  13.  */  
  14. public class KeepAlive implements Serializable{  
  15.   
  16.     private static final long serialVersionUID = -2813120366138988480L;  
  17.   
  18.     /* 覆盖该方法，仅用于测试使用。 
  19.      * @see java.lang.Object#toString() 
  20.      */  
  21.     @Override  
  22.     public String toString() {  
  23.         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";  
  24.     }  
  25.   
  26. }  

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

[java] view plain copy
 
  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.  * <p> 
  15.  * 创建时间：2010-7-18 上午12:17:37 
  16.  * @author HouLei 
  17.  * @since 1.0 
  18.  */  
  19. public class Server {  
  20.   
  21.     /** 
  22.      * 要处理客户端发来的对象，并返回一个对象，可实现该接口。 
  23.      */  
  24.     public interface ObjectAction{  
  25.         Object doAction(Object rev);  
  26.     }  
  27.       
  28.     public static final class DefaultObjectAction implements ObjectAction{  
  29.         public Object doAction(Object rev) {  
  30.             System.out.println("处理并返回："+rev);  
  31.             return rev;  
  32.         }  
  33.     }  
  34.       
  35.     public static void main(String[] args) {  
  36.         int port = 65432;  
  37.         Server server = new Server(port);  
  38.         server.start();  
  39.     }  
  40.       
  41.     private int port;  
  42.     private volatile boolean running=false;  
  43.     private long receiveTimeDelay=3000;  
  44.     private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();  
  45.     private Thread connWatchDog;  
  46.       
  47.     public Server(int port) {  
  48.         this.port = port;  
  49.     }  
  50.   
  51.     public void start(){  
  52.         if(running)return;  
  53.         running=true;  
  54.         connWatchDog = new Thread(new ConnWatchDog());  
  55.         connWatchDog.start();  
  56.     }  
  57.       
  58.     @SuppressWarnings("deprecation")  
  59.     public void stop(){  
  60.         if(running)running=false;  
  61.         if(connWatchDog!=null)connWatchDog.stop();  
  62.     }  
  63.       
  64.     public void addActionMap(Class<Object> cls,ObjectAction action){  
  65.         actionMapping.put(cls, action);  
  66.     }  
  67.       
  68.     class ConnWatchDog implements Runnable{  
  69.         public void run(){  
  70.             try {  
  71.                 ServerSocket ss = new ServerSocket(port,5);  
  72.                 while(running){  
  73.                     Socket s = ss.accept();  
  74.                     new Thread(new SocketAction(s)).start();  
  75.                 }  
  76.             } catch (IOException e) {  
  77.                 e.printStackTrace();  
  78.                 Server.this.stop();  
  79.             }  
  80.               
  81.         }  
  82.     }  
  83.       
  84.     class SocketAction implements Runnable{  
  85.         Socket s;  
  86.         boolean run=true;  
  87.         long lastReceiveTime = System.currentTimeMillis();  
  88.         public SocketAction(Socket s) {  
  89.             this.s = s;  
  90.         }  
  91.         public void run() {  
  92.             while(running && run){  
  93.                 if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){  
  94.                     overThis();  
  95.                 }else{  
  96.                     try {  
  97.                         InputStream in = s.getInputStream();  
  98.                         if(in.available()>0){  
  99.                             ObjectInputStream ois = new ObjectInputStream(in);  
  100.                             Object obj = ois.readObject();  
  101.                             lastReceiveTime = System.currentTimeMillis();  
  102.                             System.out.println("接收：\t"+obj);  
  103.                             ObjectAction oa = actionMapping.get(obj.getClass());  
  104.                             oa = oa==null?new DefaultObjectAction():oa;  
  105.                             Object out = oa.doAction(obj);  
  106.                             if(out!=null){  
  107.                                 ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());  
  108.                                 oos.writeObject(out);  
  109.                                 oos.flush();  
  110.                             }  
  111.                         }else{  
  112.                             Thread.sleep(10);  
  113.                         }  
  114.                     } catch (Exception e) {  
  115.                         e.printStackTrace();  
  116.                         overThis();  
  117.                     }   
  118.                 }  
  119.             }  
  120.         }  
  121.           
  122.         private void overThis() {  
  123.             if(run)run=false;  
  124.             if(s!=null){  
  125.                 try {  
  126.                     s.close();  
  127.                 } catch (IOException e) {  
  128.                     e.printStackTrace();  
  129.                 }  
  130.             }  
  131.             System.out.println("关闭："+s.getRemoteSocketAddress());  
  132.         }  
  133.           
  134.     }  
  135.       
  136. }  

 

 

大致解释一下什么意思：

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

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

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

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



祝好运~~

JAVA长连接demo

标签：

原文地址：http://www.cnblogs.com/jukan/p/5272235.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！