Day 67

本文介绍了使用Java实现UDP通信程序,包括从键盘输入数据直到输入'886'结束发送,以及TCP发送和接收数据的步骤。同时,提供了一个TCP通信程序的练习,涉及客户端发送数据并接收服务器反馈,以及服务器接收数据并作出响应。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

_UDP通信程序联系

  1. 按照下面的要求实现程序:

    • UDP发送数据:数据来自于键盘,直到输入的数据是886,发送数据结束
    • UDP接收数据:因为接收端不知道发送端什么时候停止发送,故采取死循环接收
  2. package demo22;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    
    
    public class Send_Demo {
        public static void main(String[] args) {
            /*
            UDP发送数据:数据来自于键盘,知道输入的数据是886,发送数据结束
             */
    
            // DatagramSocket建立发送点
            BufferedReader br = null;
            try {
                DatagramSocket ds = new DatagramSocket();
    
                // 键盘录入发送数据
                // 此处的字节缓冲流只能用InputStreamRead,不能使用其子类FileRead
                br = new BufferedReader(new InputStreamReader(System.in));
                String line;
    
                while ((line = br.readLine()) != null) {
                    if ("886".equals(line)) {
                        break;
                    }
                    // 创建数据,比把数据打包
                    // 将输入的数据编码成比特字符进行传输
                    byte[] bytes = line.getBytes();
    
                    // 调用DatagramPacket将数据打包
                        /*
                        public DatagramPacket(byte[] buf,
                          int length,
                          InetAddress address,
                          int port)
                          构造用于发送长度的分组的数据报包length指定主机上到指定的端口号。
                          length参数必须小于或等于buf.length 。
                         */
                    // 获取目的地的IP地址
                    InetAddress inetAddress = InetAddress.getByName("192.168.10.3");
                    DatagramPacket dp = new DatagramPacket(bytes, bytes.length, inetAddress, 11111);
    
                    // 发送数据
                    ds.send(dp);
                }
                // 关闭发送端
                ds.close();
            } catch (SocketException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    ==========================================
    package demo22;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class Receive_Demo {
        public static void main(String[] args) {
            /*
            UDP接收数据:因为接收端不知道发送端什么时候停止发送,故采取死循环接收
             */
            // 建立接受点
            try {
                DatagramSocket ds = new DatagramSocket(11111);
    
                // 采用死循环接收数据,直达接收到886关闭接收端
                while (true) {
                    // 创建用于接收的数据包
                    byte[] bytes = new byte[1024];
                    DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
    
                    // 调用DatagramSocket类接收数据
                    ds.receive(dp);
    
                    // 将接收到的数据解码成String类型
                    int len = dp.getLength();
                    String receiveData = new String(bytes, 0, len);
    
                    // 如果接收到886则跳出死循环
                    if (receiveData.equals("886")) {
                        break;
                    }
    
                    // 将接受到的数据在控制台输出
                    System.out.println("接收到的数据:" + receiveData);
                }
    
                // 关闭接收端
                ds.close();
            } catch (SocketException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }
    ========================================
    hello
    world
    java
    你好
    
    Process finished with exit code 130
    ========================================
    接收到的数据:hello
    接收到的数据:world
    接收到的数据:java
    接收到的数据:你好
    
    Process finished with exit code 130
    

_TCP发送数据

  1. 创建客户端的Socket对象(Socket)

  2. 获取输出流,写数据

  3. 释放资源

  4. package demo23;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    public class Client_Demo {
        public static void main(String[] args) {
            /*
            1. 创建客户端的Socket对象(Socket)
            2. 获取输出流,写数据
            3. 释放资源
            */
    
            // 创建客户端的Socket对象(Socket)
            /*
            public class Socket
            extends Object
            implements Closeable该类实现客户端套接字(也称为“套接字”)。 套接字是两台机器之间通讯的端点。
            套接字的实际工作由SocketImpl类的实例执行。 应用程序通过更改创建套接字实现的套接字工厂,可以配置自己创建适合本地防火墙的套接字。
    
            public Socket(InetAddress address,
                          int port)
           throws IOException创建流套接字并将其连接到指定IP地址的指定端口号。
             */
            try {
                Socket socket = new Socket("192.168.10.3", 10000);
    
                // 获取输出流,写数据
                /*
                public OutputStream getOutputStream()
                                 throws IOException返回此套接字的输出流。
                 */
                OutputStream os = socket.getOutputStream();
                os.write("hello world java".getBytes());
    
                // 释放资源
                os.close();
    
            } catch (IOException e) {
                e.printStackTrace();
            }
    
    
        }
    
    }
    

_TCP接收数据

  1. 接收数据的步骤:

    • 创建服务器端的Socket对象(ServerSocket)
    • 获取输入流,读取数据,并把数据显示在控制台上
    • 释放资源
  2. package demo23;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server_Demo {
        public static void main(String[] args) {
            /*
            - 创建服务器端的Socket对象(ServerSocket)
            - 获取输入流,读取数据,并把数据显示在控制台上
            - 释放资源
             */
    
            // 创建服务器端的Socket对象(ServerSocket)
            try {
                ServerSocket ss = new ServerSocket(10000);
    
                // 获取输入流
                /*
                public Socket accept()
                  throws IOException侦听要连接到此套接字并接受它。 该方法将阻塞直到建立连接。
                 */
                Socket socket = ss.accept();
    
                // 读取数据
                /*
                public InputStream getInputStream()
                               throws IOException返回此套接字的输入流。
                 */
                InputStream is = socket.getInputStream();
                byte[] bytes = new byte[1024];
                /*
                public int read(byte[] b)
                 throws IOException从输入流读取一些字节数,并将它们存储到缓冲区b 。
                 实际读取的字节数作为整数返回。 该方法阻塞直到输入数据可用,检测到文件结束或抛出异常。
                如果b的长度为零,则不会读取字节并返回0 ; 否则,尝试读取至少一个字节。
                如果没有字节可用,因为流在文件末尾,则返回值-1 ; 否则,读取至少一个字节并存储到b 。
                 */
                int len = is.read(bytes);   // 实际读取到的为字节长度
                String data = new String(bytes, 0, len);
    
                // 并把数据显示在控制台上
                System.out.println("发送的数据为:" + data);
                
                // 释放资源
                ss.close();
                socket.close();
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

_TCP通信程序练习1

  1. 练习1

    • 客户端:发送数据,接收服务器反馈

    • 服务器:接收数据,给出反馈

    • package demo23;
      
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.io.InputStream;
      import java.io.OutputStream;
      import java.net.ServerSocket;
      import java.net.Socket;
      
      public class P_Server_Demo {
          public static void main(String[] args) {
              /*
              服务器:接收数据,给出反馈
               */
      
              // 创建发送端对象ServerSocket
              try {
                  ServerSocket ss = new ServerSocket(6666);
      
                  // 获取输入流
                  Socket accept = ss.accept();
      
                  // 读取数据
                  InputStream is = accept.getInputStream();
                  byte[] bytes = new byte[1024];  // 一次读取1024个字节
                  int len = is.read(bytes);
      
                  // 将读取的数据转换成String 类型
                  String data = new String(bytes, 0, len);
      
                  System.out.println("用户所发送的数据为:" + data);
      
                  // 服务器发送反馈信息
                  OutputStream os = accept.getOutputStream();
                  os.write("消息已收到".getBytes());
      
                  // 释放资源
                  os.close();
                  ss.close();
      
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      -------------------------------------------
      package demo23;
      
      import java.io.IOException;
      import java.io.InputStream;
      import java.io.OutputStream;
      import java.net.Socket;
      
      public class P_Client_Demo {
          public static void main(String[] args) {
              /*
              客户端:发送数据,接收服务器反馈
               */
      
              // 创建发送端对象Socket对象
              try {
                  Socket socket = new Socket("192.168.10.3",6666);
      
                  // 获取数据流
                  OutputStream os = socket.getOutputStream();
      
                  // 编写需要发送的消息,并编码成比特数据
                  byte[] bytes = "xx 我爱你".getBytes();
      
                  // 用字符流发送数据
                  /*
                  public void write(byte[] b)
                  throws IOException将b.length字节从指定的字节数组写入此输出流。
                  write(b)的一般合约是应该具有与电话write(b, 0, b.length)完全相同的效果。
                   */
                  os.write(bytes);
      
                  // 接收服务器发来的反馈信息
                  InputStream is = socket.getInputStream();
                  byte[] bytes1 = new byte[1024];
                  int len = is.read(bytes1);
      
                  // 将服务器反馈的信息解码成String类型
                  String R_data = new String(bytes1, 0, len);
      
                  // 将反馈信息在控制台输出
                  System.out.println("服务器:" + R_data);
      
                  // 释放资源
                  socket.close();
                  is.close();
      
              } catch (IOException e) {
                  e.printStackTrace();
              }
      
          }
      }
      ===================================
      用户所发送的数据为:xx 我爱你
      
      Process finished with exit code 0
      ===================================
      服务器:消息已收到
      
      Process finished with exit code 0
      
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值