UDP简单案例_双人聊天

UDP传输协议：
\quad 一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。
特点：
· 非面向连接，传输不可靠，可能丢失
· 发送不管对方是否准备好，接收方收到也不确认
· 可以广播发送
· 非常简单的协议，开销小

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/**
 * 发送端
 */
public class TalkSend implements Runnable {
    private DatagramSocket client;  //套接字
    private BufferedReader reader;  //字符缓冲流
    private String toIP;            //接收端的域名
    private int toPort;             //接收端的端口

    public TalkSend(int port, String toIP, int toPort) {
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            client = new DatagramSocket(port);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true) {
            String data;
            try {
                data = reader.readLine();
                byte[] datas = data.getBytes();
                //封装成DatagramPacket包裹，需要指定目的地
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(toIP, toPort));
                //发送包裹send(DatagramPacket p)
                client.send(packet);
                if(data.equals("bye"))
                    break;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        client.close();
    }
}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/**
 * 接收端：使用面向对象封装
 */
public class TalkReceive implements Runnable {
    DatagramSocket server; //套接字
    private String from;
    public TalkReceive(int port, String from) {
        this.from = from;
        try {
            this.server = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true) {
            byte[] container = new byte[1024 * 60]; //发过来的东西不能太大
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            //阻塞式接收包裹receive(DatagramPacket p)
            try {
                server.receive(packet);
                //分析数据
                byte[] datas = packet.getData();
                String msg = new String(datas, 0, packet.getLength());
                System.out.println(from + "：" + msg);
                if(msg.equals("bye"))
                    break;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //释放资源
        server.close();
    }
}

/**
 * 加入多线程，实现双向交流 模拟在线咨询
 */
public class TalkStudent {
    public static void main(String[] args) {
        new Thread(new TalkSend(7777, "localhost", 9999)).start(); //发送
        new Thread(new TalkReceive(8888, "老师")).start(); //接收
    }
}

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkReceive(9999, "学生")).start(); //接收
        new Thread(new TalkSend(5555, "localhost", 8888)).start(); //发送
    }
}