Java Socket基础（二）

2022-01-21 10:09:49

Java Socket基础（一）


2）对象消息
         发送对象消息。服务端有LinkServer和LinkServer2两个，分别支持单客户端与多客户端，方式也有些不一样。
         附件解压工程LinkedSocketB，.test包内Test开头的即是测试类了。服务端接收到客户端连接时，直接一个循环发送n个对象过去，没什么大问题^^。
 
2.1）LinkClient.java


    

  1. /** 
    2. 

  2.  * 只建立一个Socket，长连接Server接收数据。 
    3. 

  3.  * 
    4. 

  4.  * @author Join 
    5. 

  5.  */ 
    6. 

  6. public class LinkClient extends Thread { 
    7. 

  7.   
    8. 

  8.     /** 套接字地址 */ 
    9. 

  9.     private SocketAddress address; 
    10. 

  10.     /** 超时时间 */ 
    11. 

  11.     private int timeout; 
    12. 

  12.     /** 客户端监听接口 */ 
    13. 

  13.     private OnLinkClientListener listener; 
    14. 

  14.   
    15. 

  15.     /** 
    16. 

  16.      * 构造客户端 
    17. 

  17.      * 
    18. 

  18.      * @param host 服务器名称 
    19. 

  19.      * @param port 服务器端口 
    20. 

  20.      * @param timeout 连接超时时间 
    21. 

  21.      */ 
    22. 

  22.     public LinkClient(String host, int port, int timeout) { 
    23. 

  23.        this.address = new InetSocketAddress(host, port); 
    24. 

  24.        this.timeout = timeout; 
    25. 

  25.     } 
    26. 

  26.   
    27. 

  27.     @Override 
    28. 

  28.     public void run() { 
    29. 

  29.        Socket socket = new Socket(); // 创建未连接套接字 
    30. 

  30.        try { 
    31. 

  31.            socket.connect(address, timeout); // 连接到服务器，并指定超时时间 
    32. 

  32.            if (null != listener) { 
    33. 

  33.               listener.onConnected(); 
    34. 

  34.            } 
    35. 

  35.            receiveObj(socket); // 接收服务器数据 
    36. 

  36.        } catch (ConnectException e) { // 拒绝连接 
    37. 

  37.            if (null != listener) { 
    38. 

  38.               listener.onConnectException(); 
    39. 

  39.            } 
    40. 

  40.        } catch (SocketTimeoutException e) { // 连接超时 
    41. 

  41.            if (null != listener) { 
    42. 

  42.               listener.onTimeoutException(); 
    43. 

  43.            } 
    44. 

  44.        } catch (IOException e) { 
    45. 

  45.            e.printStackTrace(); 
    46. 

  46.        } finally { 
    47. 

  47.            try { 
    48. 

  48.               if (null != socket) { 
    49. 

  49.                   socket.close(); // 关闭Socket 
    50. 

  50.               } 
    51. 

  51.            } catch (IOException e) { 
    52. 

  52.               e.printStackTrace(); 
    53. 

  53.            } 
    54. 

  54.        } 
    55. 

  55.     } 
    56. 

  56.   
    57. 

  57.     /** 接收服务器发送的对象 */ 
    58. 

  58.     private void receiveObj(Socket socket) { 
    59. 

  59.        // socket.shutdownOutput(); // 半关闭输出流 
    60. 

  60.  
    61. 

  61.        ObjectInputStream is = null; 
    62. 

  62.        try { 
    63. 

  63.            is = new ObjectInputStream(new BufferedInputStream( 
    64. 

  64.                   socket.getInputStream())); 
    65. 

  65.            /** 循环接收对象 */ 
    66. 

  66.            while (true) { 
    67. 

  67.               Object obj = is.readObject(); 
    68. 

  68.               if (null == obj) { 
    69. 

  69.                   break; 
    70. 

  70.               } 
    71. 

  71.               if (null != listener) { 
    72. 

  72.                   listener.onReceive(obj); 
    73. 

  73.               } 
    74. 

  74.            } 
    75. 

  75.            if (null != listener) { 
    76. 

  76.               listener.onExited(); 
    77. 

  77.            } 
    78. 

  78.        } catch (SocketException e) { // Connection reset 
    79. 

  79.            if (null != listener) { 
    80. 

  80.               listener.onSocketException(); 
    81. 

  81.            } 
    82. 

  82.        } catch (IOException e) { 
    83. 

  83.            e.printStackTrace(); 
    84. 

  84.        } catch (ClassNotFoundException e) { 
    85. 

  85.            e.printStackTrace(); 
    86. 

  86.        } finally { 
    87. 

  87.            try { 
    88. 

  88.               if (null != is) { 
    89. 

  89.                   is.close(); 
    90. 

  90.               } 
    91. 

  91.               if (null != socket) { 
    92. 

  92.                   socket.close(); 
    93. 

  93.               } 
    94. 

  94.            } catch (IOException e) { 
    95. 

  95.               e.printStackTrace(); 
    96. 

  96.            } 
    97. 

  97.        } 
    98. 

  98.     } 
    99. 

  99.   
    100. 

  100.     /** 设置客户端监听接口 */ 
    101. 

  101.     public void setOnLinkClientListener(OnLinkClientListener listener) { 
    102. 

  102.        this.listener = listener; 
    103. 

  103.     } 
    104. 

  104.   
    105. 

  105. } 
    106. 



 


2.2）LinkServer.java




    

  1. /** 
    2. 

  2.  * 开启服务器，长连接一个Socket，主动发送数据 
    3. 

  3.  * 
    4. 

  4.  * @author Join 
    5. 

  5.  */ 
    6. 

  6. public class LinkServer extends Thread { 
    7. 

  7.   
    8. 

  8.     /** 服务端口 */ 
    9. 

  9.     private int port; 
    10. 

  10.     /** 服务套接字 */ 
    11. 

  11.     private ServerSocket mServerSocket; 
    12. 

  12.     /** 线程池 */ 
    13. 

  13.     private ExecutorService pool; 
    14. 

  14.     /** 服务器监听接口 */ 
    15. 

  15.     private OnLinkServerListener listener; 
    16. 

  16.   
    17. 

  17.     /** 同步对象 */ 
    18. 

  18.     private Object lockObj = new Object(); 
    19. 

  19.     /** 是否等待 */ 
    20. 

  20.     private boolean isWaiting = false; 
    21. 

  21.     /** 发送对象集合 */ 
    22. 

  22.     private ArrayList<Object> sendObjList; 
    23. 

  23.   
    24. 

  24.     public LinkServer(int port) { 
    25. 

  25.        this.port = port; 
    26. 

  26.        pool = Executors.newCachedThreadPool(); // 缓存线程池 
    27. 

  27.        sendObjList = new ArrayList<Object>(); 
    28. 

  28.     } 
    29. 

  29.   
    30. 

  30.     @Override 
    31. 

  31.     public void run() { 
    32. 

  32.        try { 
    33. 

  33.            mServerSocket = new ServerSocket(port); // 创建本地特定端口服务器套接字 
    34. 

  34.            Socket client = null; 
    35. 

  35.            client = mServerSocket.accept(); // 接收连接的套接字 
    36. 

  36.            if (null != listener) { 
    37. 

  37.               listener.onClientConnected(client.getInetAddress()); 
    38. 

  38.            } 
    39. 

  39.            pool.execute(new ThreadServer(client)); // 新线程执行任务 
    40. 

  40.         } catch (BindException e) { // 端口使用中 
    41. 

  41.  
    42. 

  42.            if (null != listener) { 
    43. 

  43.               listener.onBindException(); 
    44. 

  44.            } 
    45. 

  45.        } catch (IOException e) { 
    46. 

  46.            e.printStackTrace(); 
    47. 

  47.        } 
    48. 

  48.   
    49. 

  49.     } 
    50. 

  50.   
    51. 

  51.     /** 各个连接客户端的服务线程 */ 
    52. 

  52.     private class ThreadServer extends Thread { 
    53. 

  53.   
    54. 

  54.        private Socket client; 
    55. 

  55.   
    56. 

  56.        public ThreadServer(Socket client) { 
    57. 

  57.            this.client = client; 
    58. 

  58.        } 
    59. 

  59.   
    60. 

  60.        @Override 
    61. 

  61.        public void run() { 
    62. 

  62.            ObjectOutputStream os = null; 
    63. 

  63.            try { 
    64. 

  64.               os = new ObjectOutputStream(client.getOutputStream()); 
    65. 

  65.   
    66. 

  66.               Object sendObj; 
    67. 

  67.               synchronized (lockObj) { 
    68. 

  68.                   while (true) { 
    69. 

  69.                      if (sendObjList.size() <= 0) { 
    70. 

  70.                          isWaiting = true; 
    71. 

  71.                          lockObj.wait(); 
    72. 

  72.                      } 
    73. 

  73.                      sendObj = sendObjList.get(0); 
    74. 

  74.                      os.writeObject(sendObj); 
    75. 

  75.                      os.flush(); 
    76. 

  76.   
    77. 

  77.                      /* 发送null时，表示退出了 */ 
    78. 

  78.                      if (null == sendObj) { 
    79. 

  79.                          if (null != listener) { 
    80. 

  80.                             listener.onExited(client.getInetAddress()); 
    81. 

  81.                          } 
    82. 

  82.                          break; 
    83. 

  83.                      } 
    84. 

  84.                      sendObjList.remove(0); 
    85. 

  85.                   } 
    86. 

  86.               } 
    87. 

  87.   
    88. 

  88.            } catch (SocketException e) { // Connection reset 
    89. 

  89.               if (null != listener) { 
    90. 

  90.                   listener.onSocketException(client.getInetAddress()); 
    91. 

  91.               } 
    92. 

  92.            } catch (IOException e) { 
    93. 

  93.               e.printStackTrace(); 
    94. 

  94.            } catch (InterruptedException e) { 
    95. 

  95.               e.printStackTrace(); 
    96. 

  96.            } finally { 
    97. 

  97.               try { 
    98. 

  98.                   if (null != os) { 
    99. 

  99.                      os.close(); 
    100. 

  100.                   } 
    101. 

  101.                   if (null != client) { 
    102. 

  102.                      client.close(); 
    103. 

  103.                   } 
    104. 

  104.               } catch (IOException e) { 
    105. 

  105.                   e.printStackTrace(); 
    106. 

  106.               } 
    107. 

  107.            } 
    108. 

  108.        } 
    109. 

  109.   
    110. 

  110.     } 
    111. 

  111.   
    112. 

  112.     /** 发送序列化对象 */ 
    113. 

  113.     public void sendObj(Object obj) { 
    114. 

  114.        /* 这个判断非必需的，记得就好 */ 
    115. 

  115.        if (null != obj && !isSerializable(obj)) 
    116. 

  116.            throw new IllegalArgumentException( 
    117. 

  117.                   "Object needs to implement java.io.Serializable!"); 
    118. 

  118.  
    119. 

  119.        sendObjList.add(obj); 
    120. 

  120.   
    121. 

  121.        if (isWaiting) { 
    122. 

  122.            synchronized (lockObj) { 
    123. 

  123.               lockObj.notifyAll(); 
    124. 

  124.            } 
    125. 

  125.            isWaiting = false; 
    126. 

  126.        } 
    127. 

  127.     } 
    128. 

  128.   
    129. 

  129.     /** 判断是否序列化 */ 
    130. 

  130.     private boolean isSerializa
    131. 


    132. 

  132. ble(Object obj) { 
    133. 

  133.        Class<?>[] cls = obj.getClass().getInterfaces(); 
    134. 

  134.        for (Class<?> clazz : cls) { 
    135. 

  135.            if (clazz.getName().equals(Serializable.class.getName())) 
    136. 

  136.               return true; 
    137. 

  137.        } 
    138. 

  138.        return false; 
    139. 

  139.     } 
    140. 

  140.   
    141. 

  141.     /** 设置服务器监听接口 */ 
    142. 

  142.     public void setOnLinkServerListener(OnLinkServerListener listener) { 
    143. 

  143.        this.listener = listener; 
    144. 

  144.     } 
    145. 

  145.   
    146. 

  146. } 
    147. 



 














     本文转自winorlose2000 51CTO博客，原文链接：http://blog.51cto.com/vaero/893844，如需转载请自行联系原作者





















上一篇：【Java学习笔记】显示IP

下一篇：Android广播机制