Java UDP Socket

2022-12-29 15:30:35

本文转载地址：

         Java学习路上的收获：http://blog.csdn.net/qinpeng100423/article/details/8980423



一. UDP协议定义


UDP协议的全称是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。


二. 使用UDP的原因
它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用UDP较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。比如我们聊天用的ICQ和OICQ就是使用的UDP协议。在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人不十分满意的环境下，UDP协议数据包丢失会比较严重。


三. 在Java中使用UDP协议编程的相关类
1. InetAddress
用于描述和包装一个Internet IP地址。有如下方法返回实例：
getLocalhost()：返回封装本地地址的实例。


getAllByName(String host)：返回封装Host地址的InetAddress实例数组。


getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。
InetAddress.getByAddress(addr)：根据地址串返回InetAddress实例。
InetAddress.getByAddress(host, addr)：根据主机地符串和地址串返回InetAddress实例。


2. DatagramSocket
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端


DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。


2）send(DatagramPacket dp)：发送报文dp到目的地。


3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。


4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。


3. DatagramPacket
用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：
DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组，一般用来接收客户端发送的数据。
DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。
DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口,通常用来发送数据给客户端。


DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。
主要的方法如下：
1）getData(): 从实例中取得报文的Byte数组编码。
2）setDate(byte[] buf)：将byte数组放入要发送的报文中。
四. 实例解析
下面让我们来看一个UDP的服务端和客户端交互通信的例子，在本例中，服务端循环等待客户端发送的信息，并对其进行回应，客户端向服务端发送信息，并接收服务端的回应信息。代码如下：
1.UDP的服务端程序




    

  1. import java.io.IOException;
    2. 

  2. import java.net.DatagramPacket;
    3. 

  3. import java.net.DatagramSocket;
    4. 

  4. import java.net.InetAddress;
    5. 

  5. import java.net.InetSocketAddress;
    6. 

  6. import java.net.SocketException;
    7. 

  7. /**
    8. 

  8. * Copyright 2007 GuangZhou Cotel Co. Ltd.
    9. 

  9. * All right reserved.
    10. 

  10. * UTP服务类.
    11. 

  11. * @author QPING
    12. 

  12. */
    13. 

  13. public class UdpServerSocket {
    14. 

  14. private byte[] buffer = new byte[1024];
    15. 

  15. private DatagramSocket ds = null;
    16. 

  16. private DatagramPacket packet = null;
    17. 

  17. private InetSocketAddress socketAddress = null;
    18. 

  18. private String orgIp;
    19. 

  19. /**
    20. 

  20. * 构造函数，绑定主机和端口.
    21. 

  21. * @param host 主机
    22. 

  22. * @param port 端口
    23. 

  23. * @throws Exception
    24. 

  24. */
    25. 

  25. public UdpServerSocket(String host, int port) throws Exception {
    26. 

  26. socketAddress = new InetSocketAddress(host, port);
    27. 

  27. ds = new DatagramSocket(socketAddress);
    28. 

  28. System.out.println("服务端启动!");
    29. 

  29. }
    30. 

  30. public final String getOrgIp() {
    31. 

  31. return orgIp;
    32. 

  32. }
    33. 

  33. /**
    34. 

  34. * 设置超时时间，该方法必须在bind方法之后使用.
    35. 

  35. * @param timeout 超时时间
    36. 

  36. * @throws Exception
    37. 

  37. */
    38. 

  38. public final void setSoTimeout(int timeout) throws Exception {
    39. 

  39. ds.setSoTimeout(timeout);
    40. 

  40. }
    41. 

  41. /**
    42. 

  42. * 获得超时时间.
    43. 

  43. * @return 返回超时时间.
    44. 

  44. * @throws Exception
    45. 

  45. */
    46. 

  46. public final int getSoTimeout() throws Exception {
    47. 

  47. return ds.getSoTimeout();
    48. 

  48. }
    49. 

  49. /**
    50. 

  50. * 绑定监听地址和端口.
    51. 

  51. * @param host 主机IP
    52. 

  52. * @param port 端口
    53. 

  53. * @throws SocketException
    54. 

  54. */
    55. 

  55. public final void bind(String host, int port) throws SocketException {
    56. 

  56. socketAddress = new InetSocketAddress(host, port);
    57. 

  57. ds = new DatagramSocket(socketAddress);
    58. 

  58. }
    59. 

  59. /**
    60. 

  60. * 接收数据包，该方法会造成线程阻塞.
    61. 

  61. * @return 返回接收的数据串信息
    62. 

  62. * @throws IOException
    63. 

  63. */
    64. 

  64. public final String receive() throws IOException {
    65. 

  65. packet = new DatagramPacket(buffer, buffer.length);
    66. 

  66. ds.receive(packet);
    67. 

  67. orgIp = packet.getAddress().getHostAddress();
    68. 

  68. String info = new String(packet.getData(), 0, packet.getLength());
    69. 

  69. System.out.println("接收信息：" + info);
    70. 

  70. return info;
    71. 

  71. }
    72. 

  72. /**
    73. 

  73. * 将响应包发送给请求端.
    74. 

  74. * @param bytes 回应报文
    75. 

  75. * @throws IOException
    76. 

  76. */
    77. 

  77. public final void response(String info) throws IOException {
    78. 

  78. System.out.println("客户端地址 : " + packet.getAddress().getHostAddress()
    79. 

  79. + ",端口：" + packet.getPort());
    80. 

  80. DatagramPacket dp = new DatagramPacket(buffer, buffer.length, packet
    81. 

  81. .getAddress(), packet.getPort());
    82. 

  82. dp.setData(info.getBytes());
    83. 

  83. ds.send(dp);
    84. 

  84. }
    85. 

  85. /**
    86. 

  86. * 设置报文的缓冲长度.
    87. 

  87. * @param bufsize 缓冲长度
    88. 

  88. */
    89. 

  89. public final void setLength(int bufsize) {
    90. 

  90. packet.setLength(bufsize);
    91. 

  91. }
    92. 

  92. /**
    93. 

  93. * 获得发送回应的IP地址.
    94. 

  94. * @return 返回回应的IP地址
    95. 

  95. */
    96. 

  96. public final InetAddress getResponseAddress() {
    97. 

  97. return packet.getAddress();
    98. 

  98. }
    99. 

  99. /**
    100. 

  100. * 获得回应的主机的端口.
    101. 

  101. * @return 返回回应的主机的端口.
    102. 

  102. */
    103. 

  103. public final int getResponsePort() {
    104. 

  104. return packet.getPort();
    105. 

  105. }
    106. 

  106. /**
    107. 

  107. * 关闭udp监听口.
    108. 

  108. */
    109. 

  109. public final void close() {
    110. 

  110. try {
    111. 

  111. ds.close();
    112. 

  112. } catch (Exception ex) {
    113. 

  113. ex.printStackTrace();
    114. 

  114. }
    115. 

  115. }
    116. 

  116. /**
    117. 

  117. * 测试方法.
    118. 

  118. * @param args
    119. 

  119. * @throws Exception
    120. 

  120. */
    121. 

  121. public static void main(String[] args) throws Exception {
    122. 

  122. String serverHost = "127.0.0.1";
    123. 

  123. int serverPort = 3344;
    124. 

  124. UdpServerSocket udpServerSocket = new UdpServerSocket(serverHost, serverPort);
    125. 

  125. while (true) {
    126. 

  126. udpServerSocket.receive();
    127. 

  127. udpServerSocket.response("你好,sterning!");
    128. 

  128. }
    129. 

  129. }
    130. 

  130. }
    131. 









    

  1. import java.io.*;
    2. 

  2. import java.net.*;
    3. 

  3. /**
    4. 

  4. * Copyright 2007 GuangZhou Cotel Co. Ltd.
    5. 

  5. * All right reserved.
    6. 

  6. * UDP客户端程序，用于对服务端发送数据，并接收服务端的回应信息.
    7. 

  7. * @author QPING
    8. 

  8. */
    9. 

  9. public class UdpClientSocket {
    10. 

  10. private byte[] buffer = new byte[1024];
    11. 

  11. private DatagramSocket ds = null;
    12. 

  12. /**
    13. 

  13. * 构造函数，创建UDP客户端
    14. 

  14. * @throws Exception
    15. 

  15. */
    16. 

  16. public UdpClientSocket() throws Exception {
    17. 

  17. ds = new DatagramSocket();
    18. 

  18. }
    19. 

  19. /**
    20. 

  20. * 设置超时时间，该方法必须在bind方法之后使用.
    21. 

  21. * @param timeout 超时时间
    22. 

  22. * @throws Exception
    23. 

  23. */
    24. 

  24. public final void setSoTimeout(final int timeout) throws Exception {
    25. 

  25. ds.setSoTimeout(timeout);
    26. 

  26. }
    27. 

  27. /**
    28. 

  28. * 获得超时时间.
    29. 

  29. * @return 返回超时时间
    30. 

  30. * @throws Exception
    31. 

  31. */
    32. 

  32. public final int getSoTimeout() throws Exception {
    33. 

  33. return ds.getSoTimeout();
    34. 

  34. }
    35. 

  35. public final DatagramSocket getSocket() {
    36. 

  36. return ds;
    37. 

  37. }
    38. 

  38. /**
    39. 

  39. * 向指定的服务端发送数据信息.
    40. 

  40. * @param host 服务器主机地址
    41. 

  41. * @param port 服务端端口
    42. 

  42. * @param bytes 发送的数据信息
    43. 

  43. * @return 返回构造后俄数据报
    44. 

  44. * @throws IOException
    45. 

  45. */
    46. 

  46. public final DatagramPacket send(final String host, final int port,
    47. 

  47. final byte[] bytes) throws IOException {
    48. 

  48. DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress
    49. 

  49. .getByName(host), port);
    50. 

  50. ds.send(dp);
    51. 

  51. return dp;
    52. 

  52. }
    53. 

  53. /**
    54. 

  54. * 接收从指定的服务端发回的数据.
    55. 

  55. * @param lhost 服务端主机
    56. 

  56. * @param lport 服务端端口
    57. 

  57. * @return 返回从指定的服务端发回的数据.
    58. 

  58. * @throws Exception
    59. 

  59. */
    60. 

  60. public final String receive(final String lhost, final int lport)
    61. 

  61. throws Exception {
    62. 

  62. DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
    63. 

  63. ds.receive(dp);
    64. 

  64. String info = new String(dp.getData(), 0, dp.getLength());
    65. 

  65. return info;
    66. 

  66. }
    67. 

  67. /**
    68. 

  68. * 关闭udp连接.
    69. 

  69. */
    70. 

  70. public final void close() {
    71. 

  71. try {
    72. 

  72. ds.close();
    73. 

  73. } catch (Exception ex) {
    74. 

  74. ex.printStackTrace();
    75. 

  75. }
    76. 

  76. }
    77. 

  77. /**
    78. 

  78. * 测试客户端发包和接收回应信息的方法.
    79. 

  79. * @param args
    80. 

  80. * @throws Exception
    81. 

  81. */
    82. 

  82. public static void main(String[] args) throws Exception {
    83. 

  83. UdpClientSocket client = new UdpClientSocket();
    84. 

  84. String serverHost = "127.0.0.1";
    85. 

  85. int serverPort = 3344;
    86. 

  86. client.send(serverHost, serverPort, ("你好，阿蜜果!").getBytes());
    87. 

  87. String info = client.receive(serverHost, serverPort);
    88. 

  88. System.out.println("服务端回应数据：" + info);
    89. 

  89. }
    90. 

  90. }
    91. 









上一篇：core--线程同步（内核模式）

下一篇：MyEclipse 启动 tomcate 失败 解决方法