UDP协议接收数据与发送数据

UDP：
    把数据打包
    数据有限制
    不建立连接
    速度快
    不可靠

一些需要用到的方法：
InetAddress 类：
tring getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
String getHostName() 获取此 IP 地址的主机名。
static InetAddress getByName(String host) 在给定主机名的情况下获取主机的 IP 地址对象

        //static InetAddress getByName(String host)   在给定主机名的情况下获取主机的 IP 地址对象
        InetAddress address = InetAddress.getByName("192.168.1.104");
        // 获取两个东西：主机名，IP地址
        // String getHostName()   获取此 IP 地址的主机名。 
        String name = address.getHostName();
        // tring getHostAddress()  返回 IP 地址字符串（以文本表现形式）
        String ip = address.getHostAddress();
        System.out.println(name + "---" + ip);
输出：
192.168.1.104---192.168.1.104

UDP协议接收端：
1：创建接收端Socket对象
2：创建一个数据包(接收容器)
3:调用Socket对象的接收方法接收数据
4:解析数据包
5:释放资源

public static void main(String[] args) throws IOException {
        // 创建接收端Socket对象，并设置接收端端口
        // DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。
        DatagramSocket ds = new DatagramSocket(11521);

        // 创建一个数据包(接收容器)
        // DatagramPacket(byte[] buf, int length)构造 DatagramPacket，用来接收长度为 length 的数据包。
        byte[] bys = new byte[1024];
        int length = bys.length;
        DatagramPacket dp = new DatagramPacket(bys, length);

        // 调用Socket对象的接收方法接收数据
        // public void receive(DatagramPacket p) 从此套接字接收数据报包。
        ds.receive(dp);

        // 解析数据包，并显示在控制台
        //返回某台机器的 IP 地址对象，此数据报将要发往该机器或者是从该机器接收到的。
        // public InetAddress getAddress()
        InetAddress address = dp.getAddress();
        String ip = address.getHostAddress();
        // public byte[] getData(): 返回数据缓冲区。
        // public int getLength():返回将要发送或接收到的数据的长度。
        byte[] bys2 = dp.getData();
        int len = dp.getLength();
        String s = new String(bys2, 0, len);
        System.out.println(ip + ":" + s);

        // 释放资源
        ds.close();
    }
输出：
192.168.1.104:我是发送端

UDP协议发送端：
1:创建发送端Socket对象
2:创建数据，并把数据打包
3:调用Socket对象的发送方法发送数据包
4:释放资源

    // 创建发送端Socket对象
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上任何可用的端口。
        DatagramSocket ds = new DatagramSocket();

        // 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号
        // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        // 创建数据
        byte[] bys = "我是发送端".getBytes();
        // 长度
        int length = bys.length;
        // 接收端IP地址对象
        InetAddress address = InetAddress.getByName("192.168.1.104");
        // 接收端端口
        int port = 11521;
        DatagramPacket dp = new DatagramPacket(bys, length, address, port);

        // 调用Socket对象的发送方法发送数据包
        // public void send(DatagramPacket p)  从此套接字发送数据报包。
        ds.send(dp);

        // 释放资源
        ds.close();
    }

多线程实现接收端（服务器），发送端

接收端（服务器）

public class ReceiveDemo implements Runnable {
    private DatagramSocket receiveDs;

    public ReceiveDemo(DatagramSocket receiveDs) {
        this.receiveDs = receiveDs;
    }

    @Override
    public void run() {
        try {
            while (true) {
                DatagramPacket dgp = new DatagramPacket(new byte[1024], 1024);
                receiveDs.receive(dgp);
                System.out.println("发送端IP："+dgp.getAddress().getHostAddress()+"   内容:"+new String(dgp.getData()));

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

发送端

public class SendDemo implements Runnable {
    private DatagramSocket sendDs;
    public SendDemo(DatagramSocket sendDs) {
        this.sendDs = sendDs;
    }

    @Override
    public void run() {
        while (true) {
            try {

                //键盘输入数据
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                String line = br.readLine();
                if (line.equals("over")) {
                    break;
                }
                DatagramPacket dgp = new DatagramPacket(line.getBytes(),
                        line.getBytes().length,
                        InetAddress.getByName("192.168.1.104"), 11211);
                sendDs.send(dgp);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        sendDs.close();
    }
}

开启接收端

public class Service {
public static void main(String[] args) throws SocketException {
    DatagramSocket receive=new DatagramSocket(11211);

    ReceiveDemo rd=new ReceiveDemo(receive);

    Thread rdTh=new Thread(rd);
    rdTh.start();
}
}

输出：

发送端IP：192.168.1.104   内容:1-11
发送端IP：192.168.1.104   内容:2-11

开启2个发送端

public class Client2 {
    public static void main(String[] args) throws SocketException {
        DatagramSocket send=new DatagramSocket();


        SendDemo sd=new SendDemo(send);

        Thread sdTh=new Thread(sd);
        sdTh.start();
    }
}

输入：
2-11

public class Client1 {
    public static void main(String[] args) throws SocketException {
        DatagramSocket send=new DatagramSocket();


        SendDemo sd=new SendDemo(send);

        Thread sdTh=new Thread(sd);
        sdTh.start();
    }
}

输入：
1-11

转载于:https://www.cnblogs.com/feiZhou/p/9344452.html