Java Socket基础

Java Socket基础

较基础的Java Socket通信样例！

一、长连接通信

客户端和服务端建立通道后，Socket一直开着。两端通过read()等待消息。

1）简易聊天

服务端可主动对各个客户端发送消息，而各客户端只能单独发送给服务端。当然，只要你愿意，在服务端改下，即可转发了。

附件解压工程ChatSocket，运行TestServer、TestClient即可。src下还有两批处理，详细看TestServer文件内注释了。

1.1）ChatServer.java

1. /**
2. *长连接、1对n主动发消息的服务器
3. *
4. *@authorJoin
5. */
6. publicclassChatServerextendsThread{
8. /**服务端口*/
9. privateintport;
10. /**服务套接字*/
11. privateServerSocketmServerSocket;
12. /**线程池*/
13. privateExecutorServicepool;
14. /**客户端套接字集合*/
15. privateArrayList<Socket>mClientList;
17. publicChatServer(intport){
18. this.port=port;
19. pool=Executors.newCachedThreadPool();//缓存线程池
20. mClientList=newArrayList<Socket>();
21. }
23. @Override
24. publicvoidrun(){
25. try{
26. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
27. Socketclient=null;
28. while(true){
29. client=mServerSocket.accept();//接收连接的套接字
30. mClientList.add(client);//加入客户端列表
31. System.out.println(client.getInetAddress()+"建立了连接");
32. pool.execute(newThreadServer(client));//新线程执行任务
33. }
34. }catch(BindExceptione){//端口使用中
35. System.out.println("端口使用中，请关闭后重开！");
36. }catch(IOExceptione){
37. e.printStackTrace();
38. }
39. }
41. /**各个连接客户端的服务线程*/
42. privateclassThreadServerextendsThread{
44. privateSocketclient;
46. publicThreadServer(Socketclient){
47. this.client=client;
48. }
50. @Override
51. publicvoidrun(){
52. DataInputStreamin=null;
53. DataOutputStreamout=null;
54. try{
55. in=newDataInputStream(client.getInputStream());
56. out=newDataOutputStream(client.getOutputStream());
57. BufferedReaderwt=newBufferedReader(newInputStreamReader(
58. System.in));//控制台输入流
59. while(true){
60. if(in.available()>0){
61. /*有数据时接收*/
62. Stringstr=in.readUTF();
63. System.out.println(str);
64. /*接收end或空时，退出*/
65. if(null==str||"end".equals(str)){
66. System.out
67. .println(client.getInetAddress()+"正常退出");
68. break;
69. }
70. /*回复或转发已接收数据*/
71. }else{
72. if(wt.ready()){
73. /*控制台有数据时发送*/
74. Stringstr=wt.readLine();
75. sendMessage(str);//群发消息
76. }else{
77. try{
78. /*发送紧急数据，判断连接*/
79. client.sendUrgentData(0xFF);
80. Thread.sleep(100);
81. }catch(Exceptione){
82. System.out.println(client.getInetAddress()
83. +"断开连接");
84. break;
85. }
86. }
87. }
88. }
89. }catch(SocketExceptione){//Connectionreset
90. System.out.println(client.getInetAddress()+"异常退出");
91. }catch(IOExceptione){
92. e.printStackTrace();
93. }finally{
94. mClientList.remove(client);//移除当前客户端
95. try{
96. if(null!=in){
97. in.close();
98. }
99. if(null!=out){
100. out.close();
101. }
102. if(null!=client){
103. client.close();
104. }
105. }catch(IOExceptione){
106. e.printStackTrace();
107. }
108. }
109. }
111. }
113. /**
114. *群发信息
115. *@throwsIOException
116. */
117. publicvoidsendMessage(Stringmsg)throwsIOException{
118. DataOutputStreamout=null;
119. for(Socketclient:mClientList){
120. out=newDataOutputStream(client.getOutputStream());
121. out.writeUTF(msg);
122. out.flush();
123. }
124. }
126. }

1.2）ChatClient.java

1. /**
2. *接收和发送消息的客户端
3. *
4. *@authorJoin
5. */
6. publicclassChatClientextendsThread{
8. /**套接字地址*/
9. privateSocketAddressaddress;
10. /**超时时间*/
11. privateinttimeout;
13. publicChatClient(Stringhost,intport,inttimeout){
14. this.address=newInetSocketAddress(host,port);
15. this.timeout=timeout;
16. }
18. @Override
19. publicvoidrun(){
20. Socketsocket=newSocket();//创建未连接套接字
21. try{
22. //socket.setOOBInline(false);//默认即是false，表示不处理紧急数据
23. socket.connect(address,timeout);//连接到服务器，并指定超时时间
24. handleSocket(socket);//数据接收发送处理
25. }catch(ConnectExceptione){//拒绝连接
26. System.out.println("连接不上服务器");
27. }catch(SocketTimeoutExceptione){//连接超时
28. System.out.println("连接服务器超时");
29. }catch(IOExceptione){
30. e.printStackTrace();
31. }finally{
32. try{
33. if(null!=socket){
34. socket.close();//关闭Socket
35. }
36. }catch(IOExceptione){
37. e.printStackTrace();
38. }
39. }
40. }
42. privatevoidhandleSocket(Socketsocket){
44. DataInputStreamin=null;
45. DataOutputStreamout=null;
46. try{
47. in=newDataInputStream(socket.getInputStream());
48. out=newDataOutputStream(socket.getOutputStream());
49. BufferedReaderwt=newBufferedReader(newInputStreamReader(
50. System.in));//控制台输入流
51. while(true){
52. if(wt.ready()){
53. /*控制台有数据时发送*/
54. Stringstr=wt.readLine();
55. out.writeUTF(str);
56. out.flush();
57. /*发送end时，自身也退出*/
58. if(str.equals("end")){
59. break;
60. }
61. }else{
62. try{
63. /*发送紧急数据，判断连接*/
64. socket.sendUrgentData(0xFF);
65. Thread.sleep(100);
66. }catch(Exceptione){
67. System.out.println("服务器断开连接");
68. break;
69. }
70. }
71. /*有数据时接收并输出*/
72. if(in.available()>0)
73. System.out.println(in.readUTF());
74. }
75. }catch(SocketExceptione){//Connectionreset
76. System.out.println("服务器异常");
77. }catch(IOExceptione){
78. e.printStackTrace();
79. }finally{
80. try{
81. if(null!=in){
82. in.close();
83. }
84. if(null!=out){
85. out.close();
86. }
87. }catch(IOExceptione){
88. e.printStackTrace();
89. }
90. }
91. }
93. }

2）对象消息

发送对象消息。服务端有LinkServer和LinkServer2两个，分别支持单客户端与多客户端，方式也有些不一样。

附件解压工程LinkedSocketB，.test包内Test开头的即是测试类了。服务端接收到客户端连接时，直接一个循环发送n个对象过去，没什么大问题^^。

2.1）LinkClient.java

1. /**
2. *只建立一个Socket，长连接Server接收数据。
3. *
4. *@authorJoin
5. */
6. publicclassLinkClientextendsThread{
8. /**套接字地址*/
9. privateSocketAddressaddress;
10. /**超时时间*/
11. privateinttimeout;
12. /**客户端监听接口*/
13. privateOnLinkClientListenerlistener;
15. /**
16. *构造客户端
17. *
18. *@paramhost服务器名称
19. *@paramport服务器端口
20. *@paramtimeout连接超时时间
21. */
22. publicLinkClient(Stringhost,intport,inttimeout){
23. this.address=newInetSocketAddress(host,port);
24. this.timeout=timeout;
25. }
27. @Override
28. publicvoidrun(){
29. Socketsocket=newSocket();//创建未连接套接字
30. try{
31. socket.connect(address,timeout);//连接到服务器，并指定超时时间
32. if(null!=listener){
33. listener.onConnected();
34. }
35. receiveObj(socket);//接收服务器数据
36. }catch(ConnectExceptione){//拒绝连接
37. if(null!=listener){
38. listener.onConnectException();
39. }
40. }catch(SocketTimeoutExceptione){//连接超时
41. if(null!=listener){
42. listener.onTimeoutException();
43. }
44. }catch(IOExceptione){
45. e.printStackTrace();
46. }finally{
47. try{
48. if(null!=socket){
49. socket.close();//关闭Socket
50. }
51. }catch(IOExceptione){
52. e.printStackTrace();
53. }
54. }
55. }
57. /**接收服务器发送的对象*/
58. privatevoidreceiveObj(Socketsocket){
59. //socket.shutdownOutput();//半关闭输出流
61. ObjectInputStreamis=null;
62. try{
63. is=newObjectInputStream(newBufferedInputStream(
64. socket.getInputStream()));
65. /**循环接收对象*/
66. while(true){
67. Objectobj=is.readObject();
68. if(null==obj){
69. break;
70. }
71. if(null!=listener){
72. listener.onReceive(obj);
73. }
74. }
75. if(null!=listener){
76. listener.onExited();
77. }
78. }catch(SocketExceptione){//Connectionreset
79. if(null!=listener){
80. listener.onSocketException();
81. }
82. }catch(IOExceptione){
83. e.printStackTrace();
84. }catch(ClassNotFoundExceptione){
85. e.printStackTrace();
86. }finally{
87. try{
88. if(null!=is){
89. is.close();
90. }
91. if(null!=socket){
92. socket.close();
93. }
94. }catch(IOExceptione){
95. e.printStackTrace();
96. }
97. }
98. }
100. /**设置客户端监听接口*/
101. publicvoidsetOnLinkClientListener(OnLinkClientListenerlistener){
102. this.listener=listener;
103. }
105. }

2.2）LinkServer.java

1. /**
2. *开启服务器，长连接一个Socket，主动发送数据
3. *
4. *@authorJoin
5. */
6. publicclassLinkServerextendsThread{
8. /**服务端口*/
9. privateintport;
10. /**服务套接字*/
11. privateServerSocketmServerSocket;
12. /**线程池*/
13. privateExecutorServicepool;
14. /**服务器监听接口*/
15. privateOnLinkServerListenerlistener;
17. /**同步对象*/
18. privateObjectlockObj=newObject();
19. /**是否等待*/
20. privatebooleanisWaiting=false;
21. /**发送对象集合*/
22. privateArrayList<Object>sendObjList;
24. publicLinkServer(intport){
25. this.port=port;
26. pool=Executors.newCachedThreadPool();//缓存线程池
27. sendObjList=newArrayList<Object>();
28. }
30. @Override
31. publicvoidrun(){
32. try{
33. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
34. Socketclient=null;
35. client=mServerSocket.accept();//接收连接的套接字
36. if(null!=listener){
37. listener.onClientConnected(client.getInetAddress());
38. }
39. pool.execute(newThreadServer(client));//新线程执行任务
40. }catch(BindExceptione){//端口使用中
42. if(null!=listener){
43. listener.onBindException();
44. }
45. }catch(IOExceptione){
46. e.printStackTrace();
47. }
49. }
51. /**各个连接客户端的服务线程*/
52. privateclassThreadServerextendsThread{
54. privateSocketclient;
56. publicThreadServer(Socketclient){
57. this.client=client;
58. }
60. @Override
61. publicvoidrun(){
62. ObjectOutputStreamos=null;
63. try{
64. os=newObjectOutputStream(client.getOutputStream());
66. ObjectsendObj;
67. synchronized(lockObj){
68. while(true){
69. if(sendObjList.size()<=0){
70. isWaiting=true;
71. lockObj.wait();
72. }
73. sendObj=sendObjList.get(0);
74. os.writeObject(sendObj);
75. os.flush();
77. /*发送null时，表示退出了*/
78. if(null==sendObj){
79. if(null!=listener){
80. listener.onExited(client.getInetAddress());
81. }
82. break;
83. }
84. sendObjList.remove(0);
85. }
86. }
88. }catch(SocketExceptione){//Connectionreset
89. if(null!=listener){
90. listener.onSocketException(client.getInetAddress());
91. }
92. }catch(IOExceptione){
93. e.printStackTrace();
94. }catch(InterruptedExceptione){
95. e.printStackTrace();
96. }finally{
97. try{
98. if(null!=os){
99. os.close();
100. }
101. if(null!=client){
102. client.close();
103. }
104. }catch(IOExceptione){
105. e.printStackTrace();
106. }
107. }
108. }
110. }
112. /**发送序列化对象*/
113. publicvoidsendObj(Objectobj){
114. /*这个判断非必需的，记得就好*/
115. if(null!=obj&&!isSerializable(obj))
116. thrownewIllegalArgumentException(
117. "Objectneedstoimplementjava.io.Serializable!");
119. sendObjList.add(obj);
121. if(isWaiting){
122. synchronized(lockObj){
123. lockObj.notifyAll();
124. }
125. isWaiting=false;
126. }
127. }
129. /**判断是否序列化*/
130. privatebooleanisSerializable(Objectobj){
131. Class<?>[]cls=obj.getClass().getInterfaces();
132. for(Class<?>clazz:cls){
133. if(clazz.getName().equals(Serializable.class.getName()))
134. returntrue;
135. }
136. returnfalse;
137. }
139. /**设置服务器监听接口*/
140. publicvoidsetOnLinkServerListener(OnLinkServerListenerlistener){
141. this.listener=listener;
142. }
144. }

2.3）LinkServer2.java

1. /**
2. *开启服务器，长连接各个Socket，主动发送数据
3. *
4. *@authorJoin
5. */
6. publicclassLinkServer2extendsThread{
8. /**服务端口*/
9. privateintport;
10. /**服务套接字*/
11. privateServerSocketmServerSocket;
12. /**服务器监听接口*/
13. privateOnLinkServerListenerlistener;
15. /**客户端套接字集合*/
16. privateArrayList<Socket>clientList;
17. /**客户端的输出流集合*/
18. privateArrayList<ObjectOutputStream>osList;
20. publicLinkServer2(intport){
21. this.port=port;
22. clientList=newArrayList<Socket>();
23. osList=newArrayList<ObjectOutputStream>();
24. }
26. @Override
27. publicvoidrun(){
28. try{
29. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
30. Socketclient=null;
31. while(true){
32. client=mServerSocket.accept();//接收连接的套接字
33. if(null!=listener){
34. listener.onClientConnected(client.getInetAddress());
35. }
36. clientList.add(client);
37. osList.add(newObjectOutputStream(client.getOutputStream()));//增加连接的输出流
38. }
39. }catch(BindExceptione){//端口使用中
40. if(null!=listener){
41. listener.onBindException();
42. }
43. }catch(IOExceptione){
44. e.printStackTrace();
45. }
47. }
49. /**发送序列化对象*/
50. publicvoidsendObj(Objectobj){
51. /*这个判断非必需的，记得就好*/
52. if(null!=obj&&!isSerializable(obj))
53. thrownewIllegalArgumentException(
54. "Objectneedstoimplementjava.io.Serializable!");
57. ObjectOutputStreamout=null;
58. for(inti=0;i<osList.size();i++){
59. try{
60. out=osList.get(i);
61. out.writeObject(obj);
62. out.flush();
64. /*发送null时，表示退出了*/
65. if(null==obj){
66. if(null!=listener){
67. listener.onExited(clientList.get(i).getInetAddress());
68. }
69. closeSocket(i);//关闭当前Socket
70. i--;//少了个记得减
71. }
72. }catch(SocketExceptione){//Connectionreset
73. if(null!=listener){
74. listener.onSocketException(clientList.get(i)
75. .getInetAddress());
76. }
77. closeSocket(i);//关闭当前Socket
78. i--;//少了个记得减
79. }catch(IOExceptione){
80. e.printStackTrace();
81. closeSocket(i);//关闭当前Socket
82. i--;//少了个记得减
83. }
84. }
85. }
87. /**关闭某个Socket*/
88. privatevoidcloseSocket(intindex){
89. try{
90. osList.get(index).close();
91. osList.remove(index);
92. clientList.get(index).close();
93. clientList.remove(index);
94. }catch(IOExceptione1){
95. e1.printStackTrace();
96. }
97. }
99. /**判断是否序列化*/
100. privatebooleanisSerializable(Objectobj){
101. Class<?>[]cls=obj.getClass().getInterfaces();
102. for(Class<?>clazz:cls){
103. if(clazz.getName().equals(Serializable.class.getName()))
104. returntrue;
105. }
106. returnfalse;
107. }
109. /**设置服务器监听接口*/
110. publicvoidsetOnLinkServerListener(OnLinkServerListenerlistener){
111. this.listener=listener;
112. }
114. }

二、短连接通信

客户端请求一次，建立一次Socket，完成后即可关闭。服务端通过accept()等待。

1）对象消息

客户端发送对象，服务端接受对象，很简单的例子。

1.1）EasyClient.java

1. /**
2. *每次连接服务器发送一个消息
3. *
4. *@authorJoin
5. */
6. publicclassEasyClient{
8. /**套接字地址*/
9. privateSocketAddressaddress;
10. /**超时时间*/
11. privateinttimeout;
12. /**客户端监听接口*/
13. privateOnClientListenerlistener;
15. publicEasyClient(Stringhost,intport,inttimeout){
16. this.address=newInetSocketAddress(host,port);
17. this.timeout=timeout;
18. }
20. /**
21. *发送一个消息
22. *
23. *@paramobj对象消息
24. */
25. publicbooleansendMessage(Objectobj){
26. booleanresult=false;
27. Socketsocket=null;
28. try{
29. socket=newSocket();
30. socket.connect(address,timeout);
31. if(null!=listener){
32. listener.onConnected();
33. }
34. result=sendMessage(socket,obj);
35. }catch(ConnectExceptione){//拒绝连接
36. if(null!=listener){
37. listener.onConnectException();
38. }
39. }catch(SocketTimeoutExceptione){//连接超时
40. if(null!=listener){
41. listener.onTimeoutException();
42. }
43. }catch(IOExceptione){
44. e.printStackTrace();
45. }finally{
46. try{
47. if(null!=socket){
48. socket.close();//关闭Socket
49. socket=null;
50. }
51. }catch(IOExceptione){
52. e.printStackTrace();
53. }
54. }
55. returnresult;
56. }
58. /**通过Socket发送obj消息*/
59. privatebooleansendMessage(Socketsocket,Objectobj){
60. booleanresult=false;
61. ObjectOutputStreamos=null;
62. try{
63. os=newObjectOutputStream(socket.getOutputStream());
64. os.writeObject(obj);
65. os.flush();
66. if(null!=listener){
67. listener.onMessageSent(obj);
68. }
69. result=true;
70. }catch(SocketExceptione){//Connectionreset
71. if(null!=listener){
72. listener.onSocketException();
73. }
74. }catch(IOExceptione){
75. e.printStackTrace();
76. }finally{
77. try{
78. if(null!=os){
79. os.close();
80. }
81. }catch(IOExceptione){
82. e.printStackTrace();
83. }
84. }
85. returnresult;
86. }
88. /**设置客户端监听接口*/
89. publicvoidsetOnClientListener(OnClientListenerlistener){
90. this.listener=listener;
91. }
93. }

1.2）EasyServer.java

1. publicclassEasyServerextendsThread{
3. /**服务端口*/
4. privateintport;
5. /**服务套接字*/
6. privateServerSocketmServerSocket;
7. /**服务器监听接口*/
8. privateOnServerListenerlistener;
10. publicEasyServer(intport){
11. this.port=port;
12. }
14. @Override
15. publicvoidrun(){
16. try{
17. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
18. Socketsocket=null;
19. while(true){
20. socket=mServerSocket.accept();//接收连接的套接字
21. receiveMessage(socket);//接收socket处理消息
22. }
23. }catch(BindExceptione){//端口使用中
24. if(null!=listener){
25. listener.onBindException();
26. }
27. }catch(IOExceptione){
28. e.printStackTrace();
29. }
30. }
32. /**接收处理每个Socket信息*/
33. privatevoidreceiveMessage(Socketsocket){
34. ObjectInputStreamis=null;
35. try{
36. is=newObjectInputStream(newBufferedInputStream(
37. socket.getInputStream()));
38. Objectobj=is.readObject();
39. if(null!=listener){
40. listener.onReceive(socket.getInetAddress(),obj);
41. }
42. }catch(SocketExceptione){//Connectionreset
43. if(null!=listener){
44. listener.onSocketException(socket.getInetAddress());
45. }
46. }catch(IOExceptione){
47. e.printStackTrace();
48. }catch(ClassNotFoundExceptione){
49. e.printStackTrace();
50. }finally{
51. try{
52. if(null!=is){
53. is.close();
54. }
55. if(null!=socket){
56. socket.close();
57. }
58. }catch(IOExceptione){
59. e.printStackTrace();
60. }
61. }
62. }
64. /**设置服务器监听接口*/
65. publicvoidsetOnServerListener(OnServerListenerlistener){
66. this.listener=listener;
67. }
69. }

三、后记

恩，哦，socket还有个比较常用的是setSoTimeout()，在read()阻塞超时会报SocketTimeoutException，catch住处理即可。

更多的如SSLSocket、NIO的简单例子，可以先 Click here！这个整理好的样例工程就不提供了，自己动手^^！

ps：老遇到8W冗余字符，拆着拆着就三个了==！

出处http://vaero.blog.51cto.com/4350852/893847