网络编程（12）——完善粘包处理操作（id字段）

十二、day12

之前的粘包处理是基于消息头包含的消息体长度进行对应的切包操作，但并不完整。一般来说，消息头仅包含数据域的长度，但是如果要进行逻辑处理，就需要传递一个id字段表示要处理的消息id，当然可以不在包头传id字段，将id序列化到消息体也是可以的，但是我们为了便于处理也便于回调逻辑层对应的函数，最好是将id写入包头。

之前我们设计的消息结构是这样的

而本节需要加上id字段

在此之前，先完整的复习一下基于boost::asio实现的服务器逻辑层结构

1. 服务器架构设计

1）asio底层通信

前面的asio底层通信过程如下图所示

Asio底层的通信过程

1）首先，在应用层调用async_read时，相当于在io_context中注册了一个读事件，表示程序希望在指定socket上进行异步读取操作，并提供一个读回调函数以在读取完成后做相应的处理；

2）io_context用于管理所有异步操作和相应的回调函数，且当async_read被调用时，asio会将该socket、相应的读事件和回调函数注册到系统内部的模型中（数据结构）；当io_context启动时，即io_context.run时，asio根据系统使用对应的模型管理这些事件（windows是iocp，linux是epoll）；

3）模型进入一个死循环，会监听所有注册的socket，并监测其状态（可读？可写？），如果socket的状态发生变化（事件被触发），模型将该事件放入就绪事件队列中；

4）io_context::run 在轮询就绪事件队列时，会依次调用每个就绪事件的回调函数（已经放在就绪事件队列中），每个回调函数都包含了处理读操作的逻辑，比如读取数据、处理错误等。

2）逻辑层结构

而服务器架构除了上面的内容之外，一般还有一个逻辑层。

一般在解析完对端发送的数据之后，还要对该请求做更进一步地处理，比如根据不同的消息id执行不同的逻辑层函数或不同的操作，比如读数据库、写数据库，还比如游戏中可能需要给玩家叠加不同的buff、增加积分等等，这些都需要交给逻辑层处理，而不仅仅是把消息发给对端。

服务器架构

上图所示的是一个完成的服务器架构，一般需要将逻辑层独立出来，因为如果在解析完对端数据后需要执行一些复杂的操作，比如玩家需要叠加各自buff或者技能，此时可能会耗时1s甚至更多，如果没有独立的逻辑层进行操作，那么系统会一直停留在执行回调函数那一步，造成阻塞，直至操作结束。

而逻辑层是独立的，回调函数只需将数据投递给逻辑队列（回调函数将数据放入队列中之后系统会运行下一步，便不会被阻塞），逻辑系统会自动从队列中取数据并做相应操作，如果需要在执行完操作之后做相应回复，那么逻辑系统会调用写事件并注册写回调给asio网络层，网络层就是asio底层通信的网络层步骤。

以上操作是基于单线程，如果是在多线程的情况下，阻塞的情况会不会好一些？

asio的多线程有两种模式。

1）第一种模式是启动n个线程，每个线程负责一个io_context，每一个io_context负责一部分的socket。比如现在有两个io_context，一个是负责socket的id为奇数的io_context，一个是负责socket的id为偶数的io_context，但同样会造成阻塞的情况。因为不管是多线程还是单线程，只要在线程中有一个io_context中运行，那么它负责的那部分回调函数的处理操作如果比较复杂时，仍会造成阻塞的情况。

2）第二种模式是一个io_context跑在多个线程中，即多个线程共享一个io_context。这种模式下不会造成之前的那种阻塞情况，因为在就绪事件队列中的事件不是一个线程处理了，而是不同的线程共享一个就绪事件队列，不同线程会触发执行不同的回调函数，即使某个回调处理的比较慢，但由于其他事件被不同线程处理了，系统并不需要阻塞等待该回调处理完成之后在执行处理其他回调。

虽然模式二办法会解决系统阻塞、超时的问题，但在现实中需要有一个逻辑层独立于网络层和应用层，这样可以极大地提高网络线程的收发能力，用多线程的方式管理网络层。

2. 完善粘包处理操作

之前的消息结构并不完善，缺少一个消息id，本节进行代码的相应改进。

首先，之前的消息节点被收发共用，只不过收数据用的是第一种构造函数，发数据用的是第二种构造函数。为了减少耦合和歧义，需要重新设计消息节点。

1) 消息节点

重新构建一个MsgNode类，并派生出RecvNode 和SendNode

  • MsgNode 表示消息节点的基类，头部的消息用该结构存储

  • RecvNode 表示接收消息的节点

  • SendNode 表示发送消息的节点

#pragma once
#include <iostream>
#include <string>
#include <boost/asio.hpp>using std::cout;
using std::cin;
using std::endl;class MsgNode
{
public:short _cur_len;short _total_len;char* _msg;MsgNode(short max_len) :_total_len(max_len), _cur_len(0) {_msg = new char[_total_len + 1](); // 加()会将分配内存的每个元素初始化为0，不加不会初始化_msg[_total_len] = '\0';}~MsgNode() {std::cout << "destruct MsgNode" << endl;delete[] _msg;}void Clear() {::memset(_msg, 0, _total_len);_cur_len = 0;}
};
// 构造收节点
class RecvNode :public MsgNode {
private:short _msg_id;
public:RecvNode(short max_len, short msg_id);
};
// 构造发节点
class SendNode :public MsgNode {
private:short _msg_id;
public:SendNode(const char* msg, short max_len, short msg_id);
};

具体实现为：

#include "MsgNode.h"
#include "Const.h"RecvNode::RecvNode(short max_len, short msg_id) :MsgNode(max_len),
_msg_id(msg_id) {}// 发送的数据首地址、数据长度、消息id，发送节点总长度为消息体长度+头节点长度
SendNode::SendNode(const char* msg, short max_len, short msg_id) : MsgNode(max_len + HEAD_TOTAL_LEN)
, _msg_id(msg_id) {// 将消息id转换为网络序，并存储至至发送节点内short msg_id_host = boost::asio::detail::socket_ops::host_to_network_short(msg_id);memcpy(_msg, &msg_id_host, HEAD_ID_LEN);// 将消息体长度转换为网络序，并存储至至发送节点内short max_len_host = boost::asio::detail::socket_ops::host_to_network_short(max_len);memcpy(_msg + HEAD_ID_LEN, &max_len_host, HEAD_DATA_LEN);// 将消息内容存储至发送节点内memcpy(_msg + HEAD_ID_LEN + HEAD_DATA_LEN, msg, max_len);
}

Const.h 定义为

#pragma once
const size_t MAX_LENGTH = 1024 * 2;
const short MAX_RECVQUE = 10000;
const short MAX_SENDQUE = 1000;
const size_t HEAD_TOTAL_LEN = 4;
const size_t HEAD_ID_LEN = 2;
const size_t HEAD_DATA_LEN = 2;

构建SendNode节点时，需要将消息id和消息长度转换为网络序，然后写入数据域_msg ，前2字节存储id，id后为消息长度，偏移4字节后为消息体内容。

2）Session类

Session类和前面差不多，不过需要把收发的逻辑做相应的修改

首先，队列_send_que、消息头结构、消息体结构需要重新声明，分别使用SendNode，RecvNode，MsgNode作为元素类型。

	std::queue<std::shared_ptr<SendNode> > _send_que;std::mutex _send_lock;std::shared_ptr<RecvNode> _recv_msg_node; // 收到的消息结构bool _b_head_parse; // 表示是否处理完头部信息std::shared_ptr<MsgNode> _recv_head_node; // 收到的头部结构

Session的构造函数也需要做相应变化，消息头结构的大小更改为4字节，包括id和消息体长度

	CSession(boost::asio::io_context& ioc, CServer* server) : _socket(ioc), _server(server), _b_close(false),_b_head_parse(false) {// random_generator是函数对象，加()就是函数，再加一个()就是调用该函数boost::uuids::uuid a_uuid = boost::uuids::random_generator()();_uuid = boost::uuids::to_string(a_uuid);_recv_head_node = std::make_shared<MsgNode>(HEAD_TOTAL_LEN);}

重新定义Send函数，两个Send的重载都需要重新定义

参数列表增加msgid，构造发送节点时需输入三个参数msg, max_length, msgid（发送内容，内容长度，消息id）

void CSession::Send(char* msg, int max_length, short msgid) {bool pending = false; // 发送标志，true时有未完成的发送操作，false为空// 使用lock_guard锁住_send_lock，确保_send_lock（发送队列）访问的线程安全的// 锁的存在确保了多个线程不会同时修改发送队列std::lock_guard<std::mutex> lock(_send_lock);int send_que_size = _send_que.size();if (send_que_size > MAX_SENDQUE) {cout << "session: " << _uuid << " send que fulled, size is " << MAX_SENDQUE << endl;return;}// 判断队列是否有未完成的发送操作if (_send_que.size() > 0) {pending = true;}_send_que.push(std::make_shared<SendNode>(msg, max_length, msgid)); // 将发送消息存储至队列if (pending) { // 如果有未完成的发送，直接返回return;}// 异步发送auto& msgnode = _send_que.front();boost::asio::async_write(_socket, boost::asio::buffer(msgnode->_msg, msgnode->_total_len),std::bind(&CSession::haddle_write, this, std::placeholders::_1, shared_from_this()));
} // 当'}'结束后，_send_lock解锁，发送队列解锁void CSession::Send(std::string msg, short msgid) {bool pending = false; // 发送标志，true时有未完成的发送操作，false为空// 使用lock_guard锁住_send_lock，确保_send_lock（发送队列）访问的线程安全的// 锁的存在确保了多个线程不会同时修改发送队列std::lock_guard<std::mutex> lock(_send_lock);int send_que_size = _send_que.size();if (send_que_size > MAX_SENDQUE) {cout << "session: " << _uuid << " send que fulled, size is " << MAX_SENDQUE << endl;return;}// 判断队列是否有未完成的发送操作if (_send_que.size() > 0) {pending = true;}_send_que.push(std::make_shared<SendNode>(msg.c_str(), msg.length(),msgid)); // 将发送消息存储至队列if (pending) { // 如果有未完成的发送，直接返回return;}// 异步发送auto& msgnode = _send_que.front();boost::asio::async_write(_socket, boost::asio::buffer(msgnode->_msg, msgnode->_total_len),std::bind(&CSession::haddle_write, this, std::placeholders::_1, shared_from_this()));
} // 当'}'结束后，_send_lock解锁，发送队列解锁

读回调也需更改，在文章10中haddle_write函数的基础上做修改，可参考该文章

https://zhuanlan.zhihu.com/p/722233898

void CSession::HandleRead(const boost::system::error_code& error, size_t bytes_transferred,std::shared_ptr<CSession> _self_shared) {if (!error) {// 打印缓存区的数据并将该线程暂停2s//PrintRecvData(_data, bytes_transferred);//std::chrono::milliseconds dura(2000);//std::this_thread::sleep_for(dura);// 每触发一次handale_read，它会返回实际读取的字节数bytes_transferred，copy_len表示已处理的长度，每处理一字节，copy_len便加一int copy_len = 0; // 已经处理的字符数while (bytes_transferred > 0) { // 只要读取到数据就对其处理if (!_b_head_parse) { // 判断消息头部是否已处理，_b_head_parse默认为false// 异步读取到的字节数 + 已接收到的头部长度 < 头部总长度if (bytes_transferred + _recv_head_node->_cur_len < HEAD_TOTAL_LEN) { // 收到的数据长度小于头部长度，说明头部还未全部读取// 如果未完全接收消息头，则将接收到的数据复制到头部缓冲区// _recv_head_node->_msg，更新当前头部的接收长度，并继续异步读取剩余数据。memcpy(_recv_head_node->_msg + _recv_head_node->_cur_len, _data + copy_len, bytes_transferred);_recv_head_node->_cur_len += bytes_transferred;// 缓冲区清零，无需更新copy_len追踪已处理的字符数，因为之前读取的数据已经全部写入头部节点，下一个// 读入的消息从头开始（copy_len=0）往头节点写::memset(_data, 0, MAX_LENGTH);// 继续读消息_socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::headle_read, this,std::placeholders::_1, std::placeholders::_2, _self_shared));return;}// 如果接收到的数据量足够处理消息头部，则计算头部剩余的未接收字节，// 并将其从 _data 缓冲区复制到头部消息缓冲区 _recv_head_node->_msgint head_remain = HEAD_TOTAL_LEN - _recv_head_node->_cur_len; // 头部剩余未复制的长度// 填充头部节点memcpy(_recv_head_node->_msg + _recv_head_node->_cur_len, _data + copy_len, head_remain);copy_len += head_remain; // 更新已处理的data长度bytes_transferred -= head_remain; // 更新剩余未处理的长度short msg_id = 0; // 获取消息idmemcpy(&msg_id, _recv_head_node->_msg, HEAD_ID_LEN);//网络字节序转化为本地字节序msg_id = boost::asio::detail::socket_ops::network_to_host_short(msg_id);cout << "msg_id is " << msg_id << endl;// 判断id是否合法if (msg_id > MAX_LENGTH) {std::cout << "invaild msg_id is " << msg_id << endl;_server->ClearSession(_uuid);return;}short msg_len = 0; // 获取头部数据（消息长度）memcpy(&msg_len, _recv_head_node->_msg + HEAD_ID_LEN, HEAD_DATA_LEN);//网络字节序转化为本地字节序msg_len = boost::asio::detail::socket_ops::network_to_host_short(msg_len);cout << "msg_len is " << msg_len << endl;if (msg_len > MAX_LENGTH) { // 判断头部长度是否非法std::cout << "invalid data length is " << msg_len << endl;_server->ClearSession(_uuid);return;}_recv_msg_node = std::make_shared<RecvNode>(msg_len, msg_id); // 已知数据长度msg_len，构建消息内容载体//消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里if (bytes_transferred < msg_len) {memcpy(_recv_msg_node->_msg + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);_recv_msg_node->_cur_len += bytes_transferred;// copy_len不用更新，缓冲区会清零，下一个读入data的数据从头开始写入，copy_len也会被初始化为0::memset(_data, 0, MAX_LENGTH);_socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),std::bind(&CSession::headle_read, this, std::placeholders::_1, std::placeholders::_2, _self_shared));_b_head_parse = true; //头部处理完成return;}// 接收的长度多于消息内容长度memcpy(_recv_msg_node->_msg + _recv_msg_node->_cur_len, _data + copy_len, msg_len);_recv_msg_node->_cur_len += msg_len;copy_len += msg_len;bytes_transferred -= msg_len;_recv_msg_node->_msg[_recv_msg_node->_total_len] = '\0';// cout << "receive data is " << _recv_msg_node->_msg << endl;// protobuf序列化//MsgData msgdata;//std::string receive_data;//msgdata.ParseFromString(std::string(_recv_msg_node->_msg, _recv_msg_node->_total_len));//std::cout << "receive msg id is " << msgdata.id () << " msg data is  " << msgdata.data() << endl;//std::string return_str = "Server has received msg, msg data is " + msgdata.data();//MsgData msgreturn;//msgreturn.set_id(msgdata.id());//msgreturn.set_data(return_str);//msgreturn.SerializeToString(&return_str);//Send(return_str);// jsoncpp序列化Json::Reader reader;Json::Value root;reader.parse(std::string(_recv_msg_node->_msg, _recv_msg_node->_total_len), root);std::cout << "recevie msg id  is " << root["id"].asInt() << " msg data is "<< root["data"].asString() << endl;root["data"] = "Server has received msg, msg data is " + root["data"].asString();std::string return_str = root.toStyledString();Send(return_str, root["id"].asInt());//Send(_recv_msg_node->_msg, _recv_msg_node->_total_len); // 回传// 清理已处理的头部消息并重置，准备解析下一条消息_b_head_parse = false;_recv_head_node->Clear();// 如果当前数据已经全部处理完，重置缓冲区 _data，并继续异步读取新的数据if (bytes_transferred <= 0) {::memset(_data, 0, MAX_LENGTH);_socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),std::bind(&CSession::headle_read, this, std::placeholders::_1, std::placeholders::_2, _self_shared));return;}continue; // 异步读取的消息未处理完，继续填充头节点乃至新的消息节点}//已经处理完头部，处理上次未接受完的消息数据int remain_msg = _recv_msg_node->_total_len - _recv_msg_node->_cur_len;if (bytes_transferred < remain_msg) { //接收的数据仍不足剩余未处理的memcpy(_recv_msg_node->_msg + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);_recv_msg_node->_cur_len += bytes_transferred;::memset(_data, 0, MAX_LENGTH);_socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),std::bind(&CSession::headle_read, this, std::placeholders::_1, std::placeholders::_2, _self_shared));return;}// 接收的数据多于剩余未处理的长度memcpy(_recv_msg_node->_msg + _recv_msg_node->_cur_len, _data + copy_len, remain_msg);_recv_msg_node->_cur_len += remain_msg;bytes_transferred -= remain_msg;copy_len += remain_msg;_recv_msg_node->_msg[_recv_msg_node->_total_len] = '\0';//cout << "receive data is " << _recv_msg_node->_msg << endl;// protobuf序列化//MsgData msgdata;//std::string receive_data;//msgdata.ParseFromString(std::string(_recv_msg_node->_msg, _recv_msg_node->_total_len));//std::cout << "receive msg id is " << msgdata.id() << " msg data is  " << msgdata.data() << endl;//std::string return_str = "Server has received msg, msg data is " + msgdata.data();//MsgData msgreturn;//msgreturn.set_id(msgdata.id());//msgreturn.set_data(return_str);//msgreturn.SerializeToString(&return_str);//Send(return_str);//jsoncpp序列化Json::Reader reader;Json::Value root;reader.parse(std::string(_recv_msg_node->_msg, _recv_msg_node->_total_len), root);std::cout << "recevie msg id  is " << root["id"].asInt() << " msg data is "<< root["data"].asString() << endl;root["data"] = "Server has received msg, msg data is " + root["data"].asString();std::string return_str = root.toStyledString();Send(return_str, root["id"].asInt());//此处可以调用Send发送测试//Send(_recv_msg_node->_msg, _recv_msg_node->_total_len);//继续轮询剩余未处理数据_b_head_parse = false;_recv_head_node->Clear();if (bytes_transferred <= 0) {::memset(_data, 0, MAX_LENGTH);_socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),std::bind(&CSession::headle_read, this, std::placeholders::_1, std::placeholders::_2, _self_shared));return;}continue;}}else {std::cout << "handle read failed, error is " << error.what() << endl;Close();_server->ClearSession(_uuid);}
}

HandleRead函数中新增一段读取消息id的代码

首先，当消息头节点_recv_head_node填充完毕后，获取头节点中存储的消息id并转换为本地字节序，并判断id的合法性；然后，解析消息长度，并构建消息体节点_recv_msg_node，读取剩下的消息体内容

	            short msg_id = 0; // 获取消息idmemcpy(&msg_id, _recv_head_node->_msg, HEAD_ID_LEN);//网络字节序转化为本地字节序msg_id = boost::asio::detail::socket_ops::network_to_host_short(msg_id);cout << "msg_id is " << msg_id << endl;// 判断id是否合法if (msg_id > MAX_LENGTH) {std::cout << "invaild msg_id is " << msg_id << endl;_server->ClearSession(_uuid);return;}

3）客户端

客户端也需额外收发消息id

#include <boost/asio.hpp>
#include <iostream>
#include <json/json.h>
#include <json/value.h>
#include <json/reader.h>using namespace boost::asio::ip;
using std::cout;
using std::endl;
const int MAX_LENGTH = 1024 * 2; // 发送和接收的长度为1024 * 2字节
const int HEAD_LENGTH = 2;
const int HEAD_TOTAL = 4;int main()
{try {boost::asio::io_context ioc; // 创建上下文服务// 127.0.0.1是本机的回路地址，也就是服务器和客户端在一个机器上tcp::endpoint remote_ep(address::from_string("127.0.0.1"), 10086); // 构造endpointtcp::socket sock(ioc);boost::system::error_code error = boost::asio::error::host_not_found; // 错误：主机未找到sock.connect(remote_ep, error);if (error) {cout << "connect failed, code is " << error.value() << " error msg is " << error.message();return 0;}Json::Value root;root["id"] = 1001;root["data"] = "hello world";std::string request = root.toStyledString();size_t request_length = request.length();char send_data[MAX_LENGTH] = { 0 };int msgid = 1001;int msgid_host = boost::asio::detail::socket_ops::host_to_network_short(msgid);memcpy(send_data, &msgid_host, 2);//转为网络字节序int request_host_length = boost::asio::detail::socket_ops::host_to_network_short(request_length);memcpy(send_data + 2, &request_host_length, 2);memcpy(send_data + 4, request.c_str(), request_length);boost::asio::write(sock, boost::asio::buffer(send_data, request_length + 4));char reply_head[HEAD_TOTAL]; // 首先读取对端发送消息的总长度size_t reply_length = boost::asio::read(sock, boost::asio::buffer(reply_head, HEAD_TOTAL));msgid = 0;memcpy(&msgid, reply_head, HEAD_LENGTH);short msglen = 0; // 消息总长度memcpy(&msglen, reply_head + 2, HEAD_LENGTH); // 将消息总长度赋值给msglen//转为本地字节序msglen = boost::asio::detail::socket_ops::network_to_host_short(msglen);char msg[MAX_LENGTH] = { 0 }; // 构建消息体（不含消息总长度）size_t msg_length = boost::asio::read(sock, boost::asio::buffer(msg, msglen));Json::Reader reader;reader.parse(std::string(msg, msg_length), root);std::cout << "msg id is " << root["id"] << " msg is " << root["data"] << endl;getchar();}catch (std::exception& e) {std::cerr << "Exception: " << e.what() << endl;}return 0;
}

4）测试

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

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

相关文章

naocs注册中心，配置管理，openfeign在idea中实现模块间的调用，getway的使用

naocs注册中心，配置管理，openfeign在idea中实现模块间的调用，getway的使用

一 naocs注册中心步骤 1 nacos下载安装 解压安装包&#xff0c;直接运行bin目录下的startup.cmd 这里双击运行出现问题的情况下 &#xff08;版本低的naocs&#xff09; 在bin目录下 打开cmd 运行以下命令 startup.cmd -m standalone 访问地址&#xff1a; http://localh…
阅读更多...
一文了解：最新版本 Llama 3.2

一文了解：最新版本 Llama 3.2

Meta AI最近发布了 Llama 3.2。这是他们第一次推出可以同时处理文字和图片的多模态模型。这个版本主要关注两个方面&#xff1a; 视觉功能&#xff1a;他们现在有了能处理图片的模型&#xff0c;参数量从11亿到90亿不等。 轻量级模型&#xff1a;这些模型参数量在1亿到3亿之间…
阅读更多...
基于SSM+小程序的高质量阅读微信管理系统（阅读5）（源码+sql脚本+视频导入教程+文档）

基于SSM+小程序的高质量阅读微信管理系统（阅读5）（源码+sql脚本+视频导入教程+文档）

&#x1f449;文末查看项目功能视频演示获取源码sql脚本视频导入教程视频 1、项目介绍 1、其管理员管理文章&#xff0c;留言板&#xff0c;交流论坛以及用户信息。 2、用户收藏并评论文章&#xff0c;查看和评论论坛交流信息&#xff0c;管理自己发布的帖子&#xff0c;管理…
阅读更多...
数据结构与算法笔记7：最小生成树-Prim和Kruskal算法

数据结构与算法笔记7：最小生成树-Prim和Kruskal算法

常用的最小生成树的算法主要有两种&#xff0c;一种是Prim算法&#xff0c;一种是Kruskal算法。题目链接&#xff1a;KamaCoder 53. 寻宝&#xff08;第七期模拟笔试&#xff09; 这里假设有V个节点&#xff0c;因为我们的节点的标号是1~V&#xff0c;这样我们直接使用标号作…
阅读更多...
队列及笔试题

队列及笔试题

队列 先进先出 使用单链表进行队尾插入 队头删除 其中带头结点直接尾插&#xff0c;不带头结点第一次操作要判断一下 但是带头结点需要malloc和free 函数传需要修改的参数方法 1、二级指针 2、带哨兵位的头结点 3、返回值 4、如果有多个值&#xff0c;用结构体封装起来…
阅读更多...
努比亚 Z17 NX563J Root 教程三方REC刷写工具教程

努比亚 Z17 NX563J Root 教程三方REC刷写工具教程

教程&#xff1a;1&#xff0c;自用成功 正常链接列表 adb devices 检查fastboot链接列表 fastboot devices 解锁设备fastboot oem nubia_unlock NUBIA_NX563J 我用的解锁设备是&#xff1a;fastboot flashing unlock 1.打开开发者选项。将OEM解锁的按钮打开 2.下载附件努…
阅读更多...
甄选范文“论企业应用系统的数据持久层架构设计”，软考高级论文，系统架构设计师论文

甄选范文“论企业应用系统的数据持久层架构设计”，软考高级论文，系统架构设计师论文

论文真题 数据持久层（Data Persistence Layer）通常位于企业应用系统的业务逻辑层和数据源层之间，为整个项目提供一个高层、统一、安全、并发的数据持久机制，完成对各种数据进行持久化的编程工作，并为系统业务逻辑层提供服务。它能够使程序员避免手工编写访问数据源的方法…
阅读更多...
MQ基础：RabbitMQ真面目

MQ基础：RabbitMQ真面目

同步调用方式&#xff0c;指的是发送方直接发送给接收方的形式。而这种方式在某些情况下可能出现问题&#xff0c;比如当业务逻辑变得复杂&#xff0c;同步的方式需要等待上一条指令被接收后才会继续&#xff0c;对性能的影响很大。 异步的方式&#xff0c;增加了一个消息代理…
阅读更多...
微信小程序操作蓝牙

微信小程序操作蓝牙

主要流程&#xff1a; 1.初始化蓝牙适配器openBluetoothAdapter&#xff0c;如果不成功就onBluetoothAdapterStateChange监听蓝牙适配器状态变化事件 2.startBluetoothDevicesDiscovery开始搜寻附近的蓝牙外围设备 3.onBluetoothDeviceFound监听寻找到新设备的事件&#xff0c;…
阅读更多...
PHP爬虫淘宝商品SKU详细信息获取指南

PHP爬虫淘宝商品SKU详细信息获取指南

在电子商务领域&#xff0c;获取商品的SKU&#xff08;Stock Keeping Unit&#xff0c;库存单位&#xff09;详细信息对于商家进行库存管理、订单处理和客户服务至关重要。淘宝作为中国最大的电商平台之一&#xff0c;提供了丰富的API接口&#xff0c;使得开发者能够通过PHP爬虫…
阅读更多...
前端学习笔记-JS进阶篇-02

前端学习笔记-JS进阶篇-02

构造函数&数据常用函数 1、深入对象 1.1、创建对象三种方式 1. 利用对象字面量创建对象 2. 利用new Object 创建对象 3. 利用构造函数创建对象 1.2、构造函数 构造函数&#xff1a;是一种特殊的函数&#xff0c;主要用来初始化对象 使用场景&#xff1a;常规的{...} 语…
阅读更多...
springboot购物网站源码分享

springboot购物网站源码分享

开头&#xff1a;springboot购物网站源码分享 题目&#xff1a;springboot购物网站源码分享 主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Mysql|大数据|SSM|SpringBoot|Vue|Jsp|MYSQL等)、学习资料、JAVA源码、技术咨询 文末联系获取 感兴趣可以先收藏起来&#xff…
阅读更多...
报数游戏 - 华为OD统一考试(E卷)

报数游戏 - 华为OD统一考试(E卷)

2024华为OD机试&#xff08;E卷D卷C卷&#xff09;最新题库【超值优惠】Java/Python/C合集 题目描述 100个人围成一圈&#xff0c;每个人有一个编号&#xff0c;编号从1开始到100。他们从1开始依次报数&#xff0c;报到为M的人自动退出圈圈&#xff0c;然后下一个人接着从1开始…
阅读更多...
基于SpringBoot+Vue的茶园茶农文化交流平台

基于SpringBoot+Vue的茶园茶农文化交流平台

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码 精品专栏&#xff1a;Java精选实战项目…
阅读更多...
【MySQL实战45讲4-5】索引

【MySQL实战45讲4-5】索引

文章目录 索引的定义索引的常见模型哈希表有序数组二叉搜索树 InnoDB的索引模型索引维护页分裂页合并页分裂和页合并的影响避免页分裂 覆盖索引最左前缀原则索引下推 索引的定义 索引的出现其实就是为了提高数据查询的效率&#xff0c;就像书的目录一样。一本500页的书&#x…
阅读更多...
tee命令：轻松同步输出到屏幕与文件

tee命令：轻松同步输出到屏幕与文件

一、命令简介 ​tee​ 命令在 Linux 和 Unix 系统中用于读取标准输入的数据&#xff0c;并将其同时输出到标准输出和文件中。简单来说&#xff0c;tee​ 命令可以用来分割数据流&#xff0c;使其既能够被输出到屏幕&#xff0c;也能够被写入到文件中。 ​​ ‍ 二、命令参数…
阅读更多...
基于PI控制器的车辆行驶控制系统simulink建模与仿真

基于PI控制器的车辆行驶控制系统simulink建模与仿真

目录 1.课题概述 2.系统仿真结果 3.核心程序与模型 4.系统原理简介 4.1 步骤一: 确定目标与测量 4.2 步骤二: 计算误差 4.3 步骤三: 设计PI控制器 4.4 步骤四: 应用控制信号 4.5 步骤五: 反馈循环 5.完整工程文件 1.课题概述 基于PI控制器的车辆行驶控制系统是一种常…
阅读更多...
timedatectl命令：告别时间烦恼，一键同步系统时间

timedatectl命令：告别时间烦恼，一键同步系统时间

一、命令简介 ​timedatectl​ 命令用于查看和设置系统的时间和日期&#xff0c;以及配置时区和 NTP&#xff08;Network Time Protocol&#xff09;设置。 相关命令&#xff1a;cal ​显示日历、 date ​查看、设置日期 ‍ 二、命令参数 格式&#xff1a; timedatectl […
阅读更多...
[Redis][集群][下]详细讲解

[Redis][集群][下]详细讲解

目录 1.集群搭建(基于 Docker)2.主节点宕机1.宕机后会发生什么&#xff1f;2.处理流程1.故障判定2.故障迁移 3.集群扩容0.前言1.把新的主节点加入到集群2.重新分配slots3.给新的主节点添加从节点 1.集群搭建(基于 Docker) 拓扑结构如下&#xff1a; 创建目录和配置&#xff1…
阅读更多...
【Python】FeinCMS：轻量级且可扩展的Django内容管理系统

【Python】FeinCMS：轻量级且可扩展的Django内容管理系统

在互联网飞速发展的今天&#xff0c;内容管理系统&#xff08;CMS&#xff09;成为了网站开发中的核心工具&#xff0c;尤其对于需要频繁更新内容的企业和个人站点而言&#xff0c;CMS 提供了极大的便利。市场上有许多不同的 CMS 工具可供选择&#xff0c;其中基于 Django 框架…
阅读更多...
最新文章

Copyright @ 2022~2023