C++代理模式实现远程对象访问

// common_interface.h
#include <string>
#include <vector>

// 假设这是一个简单的服务接口
class IRemoteService {
public:
    virtual ~IRemoteService() = default;
    virtual std::string fetchData(int id) = 0;
    virtual bool storeData(const std::string& key, const std::string& value) = 0;
    // 更多方法...
};

IRemoteService

// real_service.h (Server-side)
#include "common_interface.h"
#include <iostream>
#include <map>

class RealRemoteService : public IRemoteService {
private:
    std::map<std::string, std::string> dataStore; // 模拟数据存储
public:
    std::string fetchData(int id) override {
        std::cout << "Server: Fetching data for ID: " << id << std::endl;
        // 模拟一些业务逻辑和数据获取
        if (id == 101) return "Data for 101: Important Info";
        if (id == 102) return "Data for 102: Secret Document";
        return "Data not found for ID: " + std::to_string(id);
    }

    bool storeData(const std::string& key, const std::string& value) override {
        std::cout << "Server: Storing data - Key: " << key << ", Value: " << value << std::endl;
        dataStore[key] = value;
        return true;
    }
};

IRemoteService

// remote_service_proxy.h (Client-side)
#include "common_interface.h"
#include <iostream>
// 假设这里有一些网络通信的辅助类或函数
// 实际项目中会用 gRPC, Thrift, Boost.Asio, Sockets 等
namespace Network {
    // 模拟网络请求和响应结构
    struct Request {
        std::string methodName;
        std::vector<std::string> args; // 简化为字符串参数
        // 实际会用更复杂的序列化方式，如Protobuf
    };

    struct Response {
        bool success;
        std::string result;
        std::string error;
    };

    // 模拟发送请求并接收响应的函数
    Response sendRemoteCall(const Request& req) {
        std::cout << "Proxy: Sending remote call for method '" << req.methodName << "'..." << std::endl;
        // 实际这里会建立网络连接，序列化请求，发送，等待响应，反序列化
        // 为了简化，我们直接模拟服务器的响应
        if (req.methodName == "fetchData") {
            if (req.args.empty()) return {false, "", "Missing ID for fetchData"};
            int id = std::stoi(req.args[0]);
            // 模拟调用 RealRemoteService
            RealRemoteService realService; // 在实际场景中，这里是网络通信到远程服务器
            std::string data = realService.fetchData(id);
            return {true, data, ""};
        } else if (req.methodName == "storeData") {
            if (req.args.size() < 2) return {false, "", "Missing key/value for storeData"};
            RealRemoteService realService;
            bool stored = realService.storeData(req.args[0], req.args[1]);
            return {stored, stored ? "true" : "false", stored ? "" : "Failed to store"};
        }
        return {false, "", "Unknown method"};
    }
} // namespace Network

class RemoteServiceProxy : public IRemoteService {
public:
    std::string fetchData(int id) override {
        Network::Request req;
        req.methodName = "fetchData";
        req.args.push_back(std::to_string(id));

        Network::Response resp = Network::sendRemoteCall(req);
        if (resp.success) {
            return resp.result;
        } else {
            std::cerr << "Proxy Error (fetchData): " << resp.error << std::endl;
            return ""; // 或者抛出异常
        }
    }

    bool storeData(const std::string& key, const std::string& value) override {
        Network::Request req;
        req.methodName = "storeData";
        req.args.push_back(key);
        req.args.push_back(value);

        Network::Response resp = Network::sendRemoteCall(req);
        if (resp.success) {
            return resp.result == "true";
        } else {
            std::cerr << "Proxy Error (storeData): " << resp.error << std::endl;
            return false; // 或者抛出异常
        }
    }
};

// client_main.cpp
#include "remote_service_proxy.h"
#include <memory>

int main() {
    std::cout << "Client: Creating remote service proxy." << std::endl;
    std::unique_ptr<IRemoteService> service = std::make_unique<RemoteServiceProxy>();

    std::cout << "\nClient: Requesting data for ID 101." << std::endl;
    std::string data1 = service->fetchData(101);
    std::cout << "Client received: " << data1 << std::endl;

    std::cout << "\nClient: Requesting data for ID 103." << std::endl;
    std::string data2 = service->fetchData(103);
    std::cout << "Client received: " << data2 << std::endl;

    std::cout << "\nClient: Storing new data." << std::endl;
    bool stored = service->storeData("user_config", "theme=dark;lang=en");
    std::cout << "Client: Data stored status: " << (stored ? "Success" : "Failed") << std::endl;

    return 0;
}

sendRemoteCall

std::unique_ptr

std::shared_ptr

operator*

operator->