006-nlohmann/json 结构转换-C++开源库108杰

绝大多数情况下，程序和外部交换的数据，都是结构化的数据。

1. 手工实现——必须掌握的基本功

在的业务类型的同一名字空间下，实现 from_json 和 to_json 两个自由函数（必要时，也可定义为类型的友元函数），即可实现该结构类型与 nlohmann/json 数据的双向转换。

示例：

namesapce d2::ec {
struct Order  // 订单
{
    string id; 	      
    int customerID;      

    vector<long> items;  
    double totalAmount;  

    string orderDate;  
};

// json → Order
void from_json(json const& j, Order& o) 
{
    j.at("id").get_to(o.id);
    j.at("customerID").get_to(o.customerID);
    j.at("items").get_to(o.totalAmount);
    j.at("totalAmount").get_to(o.totalAmount);
    j.at("orderDate").get_to(o.orderDate);
}

// Order → json
void to_json(json& j, Order const& o)
{
   j["id"] = o.id;
   j["customID"] = o.customerID;
   j["items"] = o.items; // 完美支持 STL 容器
   j["totalAmount"] = o.totalAmount;
   j["orderDate"] = o.orderDate;
}

} // namespace d2::ec

2. 借助宏，快速定义

1. NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE // 非侵入式
2. NLOHMANN_DEFINE_TYPE_INTRUSIVE // 侵入式
3. NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT // 非侵入，且字段缺失时不报错
4. NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT // 侵入式，且字段缺失时不报错
5. NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE // 用于派生类，非侵入式
6. NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE // 用于派生类，侵入式
7. NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT //用于派生类，非侵入，字段缺失不报错
8. NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT //用于派生类，侵入，字段缺失不报错
9. NLOHMANN_JSON_SERIALIZE_ENUM //专用于让枚举类型的值，以字符串方式进行 JSON 读写

3. 视频：快速实现结构转换

4. 代码：我要打十个！

#include <iostream>
#include <string>
#include <vector>
#include <chrono> // 时间
#include <optional> // 可选值

#include <nlohmann/json.hpp>

using json = nlohmann::ordered_json; 

namespace d2::ec // d2school 电商系统
{

// 第1个：订单状态
enum class OrderStatus // 订单状态
{
    pending, // 待支付
    paid, // 已支付    
    shipped, // 已发货
    completed, // 已完成
    cancelled // 已取消
};    

NLOHMANN_JSON_SERIALIZE_ENUM(OrderStatus, {
    {OrderStatus::pending, "pending"},
    {OrderStatus::paid, "paid"},
    {OrderStatus::shipped, "shipped"},
    {OrderStatus::completed, "completed"},
    {OrderStatus::cancelled, "cancelled"}
})


// 第2个：商品
struct Item
{
    size_t id; // 商品ID
    std::string name; // 商品名称
    double price; // 商品价格
    double discount = 1; // 商品折扣    
};

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Item, id, name, price, discount)

// 第3个：客户
struct Customer
{
    std::string id; // 客户ID
    std::string nick; // 客户名称
};

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Customer, id, nick)

// 第4个：是否允许周末送货
enum class WeekendDelivery // 是否允许周末送货
{
    pending, // 选定
    allowed, // 允许
    denied // 拒绝
};

NLOHMANN_JSON_SERIALIZE_ENUM(WeekendDelivery, {
    {WeekendDelivery::pending, "-"},
    {WeekendDelivery::allowed, "✓"},
    {WeekendDelivery::denied, "✗"}
})

// 第5个：收货地址
struct Address
{
    std::string name; // 收货人姓名
    std::string phone; // 收货人电话

    std::string provinice; // 省
    std::string city; // 市
    std::string street; // 街道
    std::string detail; // 详细地址

    std::string zip; // 邮政编码

    WeekendDelivery weekendDelivery = WeekendDelivery::pending; // 是否允许周末送货
};

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Address, name, phone, provinice, city, street, detail, zip, weekendDelivery)

// 第6个：时间点
struct TimePoint : std::chrono::system_clock::time_point
{   
    using BaseClass = std::chrono::system_clock::time_point;

    using BaseClass::BaseClass;  // 继承构造函数

    TimePoint (BaseClass const& tp) 
        : BaseClass(tp) 
    {}     
};

void to_json(json& j, TimePoint const& tp)
{
    auto t = std::chrono::system_clock::to_time_t(static_cast<TimePoint::BaseClass>(tp));

    char mbstr[100];
    if (std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %H:%M:%S", std::localtime(&t)))
    {
        j = mbstr; // 转换为字符串
    }
    else 
    {
        j = nullptr; // 转换失败
    }    
}

void from_json(json const& j, TimePoint& tp)
{
    std::string str = j.get<std::string>();
    std::tm tm = {};
    std::istringstream ss(str);
    ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");

    if (ss.fail()) 
    {
        throw std::runtime_error("Failed to parse time point");
    }

    std::time_t t = std::mktime(&tm);

    tp = TimePoint(std::chrono::system_clock::from_time_t(std::mktime(&tm)));
}

// 第7个：订单（概要信息）
struct Order // 订单
{
    std::string id; // 订单ID	      
    Customer customer; // 客户
    
    // 第8个：对 std::vector<> 的先天支持
    std::vector<Item> items; // 包含商品
    
    double totalAmount; // 订单总金额 
    
    TimePoint orderTime; // 订单时间
    Address address; // 收货地址

    OrderStatus status = OrderStatus::pending; // 订单状态，默认待支付    
};  

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Order, id, customer, items, totalAmount, orderTime, address, status)

// 第9个：订单详情（派生类）
class OrderDetail : private Order // 订单详情
{
public:
    OrderDetail(Order const& order)
        : Order(order) // 继承构造函数
    {
        if (status >= OrderStatus::paid)
        {
            UpdatePayTime(); // 更新支付时间
        }
    }

    void UpdateMemo(std::string_view m)
    {
        this->memo = m; // 更新备注
    }

    void UpdateStatus(OrderStatus newStatus)
    {
        if (this->status == newStatus)
        {
            return; // 状态未改变
        }

        if (newStatus == OrderStatus::pending)
        {
            this->payTime.reset(); // 重置支付时间(变成空)
        }
        else if (newStatus >= OrderStatus::paid)
        {
            if (!this->payTime) // 当前支付时间为空
            {
                UpdatePayTime(); // 更新支付时间
            }
        }

        this->status = newStatus; // 更新状态
    }

public:    
    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(OrderDetail, Order, memo, payTime)

private:    
    // 更新支付时间
    void UpdatePayTime()
    {   
        this->payTime = TimePoint(std::chrono::system_clock::now());
    }

    std::string memo; // 订单备注
    // 第10个：对 std::optional<> 的先天支持
    std::optional<TimePoint> payTime; // 支付时间
};

}; // namespace d2::ec

int main(int, char**)
{
    using namespace d2::ec;

    // 创建一个订单
    Order o1;
    o1.id = "O-123456"; // 订单ID
    o1.customer = {"C10026Aed", "南飞的大圣"}; // 客户

    o1.items =  // 商品
    { 
        {1232, "iPhone 14 Pro", 9999.0, 0.8},
        {452, "MacBook Pro 16", 19999.0, 0.9},
        {30098, "iPad Pro", 7999.0}
    };
    
    o1.totalAmount = [&item = o1.items] () -> double
    {
        double total = 0.0;
        for (auto const& i : item)
        {                        
            total += i.price * i.discount;
        }

        return total;
    }();

    o1.orderTime = TimePoint(std::chrono::system_clock::now()); // 订单时间

    o1.address = {"孙悟空", "13800138000", "福建省", "厦门市", "沧海路", "天汇大厦908号", "3602001",
            WeekendDelivery::denied}; // 收货地址
    
    o1.status = OrderStatus::pending;

    // 序列化
    json j1 = o1; // 序列化为 JSON
    std::string jStr = j1.dump(4); // 转换为字符串
    std::cout << jStr << std::endl; // 打印 JSON

    // 反序列化
    json j2 = json::parse(jStr); // 解析 JSON
    Order o2 = j2.get<Order>(); // 反序列化为订单对象

    json j3 = o2; // 序列化为 JSON
    std::cout << j3.dump(2) << std::endl; // 打印 JSON

    std::cout << "\n=====================================\n";

    OrderDetail od1(o1); // 创建订单详情
    json j4 = od1; // 订单详情 -> JSON
    std::cout << j4.dump(2) << std::endl; // 打印 JSON

    std::cout << "\n------------------------------------------\n";  
    od1.UpdateStatus(OrderStatus::paid); // 更新状态：已支付
    od1.UpdateMemo("「商家」：已付款，请尽快发货，走顺风"); // 更新备注

    json j5 = od1; // 订单详情 -> JSON
    std::cout << j5.dump(2) << std::endl; // 打印 JSON
}