如何使用C++；节俭 我在C++中实现了一个基于节省的（0.4.0）服务，遇到了一个问题：

有没有办法从服务方法实现内部获取客户端的IP地址？我正在使用TNonblockingServer

提前谢谢

Ticket描述了一个类似的Java请求。解决方案基本上是允许访问内部（端点）传输并从中检索数据。如果不进行真正的测试，那么为C++构建类似的解决方案应该很容易。由于您使用的是Thrift 0.4.0，因此我强烈建议您首先查看当前主干（0.9.3）。

TBufferedTransport

、

TFramedTransport

和

tShortedTransport

已经实施

boost::shared_ptr<TTransport> getUnderlyingTransport();

---

在TNonblockingServer中，当调用TProcessor:：process（）时，TProtocol.transport是一个TMemoryBuffer，因此无法获取客户端ip地址

但是我们可以扩展类TServerEventHandler，当客户端即将调用处理器时，会调用方法TServerEventHandler:：processContext（）

static boost::thread_specific_ptr<std::string> thrift_client_ip; // thread specific
class MyServerEventHandler : public TServerEventHandler
{
    virtual void processContext(void* serverContext, boost::shared_ptr<TTransport> transport)
    {
        TSocket *sock = static_cast<TSocket *>(transport.get());

        if (sock)
        {
            //thrift_client_ip.reset(new string(sock->getPeerAddress())); // 0.9.2, reused TNonblockingServer::TConnection return dirty address, see https://issues.apache.org/jira/browse/THRIFT-3270
            sock->getCachedAddress(); // use this api instead
        }
    }
};

// create nonblocking server
TNonblockingServer server(processor, protocolFactory, port, threadManager);
boost::shared_ptr<MyServerEventHandler> eventHandler(new MyServerEventHandler());
server.setServerEventHandler(eventHandler);

static boost:：线程特定的节约客户端ip；//线程特定
类MyServerEventHandler:PublicTserverEventHandler
{
虚拟void processContext（void*serverContext，boost:：shared_ptr传输）
{
TSocket*sock=static_cast（transport.get（））；
如果（袜子）
{
//thrift_client_ip.reset（新字符串（sock->getPeerAddress（））；//0.9.2，重用的TNonblockingServer:：t连接返回脏地址，请参阅https://issues.apache.org/jira/browse/THRIFT-3270
sock->getCachedAddress（）；//改用此api
}
}
};
//创建非阻塞服务器
TNonblockingServer服务器（处理器、协议工厂、端口、线程管理器）；
boost:：shared_ptr eventHandler（新的MyServerEventHandler（））；
setServerEventHandler（eventHandler）；

\ifndef NONBLOCK\u SERVER\u EVENT\u HANDLER\u H
#定义非块服务器事件处理程序
#包括
#包括
名称空间apache{
名称空间节约{
命名空间服务器{
类ServerEventHandler:公共TServerEventHandler{
void*createContext（boost:：共享的ptr输入，boost:：共享的ptr输出）{
（b）输入；
（d）产出；
返回（void*）（新字符[32]）；//TODO
}
虚拟void deleteContext（void*serverContext，
boost：：共享的\u ptrinput，
boost：：共享（ptroutput）{
删除[]（char*）服务器上下文；
}
虚拟void processContext（void*serverContext，boost:：shared_ptr传输）{
TSocket*TSocket=static_cast（transport.get（））；
中频（插座）{
结构sockaddr*addrpr；
索克伦·阿德伦；
addrPtr=tsocket->getCachedAddress（&addrLen）；
if（addrPtr）{
getnameinfo（（sockaddr*）addrPtr，addrLen，（char*）serverContext，32，NULL，0,0）；
}
}
}
};
}
}
}
#恩迪夫
boost:：shared_ptr serverEventHandler（新的serverEventHandler（）
setServerEventHandler（serverEventHandler）；

在

TSocket:：getCachedAddress（socklen\u t*len）const；

中缺少参数。

static boost::thread_specific_ptr<std::string> thrift_client_ip; // thread specific
class MyServerEventHandler : public TServerEventHandler
{
    virtual void processContext(void* serverContext, boost::shared_ptr<TTransport> transport)
    {
        TSocket *sock = static_cast<TSocket *>(transport.get());

        if (sock)
        {
            //thrift_client_ip.reset(new string(sock->getPeerAddress())); // 0.9.2, reused TNonblockingServer::TConnection return dirty address, see https://issues.apache.org/jira/browse/THRIFT-3270
            sock->getCachedAddress(); // use this api instead
        }
    }
};

// create nonblocking server
TNonblockingServer server(processor, protocolFactory, port, threadManager);
boost::shared_ptr<MyServerEventHandler> eventHandler(new MyServerEventHandler());
server.setServerEventHandler(eventHandler);

#ifndef NONBLOCK_SERVER_EVENT_HANDLER_H
#define NONBLOCK_SERVER_EVENT_HANDLER_H

#include <thrift/transport/TSocket.h>
#include <thrift/server/TServer.h>

namespace apache{
namespace thrift{
namespace server{

class ServerEventHandler:public TServerEventHandler{
        void* createContext(boost::shared_ptr<TProtocol> input, boost::shared_ptr<TProtocol> output){
    (void)input;
    (void)output;
    return (void*)(new char[32]);//TODO
  }

  virtual void deleteContext(void* serverContext, 
                                boost::shared_ptr<TProtocol>input,
                                boost::shared_ptr<TProtocol>output) {
                delete [](char*)serverContext;
  }

  virtual void processContext(void *serverContext, boost::shared_ptr<TTransport> transport){
    TSocket *tsocket = static_cast<TSocket*>(transport.get());
    if(socket){
                        struct sockaddr* addrPtr;
                        socklen_t addrLen;
      addrPtr = tsocket->getCachedAddress(&addrLen);
                  if (addrPtr){
                                        getnameinfo((sockaddr*)addrPtr,addrLen,(char*)serverContext,32,NULL,0,0) ;
                        }
    }
  }
};

}
}
}

#endif

boost::shared_ptr<ServerEventHandler> serverEventHandler(new ServerEventHandler()
server.setServerEventHandler(serverEventHandler);