Oat++服务提供者未监听端口：动态配置端点失败排查

我正在封装Oat++用于多微服务场景，希望通过类方法配置服务端点（地址、端口、IP类型），但遇到了一个奇怪的问题：使用循环从std::list中读取端点配置动态创建ConnectionProvider和Server时，连接http://localhost:8888/test会出现端口超时；但将代码替换为硬编码的端点配置后，能正常返回404响应。

关键差异代码 #

动态循环实现（超时） #

for (auto entry = m_serviceProviderEntry.begin(); entry != m_serviceProviderEntry.end(); entry++)
{
    auto addrType = (*entry).networkType == SERVICENETWORKTYPE_IPV4 ?
        oatpp::network::Address::IP_4 : oatpp::network::Address::IP_6;
    auto provider = oatpp::network::tcp::server::ConnectionProvider::createShared(
        { (*entry).address, v_uint16((*entry).networkPort), addrType });
    m_connectionProviders.push_back(provider);

    oatpp::network::Server server(provider, m_connectionHandler);
    server.run(true);
}

硬编码实现（正常） #

auto provider = oatpp::network::tcp::server::ConnectionProvider::createShared(
                { "localhost", 8888, oatpp::network::Address::IP_4 });
oatpp::network::Server server(provider, m_connectionHandler);
server.run(true);

我怀疑问题和std::list中的std::shared_ptr有关，但不确定具体原因，寻求解决建议。

问题根源分析 #

经过排查，核心问题并非std::list或std::shared_ptr，而是以下几点：

1. 隐式类型转换不确定性：循环中直接传递std::string给ConnectionProvider的配置，隐式转换为oatpp::String时可能出现未定义行为，导致端点配置未正确初始化。
2. Server对象生命周期隐患：循环中创建的Server是局部变量，虽然run(true)会阻塞当前线程保持对象存活，但后续若改为非阻塞运行，局部变量销毁会直接导致服务器停止，同时不利于多端点管理。
3. 缺少Oat++环境初始化：Oat++需要显式初始化运行环境，硬编码能运行属于巧合，动态场景下未初始化会触发未定义行为。

解决方案 #

针对上述问题，给出以下修正步骤：

1. 使用范围for循环替代迭代器：简化代码，避免迭代器访问的潜在问题，确保参数传递清晰。
2. 显式转换oatpp::String：将std::string显式转换为Oat++的oatpp::String，消除隐式转换的不确定性。
3. 保存Server对象到成员变量：将Server实例存储到类成员列表中，确保其生命周期与服务一致，方便多端点管理。
4. 添加Oat++环境初始化与销毁：遵循Oat++规范，在程序启动和结束时分别调用环境初始化和销毁函数。
5. 使用原子变量管理 shutdown 状态：避免编译器优化导致的死循环问题。

修正后的完整代码 #

#include <winsock2.h>
#include <memory>
#include <atomic>
#include "oatpp/web/server/HttpConnectionHandler.hpp"
#include "oatpp/network/tcp/server/ConnectionProvider.hpp"
#include "oatpp/network/Server.hpp"
#include "oatpp/base/Environment.hpp"

enum ServiceNetworkType
{
    SERVICENETWORKTYPE_IPV4,
    SERVICENETWORKTYPE_IPV6
};

struct ServiceProviderEntry
{
    std::string address;
    v_uint16 networkPort;
    ServiceNetworkType networkType;
};

class Example
{
public:
    Example() : m_shutdownRequested(false) { }

    ~Example() {
        // 停止所有服务器实例
        for(auto& server : m_servers) {
            server->stop();
        }
    }

    bool Initialise()
    {
        int iResult;
        WSADATA wsaData;
        iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (iResult != 0) return false;

        // 初始化Oat++运行环境
        oatpp::base::Environment::init();

        return true;
    }

    void Execute()
    {
        m_router = oatpp::web::server::HttpRouter::createShared();
        m_connectionHandler = oatpp::web::server::HttpConnectionHandler::createShared(m_router);

        // 使用范围for循环遍历配置项
        for (const auto& entry : m_serviceProviderEntry)
        {
            auto addrType = entry.networkType == SERVICENETWORKTYPE_IPV4 ?
                oatpp::network::Address::IP_4 : oatpp::network::Address::IP_6;
            
            // 显式转换为oatpp::String，避免隐式转换问题
            oatpp::String oatAddress(entry.address.c_str());
            
            auto provider = oatpp::network::tcp::server::ConnectionProvider::createShared(
                { oatAddress, entry.networkPort, addrType });
            m_connectionProviders.push_back(provider);

            // 创建Server并保存到成员变量，确保生命周期稳定
            auto server = std::make_shared<oatpp::network::Server>(provider, m_connectionHandler);
            m_servers.push_back(server);
            
            // 阻塞式启动服务器（若需多端点同时运行，需改为非阻塞并管理线程）
            server->run(true);
        }

        while (!m_shutdownRequested.load()) { }
    }

    void AddServiceProvider(std::string address,
        int networkPort,
        ServiceNetworkType networkType)
    {
        ServiceProviderEntry entry = { address,
                                       v_uint16(networkPort),
                                       networkType };
        m_serviceProviderEntry.push_back(entry);
    }

    void Shutdown() {
        m_shutdownRequested.store(true);
    }

private:
    std::atomic<bool> m_shutdownRequested; // 原子变量避免编译器优化

    std::shared_ptr<oatpp::web::server::HttpRouter> m_router;
    std::shared_ptr<oatpp::web::server::HttpConnectionHandler> m_connectionHandler;
    std::list<std::shared_ptr<oatpp::network::tcp::server::ConnectionProvider>> m_connectionProviders;
    std::list<std::shared_ptr<oatpp::network::Server>> m_servers; // 新增：保存Server实例
    std::list<ServiceProviderEntry> m_serviceProviderEntry;
};

int main()
{
    auto app = std::make_unique<Example>();
    if (!app->Initialise()) {
        return EXIT_FAILURE;
    }
    
    app->AddServiceProvider("localhost", 8888, SERVICENETWORKTYPE_IPV4);
    app->Execute();
    
    // 销毁Oat++环境并清理Winsock
    oatpp::base::Environment::destroy();
    WSACleanup();
    return EXIT_SUCCESS;
}

额外说明 #

如果需要同时运行多个端点，不能使用阻塞式的run(true)，否则第一个服务器会卡住主线程，后续服务器无法启动。这种情况下需改为非阻塞运行（run(false)），并通过线程或Oat++的调度器管理多个服务器实例。

内容的提问来源于stack exchange，提问作者Swatcat