UDP编程 UDP连接对象的理解和使用

最新推荐文章于 2023-07-10 08:30:00 发布

Jlins

最新推荐文章于 2023-07-10 08:30:00 发布

阅读量2.5k

点赞数

分类专栏： java教程文章标签：编程 buffer byte java string 测试

本文链接：https://blog.csdn.net/dyllove98/article/details/7720048

版权

java教程专栏收录该内容

71 篇文章 1 订阅

订阅专栏

之前写了一个一个简单的UDP服务端和客户端示例，用于入门UDP，当我实际使用时发生了一点问题！

上次使用中我也把连接对象 DatagramSocket 写成了静态的，在类的初始化时使用，可是系统中有很多地方使用，难道我要不断的创建这个类的对象吗？

可以这么做，当时有后果，后果就是内存溢出。

UDP是没有状态的，DatagramSocket 创建一次即可，就是开始指向某个地址的端口，而不用每次创建。

由于UDP是无状态的，在创建 DatagramSocket 对象时只是创建了一个指向网络的对象，就像你架设一个大喇叭对着某个方向，可是你并不知道这个方向到底有没有人在听。

如果，即使你没有开服务端，创建连接对象并向这个地址放松数据，都是没有问题。你用喇叭向某个方向喊没人听这没有什么！可是当你需要回应时如果一直没有接到响应，超时之后就会报错！

    Java代码  
     
    
  
package udp;  
  
import java.net.*;  
  
/** 
 * @说明 UDP客户端程序，用于对服务端发送数据，并接收服务端的回应信息 
 * @author cuisuqiang 
 * @version 1.0 
 * @since <a href="mailto:cuisuqiang@163.com">cuisuqiang@163.com</a> 
 */  
public class UdpClientSocket {  
    /** 
     * 连接对象 
     */  
    private static DatagramSocket ds = null;  
    /** 
     * 地址对象 
     */  
    private static SocketAddress address = null;  
      
    /** 
     * 测试客户端发包和接收回应信息的方法 
     */  
    public static void main(String[] args) throws Exception {  
        init();  
        while(true){  
            UdpClientSocket.send(address,"你好，亲爱的!".getBytes());  
            UdpClientSocket.receive();  
            try {  
                Thread.sleep(3 * 1000);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    /** 
     * 对连接和地址初始化 
     */  
    public static void init(){  
        try {  
            ds = new DatagramSocket(8899); // 邦定本地端口作为客户端  
            ds.setSoTimeout(2 * 1000);  
            address = new InetSocketAddress("127.0.0.1",3344);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 向指定的服务端发送数据信息 
     */  
    public static void send(SocketAddress address,byte[] bytes){  
        try {  
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address);  
            ds.send(dp);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 接收从指定的服务端发回的数据 
     */  
    public static void receive(){  
        try {  
            byte[] buffer = new byte[1024];  
            DatagramPacket dp = new DatagramPacket(buffer, buffer.length);  
            ds.receive(dp);       
            byte[] data = new byte[dp.getLength()];  
            System.arraycopy(dp.getData(), 0, data, 0, dp.getLength());   
            System.out.println("服务端回应数据：" + new String(data));  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  

执行以代码运行结果如下：

    Java代码  
     
    
  
java.net.SocketTimeoutException: Receive timed out  
    at java.net.PlainDatagramSocketImpl.receive0(Native Method)  
    at java.net.PlainDatagramSocketImpl.receive(PlainDatagramSocketImpl.java:136)  
    at java.net.DatagramSocket.receive(DatagramSocket.java:712)  
    at udp.UdpClientSocket.receive(UdpClientSocket.java:69)  
    at udp.UdpClientSocket.main(UdpClientSocket.java:28)  

运行超时，但是报错的地方不是创建对象和发送数据，而是接收数据时超时！

这个程序一直运行，我们来搞一个服务端：

    Java代码  
     
    
  
package udp;  
  
import java.net.DatagramPacket;  
import java.net.DatagramSocket;  
import java.net.InetSocketAddress;  
import java.net.SocketAddress;  
  
/** 
 * @说明 UDP服务类 
 * @author cuisuqiang 
 * @version 1.0 
 * @since cuisuqiang@163.com 
 */  
public class UdpServerSocket {  
      
    private static DatagramSocket ds = null;  
    private static SocketAddress address = null;  
      
    /** 
     * 测试方法 
     */  
    public static void main(String[] args) throws Exception {  
        init();  
        System.out.println("---->服务开始监听！<----");  
        while (true) {  
            UdpServerSocket.receive();  
            UdpServerSocket.response(address,"你好,吃了吗!");  
        }         
    }  
      
    public static void init(){  
        try {  
            ds = new DatagramSocket(3344);  
            ds.setSoTimeout(0);  
            address = new InetSocketAddress("127.0.0.1",8899);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 接收数据包，该方法会造成线程阻塞 
     */  
    public static void receive() {  
        try {  
            byte[] buffer = new byte[1024];  
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);  
            ds.receive(packet);  
            String info = new String(packet.getData(), 0, packet.getLength());  
            System.out.println("接收信息：" + info);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 将响应包发送给请求端 
     */  
    public static void response(SocketAddress address,String info){  
        try {  
            DatagramPacket dp = new DatagramPacket(info.getBytes(), info.getBytes().length, address);  
            dp.setData(info.getBytes());  
            ds.send(dp);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }         
    }  
}  