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

#克隆项目
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

demo             // 测试例子源代码

open             // OpenMiniServer的全部源代码

CMakeLists.txt   // CMake的主工程文件

msg        // 定义OpenServer通信消息

server     // 存放各种模块

util       // 通用源代码

app.h      // 唯一应用实例头文件 继承 open::OpenApp

app.cpp    // 唯一应用实例实现文件

// 注册stock模块

open::OpenServer::RegisterServer<stock::Server>("stock");

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

open::OpenServer::StartServer("stock", "stock1", "");

open::OpenServer::StartServer("stock", "stock2", "");

//导入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_;

#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&amp; serverName, const std::string&amp; args)
{
    return new Server(serverName, args);
}

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

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

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

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

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

protected:

int sessionId_;

std::unordered_map<int, HttpHandle> mapHttpCalls_;

};
};

#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:

};

};

#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&lt;open::OpenServer*&gt; servers;
    open::OpenServer::GetServersByClassName(&#34;httpa&#34;, servers);
    for (size_t i = 0; i &lt; servers.size(); i++)
    {
        msg-&gt;vectAccepts_.push_back(servers[i]-&gt;pid());
    }
    open::OpenMsgProto proto;
    proto.msg_ = msg;
    onMsgProto(proto);
}

protected:

};

};

#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_;

};

};

//把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);

}