设计模式技术问询：如何统一处理无关联的Post与Product类？

Alright, let's break down how to tackle this problem step by step—here's a practical, C++-focused approach that fits all your requirements:

First, since Post and Product map to separate tables and can't share a base class, we'll model their relationship directly in the database:

• Product Table: Standard schema for product data (e.g., id as primary key, name, price, etc.)
• Post Table: Includes all post-specific fields, plus an optional product_id foreign key (nullable, since only some posts have a product attached)

In C++, implement simple Data Access Object (DAO) classes to handle persistence:

• For a Product instance, call a saveProduct() method that inserts it into the Product table and returns its auto-generated ID.
• For a Post with an attached Product, first save the product to get its ID, then save the Post with that product_id value. Wrap these two operations in a database transaction to avoid partial saves if something fails.

Since we can't use a base class, C++17's std::variant is perfect for storing mixed Post and Product instances in a single collection. Here's how to use it:

Step 2.1: Define the Variant Type #

#include <variant>
#include <vector>
#include <optional>

// Assume these are your existing classes
class Product {
public:
    int id;
    std::string name;
    double price;
};

class Post {
public:
    int id;
    std::string content;
    std::optional<Product> attachedProduct; // Use std::optional for optional product attachment
};

// Variant type to hold either Post or Product
using FeedItem = std::variant<Post, Product>;
// The final array to send to clients
std::vector<FeedItem> feedArray;

Step 2.2: Query & Populate the Array #

Query your database for all relevant Post and Product records, then add them to feedArray:

// Example: Add a Post with an attached product to the array
Post myPost{1, "Check out this new product!", Product{42, "Wireless Headphones", 99.99}};
feedArray.push_back(myPost);

// Example: Add a standalone Product to the array
Product myProduct{101, "Bluetooth Speaker", 49.99};
feedArray.push_back(myProduct);

Step 2.3: Serialize for Client Transmission #

You'll need to serialize the variant array into a format clients can parse. Two common options:

Option A: JSON (Easy for Debugging)

Use the nlohmann/json library to serialize variants:

#include <nlohmann/json.hpp>
using json = nlohmann::json;

// Serialization functions
void to_json(json& j, const Product& p) {
    j = {{"type", "product"}, {"id", p.id}, {"name", p.name}, {"price", p.price}};
}

void to_json(json& j, const Post& p) {
    j = {{"type", "post"}, {"id", p.id}, {"content", p.content}};
    if (p.attachedProduct.has_value()) {
        j["attached_product"] = *p.attachedProduct;
    }
}

// Convert feedArray to JSON string
json feedJson;
for (const auto& item : feedArray) {
    std::visit([&feedJson](const auto& obj) {
        feedJson.push_back(obj);
    }, item);
}

std::string serializedFeed = feedJson.dump();
// Send serializedFeed over your network socket

Option B: Protobuf (High Performance)

For larger datasets, use Protocol Buffers for compact binary serialization. Define a .proto file:

message FeedItem {
    oneof item_type {
        Post post = 1;
        Product product = 2;
    }
}

message Post {
    int32 id = 1;
    string content = 2;
    optional Product attached_product = 3;
}

message Product {
    int32 id = 1;
    string name = 2;
    double price = 3;
}

Generate C++ code from the proto, then serialize your std::vector<FeedItem> into a byte stream for transmission.

Once clients receive the serialized feed:

• They'll parse the data and check the type field (JSON) or item_type oneof (Protobuf) to distinguish between posts and products.
• For posts with attached products, clients can render the post content alongside product details, and add interactions like "View Product" buttons.
• On the server side, implement endpoints to handle follow-up requests (e.g., fetching full product details by ID, updating post interactions) using your DAO layer.

• If you're stuck on C++ versions pre-C++17, use boost::variant as a drop-in replacement for std::variant.
• Always add error handling for database operations, serialization failures, and network issues—log errors gracefully to simplify debugging.
• Use database indexes on frequently queried fields (like product_id in the Post table) to keep feed queries fast as your dataset grows.

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