我正在使用一个协议(protocol)，它基本上是一个基于 TCP 的请求和响应协议(protocol)，类似于其他基于行的协议(protocol)(SMTP、HTTP 等)。

该协议(protocol)有大约 130 种不同的请求方法(例如登录、用户添加、用户更新、日志获取、文件信息、文件信息等)。所有这些方法都不能很好地映射到 HTTP 中使用的广泛方法(GET、POST、PUT 等)。如此广泛的方法会导致实际含义的一些无关紧要的扭曲。

但是协议(protocol)方法可以按类型分组(例如用户管理、文件管理、 session 管理等)。

当前服务器端实现使用 class Worker与方法 ReadRequest() (读取请求，由方法加参数列表组成)，HandleRequest() (见下文)和 WriteResponse() (写入响应代码和实际响应数据)。
HandleRequest()将为实际请求方法调用一个函数 - 使用方法名称的哈希映射到指向实际处理程序的成员函数指针。

实际的处理程序是一个普通的成员函数，每个协议(protocol)方法都有一个:每个方法都验证其输入参数，执行它必须执行的任何操作并设置响应代码(成功是/否)和响应数据。

示例代码:

class Worker {
    typedef bool (Worker::*CommandHandler)();
    typedef std::map<UTF8String,CommandHandler> CommandHandlerMap;

    // handlers will be initialized once
    //   e.g. m_CommandHandlers["login"] = &Worker::Handle_LOGIN;
    static CommandHandlerMap m_CommandHandlers;

    bool HandleRequest() {
        CommandHandlerMap::const_iterator ihandler;
        if( (ihandler=m_CommandHandlers.find(m_CurRequest.instruction)) != m_CommandHandler.end() ) {
            // call actual handler
            return (this->*(ihandler->second))();
        }
        // error case:
        m_CurResponse.success = false;
        m_CurResponse.info = "unknown or invalid instruction";
        return true;
    }

    //...


    bool Handle_LOGIN() {
        const UTF8String username = m_CurRequest.parameters["username"];
        const UTF8String password = m_CurRequest.parameters["password"];

        // ....

        if( success ) {

            // initialize some state...
            m_Session.Init(...);
            m_LogHandle.Init(...);
            m_AuthHandle.Init(...);

            // set response data
            m_CurResponse.success = true;
            m_CurResponse.Write( "last_login", ... );
            m_CurResponse.Write( "whatever", ... );
        } else {
            m_CurResponse.Write( "error", "failed, because ..." );
        }
        return true;
    }


};

class HandlerBase {
protected:
    Request &request;
    Response &response;
    Session &session;
    DBHandle &db;
    FooHandle &foo;
    // ...
public:
    HandlerBase( Request &req, Response &rsp, Session &s, ... )
    : request(req), response(rsp), session(s), ...
    {}
    //...
    virtual bool Handle() = 0;
};

class LoginHandler : public HandlerBase {
public:
    LoginHandler( Request &req, Response &rsp, Session &s, ... )
    : HandlerBase(req,rsp,s,..)
    {}
    //...
    virtual bool Handle() {
        // actual code for handling "login" request ...
    }
};

最佳答案

你已经有了大部分正确的想法，这就是我将如何进行。

让我们从您的第二个问题开始:可互换协议(protocol)。如果你有通用的请求和响应对象，你可以有一个接口(interface)来读取请求和写入响应:

class Protocol {
  virtual Request *readRequest() = 0;
  virtual void writeResponse(Response *response) = 0;
}

class Command {
  virtual void execute(Request *request, Response *response, Session *session) = 0;
}

class CommandFactory {
  std::map<UTF8String, Command *> handlers;

  Command *getCommand(const UTF8String &name) {
    return handlers[name];
  }
}

class Worker {
  Protocol *protocol;
  CommandFactory *commandFactory;
  Session *session;

  void handleRequest() {
    Request *request = protocol->readRequest();
    Response response;

    Command *command = commandFactory->getCommand(request->getCommandName());
    command->execute(request, &response, session);

    protocol->writeResponse(&response);
  }
}

关于c++ - 更好的基于请求的协议(protocol)实现结构，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11856074/