Socket网络编程(三)——TCP快速入门

news2025/2/24 21:33:21

目录

概述

  1. TCP是什么
    英语：Transmission Control Protocol，缩写为 TCP
    TCP是传输控制协议；是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义
    与UDP一样完成第四层传输层所指定的功能与职责

  2. TCP的机制
    三次握手、四次挥手
    具有校验机制、可靠、数据传输稳定

  3. TCP能做什么
    聊天消息传输、推送
    单人语音、视频聊天等
    几乎UDP能做的都能做，但需要考虑复杂性、性能问题
    限制：无法进行广播，多播等操作

TCP连接可靠性

1. 三次握手过程

20240228-020352-Ph.png
三次握手的过程包括：

第一次握手：客户端发送SYN包，携带自己的序列号。
第二次握手：服务器端回复SYN+ACK包，确认收到客户端的SYN包，并携带自己的序列号。
第三次握手：客户端回复ACK包，确认收到的SYN+ACK包，完成握手过程。

这个过程确保了后续数据的可靠传输和完整性，保障了网络通信的稳定性和可靠性。

2. 四次挥手过程

20240228-020858-ym.png
四次挥手是TCP协议中用于终止连接的过程，这个过程涉及到客户端和服务端之间发送四个数据包。由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。在四次挥手中，首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭。1234

以下是四次挥手的详细步骤：

第一次挥手：客户端发送一个FIN报文，用来关闭客户端到服务器的数据传送。此时客户端进入FIN_WAIT_1状态.
第二次挥手：服务器收到FIN报文后，发送一个ACK报文作为响应，确认序号为收到序号加1。此时服务器进入CLOSE_WAIT状态。
第三次挥手：服务器完成数据发送任务后，发送一个FIN报文，用来关闭服务器到客户端的数据传送。此时服务器进入LAST_ACK状态。
第四次挥手：客户端收到FIN报文后，发送一个ACK报文作为响应，确认序号为收到序号加1。此时客户端进入TIME_WAIT状态。客户端在等待一段时间（通常为2MSL，即最大报文段寿命）后，如果没有收到服务器的任何响应，则进入CLOSE状态。

这个过程确保了双方都能正确关闭连接，避免了数据丢失。

3. 为什么挥手需要四次？

由于 TCP 的半关闭（half-close）特性，TCP 提供了连接的一端在结束它的发送后还能接收来自另一端数据的能力。

任何一方都可以在数据传送结束后发出连接释放的通知，待对方确认后进入半关闭状态。当另一方也没有数据再发送的时候，则发出连接释放通知，对方确认后就完全关闭了TCP连接。
通俗的来说，两次握手就可以释放一端到另一端的 TCP 连接，完全释放连接一共需要四次握手。

可以用下面这个例子理解：

举个例子：A 和 B 打电话，通话即将结束后，A 说 “我没啥要说的了”，B 回答 “我知道了”，于是 A 向 B 的连接释放了。但是 B 可能还会有要说的话，于是 B 可能又巴拉巴拉说了一通，最后 B 说“我说完了”，A 回答“知道了”，于是 B 向 A 的连接释放了，这样整个通话就结束了。

传输可靠性

  1. 排序、顺序发送、顺序组装
  2. 丢弃、超时
  3. 重发机制-定时器

数据传输示意图
20240228-022539-2k.png

TCP核心API

socket()：创建—个Socket
bind():绑定一个Socket到一个本地地址和端口上
connect()：连接到远程套接字
accept()：接受一个新的连接
write()：把数据写入到Socket输出流
read()：从Socket输入流读取数据

客户端Socket创建流程：
20240228-013916-lO.png

服务端ServerSocket创建流程：
20240228-014016-IO.png

Socket和进程的关系：
20240228-014241-Xq.png

TCP传输初始化配置&建立连接

  1. 初始化服务器TCP链接监听
  2. 初始化客户端发起链接操作
  3. 服务器Socket链接处理

客户端创建Socket建立连接

  1. 创建Socket基本方法和构造函数
private static Socket createSocket() throws IOException {
        /*
        // 无代理模式，等效于空构造函数
        Socket socket = new Socket(Proxy.NO_PROXY);

        // 新建一份具有HTTP代理的套接字，传输数据将通过www.baidu.com:8080端口转发
        Proxy proxy = new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(Inet4Address.getByName("www.baidu.com"), 8800));
        socket = new Socket(proxy);

        // 新建一个套接字，并且直接链接到本地20000的服务器上
        socket = new Socket("localhost", PORT);

        // 新建一个套接字，并且直接链接到本地20000的服务器上
        socket = new Socket(Inet4Address.getLocalHost(), PORT);

        // 新建一个套接字，并且直接链接到本地20000的服务器上，并且绑定到本地20001端口上
        socket = new Socket("localhost", PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        socket = new Socket(Inet4Address.getLocalHost(), PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        */

        Socket socket = new Socket();
        // 绑定到本地20001端口
        socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), LOCAL_PORT));

        return socket;
    }
  1. 初始化Socket的基本配置
private static void initSocket(Socket socket) throws SocketException {
        // 设置读取超时时间为2秒
        socket.setSoTimeout(2000);

        // 是否复用未完全关闭的Socket地址，对于指定bind操作后的套接字有效
        socket.setReuseAddress(true);

        // 是否开启Nagle算法
        socket.setTcpNoDelay(true);

        // 是否需要在长时无数据响应时发送确认数据（类似心跳包），时间大约为2小时
        socket.setKeepAlive(true);

        // 对于close关闭操作行为进行怎样的处理；默认为false，0
        // false、0：默认情况，关闭时立即返回，底层系统接管输出流，将缓冲区内的数据发送完成
        // true、0：关闭时立即返回，缓冲区数据抛弃，直接发送RST结束命令到对方，并无需经过2MSL等待
        // true、200：关闭时最长阻塞200毫秒，随后按第二情况处理
        socket.setSoLinger(true, 20);

        // 是否让紧急数据内敛，默认false；紧急数据通过 socket.sendUrgentData(1);发送
        socket.setOOBInline(true);

        // 设置接收发送缓冲器大小
        socket.setReceiveBufferSize(64 * 1024 * 1024);
        socket.setSendBufferSize(64 * 1024 * 1024);

        // 设置性能参数：短链接，延迟，带宽的相对重要性
        socket.setPerformancePreferences(1, 1, 0);
    }
  1. 客户端手动连接
public static void main(String[] args) throws IOException {
        Socket socket = createSocket();

        initSocket(socket);

        // 链接到本地20000端口，超时时间3秒，超过则抛出超时异常
        socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 3000);

        System.out.println("已发起服务器连接，并进入后续流程～");
        System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
        System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());

        try {
            // 发送接收数据
            todo(socket);
        } catch (Exception e) {
            System.out.println("异常关闭");
        }

        // 释放资源
        socket.close();
        System.out.println("客户端已退出～");

    }

服务端创建ServerSocket监听连接

  1. 创建ServerSocket方法
private static ServerSocket createServerSocket() throws IOException {
        // 创建基础的ServerSocket
        ServerSocket serverSocket = new ServerSocket();

        // 绑定到本地端口20000上，并且设置当前可允许等待链接的队列为50个
        //serverSocket = new ServerSocket(PORT);

        // 等效于上面的方案，队列设置为50个
        //serverSocket = new ServerSocket(PORT, 50);

        // 与上面等同
        // serverSocket = new ServerSocket(PORT, 50, Inet4Address.getLocalHost());

        return serverSocket;
    }
  1. 初始化ServerSocket配置
private static void initServerSocket(ServerSocket serverSocket) throws IOException {
        // 是否复用未完全关闭的地址端口
        serverSocket.setReuseAddress(true);

        // 等效Socket#setReceiveBufferSize
        serverSocket.setReceiveBufferSize(64 * 1024 * 1024);

        // 设置serverSocket#accept超时时间
        // serverSocket.setSoTimeout(2000);

        // 设置性能参数：短链接，延迟，带宽的相对重要性
        serverSocket.setPerformancePreferences(1, 1, 1);
    }
  1. 监听服务端固定端口，并且接受客户端建立连接
private static final int PORT = 20000;

    public static void main(String[] args) throws IOException {
        ServerSocket server = createServerSocket();

        initServerSocket(server);

        // 绑定到本地端口上
        server.bind(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 50);


        System.out.println("服务器准备就绪～");
        System.out.println("服务器信息：" + server.getInetAddress() + " P:" + server.getLocalPort());


        // 等待客户端连接
        for (; ; ) {
            // 得到客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();
        }
    }

ServerSocket 和 Socket的关系

serverSocket 和 Socket 都是 Java 中用于网络通信的类，但它们有不同的作用。

Socket 是用于建立连接的类，它可以让客户端和服务器之间相互通信。

ServerSocket 是用于监听连接请求的类，它在服务器端等待客户端的连接请求，并在连接成功后与客户端建立对应的 Socket 连接。

具体工作原理可以简单描述为：

当客户端与服务器建立连接时，客户端通过创建 Socket 对象实现，服务器端则通过创建 ServerSocket 对象实现。
客户端向服务器发送连接请求，请求中包含了要连接的服务器地址和端口号。
ServerSocket 接收到连接请求后，会生成一个 Socket 对象与客户端连接，并返回此连接对应的 Socket 对象。
客户端和服务器之间即可通过这个连接进行通信。

总之，ServerSocket 是用于监听连接请求的类，而 Socket 则是用于实现连接并进行通信的类。

Socket基本数据类型传输

基础类型数据传输

  • byte、 char、 short
  • boolean、 int、 long
  • float、 double、 string

客户端数据传输

  1. 客户端使用Socket输出流将客户端的数据传输出去
  2. 建立连接之后将各种数据类型的数据转换成byte字节数组，然后通过ByteBuffer工具统一放入字节流
    （这里使用到了一个ByteBuffer工具，这是一个字节缓冲区，后面会详细介绍）
  3. 最后通过Socket的输出流把数据发送给服务端

代码如下：

private static void todo(Socket client) throws IOException {
        // 得到Socket输出流
        OutputStream outputStream = client.getOutputStream();


        // 得到Socket输入流
        InputStream inputStream = client.getInputStream();
        byte[] buffer = new byte[256];
        ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);

        // byte
        byteBuffer.put((byte) 126);

        // char
        char c = 'a';
        byteBuffer.putChar(c);

        // int
        int i = 2323123;
        byteBuffer.putInt(i);

        // bool
        boolean b = true;
        byteBuffer.put(b ? (byte) 1 : (byte) 0);

        // Long
        long l = 298789739;
        byteBuffer.putLong(l);


        // float
        float f = 12.345f;
        byteBuffer.putFloat(f);


        // double
        double d = 13.31241248782973;
        byteBuffer.putDouble(d);

        // String
        String str = "Hello你好！";
        byteBuffer.put(str.getBytes());

        // 发送到服务器
        outputStream.write(buffer, 0, byteBuffer.position() + 1);

        // 接收服务器返回
        int read = inputStream.read(buffer);
        System.out.println("收到数量：" + read);

        // 资源释放
        outputStream.close();
        inputStream.close();
    }

服务端数据接收

  1. 获取监听到连接的客户端Socket套接字流
  2. 将流读取出来，转换成ByteBuffer
  3. 最后根据不同的数据类型将ByteBuffer中的数据读取并且打印出来
/**
     * 客户端消息处理
     */
    private static class ClientHandler extends Thread {
        private Socket socket;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();
            System.out.println("新客户端连接：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

            try {
                // 得到套接字流
                OutputStream outputStream = socket.getOutputStream();
                InputStream inputStream = socket.getInputStream();

                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);

                // byte
                byte be = byteBuffer.get();

                // char
                char c = byteBuffer.getChar();

                // int
                int i = byteBuffer.getInt();

                // bool
                boolean b = byteBuffer.get() == 1;

                // Long
                long l = byteBuffer.getLong();

                // float
                float f = byteBuffer.getFloat();

                // double
                double d = byteBuffer.getDouble();

                // String
                int pos = byteBuffer.position();
                String str = new String(buffer, pos, readCount - pos - 1);

                System.out.println("收到数量：" + readCount + " 数据："
                        + be + "\n"
                        + c + "\n"
                        + i + "\n"
                        + b + "\n"
                        + l + "\n"
                        + f + "\n"
                        + d + "\n"
                        + str + "\n");

                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();

            } catch (Exception e) {
                System.out.println("连接异常断开");
            } finally {
                // 连接关闭
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("客户端已退出：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

        }
    }

TCP连接客户端、服务端完整代码

服务端代码：

package cn.kt.SocketDemoL4;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;

public class Server {
    private static final int PORT = 20000;

    public static void main(String[] args) throws IOException {
        ServerSocket server = createServerSocket();

        initServerSocket(server);

        // 绑定到本地端口上
        server.bind(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 50);


        System.out.println("服务器准备就绪～");
        System.out.println("服务器信息：" + server.getInetAddress() + " P:" + server.getLocalPort());


        // 等待客户端连接
        for (; ; ) {
            // 得到客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();
        }
    }

    private static ServerSocket createServerSocket() throws IOException {
        // 创建基础的ServerSocket
        ServerSocket serverSocket = new ServerSocket();

        // 绑定到本地端口20000上，并且设置当前可允许等待链接的队列为50个
        //serverSocket = new ServerSocket(PORT);

        // 等效于上面的方案，队列设置为50个
        //serverSocket = new ServerSocket(PORT, 50);

        // 与上面等同
        // serverSocket = new ServerSocket(PORT, 50, Inet4Address.getLocalHost());

        return serverSocket;
    }

    private static void initServerSocket(ServerSocket serverSocket) throws IOException {
        // 是否复用未完全关闭的地址端口
        serverSocket.setReuseAddress(true);

        // 等效Socket#setReceiveBufferSize
        serverSocket.setReceiveBufferSize(64 * 1024 * 1024);

        // 设置serverSocket#accept超时时间
        // serverSocket.setSoTimeout(2000);

        // 设置性能参数：短链接，延迟，带宽的相对重要性
        serverSocket.setPerformancePreferences(1, 1, 1);
    }

    /**
     * 客户端消息处理
     */
    private static class ClientHandler extends Thread {
        private Socket socket;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();
            System.out.println("新客户端连接：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

            try {
                // 得到套接字流
                OutputStream outputStream = socket.getOutputStream();
                InputStream inputStream = socket.getInputStream();

                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);

                // byte
                byte be = byteBuffer.get();

                // char
                char c = byteBuffer.getChar();

                // int
                int i = byteBuffer.getInt();

                // bool
                boolean b = byteBuffer.get() == 1;

                // Long
                long l = byteBuffer.getLong();

                // float
                float f = byteBuffer.getFloat();

                // double
                double d = byteBuffer.getDouble();

                // String
                int pos = byteBuffer.position();
                String str = new String(buffer, pos, readCount - pos - 1);

                System.out.println("收到数量：" + readCount + " 数据："
                        + be + "\n"
                        + c + "\n"
                        + i + "\n"
                        + b + "\n"
                        + l + "\n"
                        + f + "\n"
                        + d + "\n"
                        + str + "\n");

                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();

            } catch (Exception e) {
                System.out.println("连接异常断开");
            } finally {
                // 连接关闭
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("客户端已退出：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

        }
    }
}

客户端代码

package cn.kt.SocketDemoL4;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.nio.ByteBuffer;

public class Client {
    private static final int PORT = 20000;
    private static final int LOCAL_PORT = 20001;

    public static void main(String[] args) throws IOException {
        Socket socket = createSocket();

        initSocket(socket);

        // 链接到本地20000端口，超时时间3秒，超过则抛出超时异常
        socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 3000);

        System.out.println("已发起服务器连接，并进入后续流程～");
        System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
        System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());

        try {
            // 发送接收数据
            todo(socket);
        } catch (Exception e) {
            System.out.println("异常关闭");
        }

        // 释放资源
        socket.close();
        System.out.println("客户端已退出～");

    }

    private static Socket createSocket() throws IOException {
        /*
        // 无代理模式，等效于空构造函数
        Socket socket = new Socket(Proxy.NO_PROXY);

        // 新建一份具有HTTP代理的套接字，传输数据将通过www.baidu.com:8080端口转发
        Proxy proxy = new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(Inet4Address.getByName("www.baidu.com"), 8800));
        socket = new Socket(proxy);

        // 新建一个套接字，并且直接链接到本地20000的服务器上
        socket = new Socket("localhost", PORT);

        // 新建一个套接字，并且直接链接到本地20000的服务器上
        socket = new Socket(Inet4Address.getLocalHost(), PORT);

        // 新建一个套接字，并且直接链接到本地20000的服务器上，并且绑定到本地20001端口上
        socket = new Socket("localhost", PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        socket = new Socket(Inet4Address.getLocalHost(), PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        */

        Socket socket = new Socket();
        // 绑定到本地20001端口
        socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), LOCAL_PORT));

        return socket;
    }

    private static void initSocket(Socket socket) throws SocketException {
        // 设置读取超时时间为2秒
        socket.setSoTimeout(2000);

        // 是否复用未完全关闭的Socket地址，对于指定bind操作后的套接字有效
        socket.setReuseAddress(true);

        // 是否开启Nagle算法
        socket.setTcpNoDelay(true);

        // 是否需要在长时无数据响应时发送确认数据（类似心跳包），时间大约为2小时
        socket.setKeepAlive(true);

        // 对于close关闭操作行为进行怎样的处理；默认为false，0
        // false、0：默认情况，关闭时立即返回，底层系统接管输出流，将缓冲区内的数据发送完成
        // true、0：关闭时立即返回，缓冲区数据抛弃，直接发送RST结束命令到对方，并无需经过2MSL等待
        // true、200：关闭时最长阻塞200毫秒，随后按第二情况处理
        socket.setSoLinger(true, 20);

        // 是否让紧急数据内敛，默认false；紧急数据通过 socket.sendUrgentData(1);发送
        socket.setOOBInline(true);

        // 设置接收发送缓冲器大小
        socket.setReceiveBufferSize(64 * 1024 * 1024);
        socket.setSendBufferSize(64 * 1024 * 1024);

        // 设置性能参数：短链接，延迟，带宽的相对重要性
        socket.setPerformancePreferences(1, 1, 0);
    }

    private static void todo(Socket client) throws IOException {
        // 得到Socket输出流
        OutputStream outputStream = client.getOutputStream();


        // 得到Socket输入流
        InputStream inputStream = client.getInputStream();
        byte[] buffer = new byte[256];
        ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);

        // byte
        byteBuffer.put((byte) 126);

        // char
        char c = 'a';
        byteBuffer.putChar(c);

        // int
        int i = 2323123;
        byteBuffer.putInt(i);

        // bool
        boolean b = true;
        byteBuffer.put(b ? (byte) 1 : (byte) 0);

        // Long
        long l = 298789739;
        byteBuffer.putLong(l);


        // float
        float f = 12.345f;
        byteBuffer.putFloat(f);


        // double
        double d = 13.31241248782973;
        byteBuffer.putDouble(d);

        // String
        String str = "Hello你好！";
        byteBuffer.put(str.getBytes());

        // 发送到服务器
        outputStream.write(buffer, 0, byteBuffer.position() + 1);

        // 接收服务器返回
        int read = inputStream.read(buffer);
        System.out.println("收到数量：" + read);

        // 资源释放
        outputStream.close();
        inputStream.close();
    }
}

执行结果

  1. 运行服务端
    20240228-151715-ZN.png

  2. 运行客户端
    20240228-151741-r9.png

  3. 服务端接收到消息并输出

20240228-151758-6Y.png

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1477841.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【MySQL】内置函数 -- 详解

【MySQL】内置函数 -- 详解

一、日期函数 日期：年月日时间：时分秒 1、获得年月日 2、获得时分秒 3、获得时间戳 4、在日期的基础上加日期 5、在日期的基础上减去时间 6、计算两个日期之间相差多少天 7、获得当前时间 ⚪练习 （1）记录生日 （2&…
阅读更多...
反转局部链表+牛客

反转局部链表+牛客

题目链接 链表内指定区间反转_牛客题霸_牛客网 题目描述 代码实现 class Solution { public:/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * param head ListNode类 * param m int整型 * param n int整型 * retur…
阅读更多...
微服务篇之分布式事务

微服务篇之分布式事务

一、Seata架构 Seata事务管理中有三个重要的角色： TC (Transaction Coordinator) - 事务协调者：维护全局和分支事务的状态，协调全局事务提交或回滚。 TM (Transaction Manager) - 事务管理器：定义全局事务的范围、开始全局事务、…
阅读更多...
ConvTranspose1d详解

ConvTranspose1d详解

文章目录 ConvTranspose1d简介二、Parameters三、Shape1、Input(batch_size, in_channels, input_length)2、kernel_size(in_channels, out_channels, kernel_size)3、Output(batch_size, out_channels, output_length) 四、Variables ConvTranspose1d简介 class torch.nn.Con…
阅读更多...
c++ for 循环语句

c++ for 循环语句

循环语句 在C中，有几种循环语句可用于重复执行一段代码，直到满足指定条件为止，主要有 for 循环、while 循环、do-while 循环三种循环语句。三者区别： 循环类型特点for 循环1. 适用于已知循环次数的情况，循环次数事先…
阅读更多...
threejs 大场景下，对小模型进行贴图处理

threejs 大场景下，对小模型进行贴图处理

接上篇小模型的删除☞threeJS 大模型中对小模型进行删除-CSDN博客 针对已有模型，根据数据状态进行贴图处理，例如：机房内电脑告警状态、电脑开关机状态下的不同状态贴图等 示例模型还是以丛林小屋为例：针对该模型中的树干进行贴图…
阅读更多...
不是苹果放弃电动车，是电动车不需要苹果

不是苹果放弃电动车，是电动车不需要苹果

苹果弃车 2月28号凌晨，著名外媒爆料：苹果公司放弃投入十多年的造车项目，将其中的大量资源转投至 AI 部门。 如此炸裂的事情，自然少不了世界级网红，特斯拉 CEO 埃隆马斯克的点评： 敬礼香烟？ 有点…
阅读更多...
搭建LNMP环境并配置个人博客系统

搭建LNMP环境并配置个人博客系统

LNMP是Linux（操作系统）、Nginx（Web服务器）、MySQL（数据库）和PHP（脚本解释器）的组合，常用于部署高性能的动态网站，如WordPress等博客平台 一、安装Linux操作系…
阅读更多...
python dictionary 字典

python dictionary 字典

Python 字典 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下 d {key1 : value1, key2 : value2, key3 : value3 }dict 作…
阅读更多...
NVIDIA DGX H100概述

NVIDIA DGX H100概述

NVIDIA DGX H100系统是一种专为AI基础架构和工作负载而设计的专用多功能解决方案，涵盖了从分析和训练到推理的各种应用场景。它包括NVIDIA Base Command™和NVIDIA AI企业软件套件，以及来自NVIDIA DGXperts的专业建议。 DGX H100硬件和组件特性 硬件概…
阅读更多...
数据卷dockerfile

数据卷dockerfile

目录 一、数据卷 1. 简介 2. 数据卷和数据卷容器 1. 数据卷： 2. 数据卷容器： 二、自定义镜像 1. 作用 2. 自定义centos 3. 自定义tomcat8 一、数据卷 1. 简介 数据卷是一个可供一个或多个容器使用的特殊目录，它将主机操作系统目录直…
阅读更多...
TOMCAT的安装与基本信息

TOMCAT的安装与基本信息

目录 引言 一、TOMCAT简介 二、TOMCAT安装 （一）JDK简介 （二）安装Oracle JDK 1.rpm安装 2.二进制安装 （三）安装TOMCAT 三、配置文件介绍及核心组件 （一）配置文件 1.目录文…
阅读更多...
lv19 多态 4

lv19 多态 4

1 虚函数 虚函数&#xff08; 基类指针可指向派生类对象&#xff0c; 动态联编&#xff09; 先看示例&#xff0c;不加virtual&#xff0c;不认对象认指针。 #include <iostream>using namespace std;class A{ public:A(){ }~A(){ }void show(){cout<<"AAA…
阅读更多...
CSS:弹性盒子Flexible Box布局

CSS:弹性盒子Flexible Box布局

CSS:Flexible Box弹性盒子布局 一、flex布局原理 ​ flex是flexible Box的缩写,意为 ”弹性布局“&#xff0c;用来为盒状模型提供最大的灵活性&#xff0c;任何一个容器都可以指定为flex布局。 当我们的父盒子设置为flex布局之后&#xff0c;子元素的 float 、clear 和 vert…
阅读更多...
实验室记账项目（java+Mysql+jdbc）

实验室记账项目（java+Mysql+jdbc）

前言&#xff1a; 因为自己学习能力有限和特殊情况必须要找一个项目来做&#xff0c;但是上网搜的那些项目有两种&#xff08;一种是技术太多&#xff0c;自己能力不够&#xff1b;一种是技术太少&#xff0c;项目太简单&#xff09;导致都不适合本人&#xff0c;本人现有技术只…
阅读更多...
C语言实现21点游戏【单人模式，双人模式，单-多电脑模式】，21点又名黑杰克（英文：Blackjack）

C语言实现21点游戏【单人模式，双人模式，单-多电脑模式】，21点又名黑杰克（英文：Blackjack）

项目背景&#xff1a; 21点又名黑杰克&#xff08;英文&#xff1a;Blackjack&#xff09; &#xff0c;起源于法国&#xff0c;已流传到世界各地。21点&#xff0c;是一种使用扑克牌玩的赌博游戏。亦是唯一一种在赌场中可以在概率中战胜庄家的一种赌博游戏。 现在在世界各地…
阅读更多...
疾控污水采样设备需具备云控功能吗

疾控污水采样设备需具备云控功能吗

疾控污水采样设备是否需要具备云控功能&#xff0c;是一个值得深入探讨的问题。从当前的技术发展趋势和实际应用需求来看&#xff0c;具备云控功能的疾控污水采样设备具有显著的优势和必要性。 第一&#xff0c;云控技术的应用可以实现远程监控和管理。在污水采样过程中&#…
阅读更多...
数字后端——DEF文件格式

数字后端——DEF文件格式

文章目录 MACRO的不同orientationDEF中在macro orientation定义前需要留空格 MACRO的不同orientation DEF中在macro orientation定义前需要留空格 像下图中这种方向和分号之间没有空格的情况&#xff0c;就是有问题的格式。
阅读更多...
大数据旅游数据分析：基于Python旅游数据采集可视化分析推荐系统

大数据旅游数据分析：基于Python旅游数据采集可视化分析推荐系统

文章目录 基于Python旅游数据采集可视化分析推荐系统一、项目概述二、项目说明三、开发环境四、功能实现五、系统页面实现用户登录注册系统首页数据操作管理价格与销量分析旅游城市和景点等级分析旅游数据评分情况分析旅游数据评论情况分析旅游景点推荐Django系统后台管理 六、…
阅读更多...
mongo之常用数据库操作

mongo之常用数据库操作

目录 一、准备环境 二、日常记录及执行示范 连接数据库查询版本查询表总数模糊查询(使用正则)查询文档中数据条数排序大于等于查询有哪些库时间查询不在条件内的查询复制数据更新字段名称删除数据库 四、高阶查询 五、备份迁移数据库 总结 一、准备环境 借鉴&#xff1a;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023