TCP及UDP协议

TCP/IP协议族

七层网络模型及其对应的TCP/IP协议

java netty tcp字节 java tcpdump_客户端

TCP与UDP对比

TCP(Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输,提供可靠的字节流服务 ,它提供的服务包括**数据流传送、可靠性、**有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送;而UDP则不为IP提供可靠性、流控或差错恢复功能。

TCP对应的是可靠性要求高的应用,而UDP对应的则是可靠性要求低、传输经济的应用。

TCP类似打电话 ,双方需要建立稳定的连接;UDP则是发短信、发邮件,不需要对方和自己建立稳定连接。

Java类实现

Java关于网络的类都封装在java.net中。

Java实现TCP协议

java服务器端:

  1. 建立服务连接地址
  2. 读取客户端消息
  • 阻塞式监听
  • 获取客户端输入
  • 使用管道流(或普通输出流)写入客户端消息
  1. 关闭资源
  2. 代码示例
//模拟发消息场景   
public static void tcpMsg() {
        try {
//            1.创建地址
            ServerSocket socket = new ServerSocket(8888);
//            2.监听、等待客户端连接
            Socket accept = socket.accept();//阻塞式监听
//            3.接收、写入客户端消息
            InputStream in = accept.getInputStream();
            ByteArrayOutputStream out = new ByteArrayOutputStream();//管道流
            byte[] buffer = new byte[124];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
                String s = new String(buffer, 0, buffer.length);
                System.out.println(s);
                System.out.println(out.toString());
            }
            //关闭资源FILO
            out.close();
            in.close();
            accept.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
}

//接收客户端文件
public static void tcpFile() {
        try {
//            1.创建服务器端口
            ServerSocket socket = new ServerSocket(8989);

//            2.等待客户端连接
            Socket accept = socket.accept();

//            3.创建输出文件
            FileOutputStream out = new FileOutputStream("cc.md");

//            4.获取客户端消息,并写入文件
            InputStream input = accept.getInputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = input.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }

//            5.通知客户端文件接收完毕
            OutputStream output = accept.getOutputStream();
            output.write("文件接收完毕".getBytes(StandardCharsets.UTF_8));

//            6.关闭资源
            output.close();
            input.close();
            out.close();
            accept.close();
            socket.close();

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

java客户端:

  1. 获取服务器连接地址
  2. 发送消息
  • 输出流
  • 文件输出流
  1. 关闭资源
  2. 代码示例
//向服务器发消息
    public static void tcpMsg() {
        try {
//            1.获取服务器地址,端口号
            InetAddress ip = InetAddress.getByName("127.0.0.1");
            int port = 8888;

//            2.创建socket连接
            Socket socket = new Socket(ip, port);

//            3.发送消息
            OutputStream out = socket.getOutputStream();
            out.write("欢迎来到世界".getBytes());

//            4.关闭资源
            out.close();
            socket.close();

        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //    向服务器发送文件
    public static void tcpFile() {
        try {
//          1.获取服务器地址和端口号,创建连接
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8989);

//          2.文件输入
            FileInputStream input = new FileInputStream("D:\\javablog\\Java反射.md");

//          3.消息发出
            OutputStream out = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = input.read(buffer)) != -1) {
                out.write(buffer, 0, buffer.length);
            }
//          4.通知文件输出结束了
            socket.shutdownOutput();

//          5.确定服务器已经收到文件
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            InputStream in = socket.getInputStream();
            byte[] buffer1 = new byte[1024];
            while ((len=in.read(buffer1))!=-1){
                outputStream.write(buffer1,0,buffer1.length);
                System.out.println(outputStream.toString());
            }

//          6.关闭资源
            in.close();
            outputStream.close();
            out.close();
            input.close();
            socket.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Java实现UDP协议

  • 发送端
  1. 创建socket连接
  2. 创建包
  3. 发送包
  4. 关闭资源
  5. 代码示例
public static void udpSendmsg() {
//1.创建socket连接
        try {
            DatagramSocket socket = new DatagramSocket();

//2.读取控制台消息
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String s = null;
            while (true) {
                s = reader.readLine();
                byte[] msg = s.getBytes(StandardCharsets.UTF_8);
//3.发送包
                InetAddress ip = InetAddress.getByName("127.0.0.1");
                int port = 8888;
                DatagramPacket packet = new DatagramPacket(msg, 0, msg.length, ip, port);
                socket.send(packet);
                if (s.equals("bye bye")) break;
            }
//4.关闭资源
            reader.close();
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
  • 接收端
  1. 创建socket连接
  2. 接收包
  3. 关闭资源
  4. 代码示例
public static void udpRecieveMsg() {
        try {
//1.创建socket连接
            int port = 8888;
            DatagramSocket socket = new DatagramSocket(port);
//2.循环接收包
            while (true) {
                byte[] bufer = new byte[1024];
                DatagramPacket packet = new DatagramPacket(bufer, 0, bufer.length);
                socket.receive(packet);
                String data = new String(packet.getData(), 0, packet.getLength());
                System.out.println(data);
                //如果消息为"bye bye",则退出聊天
                if (data.equals("bye bye")) {
                    break;
                }
            }
//3.关闭资源
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }