Java多客户端通信服务端代码介绍

Java 多客户端通信在很多人看来是一项很繁琐的工作，其实我们在编写代码的时候只要是注意留心Java 多客户端通信的源代码就能发现，我们认为枯燥的东西其实都很简单。

创新互联成立于2013年，先为锡山等服务建站，锡山等地企业，进行企业商务咨询服务。为锡山企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

来看服务端的代码:

 
 
 
    
  
  
  
  1. import java.net.*;  
    2. 
  
  
  
  2. import java.io.*;  
    3. 
  
  
  
  3. import java.util.*;  
    4. 
  
  
  
  4. public class Jserver3 {  
    5. 
  
  
  
  5. private ServerSocket server;  
    6. 
  
  
  
  6. List sManager = new ArrayList();  
    7. 
  
  
  
  7. public Jserver3(){}  
    8. 
  
  
  
  8. void startServer()　//运行服务器  
    9. 
  
  
  
  9. {  
    10. 
  
  
  
  10. try  
    11. 
  
  
  
  11. {  
    12. 
  
  
  
  12. server=new ServerSocket(719);  
    13. 
  
  
  
  13. System.out.println("服务器套接字已创建成功！");  
    14. 
  
  
  
  14. while(true)  
    15. 
  
  
  
  15. {  
    16. 
  
  
  
  16. Socket socket=server.accept();  
    17. 
  
  
  
  17. System.out.println("已经与客户端连接");  
    18. 
  
  
  
  18. new J_Thread(socket).start();  
    19. 
  
  
  
  19. sManager.add(socket);  
    20. 
  
  
  
  20. System.out.println("当前客户端连结数："+sManager.size());  
    21. 
  
  
  
  21. }  
    22. 
  
  
  
  22. }catch(Exception e){}finally  
    23. 
  
  
  
  23. {  
    24. 
  
  
  
  24. try  
    25. 
  
  
  
  25. {  
    26. 
  
  
  
  26. server.close();  
    27. 
  
  
  
  27. }catch(Exception e){}  
    28. 
  
  
  
  28. }  
    29. 
  
  
  
  29. }  
    30. 
  
  
  
  30. public static void main(String[] args) {  
    31. 
  
  
  
  31. Jserver3 server=new Jserver3();  
    32. 
  
  
  
  32. server.startServer();  
    33. 
  
  
  
  33. }  
    34. 
  
  
  
  34. class J_Thread extends Thread　　//与客户端进行通信的线程类  
    35. 
  
  
  
  35. {  
    36. 
  
  
  
  36. Socket socket;　　 //套接字引用变量  
    37. 
  
  
  
  37. private DataInputStream reader;　　 //套接字输入流  
    38. 
  
  
  
  38. private DataOutputStream writer;　 //套接字输出流  
    39. 
  
  
  
  39. J_Thread(Socket socket)　　 //构造函数  
    40. 
  
  
  
  40. {  
    41. 
  
  
  
  41. this.socket=socket;  
    42. 
  
  
  
  42. }  
    43. 
  
  
  
  43. public void run()  
    44. 
  
  
  
  44. {  
    45. 
  
  
  
  45. try  
    46. 
  
  
  
  46. {  
    47. 
  
  
  
  47. reader=new DataInputStream(socket.getInputStream());//获取套接字的输入流  
    48. 
  
  
  
  48. writer=new DataOutputStream(socket.getOutputStream());//获取套接字的输出流  
    49. 
  
  
  
  49. String msg;  
    50. 
  
  
  
  50. while((msg=reader.readUTF())!=null)//如果收到客户端发来的数据  
    51. 
  
  
  
  51. {  
    52. 
  
  
  
  52. //向客户端发送信息  
    53. 
  
  
  
  53. writer.writeUTF("您的情书已经收到");  
    54. 
  
  
  
  54. writer.flush();  
    55. 
  
  
  
  55. System.out.println("来自客户端："+msg);  
    56. 
  
  
  
  56. }  
    57. 
  
  
  
  57. }catch(Exception e){}finally  
    58. 
  
  
  
  58. {  
    59. 
  
  
  
  59. try  
    60. 
  
  
  
  60. {  
    61. 
  
  
  
  61. sManager.remove(socket); 　//删除套接字  
    62. 
  
  
  
  62. //关闭输入输出流及套接字  
    63. 
  
  
  
  63. if(reader!=null)reader.close();  
    64. 
  
  
  
  64. if(writer!=null)writer.close();  
    65. 
  
  
  
  65. if(socket!=null)socket.close();  
    66. 
  
  
  
  66. reader=null;  
    67. 
  
  
  
  67. writer=null;  
    68. 
  
  
  
  68. socket=null;  
    69. 
  
  
  
  69. System.out.println("客户端离开");//向屏幕输出相关信息  
    70. 
  
  
  
  70. System.out.println("当前客户端的连接数："+sManager.size());  
    71. 
  
  
  
  71. }catch(Exception e){}  
    72. 
  
  
  
  72. }  
    73. 
  
  
  
  73. }  
    74. 
  
  
  
  74. }  
    75. 
  
  
  
  75. }  
    76. 
  
  
  
  76. import java.net.*; 
    77. 
  
  
  
  77. import java.io.*; 
    78. 
  
  
  
  78. import java.util.*; 
    79. 
  
  
  
  79. public class Jserver3 { 
    80. 
  
  
  
  80. private ServerSocket server; 
    81. 
  
  
  
  81. List sManager = new ArrayList(); 
    82. 
  
  
  
  82. public Jserver3(){} 
    83. 
  
  
  
  83. void startServer()　//运行服务器 
    84. 
  
  
  
  84. { 
    85. 
  
  
  
  85. try 
    86. 
  
  
  
  86. { 
    87. 
  
  
  
  87. server=new ServerSocket(719); 
    88. 
  
  
  
  88. System.out.println("服务器套接字已创建成功！"); 
    89. 
  
  
  
  89. while(true) 
    90. 
  
  
  
  90. { 
    91. 
  
  
  
  91. Socket socket=server.accept(); 
    92. 
  
  
  
  92. System.out.println("已经与客户端连接"); 
    93. 
  
  
  
  93. new J_Thread(socket).start(); 
    94. 
  
  
  
  94. sManager.add(socket); 
    95. 
  
  
  
  95. System.out.println("当前客户端连结数："+sManager.size()); 
    96. 
  
  
  
  96. } 
    97. 
  
  
  
  97. }catch(Exception e){}finally 
    98. 
  
  
  
  98. { 
    99. 
  
  
  
  99. try 
    100. 
  
  
  
  100. { 
    101. 
  
  
  
  101. server.close(); 
    102. 
  
  
  
  102. }catch(Exception e){} 
    103. 
  
  
  
  103. } 
    104. 
  
  
  
  104. } 
    105. 
  
  
  
  105. public static void main(String[] args) { 
    106. 
  
  
  
  106. Jserver3 server=new Jserver3(); 
    107. 
  
  
  
  107. server.startServer(); 
    108. 
  
  
  
  108. } 
    109. 
  
  
  
  109. class J_Thread extends Thread　　//与客户端进行通信的线程类 
    110. 
  
  
  
  110. { 
    111. 
  
  
  
  111. Socket socket;　　 //套接字引用变量 
    112. 
  
  
  
  112. private DataInputStream reader;　　 //套接字输入流 
    113. 
  
  
  
  113. private DataOutputStream writer;　 //套接字输出流 
    114. 
  
  
  
  114. J_Thread(Socket socket)　　 //构造函数 
    115. 
  
  
  
  115. { 
    116. 
  
  
  
  116. this.socket=socket; 
    117. 
  
  
  
  117. } 
    118. 
  
  
  
  118. public void run() 
    119. 
  
  
  
  119. { 
    120. 
  
  
  
  120. try 
    121. 
  
  
  
  121. { 
    122. 
  
  
  
  122. reader=new DataInputStream(socket.getInputStream());//获取套接字的输入流 
    123. 
  
  
  
  123. writer=new DataOutputStream(socket.getOutputStream());//获取套接字的输出流 
    124. 
  
  
  
  124. String msg; 
    125. 
  
  
  
  125. while((msg=reader.readUTF())!=null)//如果收到客户端发来的数据 
    126. 
  
  
  
  126. { 
    127. 
  
  
  
  127. //向客户端发送信息 
    128. 
  
  
  
  128. writer.writeUTF("您的情书已经收到"); 
    129. 
  
  
  
  129. writer.flush(); 
    130. 
  
  
  
  130. System.out.println("来自客户端："+msg); 
    131. 
  
  
  
  131. } 
    132. 
  
  
  
  132. }catch(Exception e){}finally 
    133. 
  
  
  
  133. { 
    134. 
  
  
  
  134. try 
    135. 
  
  
  
  135. { 
    136. 
  
  
  
  136. sManager.remove(socket); 　//删除套接字 
    137. 
  
  
  
  137. //关闭输入输出流及套接字 
    138. 
  
  
  
  138. if(reader!=null)reader.close(); 
    139. 
  
  
  
  139. if(writer!=null)writer.close(); 
    140. 
  
  
  
  140. if(socket!=null)socket.close(); 
    141. 
  
  
  
  141. reader=null; 
    142. 
  
  
  
  142. writer=null; 
    143. 
  
  
  
  143. socket=null; 
    144. 
  
  
  
  144. System.out.println("客户端离开");//向屏幕输出相关信息 
    145. 
  
  
  
  145. System.out.println("当前客户端的连接数："+sManager.size()); 
    146. 
  
  
  
  146. }catch(Exception e){} 
    147. 
  
  
  
  147. } 
    148. 
  
  
  
  148. } 
    149. 
  
  
  
  149. } 
    150. 
  
  
  
  150. }
    151.

嘎嘎 在这段代码里，服务端MM为每一个连接的客户端GG分配一个单独的线程，而每一个线程里都持有对应的客户端GG的Java 多客户端通信对象。SO，通过这些多线程，服务端MM就练就了一心N用的功力，可以同时接受N个客户端GG发来的情书了（，真的太贱了。。。。）

客户端的代码和上面的客户端代码一模一样的，这里就不多说啦！

本文题目：Java多客户端通信服务端代码介绍
标题网址：http://www.shufengxianlan.com/qtweb/news40/512840.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

响应式网站知识

同城分类信息

云锦斋建筑　　 　网站空间　　 　网站维护报价　　 　成都花箱　　 　成都网页设计　　 　成都定制网站建设　　 　网站SEO优化　　 　网站解决方案　　 　成都展柜设计　　 　手机APP开发　　 　成都服务器租赁　　 　橡塑保温管　　 　服务器租用　　 　平城网站运维　　 　网站托管运营　　 　四川成都网站设计　　 　乐山网站建设　　 　自贡网站建设　　 　响应式网站建设　　 　成都品牌网站建设