Socket通信如何实现长连接？
长连接和断链接有什么区别？
区别在哪里？

1. 
   
2. package houlei.csdn.keepalive;
   
3. 
   
4. import java.io.Serializable;
   
5. import java.text.SimpleDateFormat;
   
6. import java.util.Date;
   
7. 
   
8. /**
   
9. * 维持连接的消息对象。
   
10. * <p>
    
11. * 创建时间：2010-7-18 上午12:22:09
    
12. * @author HouLei
    
13. * @since 1.0
    
14. */
    
15. public class KeepAlive implements Serializable{
    
16. 
    
17.     private static final long serialVersionUID = -2813120366138988480L;
    
18. 
    
19.     /* 覆盖该方法，仅用于测试使用。
    
20.      * @see java.lang.Object#toString()
    
21.      */
    
22.     @Override
    
23.     public String toString() {
    
24.         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";
    
25.     }
    
26. 
    
27. }

复制代码

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. }

复制代码

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实现类，可以实现不同对象的响应、应答过程。