零基础学JavaWeb开发（八）之 UDP协议和TCP协议

出世&入世

已于 2023-01-17 09:00:13 修改

阅读量388

点赞数

分类专栏： JavaWeb Java 文章标签： udp 网络 tcp/ip 学习 web

于 2023-01-16 14:45:00 首次发布

本文链接：https://blog.csdn.net/weixin_54828627/article/details/128700378

版权

Java 同时被 2 个专栏收录

100 篇文章 6 订阅

订阅专栏

JavaWeb

29 篇文章 1 订阅

订阅专栏

十、UDP协议

1、什么是UDP

UDP协议为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据报的方法，俗称面向无连接。通俗易懂讲解 UDP协议会把数据打包发送给目标地址，这个数据包能不能发送给目标地址就不管了，所以我们的udp协议它是不可靠协议、安全性低，容易丢包但是速度非常快无需类似于 tcp协议三次握手。

核心特点：面向无连接、不可靠的协议、安全系数很低容易丢包但是传输速度是非常快不需要类似于tcp协议三次握手。聊天工具

2、发送数据

1.创建发送端socket对象；

2.提供数据，并将数据封装到数据包中；

3.通过socket服务的发送功能，将数据包发出去；

4.释放资源；

在windows 操作系统中，C:\Windows\System32\drivers\etc\HOSTS 文件中新增

127.0.0.1 test.mayikt.com

3、接受数据

1.创建接收端socket对象；

2.接收数据；

3.解析数据；

4.输出数据；

5.释放资源；


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


public class UdpServer {
    public static void main(String[] args) throws IOException {
        //创建接收端socket对象
        DatagramSocket datagramSocket = new DatagramSocket(8848);
        //接收数据；
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
        //解析数据；
        System.out.println("开始接受数据.");
        datagramSocket.receive(datagramPacket);
        System.out.println("接受到数据.");
        //输出数据；
        String msg = new String(datagramPacket.getData());
        System.out.println(msg);
        //释放资源；
        datagramSocket.close();

    }
}

4、练习

使用udp协议客户端可以一直发送数据给服务器端，服务器端可以一直接受到客户端发送的数据。

如果客户端输入 666 就会直接退出程序。

public class UdpClient {
    public static void main(String[] args) throws IOException {
        // 创建DatagramSocket发送者
        DatagramSocket ds =
                new DatagramSocket();
        // 创建Scanner
        while (true) {
            System.out.println("客户端:请输入发送的内容");
            Scanner sc = new Scanner(System.in);
            String context = sc.nextLine();
            if ("666".equals(context)) {
                System.out.println("退出程序...");
                break;
            }
            byte[] data = context.getBytes();
            // 封装数据包
            DatagramPacket dp =
                    new DatagramPacket(data, data.length, InetAddress.getByName("mayikt.server.com"), 8080);
            ds.send(dp);
            System.out.println("发送数据成功...");
        }
        ds.close();
    }
}
public class UdpServer {
    public static void main(String[] args) throws IOException {
        // 创建DatagramSocket接受
        DatagramSocket ds =
                new DatagramSocket(8080);
        // 创建Scanner
        while (true) {
            //2.接收数据
            byte[] bytes = new byte[1024];
            // 数据包的形式接受
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
            ds.receive(dp);
            System.out.println("服务器端接受到数据:" + new String(dp.getData()));
        }
//        ds.close();

    }
}

十一、TCP协议

1、三次握手

TCP是面向连接的可靠协议、通过三次握手建立连接，通讯完成时拆除连接；

UDP是面向无连接通讯协议，udp通讯时不需要接受方确定，属于不可靠传输，可能会存在丢包的现象。

tcp协议需要先经历三次握手成功之后在将数据发送给服务器端确保服务器端是在在将数据

发送给服务器端。三次握手、四次挥手。

udp协议直接将数据发送给服务器端-----传输效率高缺陷没有验证服务器端

是否存在如果不在的情况下直接传输数据可能丢失数据

数据连接池目的：tcp协议连接复用

jdbc

首先我们要知道在tcp建立连接中，有一些名词表示：

比如：syn就是建立连接、ack就是确认标志、fin终止标志

第一次握手：客户端会向服务器端发送码为syn=1，随机产生一个seq_number=x的数据包到服务器端（syn）

第二次握手：服务端接受到客户端请求之后，确认ack=x+1, 于是就向客户端发送syn（服务端独立生成随机生成数字Y）+ack

第三次握手：客户端接受syn+ack，向服务器端发送ack=y+1，此包发送完毕即可建立tcp连接。

白话文翻译：

第一次握手：客户端向服务器端发送问服务器你在不在？

第二次握手：服务器端回应客户端说：我在的。

第三次握手：客户端发送给服务器端：ok，那我开始建立连接的

关闭连接：

第一次挥手：客户端向服务器端发送释放的报文，停止发送数据fin=1、生成一个序列号seq=u；

第二次挥手：服务器端接受到释放的报文后，发送ack=u+1；随机生成的seq=v给客户端；当前状态为关闭等待状态

客户端收到了服务器确认通知之后，此时客户端就会进入到终止状态，等待服务器端发送释放报文。

第三次挥手：服务器端最后数据发送完毕之后，就向客户端发送连接释放报文，FIN=1，ack=u+1 当前为半关闭状态，随机生成一个随机树w

第四次挥手，客户端必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。

服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。

白话文翻译四次挥手：

第一次挥手客户端向服务端发送一个释放连接通知；

第二次挥手服务端接受到释放通知之后，告诉给客户端说等待一下，因为可能存在有其他的数据没有发送完毕，等待数据全部传输完毕之后就开始关闭连接；

第三次挥手服务器端所有的数据发送完毕之后，就告诉客户端说现在可以释放连接了。

第四次挥手：客户端确认是最终释放连接通知，ok 就开始就向服务区端发送我们可以开始关闭连接啦；

2、客户端

1.创建发送端Socket对象（创建连接）

2.获取输出流对象；

3.发送数据；

4.释放资源；

public class TcpClient {
    public static void main(String[] args) throws IOException {
        //创建socket连接Socket
        Socket s = new Socket(InetAddress.getByName("mayikt.server.com"), 8090);
        //获取数据流对象
        OutputStream outputStream = s.getOutputStream();
        String data = "mayikt tcp";
        // 写入数据
        outputStream.write(data.getBytes());
        // 关闭资源
        outputStream.close();
        s.close();
    }
}

3、服务器端

1.创建接收端Socket对象；

2.监听（阻塞:如果建立连接失败，程序会一直阻塞，不往下执行；

3.获取输入流对象；

4.获取数据；

5.输出数据；

6.释放资源；

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class TcpServer {
    public static void main(String[] args) throws IOException {
        // 创建serverSocket
        ServerSocket serverSocket = new ServerSocket(8090);
        // 监听客户端数据
        Socket socket = serverSocket.accept();
        // 获取到客户端发送的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        System.out.println("客户端发送的数据:" + new String(bytes, 0, len));
        // 关闭资源
        inputStream.close();
        serverSocket.close();

    }
}

报错：

Exception in thread "main" java.net.ConnectException: Connection refused: connect

at java.net.DualStackPlainSocketImpl.connect0(Native Method)

at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:75)

at java.net.AbstractPlainSocketImpl

客户端连接不上服务器端 javaweb开发 http协议底层就是基于 tcp协议封装

tomcat 报错：Connection refused: connect

原因：

ip 访问不同防火墙没有关闭或者只能够在局域网访问

4、练习题

练习1

使用tcp协议客户端可以一直发送数据给服务器端，服务器端可以一直接受到客户端发送的数据。

如果客户端输入 666 就会直接退出程序。

服务器端代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;


public class TcpServer {
    public static void main(String[] args) throws IOException {
        // 创建serversocket对象
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器端启动成功....");
        while (true) {
            // 接受客户端数据
            Socket socket = serverSocket.accept();
            //inputStream
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes);
            System.out.println("服务器端接受客户端：" + new String(bytes, 0, len));
            // 服务端响应数据给客户端
            OutputStream outputStream = socket.getOutputStream();
            String resp = "我收到啦" + UUID.randomUUID().toString();
            outputStream.write(resp.getBytes());
            inputStream.close();
            outputStream.close();
            socket.close();
        }
    }
}

客户端：

package com.mayikt.test04;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;


public class TcpClinet {
    public static void main(String[] args) throws IOException {

        while (true) {
            // 创建socket对象
            Socket socket = new Socket("127.0.0.1", 8080);
            System.out.println("客户端：请输入发送数据的内容");
            Scanner sc = new Scanner(System.in);
            String context = sc.nextLine();
            if (context.equals("666")) {
                break;// 退出循环
            }
            // 获取getOutputStream
            OutputStream outputStream = socket.getOutputStream();
            // 写入数据给服务器端
            outputStream.write(context.getBytes());
            // 接受服务器端响应的内容
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes);
            System.out.println("服务端响应数据给客户端：" + new String(bytes, 0, len));
            outputStream.close();
            socket.close();
        }

    }
}

可以改造成多线程方式

练习题2

使用tcp协议实现登录

tcp服务器端代码

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;

public class TcpServer {
    public static void main(String[] args) throws IOException {
        // 服务器端可以一直接受 客户端数据
        // 创建监听端口号码 ServerSocket
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器端启动成功...");
        while (true) {
            // 监听客户端发送过来的数据注意  我们的客户端没有发送数据给服务器端 该方法就会在这里一直阻塞
            Socket socket = serverSocket.accept();
            //不允许单独new线程 线程池来维护线程----java进阶
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 接受客户端数据
                        InputStream inputStream = socket.getInputStream();
                        byte[] bytes = new byte[1024];
                        int len = inputStream.read(bytes);
                        // userName=mayikt&userPwd=123456
                        String text = new String(bytes, 0, len);
                        String[] split = text.split("&");
                        String userName = split[0].split("=")[1];
                        String userPwd = split[1].split("=")[1];
                        // 回应数据给客户端
                        OutputStream outputStream = socket.getOutputStream();
                        if (("mayikt".equals(userName) && "123456".equals(userPwd))) {
                            outputStream.write("ok".getBytes());
                        } else {
                            outputStream.write("fails".getBytes());
                        }
                        // 关闭资源
                        inputStream.close();
                        socket.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

tcp客户端代码

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class TcpClient {
    public static void main(String[] args) throws IOException {
        // 客户端是可以一直发送数据给服务器端
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户的名称：");
            String userName = sc.nextLine();
            System.out.println("请输入用户的密码：");
            String userPwd = sc.nextLine();
            Socket socket = new Socket("127.0.0.1", 8080);
            // 获取到我们的outputStream
            OutputStream outputStream = socket.getOutputStream();
            // 发送数据
            String text = "userName=" + userName + "&userPwd=" + userPwd;
            outputStream.write(text.getBytes());
            // 接受服务器端响应数据给客户端
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes);
            String resp = new String(bytes, 0, len
            );
            if ("ok".equals(resp)) {
                System.out.println("登录成功");
            } else {
                System.out.println("登录失败");
            }

            // 关闭资源
            outputStream.close();
            socket.close();
        }
    }
}

练习题3

使用tcp协议 web服务器

package com.mayikt.test06;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class HttpTcpServer {
    public static void main(String[] args) throws IOException {
        // 服务器端可以一直接受 客户端数据
        // 创建监听端口号码 ServerSocket
        ServerSocket serverSocket = new ServerSocket(80);
        System.out.println("服务器端启动成功...");
        while (true) {
            // 监听客户端发送过来的数据注意  我们的客户端没有发送数据给服务器端 该方法就会在这里一直阻塞
            Socket socket = serverSocket.accept();
            //不允许单独new线程 线程池来维护线程----java进阶
            new Thread(new Runnable() {
                @Override
                public void run() {
                    InputStream inputStream = null;
                    OutputStream outputStream = null;
                    try {
                        // 获取请求地址
                        byte[] reqByte = new byte[1024];
                        inputStream = socket.getInputStream();
                        outputStream = socket.getOutputStream();
                        int reqLen = inputStream.read(reqByte);
                        String reqUrl = new String(reqByte, 0, reqLen);
                        String url = reqUrl.split("\r\n")[0].split(" ")[1];
                        File file = new File("D:\\mayikt\\html" + url);
                        byte[] bytes = new byte[20480];
                        FileInputStream fileInputStream = new FileInputStream(file);
                        //从硬盘中读取数据到内存中
                        int len = fileInputStream.read(bytes);
                        //返回数据给浏览器
                        outputStream.write(bytes, 0, len);
                    } catch (Exception e) {
                        e.printStackTrace();
                        if (outputStream != null) {
                            try {
                                outputStream.write("404".getBytes());
                            } catch (IOException ioException) {
                                ioException.printStackTrace();
                            }
                        }
                    } finally {
                        // 关闭资源
                        try {
                            outputStream.close();
                            inputStream.close();
                            socket.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
    }
    
}

出世&入世

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
零基础学JavaWeb开发（八）之 UDP协议和TCP协议

什么是UDP协议？UDP协议为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据报的方法，俗称面向无连接。通俗易懂讲解 UDP协议会把数据打包发送给目标地址，这个数据包能不能发送给目标地址就不管了，所以我们的udp协议它是不可靠协议、安全性低，容易丢包但是速度非常快无需类似于 tcp协议三次握手。
复制链接

扫一扫