腾讯云

开发者社区

文档建议反馈控制台

首页

文章/答案/技术大牛

发布

社区首页 >专栏 >OpenMiniServer是一个超迷你、超易用的C++高并发跨平台服务器框架

OpenMiniServer是一个超迷你、超易用的C++高并发跨平台服务器框架

原创

linyouhappy

发布于 2023-07-20 09:38:35

6501

文章被收录于专栏：OpenLinyouOpenLinyou

OpenMiniServer

OpenMiniServer是一个超迷你、超易用的C++高并发跨平台服务器框架。它基于Actor模型，提供了高性能的服务器功能，支持高并发和跨平台。

与其他C++服务器框架相比，OpenMiniServer更加轻量级，依赖更少的第三方库，对跨平台的支持也特别友好。

OpenMiniServer的目标是用尽可能少的C++代码实现高性能、高并发的服务器项目。它使用CMake构建系统实现跨平台支持，使同一份代码可以在不同的平台上开发和编译运行。可以在Windows环境下开发，无需要改动，就可以在Linux上编译出功能一样的程序。

为了开发OpenMiniServer开源项目，从零开发设计各基础库，如高并发socket库-OpenSocket、多线程库-OpenThread等。

OpenSocket是一个高性能的可复用IO库，是实现网络高并发的关键。OpenThread实现了Actor模式,大大简化了服务器业务逻辑的开发,可以轻松实现多核支持。

技术架构

线程处理 OpenThread采用固定大小线程池实现高效线程管理。结合智能指针的线程安全特性，实现了OpenThread对象的无锁访问。

每个OpenThread对象在创建启动时，会创建一条线程并加入线程池中，以便统一管理该线程及其业务逻辑。

服务器计算业务根据CPU负载进行拆分，分发到多个OpenThread对象上，从而实现多核处理。

OpenThread通过条件锁实现线程间安全通信，构建Actor模型。多个OpenThread对象通过线程通信进行协作，处理复杂业务逻辑，实现简化开发工作，应对服务器高压处理业务需求。

OpenServer类是OpenMiniServer的核心类，它继承OpenThread，在OpenThread的基础上按照Actor模型进一步封装设计，提供更多便利的统一的接口。

网络处理 OpenSocket是高性能socket库，提供高性能网络通信服务。请求socket服务时可以指定sessionID，OpenSocket返回网络消息就会携带此sessionID，根据sessionID可以把网络消息分发给申请者。
线程与网络结合每个OpenServer对象拥有唯一ID，把这个唯一ID当作sessionID处理，向OpenSocket请求socket服务，返回的网络消息会携带此ID，根据此ID可以找到OpenServer对象，把网络消息发给该OpenServer对象。

这就是OpenMiniServer框架的主要工作流，非常简单。

测试例子

OpenMiniServer设计的使用场景是大数据分析服务器，比如量化分析等。

在开始之前，先编译运行项目。

1.编译和执行

请安装cmake工具，用cmake可以构建出VS或者XCode工程，就可以在vs或者xcode上编译运行。

源代码：https://github.com/OpenMiniServer/OpenMiniServer

#克隆项目
git clone https://github.com/OpenMiniServer/OpenMiniServer
cd ./OpenMiniServer
#创建build工程目录
mkdir build
cd build
cmake ..
#如果是windows系统，在该目录出现OpenMiniServer.sln，点击它就可以启动vs写代码调试
make
./OpenMiniServer

运行结果

OpenHttpServer Listen: 0.0.0.0:8080
start OpenServer
OpenHttpServer::accept:127.0.0.1:50285
OpenHttpAgent::Client::start[127.0.0.1:50285]
OpenComHttpAgent::Client::open[127.0.0.1:50285]
HTTP visit:127.0.0.1:50285 /api/stock?code=399001

csv content:
code,time,price
399001,2023-07-18,10.000000
399001,2023-07-19,20.000000

2.项目文件

项目根目录文件很少，符合尽可能简单的设计目标。

demo             // 测试例子源代码
open             // OpenMiniServer的全部源代码
CMakeLists.txt   // CMake的主工程文件

如果OpenMiniServer需要使用https功能，就需要导入OpenSSL库，并加入编译宏定义USE_OPEN_SSL，即可。

3.测试例子介绍

在demo文件夹下

msg        // 定义OpenServer通信消息
server     // 存放各种模块
util       // 通用源代码
app.h      // 唯一应用实例头文件 继承 open::OpenApp
app.cpp    // 唯一应用实例实现文件

demo/server有3个模块，centor、httpd和stock，它们最终继承OpenServer类，相当于有3种Actor，每种定制某种业务。

虽然它们的类名都一样，但可以靠namespace去区分，这样处理可以提高写代码效率。

stock模块主要负责下载股票数据，下载完就返回一条消息给请求者，它继承OpenHttpClient，拥有请求http功能；
centor模块主要负责控制，向stock模块发消息请求股票数据，然后收到股票数据后，把json格式的数据转成csv格式的数据；
httpd模块负责web服务，提供数据下载业务。它有两种OpenServer，一种是httpa，继承OpenHttpAgent，可以处理接收和发送网络消息；另一种是httpd，继承OpenHttpServer，负责监听客户端连接，然后把连接发给httpa处理。
stock模块通过web请求向httpd模块下载股票数据。
不同的业务，需要设计不同的OpenServer子类，把它们注册到OpenServerPool中，才能对它们进行启动，启动OpenServer的内部线程。 open::OpenApp负责这个事情，需要先对三种模块进行注册，每个模块绑定一个名字，然后用这个名字进行启动。

// 注册stock模块
open::OpenServer::RegisterServer<stock::Server>("stock");

// 启动两个stock模块： stock1和stock2。 相当于启动了两条线程，两条业务流水线。 当然，可以创建更多，实现多核处理同一业务。
open::OpenServer::StartServer("stock", "stock1", "");
open::OpenServer::StartServer("stock", "stock2", "");

1.app源代码

App继承open::OpenApp，是一个单例类，主要负责注册OpenServer，然后对它们进行启动。

//导入centor、httpd和stock三个模块的头文件
#include "server/stock/server.h"
#include "server/httpd/httpa.h"
#include "server/httpd/httpd.h"
#include "server/centor/server.h"
//程序唯一应用实例
class App : public open::OpenApp
{
    static App TheApp_;
public:
    static inline App& Instance() { return TheApp_; }
    virtual void start()
    {
        OpenApp::start();
        //启动定时器模块
        open::OpenTimerServer::Run();

        //注册自定义模块
        //注册httpa::Server模块
        open::OpenServer::RegisterServer<httpa::Server>("httpa");
        open::OpenServer::RegisterServer<httpd::Server>("httpd");
        open::OpenServer::RegisterServer<stock::Server>("stock");
        open::OpenServer::RegisterServer<centor::Server>("centor");

        //启动4个httpa::Server对象，负责接收和发送客户端的网络消息
        open::OpenServer::StartServer("httpa", "httpa1", "");
        open::OpenServer::StartServer("httpa", "httpa2", "");
        open::OpenServer::StartServer("httpa", "httpa3", "");
        open::OpenServer::StartServer("httpa", "httpa4", "");

        //启动1个httpa::Server对象，负责监听客户端连接，并把连接发给httpa::Server对象处理
        open::OpenServer::StartServer("httpd", "httpd", "");

        //启动2个stock::Server对象，可以两条线程负债均衡处理同一业务，如果业务很大，CPU核数很多，可以多创建几个。
        open::OpenServer::StartServer("stock", "stock1", "");
        open::OpenServer::StartServer("stock", "stock2", "");

        //启动1个centor::Server对象
        open::OpenServer::StartServer("centor", "centor", "");

        //上述只是创建OpenServer，接下来启动它们，创建线程，处理各自的业务
        open::OpenServer::RunServers();
        printf("Start OpenMiniServer complete!\n");
    }
};
//应用实例对象
App App::TheApp_;

三种模块centor、httpd和stock，它们最终继承OpenServer类，而OpenServer类继承了OpenThread，也就是每个模块对象都有一条专属线程处理业务，无需考虑多线程问题。

每个OpenServer对象都是独立的，它们各自处理各自的事情，当需要协作时，只要互相发送消息即可。

接下来实现各个模块的源代码

2.stock模块源代码

stock模块其实就是一个http请求客户端，OpenMiniServer提供了open::OpenHttpClient模块，可以简单实现http请求功能。

#include "open.h"
#include "msg/msg.h"
//用域名空间的名字来区分模块，模块名叫stock
namespace stock
{
// 继承open::OpenHttpClient，拥有请求http的能力，open::OpenHttpClient继承OpenServer
class Server : public open::OpenHttpClient
{
    typedef std::function<void(open::OpenHttpRequest&, open::OpenHttpResponse&)> HttpHandle;
public:
    Server(const std::string& name, const std::string& args)
        :open::OpenHttpClient(name, args)
    {
        sessionId_ = 0;
    }
    virtual ~Server() {}

    //每个模块都需要实现New函数，否则open::OpenServer::StartServer启动会失败
    static OpenServer* New(const std::string& serverName, const std::string& args)
    {
        return new Server(serverName, args);
    }

    //它的父类OpenServer 启动以后，会启动它的线程，此线程启动成功，就会调用onStart方法
    virtual void onStart() {}

    //业务方法，请求股票数据，并通过回调函数返回结果
    bool reqStockData(const std::string& code, const HttpHandle& cb)
    {
        auto request = std::shared_ptr<open::OpenHttpRequest>(new open::OpenHttpRequest);
        request->method_ = "GET";
        request->url_ = "http://localhost:8080/api/stock?code=" + code;

        ++sessionId_;
        request->uid_ = sessionId_;
        mapHttpCalls_[sessionId_] = cb;
        sendHttp(request);
        return true;
    }

    //open::OpenHttpClient发送http请求，返回就调用此方法。通过sessionId到回到函数cb
    virtual void onHttp(open::OpenHttpRequest& req, open::OpenHttpResponse& rep)
    {
        int sessionId = req.uid_;
        auto iter = mapHttpCalls_.find(sessionId);
        if (iter != mapHttpCalls_.end())
        {
            iter->second(req, rep);
            mapHttpCalls_.erase(iter);
        }
    }

    //其他模块发送过来的消息。
    virtual void onMsgProto(open::OpenMsgProto& proto)
    {
        //接收处理centor模块的消息，请求股票数据
        if (StockRequestStockMsg::MsgId() == proto.msg_->msgId())
        {
            std::shared_ptr<StockRequestStockMsg> protoMsg = std::dynamic_pointer_cast<StockRequestStockMsg>(proto.msg_);
            if (!protoMsg) {
                assert(false); return;
            }
            //请求股票数据，http结果通过std::function返回
            reqStockData(protoMsg->code_, [=](open::OpenHttpRequest& req, open::OpenHttpResponse& rep) {
                auto sendProtoMsg = std::shared_ptr<StockResponseStockMsg>(new StockResponseStockMsg);
                sendProtoMsg->code_ = protoMsg->code_;
                rep.getBody(sendProtoMsg->stockData_);
                sendMsgProto<StockResponseStockMsg>(proto.srcName_, sendProtoMsg);
            });
        }
    }
protected:
    int sessionId_;
    std::unordered_map<int, HttpHandle> mapHttpCalls_;
};

};

3.centor模块源代码

centor模块是一个controller角色。

#include "open.h"
#include "msg/msg.h"
//用域名空间的名字来区分模块，模块名叫centor
namespace centor
{
// 继承open::OpenServer
class Server : public open::OpenServer
{
public:
    Server(const std::string& name, const std::string& args)
        :open::OpenServer(name, args){}

    virtual ~Server() {}

    //每个模块都需要实现New函数，否则open::OpenServer::StartServer启动失败
    static OpenServer* New(const std::string& serverName, const std::string& args)
    {
        return new Server(serverName, args);
    }

    //它的父类open::OpenServer启动以后，会启动它的线程，此线程启动成功，就会调用onStart方法
    void onStart()
    {
        //创建消息，请求指数399001的数据，在stock模块，有对它的处理
        auto protoMsg = std::shared_ptr<StockRequestStockMsg>(new StockRequestStockMsg);
        protoMsg->code_ = "399001";
        //把消息发给"stock1"绑定的对象。当然，也可以发给"stock2"，看谁比较空闲。
        sendMsgProto<StockRequestStockMsg>("stock1", protoMsg);
    }
    //接收stock模块返回的数据，
    virtual void onMsgProto(open::OpenMsgProto& proto)
    {
        if (StockResponseStockMsg::MsgId() == proto.msg_->msgId())
        {
            std::shared_ptr<StockResponseStockMsg> protoMsg = std::dynamic_pointer_cast<StockResponseStockMsg>(proto.msg_);
            if (!protoMsg)
            {
                assert(false); return;
            }
            //json parse
            open::OpenJson json;
            json.decode(protoMsg->stockData_);

            auto& nodeCode = json["code"];
            assert(nodeCode.isString());
            auto code = nodeCode.s();

            auto& nodeDatas = json["data"];
            assert(nodeDatas.size() == 2);

            //convert csv
            open::OpenCSV csv = { "code", "time", "price" };
            for (size_t i = 0; i < nodeDatas.size(); i++)
            {
                auto& nodeRow = nodeDatas[i];
                csv = { 
                    code,
                    nodeRow["time"].s(),
                    std::to_string(nodeRow["price"].d())
                };
            }
            std::string output;
            csv >> output;
            printf("\ncsv content:\n");
            printf("%s\n", output.data());
        }
    }
protected:
};
};

4.httpd模块源代码

这个模块，有两种OpenServer：httpd和httpa，分别负责监听（listen）和处理业务（accept）。负责web下载服务。

httpd源代码

#include "open.h"

//用域名空间的名字来区分模块，模块名叫httpd，负责监听客户端连接
namespace httpd
{
// 继承open::OpenHttpServer，拥有监听网络端口的能力
class Server : public open::OpenHttpServer
{
public:
    Server::Server(const std::string& name, const std::string& args)
        :open::OpenHttpServer(name, args){}
    virtual ~Server() {}
    static OpenServer* New(const std::string& serverName, const std::string& args)
    {
        return new Server(serverName, args);
    }
    virtual void onStart()
    {
        //创建消息，启动http监听：0.0.0.0:8080
        auto msg = std::shared_ptr<open::OpenHttpServerMsg>(new open::OpenHttpServerMsg);
        msg->ip_ = "0.0.0.0";
        //在CMakeLists.txt打开这个宏定义，可提供HTTPS服务，但编译的时候需要导入OpenSSL库
        #ifdef USE_OPEN_SSL
            msg->port_ = 443;
            msg->port1_ = 80;
            msg->isHttps_ = 1;
            msg->keyFile_ = "/xx/www.xx.com.key";
            msg->certFile_ = "/xx/www.xx.com.crt";
        #else
            msg->port_ = 8080;
            msg->port1_ = 0;
            msg->isHttps_ = 0;
        #endif
        msg->handle_ = 0;

        //获取所有属于模块”httpa“的open::OpenServer对象。注意，不能对它们进行delete操作
        std::vector<open::OpenServer*> servers;
        open::OpenServer::GetServersByClassName("httpa", servers);
        for (size_t i = 0; i < servers.size(); i++)
        {
            msg->vectAccepts_.push_back(servers[i]->pid());
        }
        open::OpenMsgProto proto;
        proto.msg_ = msg;
        onMsgProto(proto);
    }
protected:
};
};

httpa源代码

#include "open.h"
#include "util/http_util.h"

//用域名空间的名字来区分模块，模块名叫httpa，处理httpa发过来的客户端连接
namespace httpa
{

typedef open::OpenHttpRequest Req;
typedef open::OpenHttpResponse Rep;
typedef void(*HttpHandle)(Req* req, Rep* rep);

//处理客户端的http请求
class Handle
{
    //  /index.html
    void OnIndex(Req* req, Rep* rep)
    {
        auto html = Dom::DomCreate();
        auto& body = html->child("body");
        auto& h1 = body.create("h1");
        h1 = "Welcome OpenServer, Thanks.";
        std::string buffer;
        html->echo(buffer);
        rep->response(200, ".html", buffer);
    }

    //  /api/stock
    void OnApiStock(Req* req, Rep* rep)
    {
        //{
        //    "code": "xxxxx",
        //    "data" : [
        //       {"time": "2023-07-18", "price" : 10}
        //       {"time": "2023-07-19", "price": 20}
        //    ]
        //}
        auto& code = req->params_["code"];

        open::OpenJson json;
        json["code"] = code;
        auto& nodeData = json["data"];

        auto& row0 = nodeData[0];
        row0["time"] = "2023-07-18";
        row0["price"] = 10;

        auto& row1 = nodeData[1];
        row1["time"] = "2023-07-19";
        row1["price"] = 20;

        auto& buffer = json.encode();
        rep->response(200, ".json", buffer);
    }

    typedef void (Handle::* HttpCall)(Req* req, Rep* rep);
    std::unordered_map<std::string, HttpCall> mapRouteHandles;
public:
    Handle()
    {
        mapRouteHandles["/"] = (HttpCall)&Handle::OnIndex;
        mapRouteHandles["/index.html"] = (HttpCall)&Handle::OnIndex;
        mapRouteHandles["/api/stock"] = (HttpCall)&Handle::OnApiStock;
    }

    ~Handle() {}
    void onCallBack(Req* req, Rep* rep)
    {
        printf("HTTP visit:%s:%d %s \n", req->ip().data(), req->port_, req->url_.data());
        if (req->url_ == "robots.txt")
        {
            rep->body_ = "User-agent: *\nDisallow: / \n";
            rep->code_ = 200;
            rep->ctype_ = "text/plain;charset=utf-8";
            return;
        }
        HttpCall handle = 0;
        auto iter = mapRouteHandles.find(req->path_);
        if (mapRouteHandles.end() != iter)
        {
            handle = iter->second;
        }
        if (!handle)
        {
            handle = mapRouteHandles["/"];
        }
        (this->*handle)(req, rep);
    }
};

// 继承open::OpenHttpAgent，拥有处理客户端连接的能力
class Server : public open::OpenHttpAgent
{
public:
    Server(const std::string& name, const std::string& args)
        :open::OpenHttpAgent(name, args)
    {
    }
    virtual ~Server() {}
    static OpenServer* New(const std::string& serverName, const std::string& args)
    {
        return new Server(serverName, args);
    }

    virtual void onStart() {}

    //处理客户端的http请求
    virtual void onHttp(open::OpenHttpRequest& req, open::OpenHttpResponse& rep)
    {
        handle_.onCallBack(&req, &rep);
    }
protected:
    Handle handle_;
};
};

4.OpenSocket和OpenThread的结合

在open::OpenApp::SocketFun方法中，处理OpenSocket的消息

//把OpenSocket的消费派发给绑定的OpenServer
void OpenApp::SocketFunc(const OpenSocketMsg* msg)
{
    if (!msg) return;
    if (msg->uid_ >= 0)
    {
        auto proto = std::shared_ptr<OpenSocketProto>(new OpenSocketProto);
        proto->srcPid_ = -1;
        proto->srcName_ = "OpenSocket";
        proto->data_ = std::shared_ptr<OpenSocketMsg>((OpenSocketMsg*)msg);
        //msg->uid_ 是请求者OpenServer的ID
        if (!OpenThread::Send((int)msg->uid_, proto))
            printf("SocketFunc dispatch faild pid = %d\n", (int)msg->uid_);
    }
    else delete msg;
}

//
void OpenApp::start()
{
    if (isRunning_) return;
    isRunning_ = true;
    //启动网络线程，并设置网络处理函数OpenApp::SocketFunc
    OpenSocket::Start(OpenApp::SocketFunc);
}

技术特点

OpenMiniServer极为轻巧简洁,通过自主设计的网络库和多线程库实现高性能服务器功能,代码量非常少却能发挥强大效果。
采用CMake跨平台构建系统,实现写一次代码,随处编译运行的跨平台支持,不受限于特定系统环境。
基于Actor模型设计,可以轻松实现高效的多核并行处理,配合Nginx负载均衡,可以便捷构建高可用的服务器集群。
开发环境部署极为简单,第三方依赖库很少,一旦掌握Actor模型,使用OpenMiniServer构建服务器会变得非常容易。

总体来说, OpenMiniServer是一个迷你、轻巧、高效、跨平台的C++服务器框架，非常适合需要快速构建复杂服务器项目的开发者。它极简的代码风格和Actor模式设计可以提高开发效率，是值得推荐的高性能服务器解决方案。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

服务器开发

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

服务器开发

登录后参与评论

1 条评论

热度

最新

腾讯云开发者社区

2023-11-22

Hi，您好呀，您近期内容创作表现突出，已入选腾讯云开发者社区内容共创官计划。内容共创官计划是腾讯云开发者社区面向社区重点潜力创作者打造的内容创作扶持机制，提供一系列技术创作教程、独家有奖创作激励、活动优先参会、社区流量曝光等资源。请您添加社区助理微信(微信号: yun _assistant)沟通加入计划。

回复回复点赞举报

编辑精选文章

换一批

万字详解高可用架构设计

1424

Go 开发者必备：Protocol Buffers 入门指南

亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？