零基础学JavaWeb开发（八）之UDP协议和TCP协议-创新互联

十、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

相关代码：

import java.io.IOException;
import java.net.*;

public class UdpClient {
    public static void main(String[] args) throws IOException {
        //1.创建发送端socket对象；
        DatagramSocket datagramSocket = new DatagramSocket();
        //2.提供数据，并将数据封装到数据包中；
        byte[] msg = "mayikt".getBytes();
        InetAddress inetAddress = InetAddress.getByName("test.mayikt.com");
        int port = 8848;
        DatagramPacket datagramPacket = new DatagramPacket(msg, msg.length, inetAddress, port);
        //3.通过socket服务的发送功能，将数据包发出去；
        datagramSocket.send(datagramPacket);
        //4.释放资源；
        datagramSocket.close();
    }
}

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();
        }
    }
    
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

分享标题：零基础学JavaWeb开发（八）之UDP协议和TCP协议-创新互联
文章路径：http://cdxtjz.cn/article/dggghi.html