网络编程（六）UDP的应用（聊天功能的实现）

网络编程（六）UDP的应用

目录

• 网络编程（六）UDP的应用
  • UDP实现消息发送
    • • 代码实现
  • UDP聊天功能的实现
    • 实现循环接收
      • 实现代码
    • 实现两个人都能发送和接收
      • 实现代码

UDP实现消息发送

• 发送短信，不用连接，需要知道对方的地址！
• 用到DatagramSocket类和
• 因为UDP没有真正的服务器和客户端的概念，所以直接启动客户端不启动服务器也不会报错

代码实现

• 发送端

  //不需要连接服务器
  public class UdpClientDemo01 {
      public static void main(String[] args) throws Exception{
          //1.建立一个Socket
          DatagramSocket socket = new DatagramSocket();
          //2.建个包
          InetAddress localhost = InetAddress.getByName("localhost");//发送给谁
          int port=9090;
          String msg="你好，服务器";
          DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);//数据，数据的长度，发送给谁(ip和端口号)
          //3.发送包
          socket.send(packet);
          //4.关闭
          socket.close();
      }
  }
  

• 接收端

  //等待客户端连接
  public class UdpServerDemo01 {
      public static void main(String[] args) throws Exception{
          //开放端口
          DatagramSocket socket = new DatagramSocket(9090);
          //接收数据包
          byte[] buffer=new byte[1024];
          //创建包空间
          DatagramPacket packet=new DatagramPacket(buffer,0,buffer.length);
          socket.receive(packet);//阻塞接收
          System.out.println(packet.getAddress().getHostAddress());
          System.out.println(new String(packet.getData(),0,packet.getLength()));//getData()返回数据缓冲区
          //关闭连接
          socket.close();
      }
  }
  

UDP聊天功能的实现

实现循环接收

实现代码

• 接收

  //接收
  public class UdpReceiveDemo01 {
      public static void main(String[] args) throws Exception{
          DatagramSocket socket = new DatagramSocket(6666);
          //循环接收
          while (true) {
              //准备接收包裹
              byte[] container = new byte[1024];
              DatagramPacket packet = new DatagramPacket(container, 0, container.length);
              socket.receive(packet);//阻塞式接收包裹
              //断开连接(当输入为bye时断开连接)
              byte[] data=packet.getData();
              String receiveData=new String(data,0,packet.getLength());
              System.out.println(receiveData);//读出接收到了什么
              if(receiveData.equals("bye")){
                  break;
              }
  
          }
          socket.close();
      }
  }
  

• 发送端

  //发送方
  public class UdpSenderDemo01 {
      public static void main(String[] args) throws Exception{
          DatagramSocket socket = new DatagramSocket(8888);
          //准备数据，控制台System.in
          BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
          //循环输入
          while (true) {
              String data = reader.readLine();
              byte[] datas = data.getBytes();
              DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
              socket.send(packet);
              //当输入bye时停止输入
              if(data.equals("bye")){
                  break;
              }
          }
          socket.close();
      }
  }
  

实现两个人都能发送和接收

实现代码

接收类：

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(this.port);
        }catch (Exception 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);//阻塞式接收包裹
                //断开连接(当输入为bye时断开连接)
                byte[] data=packet.getData();
                String receiveData=new String(data,0,packet.getLength());
                System.out.println(msgFrom+":"+receiveData);//读出接收到了什么
                if(receiveData.equals("bye")){
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

发送类：

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromIP;
    private String toIP;
    private int toPort;

    public TalkSend(int fromIP, String toIP, int toPort) {
        this.fromIP = fromIP;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            this.socket = new DatagramSocket(fromIP);
            //准备数据，控制台System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        //循环输入
        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0,datas.length,new InetSocketAddress(this.toIP, this.toPort));
                socket.send(packet);
                //当输入bye时停止输入
                if(data.equals("bye")){
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

学生（使用接收类和发送类）：

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();//7777发送，9999接收
        new Thread(new TalkReceive(8888,"老师")).start();//老师8888接收
    }
}

老师（使用接收类和发送类）：

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

    }
}