网络编程（21）——通过beast库快速实现http服务器

目录

二十一、day21

1. 头文件和作用域重命名

2. reponse时调用的一些函数

3. http_connection

a. 构造函数

b. start()

c. process_request()

d. create_response()

e. create_post_response()

f. write_response()

4. Server

5. 主函数

6. 测试

1）测试get

2）测试post

二十一、day21

上一节学习了一个http服务器是如何实现的，以及每一步函数的实现过程。但上面大部分函数其实以及被封装好了，我们只需要调用就行了，今天跟着恋恋风辰大佬学习如何通过beast网络库快速搭建http服务器。

其实官网以及给出了如何通过beast快速搭建服务器的示例，可以参考boost官网“

Chapter 1. Boost.Beast​www.boost.org/doc/libs/1_86_0/libs/beast/doc/html/index.html

视频参考：

【C++ 网络编程(22) beast网络库实现http服务器】

https://www.bilibili.com/video/BV1Ck4y1T7na?vd_source=cb95e3058c2624d2641da6f4eeb7e3a1​www.bilibili.com/video/BV1Ck4y1T7na?vd_source=cb95e3058c2624d2641da6f4eeb7e3a1

1. 头文件和作用域重命名

#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio.hpp>
#include <ctime>
#include <cstdlib>
#include <memory>
#include <string>
#include <json/json.h>
#include <json/value.h>
#include <json/reader.h>
#include <iostream>

// 因为beast、http、net是作用域，所以可以直接用namespace重命名
// 但是tcp是一个类，所以只能通过using重命名
namespace beast = boost::beast;
namespace http = beast::http;
namespace net = boost::asio;
using tcp = boost::asio::ip::tcp;

2. reponse时调用的一些函数

namespace my_program_state {
    std::size_t request_count() { // 统计请求的次数
        static std::size_t count = 0;
        return count++;
    }

    std::time_t now() { // 当前的时间
        return std::time(0);
    }
}

只封装两个函数，一个返回请求次数，一个返回当前的时间戳

3. http_connection

封装一个http_connection类用于处理 HTTP 请求和响应。负责接收客户端请求，解析请求内容，生成适当的响应，并将响应发送回客户端。同时，该类还管理连接的超时处理，确保长时间未响应的连接能够及时关闭

class http_connection : public std::enable_shared_from_this<http_connection> {
private:
    tcp::socket _socket;
    beast::flat_buffer _buffer{ 8192 }; // 缓存区_buffer
    http::request<http::dynamic_body> _request;// 请求头
    http::response<http::dynamic_body> _response; // 回应
    net::steady_timer _deadline{ // 定时器
        _socket.get_executor(),
        std::chrono::seconds(60)
    };

    void read_request() {
    }

    void check_deadline() {
    }

    void process_request() {
    }

    void create_response() {
    }

    void write_response() {
    }

    void create_post_response() {
    }

public:
    http_connection(tcp::socket&& socket) : _socket(std::move(socket)) {}

    void start() {
        read_request(); // 读请求
        check_deadline(); // 判断超时
    }

};

http_connection类继承std::enable_shared_from_this<T>模板类，便于使用shared_from_this()函数实现伪闭包。http_connection类成员变量的解释如下：

  • _buffer：定义一个缓存区，缓存区大小不超过8k
  • _request：构造一个请求头，类型为http::request<http::dynamic_body>
    • dynamic_body：允许发送各种类型的请求
    • string_body：只允许发文本类型的请求
  • _response：响应，同样也是dynamic_body类型
  • _deadline：定时器，用于异步操作时的超时控制或延时任务，使用的是steady_timer定时器对象，即使系统时间被改变，定时器仍能够按照预期的时间触发
    • get_executor()：获取于socket相关的执行器，也就是说，定时器和socket共享相同的IO线程资源
    • std::chrono::seconds(60)：定时器在60s后被触发

成员函数的实现如下：

a. 构造函数

http_connection(tcp::socket socket) : _socket(socket) {}

该构造函数会报错，因为boost::asio::basic_stream_socket 类不支持复制构造。因此，在构造函数中尝试通过复制传递 socket 时，会发生编译错误，socket 只能通过移动语义来传递。

正确的构造函数如下：

http_connection(tcp::socket&& socket) : _socket(std::move(socket)) {}

为什么http_connection(tcp::socket socket)中按值传递不会调用复制构造函数，而是在初始化成员变量_socket(socket)时才调用复制构造函数？

http_connection(tcp::socket socket) 中的参数 socket 是按值传递的，这意味着它是从调用者那里“拷贝”进来的。由于 tcp::socket 禁止复制，但支持移动，所以编译器会自动尝试使用移动构造函数来初始化这个按值传递的参数。如果调用者传入的是一个临时对象（例如 std::move(socket) 或新创建的对象），那么这个按值传递的 socket 实际上是“移动”进来的，而不是复制进来的。

为什么仅在 _socket(socket) 这里出错？

在构造函数的初始化列表中，_socket(socket) 试图复制socket 参数，因为没有显式地使用 std::move。按值传递的参数 socket 本身是一个左值，要想移动它，必须显式地使用 std::move，将其转换为右值引用。这就是为什么必须在初始化列表中使用 std::move(socket)。

总结：

  • 按值传递的 tcp::socket 是通过移动语义构造的，不会有问题。
  • 但在初始化成员变量时，如果不显式使用 std::move，编译器会尝试复制 socket 参数，这是不允许的。因此，必须使用 std::move 使其变成右值，从而调用移动构造函数来初始化成员变量

除此之外，还有另外一种方式可以调用外界的socket，就是通过引用：

1）引用

引用绑定到已有的 socket 对象，并且始终指向这个对象，没有复制或移动。保证了在 http_connection 类中操作的 socket 与外部的 socket 是同一个对象，因此可以共享状态。

但是，由于 _socket 引用的是外部传入的对象，所以在 http_connection 对象的生命周期内，这个 socket 对象必须始终存在。如果 socket 对象被销毁了，引用就变成悬空引用，可能导致未定义行为。

tcp::socket& _socket;
http_connection(tcp::socket& socket) : _socket(socket)

2）移动构造函数

但如果我们像http_connection独立的管理connection，而不需要接收外界传递进来的socket，那么如何做？

tcp::socket _socket;
http_connection(tcp::socket socket) : _socket(std::move(socket))

或者这样写

tcp::socket _socket;
http_connection(tcp::socket&& socket) : _socket(std::move(socket))

其实 tcp::socket&& 和 tcp::socket 完全不一样，一个是按值传递，一个是右值引用，但因为socket中禁用了复制构造函数，允许移动，所以编译器会自动尝试使用移动构造函数来初始化这个按值传递的参数，所以这里都是相同的。但在其他时候，不能这样用，这两种传递完全不同。

特性引用 (tcp::socket&)移动语义 (tcp::socket&&)
对象所有权由外部对象管理由 http_connection 管理
效率无复制或移动，效率高通过移动语义高效转移对象所有权
生命周期依赖性依赖于外部对象的生命周期不依赖外部对象生命周期，自行管理
适用场景适合共享已有对象并保证生命周期的一致性适合 http_connection 需要完全控制 socket 对象

b. start()

    void start() {
        read_request(); // 读请求
        check_deadline(); // 判断超时
    }

http_connection类就是负责服务器与客户端的联系，如果server接收到一个新的客户端连接，那么就创建一个http_connection对象，并调用start函数开始读客户端的请求。

其中，read_request()函数的实现如下

    void read_request() {
        auto self = shared_from_this(); // 伪闭包
        http::async_read(_socket, _buffer, _request,
            [self](beast::error_code ec, std::size_t bytes_transferred) {
                boost::ignore_unused(bytes_transferred); // 没用到bytes_transferred参数，编译器会警告，这里直接忽略掉
                if (!ec) {
                    self->process_request();
                }
            });
    }

调用异步读async_read函数从socket读取HTTP请求，数据存储至_buffer，解析后的数据存储至_request

  • _socket: 表示与客户端的通信套接字，负责接收数据
  • _buffer: 用于临时存储接收到的原始数据（未解析的字节流）
  • _request: HTTP 请求对象，解析后的 HTTP 请求会存储在这个对象中

读取成功后调用lambda函数，因为async_read的回调函数中必须有error_code 和 bytes_transferred参数，但后者我们并没有在lambda函数体中使用到，为了避免编译器警告，通过boost::ignore_unused函数忽略该参数。当HTTP请求被成功读取后，调用process_request函数处理请求头。

    void check_deadline() {
        auto self = shared_from_this(); // 伪闭包
        _deadline.async_wait([self](boost::system::error_code ec) {
            if (!ec) {
                self->_socket.close(ec);
            }
            });
    }

check_deadline() 通常用于实现超时处理。比如在一个网络服务中，客户端可能需要在一定时间内完成请求或响应。如果超过了这个时间（如60秒），定时器会触发，然后关闭客户端的连接。这样可以避免占用资源过久，确保服务器的稳定运行。

之前学的tcp是一个长连接，但今天学习的http是一个短连接，如果处理请求时间太长，我们应该主动将其连接断掉。

通过调用异步等待async_wait函数，用于等待定时器的超时事件发生。这个函数不会阻塞当前线程，而是让程序继续执行其他任务，当定时器时间到时，执行给定的回调函数。该回调函数用于关闭套接字，断开客户端与服务器的通信连接。

该函数还有另外一种写法，你觉得对吗？

    void check_deadline() {
        auto self = shared_from_this(); // 伪闭包
        _deadline.async_wait([this](boost::system::error_code ec) {
            if (!ec) {
                this->_socket.close(ec);
            }
            });
    }

其实这个函数有风险存在，因为当调用check_deadline()时，需要过60s后判断超时后才会执行lambda函数，但是比如在58s在执行这个lambda函数时，http_connection因为某种原因（网络断开，引用计数减为0）被回收，那么lambda就会出错（this->_socket.close(ec);中this指向的空间发生了改变，那么这个close的执行是无效的，系统会崩溃）。所以必须将self传进来，让lambda捕获该参数，使其引用计数加一，实现伪闭包。

        auto self = shared_from_this(); // 伪闭包
        _deadline.async_wait([sel,thisf](boost::system::error_code ec) {
            if (!ec) {
                this->_socket.close(ec);
            }
            });

还有，如果将self显式放在捕获列表中，那么无论是否在 lambda 体内使用，引用计数都会增加，因为捕获行为本身就会创建一个 shared_ptr 的拷贝。

注意【self】和【=】的区别，后者虽然也会捕获self，但如果在函数体没有使用到的话，编译器会优化，不让其创建实例。

c. process_request()

该函数用于处理不同的HTTP请求类型（GET或POST），并根据请求的具体方法生成相应的响应数据，返回给客户端。

    void process_request() {
        _response.version(_request.version());
        _response.keep_alive(false); // true是长连接,false是短连接
        switch (_request.method()) {
        case http::verb::get:
            _response.result(http::status::ok);
            _response.set(http::field::server, "Beast");
            create_response();
            break;
        case http::verb::post:
            _response.result(http::status::ok);
            _response.set(http::field::server, "Beast");
            create_post_response();
            break;
        default:
            _response.result(http::status::bad_request);
            _response.set(http::field::content_type, "text/plain");
            beast::ostream(_response.body()) << "Invalid request-method"
                << std::string(_request.method_string()) << "'";
            break;
        }

        write_response();
    }

首先，将响应对象_response的HTTP版本设置为与请求对象_request相同的版本。HTTP 请求和响应都包含一个版本号，通常是 HTTP/1.1 或 HTTP/1.0，该操作确保响应与请求的协议版本匹配。

然后设置为短连接，keep_alive 用于决定是否启用长连接。在 HTTP/1.1 中，长连接允许客户端在同一个 TCP 连接上发送多个请求。

  • false: 表示使用短连接，即在发送完响应后，服务器将关闭连接。
  • true: 表示启用长连接，连接不会在响应后立即关闭，客户端可以继续发送更多请求。

最后，判断请求方法是GET还是POST。

如果请求方法是GET，那么

  • 设置响应状态为 http::status::ok（200 OK），表示请求成功
  • 设置响应头字段 server，其值为 "Beast"，表明服务器使用了 Beast 库
  • 调用 create_response() 来生成 GET 请求的响应数据（内容在 create_response() 中处理）

如果请求方法是POST，那么

  • 设置响应状态为 http::status::ok，表示请求成功
  • 同样设置 server 字段
  • 调用 create_post_response()，处理 POST 请求的特定逻辑

如果是未被明确处理的 HTTP 方法（如 PUT、DELETE 等），默认行为是

  • 设置响应状态为 http::status::bad_request，表示这是一个无效请求
  • 设置响应头字段 content-type 为 "text/plain"，告知客户端响应的内容类型是纯文本
  • 使用 beast::ostream(_response.body()) 向响应_response的正文中写入一条错误消息，说明这个请求使用了无效的 HTTP 方法，并附上具体的请求方法字符串

d. create_response()

该函数生成GET请求的响应数据。

    void create_response() {
        if (_request.target() == "/count") {
            _response.set(http::field::content_type, "text/html");
            beast::ostream(_response.body())
                << "<html>\n"
                << "<head><title>Request count</title></head>\n"
                << "<body>\n"
                << "<h1>Request count</h1>\n"
                << "<p>There have been "
                << my_program_state::request_count()
                << " requests so far.</p>\n"
                << "</body>\n"
                << "</html>\n";
        }
        else if (_request.target() == "/time") {
            _response.set(http::field::content_type, "text/html");
            beast::ostream(_response.body())
                << "<html>\n"
                << "<head><title>Current time</title></head>\n"
                << "<body>\n"
                << "<h1>Current time</h1>\n"
                << "<p>The current time is "
                << my_program_state::now()
                << " seconds since the epoch.</p>\n"
                << "</body>\n"
                << "</html>\n";
        }
        else {
            _response.result(http::status::not_found);
            _response.set(http::field::content_type, "text/plain");
            beast::ostream(_response.body()) << "File not found\r\n";
        }
    }

1）判断请求的URL目标路径是否为‘/count’，表示客户端请求获取请求计数

  • 在这种情况下，响应将设置内容类型为 text/html，表示返回的是一个 HTML 页面
  • 然后通过 beast::ostream(_response.body()) 将 HTML 数据写入到响应的正文中，内容包括页面的标题“Request count”和请求计数
  • my_program_state::request_count() 返回当前的请求计数，该值会被插入到响应的 HTML 中，显示在页面上

生成的HTML如下：

<html>
<head><title>Request count</title></head>
<body>
<h1>Request count</h1>
<p>There have been [请求计数] requests so far.</p>
</body>
</html>

2）判断请求的URL目标路径是否为‘/time’，表示客户端请求当前的系统时间

  • 响应同样设置内容类型为 text/html
  • 生成一个 HTML 页面，显示当前时间。时间通过 my_program_state::now() 来获取，返回自 Unix 纪元以来的秒数

生成的HTML如下：

<html>
<head><title>Current time</title></head>
<body>
<h1>Current time</h1>
<p>The current time is [当前秒数] seconds since the epoch.</p>
</body>
</html>

3）判断请求的URL目标路径既不是/count，也不是/time，则认为该资源不存在

  • 设置响应状态为 http::status::not_found，即 HTTP 404 Not Found
  • 设置内容类型为 text/plain，表示返回的是纯文本
  • 然后向响应正文写入一条简单的错误消息：File not found\r\n

e. create_post_response()

该函数处理客户端发送的 POST 请求，主要处理 /email 路径的请求，并解析接收到的 JSON 数据。函数根据收到的 POST 数据生成不同的响应。

void create_post_response() {
        if (_request.target() == "/email") {
            // 读取并打印收到的request
            auto& body = this->_request.body();
            auto body_str = boost::beast::buffers_to_string(body.data());
            std::cout << "receive body is " << body_str << std::endl;
            // 构造返回的response
            this->_response.set(http::field::content_type, "text/json");
            Json::Value root; // 发送的根
            Json::Reader reader;
            Json::Value src_root; // 原始的根
            // 解析数据
            bool parse_success = reader.parse(body_str, src_root);
            if (!parse_success) { // 解析失败
                std::cout << "Failed to parse JSON data!" << std::endl;
                root["error"] = 1001;
                std::string jsonstr = root.toStyledString();
                beast::ostream(this->_response.body()) << jsonstr; // 将数据写入body
                return;
            }
            // 解析成功
            auto email = src_root["email"].asString(); // 将收到的email转为string
            std::cout << "email is " << email << std::endl;
            root["error"] = 0;
            root["email"] = src_root["email"];
            root["msg"] = "recevie email post success";
            std::string jsonstr = root.toStyledString(); // 序列化root数据
            beast::ostream(this->_response.body()) << jsonstr; // 将数据写入body
        }
        else {
            _response.result(http::status::not_found);
            _response.set(http::field::content_type, "text/plain");
            beast::ostream(_response.body()) << "File not found\r\n";
        }
    }

1）如果客户端发送的POST请求的目标路径是‘/email’：

  • 读取并打印请求的 body： 从 _request.body() 中获取请求体数据（通常是客户端通过 POST 方式发送的内容），并将其转换为字符串格式，然后打印
  • 设置响应的内容类型：服务器将返回 JSON 格式的响应，因此设置响应的 Content-Type 为 text/json
  • 解析 JSON 数据：使用 Json::Reader 对请求体中的字符串进行 JSON 解析，解析 body_str 中的 JSON 数据，并将其存储在 src_root 中。如果解析失败，parse_success 将为 false。
    • 如果解析失败，打印错误消息并构造带有错误码的 JSON 响应，比如
{
  "error": 1001
}
    • 如果解析成功，从 src_root 中提取 email 字段，并打印它
    • 构造返回的 JSON 响应，包含 email 和成功消息
    • 最后，将 root 数据序列化为字符串并写入响应体中

返回的 JSON 响应内容类似于：

{
  "error": 0,
  "email": "example@example.com",
  "msg": "receive email post success"
}

2）如果客户端的 POST 请求目标路径不是 /email，服务器返回 HTTP 404 Not Found 错误

f. write_response()

当系统解析完请求后并执行过GET/POST的相应操作生成响应后，执行write_response函数，将生成的 HTTP 响应异步写回客户端，并在发送完成后执行一些清理操作。

    void write_response() {
        auto self = shared_from_this(); // 伪闭包
        _response.content_length(_response.body().size()); // 响应的长度
        http::async_write(_socket, _response, [self](beast::error_code ec, std::size_t) {
            // 只关闭服务器发送端，客户端收到服务器的响应后，也关闭客户端的发送端
            self->_socket.shutdown(tcp::socket::shutdown_send, ec);
            self->_deadline.cancel();
            });
    }

首先，设置响应的 Content-Length，即响应正文的长度，表示服务器将要发送的内容大小，并将该长度赋值到 HTTP 头部的 Content-Length 字段。

然后，调用异步写函数将响应_response发送到客户端，发送完成后关闭连接：

  • 关闭 TCP 连接的发送端，这意味着服务器已经完成了发送操作，但连接仍然可以用于接收数据
  • tcp::socket::shutdown_send 表示只关闭发送端，而保留接收端未关闭。这是为了遵循 TCP 的四次挥手协议：客户端在接收到服务器的响应后，应关闭自己的发送端，并最终关闭整个连接
  • 在调用 shutdown() 时遇到错误，错误信息会存储在 ec 中，但不做额外处理

最后，取消定时器，表示当前操作已经完成，不再需要超时检测了，这样可以防止超时处理逻辑错误地关闭仍然活跃的连接。

4. Server

为了方便，server直接写为一个函数，不封装为类

void http_server(tcp::acceptor& acceptor, tcp::socket& socket) {
    acceptor.async_accept(socket, [&](boost::system::error_code ec) {
        if (!ec) {
            // 创建一个http_connection新实例，并调用start函数
            std::make_shared<http_connection>(std::move(socket))->start();
        }

        http_server(acceptor, socket);
        });
}

调用async_accept函数异步等待客户端的连接，如果有新的连接，那么创建一个http_connection新实例，并调用start函数，读取客户端发送的请求头并执行相应操作。

5. 主函数

int main()
{
    try {
        auto const address = net::ip::make_address("127.0.0.1");
        unsigned short port = static_cast<unsigned short>(8080);
        net::io_context ioc{ 1 };
        tcp::acceptor acceptor( ioc,{address,port} );
        tcp::socket socket(ioc);
        http_server(acceptor, socket);
        ioc.run();

    }
    catch (std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return 0;
}

6. 测试

首先，从PostMan官网下载postman：

Download Postman | Get Started for Free​www.postman.com/downloads/

1）测试get

然后启动服务器并打开浏览器的新页面，输入‘127.0.0.1:8080/count’，测试get。

服务器成功返回数据，并展示位HTML页面，当刷新页面后，count也会相应的增加

测试time，输入‘127.0.0.1:8080/time’，页面会显示当前的时间戳

2）测试post

打开postman，按照图片进行如下操作

首先，创建一个新的请求，并设置位post，然后输入‘127.0.0.1:8080/email’，在raw中输入数据并点击发送

{
    "email":"123456@edu.com"
}

服务器返回相应数据

同时，服务器这里也打印处POST的相应数据

同理，也可以用postman做get测试，我这里就不再演示了

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

零基础入门人工智能，如何利用AI工具提升你的学习效率？

零基础入门人工智能，如何利用AI工具提升你的学习效率？

在这个信息爆炸的时代&#xff0c;人工智能&#xff08;AI&#xff09;不仅是技术行业的热词&#xff0c;更是我们日常生活中不可或缺的部分。你是否也想过&#xff0c;如何更有效地学习和利用这些强大的AI工具来提升自己的学习效率&#xff1f;今天&#xff0c;我们将介绍六款…
阅读更多...
electron本地OCR实现

electron本地OCR实现

使用tesseract.js - npm (npmjs.com) 官方demo&#xff1a;GitHub - Balearica/tesseract.js-electron: An example to use tesseract.js in electron 目录结构&#xff1a; // 引入 <script type"module" src"./ocr/tesseract.js"></script>…
阅读更多...
垃圾收集器与内存分配机制（三）

垃圾收集器与内存分配机制（三）

目录 学习前言 一、低延迟垃圾收集器 1. Shenandoah收集器 二、ZGC 1. 内存布局 2. 更巧妙的并发整理 三、其他垃圾收集器 学习前言 除了之前我们所学习的经典垃圾收集器除外&#xff0c;我们还有一些低延迟垃圾收集等&#xff01; 之前所学经典垃圾收集器&#xff0c;…
阅读更多...
ubuntu 安装nginx

ubuntu 安装nginx

sudo apt-get update sudo apt-get install nginx sudo nginx -vsudo systemctl status nginx sudo systemctl start nginx sudo systemctl stop nginx sudo systemctl restart nginx#浏览器输入&#xff1a;http://192.168.31.181/#查看文件结构 cd /etc/nginx sudo cp nginx.…
阅读更多...
瑞云快图云渲染怎么样？渲染一张图贵吗？

瑞云快图云渲染怎么样？渲染一张图贵吗？

在如今的数字时代&#xff0c;云渲染已经成为了设计师和建筑师们不可或缺的工具。而瑞云快图作为一款备受瞩目的云渲染平台&#xff0c;以其出色的性能和实惠的价格吸引了众多用户。 那么&#xff0c;瑞云快图云渲染究竟怎么样&#xff1f;渲染一张图贵吗&#xff1f;本文将为…
阅读更多...
kernel32.dll下载地址：如何安全地恢复系统文件

kernel32.dll下载地址：如何安全地恢复系统文件

关于从网络上寻找kernel32.dll的下载地址&#xff0c;这通常不是一个安全的做法&#xff0c;而且可能涉及到多种风险。kernel32.dll是Windows操作系统的核心组件之一&#xff0c;负责内存管理、进程和线程管理以及其他关键系统功能。因为kernel32.dll是系统的基础文件&#xff…
阅读更多...
初试PostgreSQL数据库

初试PostgreSQL数据库

文章目录 一、PostgreSQL数据库概述1.1 PostgreSQL的历史1.2 PostgreSQL安装1.3 安装PostgreSQL二、PostgreSQL起步2.1 连接数据库2.1.1 SQL Shell2.1.2 执行SQL语句2.2 pgAdmin 42.2.1 打开pgAdmin 42.2.2 查找数据库2.2.3 打开查询工具2.2.4 执行SQL语句三、实战小结文章目录…
阅读更多...
使用cmdline-tools安装Android SDK与NDK

使用cmdline-tools安装Android SDK与NDK

1.下载SDK工具： www.android.com 选择下载平台包 同意并下载Command Line Tools 下载中 下载完成后解压 2. 创建android sdk目录并复制sdk工具 创建目录
阅读更多...
一文彻底弄懂MySQL的MVCC多版本控制器

一文彻底弄懂MySQL的MVCC多版本控制器

InnoDB 的 MVCC&#xff08;Multi-Version Concurrency Control&#xff0c;多版本并发控制&#xff09; 是 MySQL 实现高并发事务处理的一种机制。通过 MVCC&#xff0c;InnoDB 可以在高并发环境下支持 事务隔离&#xff0c;并提供 非阻塞的读操作&#xff0c;从而避免锁定所有…
阅读更多...
Docker配置网站环境

Docker配置网站环境

Mysql 先安装mysql 启动并后台运行&#xff1a;run -d 容器名称&#xff1a;--name 设置端口映射&#xff1a;-p 主机端口&#xff1a;容器端口 环境变量&#xff1a;-e 最后指定镜像名称 sudo docker run -d \--name mysql\-p 3306:3306\-e MYSQL_ROOT_PASSWORD123456\…
阅读更多...
开发工具(上）

开发工具(上）

前面我们在Linux部分了解文件权限&#xff0c;和基本指令的内容&#xff0c;但对于开发工具还是没有很多的接触&#xff0c;现在这一篇就是主要讲基础的工具&#xff1b;如yum&#xff0c;yum源&#xff0c;包管理器等等&#xff1b; Linux中的安装软件&#xff1a; 源码安装 …
阅读更多...
落地 ZeroETL 轻量化架构，ByteHouse 推出“四个一体化”策略

落地 ZeroETL 轻量化架构，ByteHouse 推出“四个一体化”策略

在数字化转型的浪潮中&#xff0c;数据仓库作为企业的核心数据资产&#xff0c;其重要性日益凸显。随着业务范围扩大&#xff0c;企业也会使用不同的数据仓库来管理、维护相关数据。研发人员需要花费大量时间和精力&#xff0c;从中导出数据&#xff0c;然后进行手动整理、转换…
阅读更多...
一文1800字从0到1浅谈web性能测试！

一文1800字从0到1浅谈web性能测试！

什么是性能测试&#xff1f; web性能应该注意些什么&#xff1f; 性能测试&#xff0c;简而言之就是模仿用户对一个系统进行大批量的操作&#xff0c;得出系统各项性能指标和性能瓶颈&#xff0c;并从中发现存在的问题&#xff0c;通过多方协助调优的过程。而web端的性能测试…
阅读更多...
PYQT5 简单项目实践

PYQT5 简单项目实践

在VSCode编辑器我们通过引入pyqt5&#xff0c;用QTdesigner 实现拖拽实现图形化界面 下面我们实现一个简单项目实践一下吧 效果图&#xff1a; 用法&#xff1a;Python编写逻辑&#xff0c;用pyqt实现界面显示。 功能&#xff1a; 第一行把处理的数据文件拖拽到文本框中第二…
阅读更多...
017_基于python+django美术馆预约系统2024_802l04c5

017_基于python+django美术馆预约系统2024_802l04c5

目录 系统展示 开发背景 代码实现 项目案例 获取源码 博主介绍&#xff1a;CodeMentor毕业设计领航者、全网关注者30W群落&#xff0c;InfoQ特邀专栏作家、技术博客领航者、InfoQ新星培育计划导师、Web开发领域杰出贡献者&#xff0c;博客领航之星、开发者头条/腾讯云/AW…
阅读更多...
GPIO口的学习

GPIO口的学习

推挽输出 用它去控制一个mos管&#xff0c;当输出高电平时电流这样流出去&#xff0c;给外面的这颗mos管的栅极充电&#xff0c;所以这个过程称为推把电流推出去 然后当IO口输出低电平时电流这样流进来,给外面的这颗mos管的栅极放电,那这就是挽&#xff0c;把电流挽回来,所以所…
阅读更多...
Android Framework AMS（06）startActivity分析-3(补充：onPause和onStop相关流程解读)

Android Framework AMS（06）startActivity分析-3(补充：onPause和onStop相关流程解读)

该系列文章总纲链接&#xff1a;专题总纲目录 Android Framework 总纲 本章关键点总结 & 说明&#xff1a; 说明&#xff1a;本章节主要解读AMS通过startActivity启动Activity的整个流程的补充&#xff0c;更新了startActivity流程分析部分。 一般来说&#xff0c;有Activ…
阅读更多...
IT监控平台可视化：3D机房与设备监控的革新实践

IT监控平台可视化：3D机房与设备监控的革新实践

在信息化高速发展的今天&#xff0c;IT运维行业面临着前所未有的挑战。随着数据中心规模的不断扩大和设备复杂度的日益提升&#xff0c;如何高效、准确地监控和管理这些设备&#xff0c;成为了运维团队亟待解决的问题。IT监控平台的可视化功能&#xff0c;尤其是3D机房与设备监…
阅读更多...
从零开始学PHP之输出语句变量常量

从零开始学PHP之输出语句变量常量

一、 输出方式 在 PHP 中输出方式&#xff1a; echo&#xff0c;print&#xff0c;print_r&#xff0c;var_dump 1、echo和print为php的输出语句 2、var_dump&#xff0c;print_r为php的输出函数 &#xff08;这里不做介绍&#xff09;echo 和 print 区别 1、echo - 可以输出…
阅读更多...
CSS3 提示框带边角popover

CSS3 提示框带边角popover

CSS3 提示框带边角popover。因为需要绝对定位子元素&#xff08;这里就是伪元素&#xff09;&#xff0c;所以需要将其设置为相对对位 <!DOCTYPE html> <html> <head> <title>test1.html</title> <meta name"keywords" con…
阅读更多...
最新文章

Copyright @ 2022~2023