msgqueue.hpp队列模块

已于 2024-08-14 15:05:02 修改
阅读量437 收藏 3
点赞数 10
分类专栏： MQ项目 文章标签： 算法 c++ git 数据结构 sql 后端 中间件
于 2024-08-14 10:57:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzfnb666/article/details/141183960
版权

目录

一.MsgQueue模块介绍

二.MsgQueue类的实现

成员变量

构造函数与析构函数

成员函数

参数设置函数 setArgs

参数获取函数 getArgs

三.MsgQueueMapper类的实现

成员变量

构造函数

成员函数

创建表格函数 createTable

删除表格函数 dropTable

插入数据函数 insert

删除数据函数 remove

数据恢复函数 recover

msgQueueMapCb

四.MsgQueueMapper类的实现

成员变量

构造函数

成员函数

声明队列函数 declareQueue

删除队列函数 removeQueue

查询队列函数 selectQueue

查询所有队列函数 selectAll

队列是否存在函数 exists

队列数量函数 size

清空所有队列函数 clear

一.MsgQueue模块介绍

二.MsgQueue类的实现

成员变量

MsgQueue 结构体用于描述一个消息队列的基本属性。

std::string _name; // 队列名称
bool _durable;     // 队列是否持久化
bool _exclusive;   // 队列是否独占
bool _auto_del;    // 队列是否自动删除
google::protobuf::Map<std::string, std::string> _args; // 队列的附加参数

构造函数与析构函数

结构体提供了一个带参数的构造函数用于初始化各成员变量。同时提供了一个默认构造函数以支持无参初始化。

MsgQueue(const std::string &name, bool durable, bool exclusive, bool auto_del, const google::protobuf::Map<std::string, std::string> &_args)
    : _name(name), _durable(durable), _exclusive(exclusive), _auto_del(auto_del), _args(_args) {}

成员函数

MsgQueue 提供了两个主要的成员函数，用于设置和获取队列的附加参数。

参数设置函数 setArgs

setArgs 方法接收一个格式化的字符串参数，并将其解析为键值对，存储在 _args 中。
该方法使用了 StrHelper::split 函数来分割字符串，通过 = 符号区分键和值，并存储在 _args 中。

参数获取函数 getArgs

getArgs 方法用于将 _args 中的键值对组合成格式化字符串，返回给调用者。

std::string getArgs()
{
    std::string ret;
    for (auto &kv : _args)
    {
        ret += kv.first + "=" + kv.second + "&";
    }
    return ret;
}

三.MsgQueueMapper类的实现

成员变量

SqliteHelper sql_helper; //数据库管理句柄
  • sql_helper：SqliteHelper 是一个辅助类，封装了SQLite的基本操作，如执行SQL语句和管理数据库连接。

构造函数

MsgQueueMapper(const std::string &dbname) : sql_helper(dbname)
{
    std::string path = FileHelper::getParentDirName(dbname);
    FileHelper::createDir(path);
    if (!sql_helper.open())
    {
        ELOG("MsgQueueMapper open db failed:%s", dbname.c_str());
        assert(0);
    }
    createTable();
}

构造函数接受一个数据库名称参数，初始化 sql_helper，并在必要时创建数据库目录和表。

成员函数

创建表格函数 createTable
void createTable()
{
    std::stringstream sql;
    sql << "create table if not exists msg_queue(";
    sql << "name varchar(64) primary key,";
    sql << "durable int,";
    sql << "exclusive int,";
    sql << "auto_del int,";
    sql << "args varchar(64));";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("MsgQueueMapper create table failed:%s", sql.str().c_str());
        assert(0);
    }
}
删除表格函数 dropTable

dropTable 方法用于删除现有的消息队列表格。该方法执行删除表格的SQL语句，如果表格存在，它将被移除。

void dropTable()
{
    std::stringstream sql;
    sql << "drop table if exists msg_queue;";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("MsgQueueMapper drop table failed:%s", sql.str().c_str());
        assert(0);
    }
}
插入数据函数 insert

insert 方法将 MsgQueue 对象插入到数据库中。

void insert(MsgQueue::ptr &msg_queue_ptr)
{
    std::stringstream sql;
    sql << "insert into msg_queue(name, durable, exclusive, auto_del, args) values(";
    sql << "'" << msg_queue_ptr->_name << "',";
    sql << msg_queue_ptr->_durable << ",";
    sql << msg_queue_ptr->_exclusive << ",";
    sql << msg_queue_ptr->_auto_del << ",";
    sql << "'" << msg_queue_ptr->getArgs() << "');";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("MsgQueueMapper insert msg_queue failed:%s", sql.str().c_str());
        assert(0);
    }
}
删除数据函数 remove

remove 方法用于从数据库中删除指定名称的消息队列。

void remove(const std::string &name)
{
    std::stringstream sql;
    sql << "delete from msg_queue where name = '" << name << "';";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("MsgQueueMapper remove msg_queue failed:%s", sql.str().c_str());
        assert(0);
    }
}
数据恢复函数 recover

recover 方法用于从数据库中恢复所有消息队列。该方法执行SQL查询语句，遍历结果集，并将每个消息队列恢复到内存中的 _msgQueues 容器中。

   msgqueue_map recover()
        {
            msgqueue_map ret;
            std::string sql = "select * from msg_queue;";
            if (!sql_helper.exec(sql, MsgQueueMapper::msgQueueMapCb, &ret))
            {
                ELOG("MsgQueueMapper recover failed:%s", sql.c_str());
                assert(0);
            }

            return ret;
        }
msgQueueMapCb
  • 该静态回调函数在 recover 函数中被调用，用于将数据库查询结果中的每一行转化为一个 MsgQueue对象，并将其存储到 msgqueue_map中。
      static int msgQueueMapCb(void *arg, int col_count, char **col_values, char **col_names)
        {
            msgqueue_map *ret = (msgqueue_map *)arg;
            MsgQueue::ptr msg_queue_ptr = std::make_shared<MsgQueue>();

            msg_queue_ptr->_name = col_values[0];
            msg_queue_ptr->_durable = std::stoi(col_values[1]);
            msg_queue_ptr->_exclusive = std::stoi(col_values[2]);
            msg_queue_ptr->_auto_del = std::stoi(col_values[3]);
            if (col_values[4])
            {
                msg_queue_ptr->setArgs((std::string)col_values[4]);
            }
            else
                ELOG("没有其它参数");

            ret->insert(std::make_pair(msg_queue_ptr->_name, msg_queue_ptr));
            return 0;
        }

四.MsgQueueMapper类的实现

MsgQueueManager 类用于管理内存中的消息队列对象，并与 MsgQueueMapper 协作实现消息队列的持久化。

成员变量

  • _msgQueues：一个键值对映射，用于存储当前内存中的所有消息队列。
  • _mapper：MsgQueueMapper 对象，用于与数据库进行持久化操作。
  • _mutex：用于保护消息队列操作的线程安全。

构造函数

构造函数在初始化时会调用 MsgQueueMapper 的 recover 方法，从数据库恢复所有消息队列。

MsgQueueManager(const std::string &dbname) : _mapper(dbname)
{
    _mapper.recover(_msgQueues);
}

成员函数

声明队列函数 declareQueue

declareQueue 方法用于声明一个新的消息队列，并将其加入到内存和数据库中。

该方法首先检查队列是否已经存在，若不存在，则创建并插入新的队列。如果队列需要持久化，则还会将其插入到数据库中。

bool declareQueue(const std::string &name, bool durable, bool exclusive, bool auto_del, const google::protobuf::Map<std::string, std::string> &args)
{
    std::lock_guard<std::mutex> lock(_mutex);
    auto it = _msgQueues.find(name);
    if (it != _msgQueues.end())
    {
        ILOG("MsgQueueManager declareQueue:%s already exists", name.c_str())
        return true;
    }

    MsgQueue::ptr msg_queue_ptr = std::make_shared<MsgQueue>(name, durable, exclusive, auto_del, args);
    _msgQueues.insert(std::make_pair(name, msg_queue_ptr));
    if (msg_queue_ptr->_durable)
        _mapper.insert(msg_queue_ptr);

    return true;
}
删除队列函数 removeQueue

removeQueue 方法用于删除指定名称的消息队列。

bool removeQueue(const std::string &name)
{
    std::lock_guard<std::mutex> lock(_mutex);
    auto it = _msgQueues.find(name);
    if (it == _msgQueues.end())
    {
        ELOG("MsgQueueManager removeQueue:%s not exists", name.c_str());
        return false;
    }

    if (it->second->_durable)
        _mapper.remove(name);
    _msgQueues.erase(it);
    return true;
}
查询队列函数 selectQueue

selectQueue 方法根据队列名称查询并返回消息队列对象

该方法用于在内存中查找指定名称的队列，并返回指向该队列的智能指针。

MsgQueue::ptr selectQueue(const std::string &name)
{
    std::lock_guard<std::mutex> lock(_mutex);
    auto it = _msgQueues.find(name);
    if (it == _msgQueues.end())
    {
        ELOG("MsgQueueManager selectQueue:%s not exists", name.c_str());
        return nullptr;
    }
    return it->second;
}
查询所有队列函数 selectAll
  msgqueue_map selectAll()
        {
            return _msgQueues;
        }
队列是否存在函数 exists

exists 方法用于判断指定名称的消息队列是否存在。


bool exists(const std::string &name) { std::lock_guard<std::mutex> lock(_mutex); return _msgQueues.find(name) != _msgQueues.end(); }

该方法返回一个布尔值，指示队列是否存在。

队列数量函数 size

size 方法用于返回当前存在的消息队列数量。

size_t size() { std::lock_guard<std::mutex> lock(_mutex); return _msgQueues.size(); }

该方法返回一个整数值，表示内存中队列的数量。

清空所有队列函数 clear

clear 方法用于清空所有当前存在的消息队列。


void clear() { std::lock_guard<std::mutex> lock(_mutex); _msgQueues.clear(); _mapper.dropTable(); _mapper.createTable(); }

该方法清空内存中的所有队列，并在数据库中删除和重建消息队列表格。

五.MsgQueue.hpp所有代码

#pragma once
#include "../common_mq/helper.hpp"
#include "../common_mq/logger.hpp"
#include "../common_mq/msg.pb.h"
#include <string>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <cassert>
#include <cstring>
#include <google/protobuf/map.h>

namespace mq
{
    struct MsgQueue
    {
        std::string _name;
        bool _durable;   // 是否持久化
        bool _exclusive; // 是否独占
        bool _auto_del;  // 是否自动删除
        google::protobuf::Map<std::string, std::string> _args;

        using ptr = std::shared_ptr<MsgQueue>;

        MsgQueue(const std::string &name, bool durable, bool exclusive,
                 bool auto_del, const google::protobuf::Map<std::string, std::string> &_args)
            : _name(name),
              _durable(durable),
              _exclusive(exclusive),
              _auto_del(auto_del),
              _args(_args)
        {
        }
        MsgQueue() {}
        void setArgs(const std::string &str_args)
        {
            std::vector<std::string> args;
            size_t sz = StrHelper::split(str_args, "&", args);
            for (auto &kv : args)
            {
                size_t pos = kv.find("=");
                if (pos == std::string::npos)
                {
                    ELOG("MsgQueue args format error:%s", kv.c_str());
                    assert(0);
                }
                std::string key = kv.substr(0, pos);
                std::string val = kv.substr(pos + 1);
                _args[key] = val;
            }
        }
        std::string getArgs()
        {
            std::string ret;
            for (auto &kv : _args)
            {
                ret += kv.first + "=" + kv.second + "&";
            }

            return ret;
        }
    };

    using msgqueue_map = std::unordered_map<std::string, std::shared_ptr<MsgQueue>>;

    class MsgQueueMapper
    {
    private:
        SqliteHelper sql_helper;

    public:
        MsgQueueMapper(const std::string &dbname)
            : sql_helper(dbname)
        {
            // 数据库有path即可，open时自动创建文件
            std::string path = FileHelper::getParentDirName(dbname);
            FileHelper::createDir(path);
            if (!sql_helper.open())
            {
                ELOG("MsgQueueMapper open db failed:%s", dbname.c_str());
                assert(0);
            }
            createTable();
        }
        // 1.创建，删除表
        void createTable()
        {
            std::stringstream sql;
            sql << "create table if not exists msg_queue(";
            sql << "name varchar(64) primary key,";
            sql << "durable int,";
            sql << "exclusive int,";
            sql << "auto_del int,";
            sql << "args varchar(64));";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("MsgQueueMapper create table failed:%s", sql.str().c_str());
                assert(0);
            }
        }
        void dropTable()
        {
            std::stringstream sql;
            sql << "drop table if exists msg_queue;";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("MsgQueueMapper drop table failed:%s", sql.str().c_str());
                assert(0);
            }
        }
        // 2.插入/删除数据
        void insert(MsgQueue::ptr &msg_queue_ptr)
        {
            std::stringstream sql;
            sql << "insert into msg_queue (name,durable,exclusive,auto_del,args) values(";
            sql << "'" << msg_queue_ptr->_name << "',";
            sql << msg_queue_ptr->_durable << ",";
            sql << msg_queue_ptr->_exclusive << ",";
            sql << msg_queue_ptr->_auto_del << ",";
            sql << "'" << msg_queue_ptr->getArgs() << "');";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("MsgQueueMapper insert failed:%s", sql.str().c_str());
                assert(0);
            }
        }
        void remove(const std::string &name)
        {
            std::stringstream sql;
            sql << "delete from msg_queue where name='" << name << "';";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("MsgQueueMapper remove failed:%s", sql.str().c_str());
                assert(0);
            }
        }
        // 3.recover
        msgqueue_map recover()
        {
            msgqueue_map ret;
            std::string sql = "select * from msg_queue;";
            if (!sql_helper.exec(sql, MsgQueueMapper::msgQueueMapCb, &ret))
            {
                ELOG("MsgQueueMapper recover failed:%s", sql.c_str());
                assert(0);
            }

            return ret;
        }

    private:
        static int msgQueueMapCb(void *arg, int col_count, char **col_values, char **col_names)
        {
            msgqueue_map *ret = (msgqueue_map *)arg;
            MsgQueue::ptr msg_queue_ptr = std::make_shared<MsgQueue>();

            msg_queue_ptr->_name = col_values[0];
            msg_queue_ptr->_durable = std::stoi(col_values[1]);
            msg_queue_ptr->_exclusive = std::stoi(col_values[2]);
            msg_queue_ptr->_auto_del = std::stoi(col_values[3]);
            if (col_values[4])
            {
                msg_queue_ptr->setArgs((std::string)col_values[4]);
            }
            else
                ELOG("没有其它参数");

            ret->insert(std::make_pair(msg_queue_ptr->_name, msg_queue_ptr));
            return 0;
        }
    };

    class MsgQueueManager
    {
    public:
        using ptr = std::shared_ptr<MsgQueueManager>;

    private:
        msgqueue_map _msgQueues;
        std::mutex _mutex;
        MsgQueueMapper _mapper;

    public:
        MsgQueueManager(const std::string &dbname)
            : _mapper(dbname)
        {
            _msgQueues = _mapper.recover();
        }
        // 1. 插入/删除数据
        bool declareQueue(const std::string &name,
                          bool durable,
                          bool exclusive,
                          bool auto_del,
                          const google::protobuf::Map<std::string, std::string> &args)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            auto it = _msgQueues.find(name);
            if (it != _msgQueues.end())
            {
                ILOG("MsgQueueManager declareQueue:%s already exists", name.c_str())
                return true;
            }

            MsgQueue::ptr msg_queue_ptr = std::make_shared<MsgQueue>(name, durable, exclusive, auto_del, args);
            _msgQueues.insert(std::make_pair(name, msg_queue_ptr));
            if (msg_queue_ptr->_durable)
                _mapper.insert(msg_queue_ptr);
            // std::cout<<"declare队列:"<<msg_queue_ptr->_name<<std::endl;
            // std::cout<<"队列的个数:"<<_msgQueues.size()<<std::endl;
            return true;
        }
        bool removeQueue(const std::string &name)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            auto it = _msgQueues.find(name);
            if (it == _msgQueues.end())
            {
                ILOG("MsgQueueManager removeQueue:%s not exists", name.c_str());
                return true;
            }
            _msgQueues.erase(it);
            if (it->second->_durable)
                _mapper.remove(name);
            return true;
        }
        // 2. 查询一个/所有 queue
        MsgQueue::ptr selectQueue(const std::string &name)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            auto it = _msgQueues.find(name);
            if (it == _msgQueues.end())
            {
                ILOG("MsgQueueManager select:%s not exists", name.c_str());
                return MsgQueue::ptr();
            }

            return it->second;
        }
        msgqueue_map selectAll()
        {
            return _msgQueues;
        }
        // 3. 其它操作
        bool exists(const std::string &name)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            auto it = _msgQueues.find(name);
            if (it == _msgQueues.end())
            {
                ILOG("MsgQueueManager :%s not exists", name.c_str());
                return false;
            }

            return true;
        }
        size_t size()
        {
            std::unique_lock<std::mutex> lock(_mutex);
            return _msgQueues.size();
        }
        void clear()
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _mapper.dropTable();
            _msgQueues.clear();
        }
    };
};

乄北城以北乀
关注
  • 10
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
posix_msgqueue.rar
03-16
在本压缩包"posix_msgqueue.rar"中，包含了一个示例项目，用于演示如何使用POSIX消息队列进行线程间的通信。 首先，我们来理解一下POSIX消息队列的基本概念。POSIX消息队列是一种异步通信方式，每个消息都有一个...
MsgQueue.unitypackage
12-25
unity 消息队列。用于防止同一时间执行N个任务，对UI做数据分离~。。。。。。。。。。。。。。。。
binding.hpp绑定模块
最新发布
lzf的博客
08-14 606
Binding模块
Java：实现消息队列功能。
孤芳不自赏
10-21 677
使用java实现的线程池 消息队列功能。
MSGQueue 使用介绍
chenwh_cn的博客
05-25 1431
文章目录一、MSGQueue 消息队列简介二、MSGQueue 基本函数1. `key_t ftok(const char *pathname, int proj_id);`2. `int msgget(key_t key, int msgflg);`3. `int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);`4. `ssize_t msgrcv( int msqid, void *msgp, size_t msgsz, l
OS-POSIX MSGQUEUE. MUTEX
he91-com
06-10 76
网上找了一会儿，一时半刻找不到合适的实现SysV 消息队列的API，没办法，只好直接用Mutex 实现了一个PV操作的消息队列。 接口： OS_MSGQ_Handle OS_MSGQ_Create(API_IN int queueSize, // should &lt;= MSGQ_SIZE_MAXAPI_IN int dataSize // should &lt;= MSGQ_DATA...
开源项目-go-msgqueue-msgqueue.zip
10-09
开源项目-go-msgqueue-msgqueue.zip,SQS & IronMQ & in-memory message queue with rate limiting and call once
9_posix_msgqueue.tgz
12-05
标题“9_posix_msgqueue.tgz”所对应的资源是一个与Linux进程间通信（IPC）相关的压缩包，特别关注的是POSIX消息队列的实现。在Linux操作系统中，进程间通信是多个进程之间交换数据和协调任务执行的重要机制。POSIX...
a_sysv_msgqueue.tgz
12-08
本项目"a_sysv_msgqueue.tgz"是一个关于System V消息队列实现的源码示例，适用于学习和理解这一通信机制。 System V消息队列允许进程将数据结构（通常为字符串）存储在内核管理的队列中，其他进程可以通过消息队列...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 246
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
day 9 回溯算法
m0_73924943的博客
08-08 376
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1210
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
[算法2] 第二集 二叉树中的深度搜索
2301_80017277的博客
08-09 858
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
算法：外卖调度
m0_73915763的博客
08-13 707
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
【算法】二分查找
2301_80277275的博客
08-10 254
二分查找、在排序数组中查找元素的第一个和最后一个位置、x的平方根、搜索插入位置、山脉数组的峰顶索引、寻找峰值、寻找旋转排序数组中的最小值、点名
经典算法题总结：十大排序算法，外部排序和Google排序简介
技术研究记录
08-10 542
快速排序（Quick Sort）是一种常用的高效的排序算法，它是一种基于比较的排序算法，利用了分治（自顶向下）的思想。快速排序的主要思想是选择一个基准元素，将数组分成两个子数组，一个子数组的所有元素都小于基准元素，另一个子数组的所有元素都大于基准元素，然后递归地对这两个子数组进行排序，最后将它们合并起来。
C语言 | Leetcode C语言题解之第332题重新安排行程
m0_59237910的博客
08-13 371
C语言 | Leetcode C语言题解之第332题重新安排行程
算法定制与双光谱技术融合：提升巡检车入侵检测系统效能
LntonCEC的博客
08-13 286
需要定制一项基于双光谱云台相机的入侵检测系统，该系统将被应用于机场周界巡检车辆，以实现全天候的周界安全监控，包括周界状态监测、入侵物体识别、特定行为分析及夜视能力强化。这种需求不仅体现在数量上，更体现在质量上，尤其是对算法定制化的需求。微调：就是已有算法和相关场景的数据，需要加入一些现场样本（每次至少需1000张），重新训练，就是不停根据现场的误报和漏报进行标注训练的迭代过程。定制：明确需求后，提供初步样本，再收集一些样本，标注训练形成初始算法，需要的数据量相比微调要大一些，周期要长一些，费用要高一些。
public class Demo { private MessageQueue msgQueue; public Demo(MessageQueue msgQueue) { this.msgQueue = msgQueue; } 这段代码的 public Demo(MessageQueue msgQueue) { this.msgQueue = msgQueue; } 意义在哪
07-12
这段代码是一个类`Demo`的构造函数，它接受一个`MessageQueue`对象作为参数，并将该对象赋值给类中的私有成员变量`msgQueue`。构造函数的作用是在创建`Demo`对象时初始化`msgQueue`成员变量的值。 通过使用构造函数的参数注入方式，可以实现依赖注入，即将依赖的对象作为参数传递给类的构造函数，而不是在类内部直接创建依赖对象。这样做的好处是提高代码的可维护性和扩展性，使得类与依赖对象之间的耦合度降低。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值