Qt项目:基于Qt实现的网络聊天室---TCP服务器和token验证

文章目录

  • TCP服务器设计
    • 客户端TCP管理者
    • ChatServer
    • AsioIOServicePool
    • Session层
    • LogicSystem
    • 总结
  • token验证模块
    • 完善proto
    • StatusServer验证token
    • 客户端处理登陆回包
    • 用户管理
    • 登陆界面

本篇完成的模块是TCP服务器的设计和token验证

TCP服务器设计

客户端TCP管理者

因为聊天服务要维持一个长链接,方便服务器和客户端双向通信,那么就需要一个TCPMgr来管理TCP连接

而实际开发中网络模块一般以单例模式使用,那我们就基于单例基类和可被分享类创建一个自定义的TcpMgr类,在QT工程中新建TcpMgr类,会生成头文件和源文件,头文件修改如下

#ifndef TCPMGR_H
#define TCPMGR_H
#include <QTcpSocket>
#include "singleton.h"
#include "global.h"
class TcpMgr:public QObject, public Singleton<TcpMgr>,public std::enable_shared_from_this<TcpMgr>
{Q_OBJECT
public:TcpMgr();
private:QTcpSocket _socket;QString _host;uint16_t _port;QByteArray _buffer;bool _b_recv_pending;quint16 _message_id;quint16 _message_len;
public slots:void slot_tcp_connect(ServerInfo);void slot_send_data(ReqId reqId, QString data);
signals:void sig_con_success(bool bsuccess);void sig_send_data(ReqId reqId, QString data);
};#endif // TCPMGR_H

接下来我们在构造函数中连接网络请求的各种信号

TcpMgr::TcpMgr():_host(""),_port(0),_b_recv_pending(false),_message_id(0),_message_len(0)
{QObject::connect(&_socket, &QTcpSocket::connected, [&]() {qDebug() << "Connected to server!";// 连接建立后发送消息emit sig_con_success(true);});QObject::connect(&_socket, &QTcpSocket::readyRead, [&]() {// 当有数据可读时,读取所有数据// 读取所有数据并追加到缓冲区_buffer.append(_socket.readAll());QDataStream stream(&_buffer, QIODevice::ReadOnly);stream.setVersion(QDataStream::Qt_5_0);forever {//先解析头部if(!_b_recv_pending){// 检查缓冲区中的数据是否足够解析出一个消息头(消息ID + 消息长度)if (_buffer.size() < static_cast<int>(sizeof(quint16) * 2)) {return; // 数据不够,等待更多数据}// 预读取消息ID和消息长度,但不从缓冲区中移除stream >> _message_id >> _message_len;//将buffer 中的前四个字节移除_buffer = _buffer.mid(sizeof(quint16) * 2);// 输出读取的数据qDebug() << "Message ID:" << _message_id << ", Length:" << _message_len;}//buffer剩余长读是否满足消息体长度,不满足则退出继续等待接受if(_buffer.size() < _message_len){_b_recv_pending = true;return;}_b_recv_pending = false;// 读取消息体QByteArray messageBody = _buffer.mid(0, _message_len);qDebug() << "receive body msg is " << messageBody ;_buffer = _buffer.mid(_message_len);}});// 处理错误(适用于Qt 5.15之前的版本)QObject::connect(&_socket, static_cast<void (QTcpSocket::*)(QTcpSocket::SocketError)>(&QTcpSocket::error),[&](QTcpSocket::SocketError socketError) {qDebug() << "Error:" << _socket.errorString() ;switch (socketError) {case QTcpSocket::ConnectionRefusedError:qDebug() << "Connection Refused!";emit sig_con_success(false);break;case QTcpSocket::RemoteHostClosedError:qDebug() << "Remote Host Closed Connection!";break;case QTcpSocket::HostNotFoundError:qDebug() << "Host Not Found!";emit sig_con_success(false);break;case QTcpSocket::SocketTimeoutError:qDebug() << "Connection Timeout!";emit sig_con_success(false);break;case QTcpSocket::NetworkError:qDebug() << "Network Error!";break;default:qDebug() << "Other Error!";break;}});// 处理连接断开QObject::connect(&_socket, &QTcpSocket::disconnected, [&]() {qDebug() << "Disconnected from server.";});QObject::connect(this, &TcpMgr::sig_send_data, this, &TcpMgr::slot_send_data);
}

连接对端服务器

void TcpMgr::slot_tcp_connect(ServerInfo si)
{qDebug()<< "receive tcp connect signal";// 尝试连接到服务器qDebug() << "Connecting to server...";_host = si.Host;_port = static_cast<uint16_t>(si.Port.toUInt());_socket.connectToHost(si.Host, _port);
}

因为客户端发送数据可能在任何线程,为了保证线程安全,我们在要发送数据时发送TcpMgr的sig_send_data信号,然后实现接受这个信号的槽函数

void TcpMgr::slot_send_data(ReqId reqId, QString data)
{uint16_t id = reqId;// 将字符串转换为UTF-8编码的字节数组QByteArray dataBytes = data.toUtf8();// 计算长度(使用网络字节序转换)quint16 len = static_cast<quint16>(data.size());// 创建一个QByteArray用于存储要发送的所有数据QByteArray block;QDataStream out(&block, QIODevice::WriteOnly);// 设置数据流使用网络字节序out.setByteOrder(QDataStream::BigEndian);// 写入ID和长度out << id << len;// 添加字符串数据block.append(data);// 发送数据_socket.write(block);
}

然后修改LoginDialog中的initHandlers中的收到服务器登陆回复后的逻辑,这里发送信号准备发起长链接到聊天服务器

void LoginDialog::initHttpHandlers()
{//注册获取登录回包逻辑_handlers.insert(ReqId::ID_LOGIN_USER, [this](QJsonObject jsonObj){int error = jsonObj["error"].toInt();if(error != ErrorCodes::SUCCESS){showTip(tr("参数错误"),false);enableBtn(true);return;}auto user = jsonObj["user"].toString();//发送信号通知tcpMgr发送长链接ServerInfo si;si.Uid = jsonObj["uid"].toInt();si.Host = jsonObj["host"].toString();si.Port = jsonObj["port"].toString();si.Token = jsonObj["token"].toString();_uid = si.Uid;_token = si.Token;qDebug()<< "user is " << user << " uid is " << si.Uid <<" host is "<< si.Host << " Port is " << si.Port << " Token is " << si.Token;emit sig_connect_tcp(si);});
}

在LoginDialog构造函数中连接信号,包括建立tcp连接,以及收到TcpMgr连接成功或者失败的信号处理

//连接tcp连接请求的信号和槽函数connect(this, &LoginDialog::sig_connect_tcp, TcpMgr::GetInstance().get(), &TcpMgr::slot_tcp_connect);
//连接tcp管理者发出的连接成功信号
connect(TcpMgr::GetInstance().get(), &TcpMgr::sig_con_success, this, &LoginDialog::slot_tcp_con_finish);

LoginDialog收到连接结果的槽函数

void LoginDialog::slot_tcp_con_finish(bool bsuccess)
{if(bsuccess){showTip(tr("聊天服务连接成功,正在登录..."),true);QJsonObject jsonObj;jsonObj["uid"] = _uid;jsonObj["token"] = _token;QJsonDocument doc(jsonObj);QString jsonString = doc.toJson(QJsonDocument::Indented);//发送tcp请求给chat serverTcpMgr::GetInstance()->sig_send_data(ReqId::ID_CHAT_LOGIN, jsonString);}else{showTip(tr("网络异常"),false);enableBtn(true);}}

在这个槽函数中我们发送了sig_send_data信号并且通知TcpMgr将数据发送给服务器。

ChatServer

一个TCP服务器必然会有连接的接收,维持,收发数据等逻辑。那我们就要基于asio完成这个服务的搭建。主服务是这个样子的

#include "LogicSystem.h"
#include <csignal>
#include <thread>
#include <mutex>
#include "AsioIOServicePool.h"
#include "CServer.h"
#include "ConfigMgr.h"
using namespace std;
bool bstop = false;
std::condition_variable cond_quit;
std::mutex mutex_quit;int main()
{try {auto &cfg = ConfigMgr::Inst();auto pool = AsioIOServicePool::GetInstance();boost::asio::io_context  io_context;boost::asio::signal_set signals(io_context, SIGINT, SIGTERM);signals.async_wait([&io_context, pool](auto, auto) {io_context.stop();pool->Stop();});auto port_str = cfg["SelfServer"]["Port"];CServer s(io_context, atoi(port_str.c_str()));io_context.run();}catch (std::exception& e) {std::cerr << "Exception: " << e.what() << endl;}}

CServer类的声明

#include <boost/asio.hpp>
#include "CSession.h"
#include <memory.h>
#include <map>
#include <mutex>
using namespace std;
using boost::asio::ip::tcp;
class CServer
{
public:CServer(boost::asio::io_context& io_context, short port);~CServer();void ClearSession(std::string);
private:void HandleAccept(shared_ptr<CSession>, const boost::system::error_code & error);void StartAccept();boost::asio::io_context &_io_context;short _port;tcp::acceptor _acceptor;std::map<std::string, shared_ptr<CSession>> _sessions;std::mutex _mutex;
};

构造函数中监听对方连接

CServer::CServer(boost::asio::io_context& io_context, short port):_io_context(io_context), _port(port),
_acceptor(io_context, tcp::endpoint(tcp::v4(),port))
{cout << "Server start success, listen on port : " << _port << endl;StartAccept();
}

接受连接的函数

void CServer::StartAccept() {auto &io_context = AsioIOServicePool::GetInstance()->GetIOService();shared_ptr<CSession> new_session = make_shared<CSession>(io_context, this);_acceptor.async_accept(new_session->GetSocket(), std::bind(&CServer::HandleAccept, this, new_session, placeholders::_1));
}

AsioIOServicePool

从AsioIOServicePool中返回一个可用的iocontext构造Session,然后将接受的新链接的socket写入这个Session保管

AsioIOServicePool已经在前面讲解很多次了,它的声明如下

#include <vector>
#include <boost/asio.hpp>
#include "Singleton.h"
class AsioIOServicePool:public Singleton<AsioIOServicePool>
{friend Singleton<AsioIOServicePool>;
public:using IOService = boost::asio::io_context;using Work = boost::asio::io_context::work;using WorkPtr = std::unique_ptr<Work>;~AsioIOServicePool();AsioIOServicePool(const AsioIOServicePool&) = delete;AsioIOServicePool& operator=(const AsioIOServicePool&) = delete;// 使用 round-robin 的方式返回一个 io_serviceboost::asio::io_context& GetIOService();void Stop();
private:AsioIOServicePool(std::size_t size = std::thread::hardware_concurrency());std::vector<IOService> _ioServices;std::vector<WorkPtr> _works;std::vector<std::thread> _threads;std::size_t                        _nextIOService;
};

AsioIOServicePool具体实现

#include "AsioIOServicePool.h"
#include <iostream>
using namespace std;
AsioIOServicePool::AsioIOServicePool(std::size_t size):_ioServices(size),
_works(size), _nextIOService(0){for (std::size_t i = 0; i < size; ++i) {_works[i] = std::unique_ptr<Work>(new Work(_ioServices[i]));}//遍历多个ioservice,创建多个线程,每个线程内部启动ioservicefor (std::size_t i = 0; i < _ioServices.size(); ++i) {_threads.emplace_back([this, i]() {_ioServices[i].run();});}
}AsioIOServicePool::~AsioIOServicePool() {std::cout << "AsioIOServicePool destruct" << endl;
}boost::asio::io_context& AsioIOServicePool::GetIOService() {auto& service = _ioServices[_nextIOService++];if (_nextIOService == _ioServices.size()) {_nextIOService = 0;}return service;
}void AsioIOServicePool::Stop(){//因为仅仅执行work.reset并不能让iocontext从run的状态中退出//当iocontext已经绑定了读或写的监听事件后,还需要手动stop该服务for (auto& work : _works) {//把服务先停止work->get_io_context().stop();work.reset();}for (auto& t : _threads) {t.join();}
}

CServer的处理连接逻辑

void CServer::HandleAccept(shared_ptr<CSession> new_session, const boost::system::error_code& error){if (!error) {new_session->Start();lock_guard<mutex> lock(_mutex);_sessions.insert(make_pair(new_session->GetUuid(), new_session));}else {cout << "session accept failed, error is " << error.what() << endl;}StartAccept();
}

Session层

上面的逻辑接受新链接后执行Start函数,新链接接受数据,然后Server继续监听新的连接

void CSession::Start(){AsyncReadHead(HEAD_TOTAL_LEN);
}

先读取头部数据

void CSession::AsyncReadHead(int total_len)
{auto self = shared_from_this();asyncReadFull(HEAD_TOTAL_LEN, [self, this](const boost::system::error_code& ec, std::size_t bytes_transfered) {try {if (ec) {std::cout << "handle read failed, error is " << ec.what() << endl;Close();_server->ClearSession(_uuid);return;}if (bytes_transfered < HEAD_TOTAL_LEN) {std::cout << "read length not match, read [" << bytes_transfered << "] , total ["<< HEAD_TOTAL_LEN << "]" << endl;Close();_server->ClearSession(_uuid);return;}_recv_head_node->Clear();memcpy(_recv_head_node->_data, _data, bytes_transfered);//获取头部MSGID数据short msg_id = 0;memcpy(&msg_id, _recv_head_node->_data, HEAD_ID_LEN);//网络字节序转化为本地字节序msg_id = boost::asio::detail::socket_ops::network_to_host_short(msg_id);std::cout << "msg_id is " << msg_id << endl;//id非法if (msg_id > MAX_LENGTH) {std::cout << "invalid msg_id is " << msg_id << endl;_server->ClearSession(_uuid);return;}short msg_len = 0;memcpy(&msg_len, _recv_head_node->_data + HEAD_ID_LEN, HEAD_DATA_LEN);//网络字节序转化为本地字节序msg_len = boost::asio::detail::socket_ops::network_to_host_short(msg_len);std::cout << "msg_len is " << msg_len << endl;//id非法if (msg_len > MAX_LENGTH) {std::cout << "invalid data length is " << msg_len << endl;_server->ClearSession(_uuid);return;}_recv_msg_node = make_shared<RecvNode>(msg_len, msg_id);AsyncReadBody(msg_len);}catch (std::exception& e) {std::cout << "Exception code is " << e.what() << endl;}});
}

上面的逻辑里调用asyncReadFull读取整个长度,然后解析收到的数据,前两个字节为id,之后两个字节为长度,最后n个长度字节为消息内容

//读取完整长度
void CSession::asyncReadFull(std::size_t maxLength, std::function<void(const boost::system::error_code&, std::size_t)> handler )
{::memset(_data, 0, MAX_LENGTH);asyncReadLen(0, maxLength, handler);
}

读取指定长度

//读取指定字节数
void CSession::asyncReadLen(std::size_t read_len, std::size_t total_len, std::function<void(const boost::system::error_code&, std::size_t)> handler)
{auto self = shared_from_this();_socket.async_read_some(boost::asio::buffer(_data + read_len, total_len-read_len),[read_len, total_len, handler, self](const boost::system::error_code& ec, std::size_t  bytesTransfered) {if (ec) {// 出现错误,调用回调函数handler(ec, read_len + bytesTransfered);return;}if (read_len + bytesTransfered >= total_len) {//长度够了就调用回调函数handler(ec, read_len + bytesTransfered);return;}// 没有错误,且长度不足则继续读取self->asyncReadLen(read_len + bytesTransfered, total_len, handler);});
}

读取头部成功后,其回调函数内部调用了读包体的逻辑

void CSession::AsyncReadBody(int total_len)
{auto self = shared_from_this();asyncReadFull(total_len, [self, this, total_len](const boost::system::error_code& ec, std::size_t bytes_transfered) {try {if (ec) {std::cout << "handle read failed, error is " << ec.what() << endl;Close();_server->ClearSession(_uuid);return;}if (bytes_transfered < total_len) {std::cout << "read length not match, read [" << bytes_transfered << "] , total ["<< total_len<<"]" << endl;Close();_server->ClearSession(_uuid);return;}memcpy(_recv_msg_node->_data , _data , bytes_transfered);_recv_msg_node->_cur_len += bytes_transfered;_recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';cout << "receive data is " << _recv_msg_node->_data << endl;//此处将消息投递到逻辑队列中LogicSystem::GetInstance()->PostMsgToQue(make_shared<LogicNode>(shared_from_this(), _recv_msg_node));//继续监听头部接受事件AsyncReadHead(HEAD_TOTAL_LEN);}catch (std::exception& e) {std::cout << "Exception code is " << e.what() << endl;}});
}

读取包体完成后,在回调中继续读包头。以此循环往复直到读完所有数据。如果对方不发送数据,则回调函数就不会触发。不影响程序执行其他工作,因为我们采用的是asio异步的读写操作

当然我们解析完包体后会调用LogicSystem单例将解析好的消息封装为逻辑节点传递给逻辑层进行处理

LogicSystem

我们在逻辑层处理

void LogicSystem::RegisterCallBacks() {_fun_callbacks[MSG_CHAT_LOGIN] = std::bind(&LogicSystem::LoginHandler, this,placeholders::_1, placeholders::_2, placeholders::_3);
}void LogicSystem::LoginHandler(shared_ptr<CSession> session, const short &msg_id, const string &msg_data) {Json::Reader reader;Json::Value root;reader.parse(msg_data, root);std::cout << "user login uid is  " << root["uid"].asInt() << " user token  is "<< root["token"].asString() << endl;std::string return_str = root.toStyledString();session->Send(return_str, msg_id);
}

并在构造函数中注册这些处理流程

LogicSystem::LogicSystem():_b_stop(false){RegisterCallBacks();_worker_thread = std::thread (&LogicSystem::DealMsg, this);
}

总结

到此,完成了ChatServer收到QT客户端发送过来的长链接请求,并解析读取的数据,将收到的数据通过tcp发送给对端

token验证模块

完善proto

在proto文件里新增登陆验证服务

message LoginReq{int32 uid = 1;string token= 2;
}message LoginRsp {int32 error = 1;int32 uid = 2;string token = 3;
}service StatusService {rpc GetChatServer (GetChatServerReq) returns (GetChatServerRsp) {}rpc Login(LoginReq) returns(LoginRsp);
}

接下来是调用grpc命令生成新的pb文件覆盖原有的,并且也拷贝给StatusServer一份

我们完善登陆逻辑,先去StatusServer验证token是否合理,如果合理再从内存中寻找用户信息,如果没找到则从数据库加载一份

void LogicSystem::LoginHandler(shared_ptr<CSession> session, const short &msg_id, const string &msg_data) {Json::Reader reader;Json::Value root;reader.parse(msg_data, root);auto uid = root["uid"].asInt();std::cout << "user login uid is  " << uid << " user token  is "<< root["token"].asString() << endl;//从状态服务器获取token匹配是否准确auto rsp = StatusGrpcClient::GetInstance()->Login(uid, root["token"].asString());Json::Value  rtvalue;Defer defer([this, &rtvalue, session]() {std::string return_str = rtvalue.toStyledString();session->Send(return_str, MSG_CHAT_LOGIN_RSP);});rtvalue["error"] = rsp.error();if (rsp.error() != ErrorCodes::Success) {return;}//内存中查询用户信息auto find_iter = _users.find(uid);std::shared_ptr<UserInfo> user_info = nullptr;if (find_iter == _users.end()) {//查询数据库user_info = MysqlMgr::GetInstance()->GetUser(uid);if (user_info == nullptr) {rtvalue["error"] = ErrorCodes::UidInvalid;return;}_users[uid] = user_info;}else {user_info = find_iter->second;}rtvalue["uid"] = uid;rtvalue["token"] = rsp.token();rtvalue["name"] = user_info->name;
}

StatusServer验证token

在StatusServer验证token之前,我们需要在StatusServer中的GetServer的服务里将token写入内存

Status StatusServiceImpl::GetChatServer(ServerContext* context, const GetChatServerReq* request, GetChatServerRsp* reply)
{std::string prefix("llfc status server has received :  ");const auto& server = getChatServer();reply->set_host(server.host);reply->set_port(server.port);reply->set_error(ErrorCodes::Success);reply->set_token(generate_unique_string());insertToken(request->uid(), reply->token());return Status::OK;
}

接下来我们实现登陆验证服务

Status StatusServiceImpl::Login(ServerContext* context, const LoginReq* request, LoginRsp* reply)
{auto uid = request->uid();auto token = request->token();std::lock_guard<std::mutex> guard(_token_mtx);auto iter = _tokens.find(uid);if (iter == _tokens.end()) {reply->set_error(ErrorCodes::UidInvalid);return Status::OK;}if (iter->second != token) {reply->set_error(ErrorCodes::TokenInvalid);return Status::OK;}reply->set_error(ErrorCodes::Success);reply->set_uid(uid);reply->set_token(token);return Status::OK;
}

这样当GateServer访问StatusServer的Login服务做验证后,就可以将数据返回给QT前端了

客户端处理登陆回包

QT 的客户端TcpMgr收到请求后要进行对应的逻辑处理。所以我们在TcpMgr的构造函数中调用initHandlers注册消息

void TcpMgr::initHandlers()
{//auto self = shared_from_this();_handlers.insert(ID_CHAT_LOGIN_RSP, [this](ReqId id, int len, QByteArray data){qDebug()<< "handle id is "<< id << " data is " << data;// 将QByteArray转换为QJsonDocumentQJsonDocument jsonDoc = QJsonDocument::fromJson(data);// 检查转换是否成功if(jsonDoc.isNull()){qDebug() << "Failed to create QJsonDocument.";return;}QJsonObject jsonObj = jsonDoc.object();if(!jsonObj.contains("error")){int err = ErrorCodes::ERR_JSON;qDebug() << "Login Failed, err is Json Parse Err" << err ;emit sig_login_failed(err);return;}int err = jsonObj["error"].toInt();if(err != ErrorCodes::SUCCESS){qDebug() << "Login Failed, err is " << err ;emit sig_login_failed(err);return;}UserMgr::GetInstance()->SetUid(jsonObj["uid"].toInt());UserMgr::GetInstance()->SetName(jsonObj["name"].toString());UserMgr::GetInstance()->SetToken(jsonObj["token"].toString());emit sig_swich_chatdlg();});
}

并且增加处理请求

void TcpMgr::handleMsg(ReqId id, int len, QByteArray data)
{auto find_iter =  _handlers.find(id);if(find_iter == _handlers.end()){qDebug()<< "not found id ["<< id << "] to handle";return ;}find_iter.value()(id,len,data);
}

用户管理

为管理用户数据,需要创建一个UserMgr类,统一管理用户数据,我们这么声明

#ifndef USERMGR_H
#define USERMGR_H
#include <QObject>
#include <memory>
#include <singleton.h>class UserMgr:public QObject,public Singleton<UserMgr>,public std::enable_shared_from_this<UserMgr>
{Q_OBJECT
public:friend class Singleton<UserMgr>;~ UserMgr();void SetName(QString name);void SetUid(int uid);void SetToken(QString token);
private:UserMgr();QString _name;QString _token;int _uid;
};#endif // USERMGR_H

简单实现几个功能

#include "usermgr.h"UserMgr::~UserMgr()
{}void UserMgr::SetName(QString name)
{_name = name;
}void UserMgr::SetUid(int uid)
{_uid = uid;
}void UserMgr::SetToken(QString token)
{_token = token;
}UserMgr::UserMgr()
{}

详细和复杂的管理后续不断往这里补充就行了

登陆界面

登陆界面响应TcpMgr返回的登陆请求,在其构造函数中添加

   //连接tcp管理者发出的登陆失败信号connect(TcpMgr::GetInstance().get(), &TcpMgr::sig_login_failed, this, &LoginDialog::slot_login_failed);

并实现槽函数

void LoginDialog::slot_login_failed(int err)
{QString result = QString("登录失败, err is %1").arg(err);showTip(result,false);enableBtn(true);
}

到此完成了登陆的请求和响应,接下来要实现响应登陆成功后跳转到聊天界面。下一篇先实现聊天布局。

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

游戏服务端设计:任务系统

任务系统的设计 导读 在众多的游戏系统当中,任务系统可谓是缺一不可。它是策划对游戏周期的一种抽象拆分。每个阶段的任务设定和游戏的进度密切相关,可以视其为带有目标的玩法提示和指引。通过完成任务,来了解游戏背景、熟悉玩法,或者是达到某种目标(等级提升/道具获取/条…

C#开发翻译较好的API

用于翻译服务的网站或API&#xff0c;尤其适合C#开发&#xff0c;以下是一些知名的选项&#xff1a; Google Cloud Translation API Google 提供的翻译服务非常强大&#xff0c;支持多种语言&#xff0c;而且有很好的文档和社区支持。您可以使用C# SDK来调用此API。 Microsoft …

LabVIEW心电信号自动测试系统

开发了一种基于LabVIEW的心电信号自动测试系统&#xff0c;通过LabVIEW开发的上位机软件&#xff0c;实现对心电信号的实时采集、分析和自动化测试。系统包括心电信号采集模块、信号处理模块和自动化测试模块&#xff0c;能够高效、准确地完成心电信号的测量与分析。 硬件系统…

计算机视觉之Vision Transformer图像分类

Vision Transformer&#xff08;ViT&#xff09;简介 自注意结构模型的发展&#xff0c;特别是Transformer模型的出现&#xff0c;极大推动了自然语言处理模型的发展。Transformers的计算效率和可扩展性使其能够训练具有超过100B参数的规模空前的模型。ViT是自然语言处理和计算…

STM32+HC-05蓝牙模块学习与使用(内附资料)

引言 随着物联网技术的快速发展&#xff0c;短距离无线通信技术变得日益重要。蓝牙作为一种低功耗、低成本的无线通信技术&#xff0c;在嵌入式系统中得到了广泛应用。本文将详细介绍如何使用STM32微控制器与HC-05蓝牙模块进行通信&#xff0c;实现数据的无线传输。 硬件准备…

prompt第一讲-prompt科普

文章目录 大语言模型输入要求中英翻译助手直接抛出问题描述问题描述&#xff08;详细&#xff09;问题描述案例问题描述案例上下文问题为什么要加入上下文 prompt总结prompt心得 大语言模型输入要求 大语言模型本质上就是一个NLP语言模型&#xff0c;语言模型其实就是接受一堆…

ubuntu服务器安装labelimg报错记录

文章目录 报错提示查看报错原因安装报错 报错提示 按照步骤安装完labelimg后&#xff0c;在终端输入labelImg后&#xff0c;报错&#xff1a; (labelimg) rootinteractive59753:~# labelImg ………………Got keys from plugin meta data ("xcb") QFactoryLoader::Q…

日常学习--20240713

1、字节流转字符流时&#xff0c;除了使用字节流实例作为参数&#xff0c;还需要什么参数&#xff1f; 还需要使用字符编码作为参数&#xff0c;保证即使在不同平台上也是使用相同的字符编码&#xff08;否则会使用平台默认的编码&#xff0c;不同平台默认编码可能不一样&…

hutool处理excel时候空指针小记

如图所示&#xff0c;右侧的会识别不到 参考解决方案&#xff1a; /***Description: 填补空缺位置为null/空串*Param: hutool读取的list*return: 无*Author: y*date: 2024/7/13*/public static void formatHutoolExcelArr(List<List<Object>> list) {if (CollUtil…

企业网络实验dhcp-snooping、ip source check,防非法dhcp服务器、自动获取ip(虚拟机充当DHCP服务器)、禁手动修改IP

文章目录 需求相关配置互通性配置配置vmware虚拟机&#xff08;dhcp&#xff09;分配IP服务配置dhcp relay&#xff08;dhcp中继&#xff09;配置dhcp-snooping&#xff08;防非法dhcp服务器&#xff09;配置ip source check&#xff08;禁手动修改IP&#xff09; DHCP中继&…

Android ListView

ListView ListView是以列表的形式展示具体内容的控件&#xff0c;ListView能够根据数据的长度自适应显示&#xff0c;如手机通讯录、短消息列表等都可以使用ListView实现。如图1所示是两个ListView&#xff0c;上半部分是数组形式的ListView&#xff0c;下半部分是简单列表Lis…

《Linux系统编程篇》认识在linux上的文件 ——基础篇

前言 Linux系统编程的文件操作如同掌握了一把魔法钥匙&#xff0c;打开了无尽可能性的大门。在这个世界中&#xff0c;你需要了解文件描述符、文件权限、文件路径等基础知识&#xff0c;就像探险家需要了解地图和指南针一样。而了解这些基础知识&#xff0c;就像学会了魔法咒语…

【C++】指针学习 知识点总结+代码记录

一.示例代码知识点总结 1. 基本指针操作 指针声明和初始化&#xff1a;int* ptr_a a; 表示声明了一个指向整型的指针&#xff0c;并初始化为指向数组a的首地址。引用和指针的区别&#xff1a;int& i2 i; 声明了一个整型引用&#xff0c;绑定到变量i上&#xff0c;而int…

k3s配置docker容器/dev/shm

在使用K3s和Docker容器时&#xff0c;如果你发现容器的 /dev/shm 默认大小是64MB&#xff0c;并且需要扩大它的大小&#xff0c;可以通过以下几种方法实现。 方法1&#xff1a;使用 Docker 的 --shm-size 选项 如果你直接使用 Docker 运行容器&#xff0c;可以通过 --shm-siz…

jenkins系列-07.轻易级jpom安装

jpom是一个容器化服务管理工具&#xff1a;在线构建&#xff0c;自动部署&#xff0c;日常运维, 比jenkins轻量多了。 本篇介绍mac m1安装jpom: #下载&#xff1a;https://jpom.top/pages/all-downloads/ 解压&#xff1a;/Users/jelex/Documents/work/jpom-2.10.40 启动前修…

git 分支介绍

在Git版本控制系统中&#xff0c;分支&#xff08;Branch&#xff09;是一种非常强大的功能&#xff0c;它允许开发者在不影响主代码库&#xff08;如master分支&#xff09;的情况下进行开发或修复工作。你提到的五种分支类型是在Gitflow工作流&#xff08;Gitflow Workflow&a…

css基础(1)

CSS CCS Syntax CSS 规则由选择器和声明块组成。 CSS选择器 CSS选择器用于查找想要设置样式的HTML元素 一般选择器分为五类 Simple selectors (select elements based on name, id, class) 简单选择器&#xff08;根据名称、id、类选择元素&#xff09; //页面上的所有 …

Git配置笔记

文章目录 Git配置一、Git配置文件1.1 配置文件位置1.2 参考 二、换行符相关2.1 背景2.2 相关配置2.3 推荐配置2.4 参考资料 Git配置 一、Git配置文件 1.1 配置文件位置 Git 自带一个 git config 的工具来帮助设置控制 Git 外观和行为的配置变量。 这些变量存储在三个不同的位…

Web 性能入门指南-1.5 创建 Web 性能优化文化的最佳实践

最成功的网站都有什么共同点&#xff1f;那就是他们都有很强的网站性能和可用性文化。以下是一些经过验证的有效技巧和最佳实践&#xff0c;可帮助您建立健康、快乐、值得庆祝的性能文化。 创建强大的性能优化文化意味着在你的公司或团队中创建一个如下所示的反馈循环&#xff…

MySQL入门学习-深入索引.匹配顺序

在 MySQL 中&#xff0c;索引的匹配顺序是指在查询执行时&#xff0c;数据库系统根据查询条件中涉及的列和索引的结构&#xff0c;决定如何使用索引来提高查询效率的方式。 以下是关于深入索引和匹配顺序的一些详细信息&#xff1a; 一、索引的类型&#xff1a; - B-Tree 索引…