网络编程之 UDP 多线程实现在线咨询

 

在线咨询：两个人都可以是发送方，也可以是接收方，实现网上在线咨询正常通信。

 

 

聊天发送线程

 

package chat;

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;

/**
 * 聊天发送线程：
 * 重写 run 方法通过 implements 关键字实现 Runnable 接口
 * 重写方法快捷键：Ctrl + O
 */
public class TalkSend implements Runnable {

    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort; //从哪个端口
    private String toIP; //到哪个地址
    private int toPort; //到哪个端口

    //构造：Alt + Insert
    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        //快捷键：Ctrl + Alt + T
        try {
            //构造一个数据报套接字并将其绑定到本地主机上的指定端口
            socket = new DatagramSocket(fromPort);

            //准备数据：控制台读取：System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true){
            try {
                String data = reader.readLine();
                byte[] dataBytes = data.getBytes();
                DatagramPacket packet = new DatagramPacket(dataBytes, 0 , dataBytes.length, new InetSocketAddress(this.toIP, this.toPort));

                //发送数据包
                socket.send(packet);

                //当发送一句 bye 的时候表示结束发送
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //关闭
        socket.close();

    }
}

聊天接收线程

 

package chat;

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

/**
 * 聊天接收线程：
 * 重写 run 方法通过 implements 关键字实现 Runnable 接口
 * 重写方法快捷键：Ctrl + O
 */
public class TalkReceive implements Runnable {

    DatagramSocket socket = null;

    private int port;
    private String msgFrom;

    //构造
    public TalkReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true){
            try {
                //准备接收数据包
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);

                //接收数据包
                socket.receive(packet); //阻塞式接收包裹

                //读取数据
                byte[] data = packet.getData();

                String receiveData = new String(data, 0, data.length);

                //接收到的数据
                System.out.println(msgFrom + "：" + receiveData);

                //当我们说一声 bye 的时候就表示断开连接
                if (receiveData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //关闭
        socket.close();

    }
}

学生端

 

package chat;

/**
 * 学生端
 */
public class TalkStudent {

    public static void main(String[] args) {

        /**
         * 学生端
         * 从 7777 端口发送消息
         * 发送消息到 9999 端口
         * 从 8888 端口接收消息
         *
         * 开启两个线程：
         * new TalkSend：从 77777 端口发送,发送到 localhost,发送给 9999 端口
         * @param fromPort
         * @param toIP
         * @param toPort
         *
         * new TalkReceive：从 8888 端口接收,接收来自 “老师” 的消息
         * @param port
         * @param msgFrom
         *
         * 使用了一种模式：静态代理模式
         */
        new Thread(new TalkSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceive(8888, "老师")).start();
    }

}

老师端

 

package chat;

/**
 * 老师端
 */
public class TalkTeacher {

    public static void main(String[] args) {

        /**
         * 老师端
         * 从 5555 端口发送消息
         * 发送消息到 8888 端口
         * 从 9999 端口接收消息
         *
         * 开启两个线程：
         * new TalkSend：从 5555 端口发送,发送到 localhost,发送给 8888 端口
         * @param fromPort
         * @param toIP
         * @param toPort
         *
         * new TalkReceive：从 9999 端口接收,接收来自 “学生” 的消息
         * @param port
         * @param msgFrom
         *
         * 使用了一种模式：静态代理模式
         */
        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999, "学生")).start();
    }

}

效果一览