JAVA长连接demo

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

JAVA长连接demo

2014-08-25 23:20 4767人阅读 评论(2) 收藏 举报

 分类：

JAVA（161） 

1. package houlei.csdn.keepalive;
2. import java.io.Serializable;
3. import java.text.SimpleDateFormat;
4. import java.util.Date;
5. /**
6. * 维持连接的消息对象。
7. * <p>
8. * 创建时间：2010-7-18 上午12:22:09
9. * @author HouLei
10. * @since 1.0
11. */
12. public class KeepAlive implements Serializable{
13. private static final long serialVersionUID = -2813120366138988480L;
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())+"\t维持连接包";
20. }
21. }

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

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

大致解释一下什么意思：

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

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

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

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

祝好运~~