275 lines
8.3 KiB
C++
275 lines
8.3 KiB
C++
#include <iostream>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <map>
|
|
#include <stdexcept>
|
|
#include <functional>
|
|
|
|
// 通信策略接口
|
|
class ICommunicationStrategy {
|
|
public:
|
|
virtual ~ICommunicationStrategy() = default;
|
|
virtual void sendCommand(const std::string& command, int value) = 0;
|
|
virtual void connect() = 0;
|
|
virtual void disconnect() = 0;
|
|
virtual bool isConnected() const = 0;
|
|
};
|
|
|
|
// MQTT适配器
|
|
class MQTTAdapter : public ICommunicationStrategy {
|
|
private:
|
|
std::string brokerUrl;
|
|
std::string clientId;
|
|
bool connected = false;
|
|
|
|
public:
|
|
MQTTAdapter(const std::string& broker, const std::string& id)
|
|
: brokerUrl(broker), clientId(id) {}
|
|
|
|
void connect() override {
|
|
// 实现MQTT连接逻辑
|
|
std::cout << "Connecting to MQTT broker: " << brokerUrl << std::endl;
|
|
connected = true;
|
|
}
|
|
|
|
void disconnect() override {
|
|
// 实现MQTT断开连接逻辑
|
|
std::cout << "Disconnecting from MQTT broker" << std::endl;
|
|
connected = false;
|
|
}
|
|
|
|
void sendCommand(const std::string& command, int value) override {
|
|
if (!connected) {
|
|
throw std::runtime_error("MQTT not connected");
|
|
}
|
|
std::string topic = "terminal/control/" + command;
|
|
std::string payload = std::to_string(value);
|
|
std::cout << "MQTT Publish - Topic: " << topic << ", Payload: " << payload << std::endl;
|
|
// 实际的MQTT发布逻辑
|
|
}
|
|
|
|
bool isConnected() const override {
|
|
return connected;
|
|
}
|
|
};
|
|
|
|
// HTTP适配器
|
|
class HTTPAdapter : public ICommunicationStrategy {
|
|
private:
|
|
std::string baseUrl;
|
|
bool connected = false;
|
|
|
|
public:
|
|
HTTPAdapter(const std::string& url) : baseUrl(url) {}
|
|
|
|
void connect() override {
|
|
std::cout << "Initializing HTTP client with base URL: " << baseUrl << std::endl;
|
|
connected = true;
|
|
}
|
|
|
|
void disconnect() override {
|
|
std::cout << "Cleaning up HTTP client" << std::endl;
|
|
connected = false;
|
|
}
|
|
|
|
void sendCommand(const std::string& command, int value) override {
|
|
if (!connected) {
|
|
throw std::runtime_error("HTTP client not initialized");
|
|
}
|
|
std::string url = baseUrl + "/api/control/" + command;
|
|
std::cout << "HTTP POST - URL: " << url << ", Value: " << value << std::endl;
|
|
// 实际的HTTP POST请求逻辑
|
|
}
|
|
|
|
bool isConnected() const override {
|
|
return connected;
|
|
}
|
|
};
|
|
|
|
// WebSocket适配器
|
|
class WebSocketAdapter : public ICommunicationStrategy {
|
|
private:
|
|
std::string wsUrl;
|
|
bool connected = false;
|
|
|
|
public:
|
|
WebSocketAdapter(const std::string& url) : wsUrl(url) {}
|
|
|
|
void connect() override {
|
|
std::cout << "Connecting to WebSocket: " << wsUrl << std::endl;
|
|
connected = true;
|
|
}
|
|
|
|
void disconnect() override {
|
|
std::cout << "Disconnecting WebSocket" << std::endl;
|
|
connected = false;
|
|
}
|
|
|
|
void sendCommand(const std::string& command, int value) override {
|
|
if (!connected) {
|
|
throw std::runtime_error("WebSocket not connected");
|
|
}
|
|
std::string message = "{\"command\":\"" + command + "\",\"value\":" + std::to_string(value) + "}";
|
|
std::cout << "WebSocket Send: " << message << std::endl;
|
|
// 实际的WebSocket发送逻辑
|
|
}
|
|
|
|
bool isConnected() const override {
|
|
return connected;
|
|
}
|
|
};
|
|
|
|
// TCP适配器
|
|
class TCPAdapter : public ICommunicationStrategy {
|
|
private:
|
|
std::string host;
|
|
int port;
|
|
int socketFd = -1;
|
|
|
|
public:
|
|
TCPAdapter(const std::string& h, int p) : host(h), port(p) {}
|
|
|
|
void connect() override {
|
|
std::cout << "Connecting TCP to " << host << ":" << port << std::endl;
|
|
// 实际的TCP连接逻辑
|
|
socketFd = 1; // 模拟连接成功
|
|
}
|
|
|
|
void disconnect() override {
|
|
std::cout << "Disconnecting TCP" << std::endl;
|
|
socketFd = -1;
|
|
}
|
|
|
|
void sendCommand(const std::string& command, int value) override {
|
|
if (socketFd < 0) {
|
|
throw std::runtime_error("TCP not connected");
|
|
}
|
|
std::string data = command + ":" + std::to_string(value) + "\n";
|
|
std::cout << "TCP Send: " << data;
|
|
// 实际的TCP发送逻辑
|
|
}
|
|
|
|
bool isConnected() const override {
|
|
return socketFd >= 0;
|
|
}
|
|
};
|
|
|
|
// 配置结构体
|
|
struct Config {
|
|
std::map<std::string, std::string> params;
|
|
};
|
|
|
|
// 工厂类
|
|
class CommunicationFactory {
|
|
public:
|
|
static std::unique_ptr<ICommunicationStrategy> createStrategy(
|
|
const std::string& type,
|
|
const Config& config) {
|
|
|
|
if (type == "mqtt") {
|
|
auto it = config.params.find("broker");
|
|
std::string broker = (it != config.params.end()) ? it->second : "tcp://localhost:1883";
|
|
it = config.params.find("clientId");
|
|
std::string clientId = (it != config.params.end()) ? it->second : "terminal_default";
|
|
return std::make_unique<MQTTAdapter>(broker, clientId);
|
|
}
|
|
else if (type == "http") {
|
|
auto it = config.params.find("baseUrl");
|
|
std::string baseUrl = (it != config.params.end()) ? it->second : "http://localhost:8080";
|
|
return std::make_unique<HTTPAdapter>(baseUrl);
|
|
}
|
|
else if (type == "websocket") {
|
|
auto it = config.params.find("url");
|
|
std::string url = (it != config.params.end()) ? it->second : "ws://localhost:8081";
|
|
return std::make_unique<WebSocketAdapter>(url);
|
|
}
|
|
else if (type == "tcp") {
|
|
auto it = config.params.find("host");
|
|
std::string host = (it != config.params.end()) ? it->second : "localhost";
|
|
it = config.params.find("port");
|
|
int port = (it != config.params.end()) ? std::stoi(it->second) : 8082;
|
|
return std::make_unique<TCPAdapter>(host, port);
|
|
}
|
|
else {
|
|
throw std::invalid_argument("Unsupported communication type: " + type);
|
|
}
|
|
}
|
|
};
|
|
|
|
// 终端控制器
|
|
class TerminalController {
|
|
private:
|
|
std::unique_ptr<ICommunicationStrategy> strategy;
|
|
|
|
public:
|
|
void setStrategy(std::unique_ptr<ICommunicationStrategy> newStrategy) {
|
|
if (strategy && strategy->isConnected()) {
|
|
strategy->disconnect();
|
|
}
|
|
strategy = std::move(newStrategy);
|
|
if (strategy) {
|
|
strategy->connect();
|
|
}
|
|
}
|
|
|
|
void controlVolume(int volume) {
|
|
if (!strategy) {
|
|
throw std::runtime_error("No communication strategy set");
|
|
}
|
|
strategy->sendCommand("volume", volume);
|
|
}
|
|
|
|
void controlBrightness(int brightness) {
|
|
if (!strategy) {
|
|
throw std::runtime_error("No communication strategy set");
|
|
}
|
|
strategy->sendCommand("brightness", brightness);
|
|
}
|
|
};
|
|
|
|
// 使用示例
|
|
int main() {
|
|
try {
|
|
TerminalController controller;
|
|
|
|
// 使用MQTT协议
|
|
Config mqttConfig;
|
|
mqttConfig.params["broker"] = "tcp://mqtt.example.com:1883";
|
|
mqttConfig.params["clientId"] = "terminal_001";
|
|
|
|
controller.setStrategy(CommunicationFactory::createStrategy("mqtt", mqttConfig));
|
|
controller.controlVolume(80);
|
|
controller.controlBrightness(60);
|
|
|
|
// 切换到HTTP协议
|
|
Config httpConfig;
|
|
httpConfig.params["baseUrl"] = "http://192.168.1.100:8080";
|
|
|
|
controller.setStrategy(CommunicationFactory::createStrategy("http", httpConfig));
|
|
controller.controlVolume(75);
|
|
controller.controlBrightness(70);
|
|
|
|
// 切换到WebSocket协议
|
|
Config wsConfig;
|
|
wsConfig.params["url"] = "ws://192.168.1.100:8081/ws";
|
|
|
|
controller.setStrategy(CommunicationFactory::createStrategy("websocket", wsConfig));
|
|
controller.controlVolume(85);
|
|
controller.controlBrightness(65);
|
|
|
|
// 切换到TCP协议
|
|
Config tcpConfig;
|
|
tcpConfig.params["host"] = "192.168.1.100";
|
|
tcpConfig.params["port"] = "8082";
|
|
|
|
controller.setStrategy(CommunicationFactory::createStrategy("tcp", tcpConfig));
|
|
controller.controlVolume(90);
|
|
controller.controlBrightness(75);
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error: " << e.what() << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
} |