如何用GSON解析JSON并基于产品库存JSON生成账单？

嘿，作为GSON新手遇到这个问题太正常了！咱们不用慌，一步步拆解这个计算总账单的逻辑就行——核心就是把你手里的三个JSON数据（产品库存、税率、订单）关联起来，按订单条目逐个计算费用再累加。下面是详细的实现步骤：

第一步：定义Java数据类（映射JSON结构） #

GSON是基于对象映射的解析库，所以咱们得先把JSON结构转换成对应的Java实体类，这样GSON才能把JSON字符串自动转成对象：

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

// 产品变体类，对应库存JSON里的variants数组元素
class Variant {
    private String size;
    private double price;
    private int tax_code;

    // 只需要getter方法，GSON解析时会自动映射字段
    public String getSize() { return size; }
    public double getPrice() { return price; }
    public int getTax_code() { return tax_code; }
}

// 产品类，对应库存JSON里的每个产品对象
class Product {
    private int id;
    private String name;
    private List<Variant> variants;

    public int getId() { return id; }
    public String getName() { return name; }
    public List<Variant> getVariants() { return variants; }
}

// 税率类，对应税率JSON里的每个对象
class TaxRate {
    private int code;
    private String name;
    private double rate;

    public int getCode() { return code; }
    public String getName() { return name; }
    public double getRate() { return rate; }
}

// 订单条目类，对应订单JSON里的每个对象
class OrderItem {
    private int product;
    private int variant; // 注意：这里是变体在产品variants列表中的索引（从0开始计数）
    private int quantity;

    public int getProduct() { return product; }
    public int getVariant() { return variant; }
    public int getQuantity() { return quantity; }
}

第二步：用GSON解析三个JSON字符串 #

接下来把你提供的JSON字符串解析成Java对象列表，这里要用到TypeToken来处理泛型列表（因为GSON没法直接识别List<Product>这种泛型类型）：

public class BillingCalculator {
    public static void main(String[] args) {
        // 你的三个原始JSON字符串
        String inventoryJson = "[ { \"id\": 2000, \"name\": \"Child Shoes\", \"variants\": [ { \"size\": \"size 7\", \"price\": 19.99, \"tax_code\": 0 } ] }, { \"id\": 3000, \"name\": \"Eggs\", \"variants\": [ { \"size\": \"6\", \"price\": 1.50, \"tax_code\": 7 }, { \"size\": \"12\", \"price\": 2.25, \"tax_code\": 1 } ] }, { \"id\": 3100, \"name\": \"Apples\", \"variants\": [ { \"size\": \"1\", \"price\": 0.30, \"tax_code\": 7 }, { \"size\": \"10\", \"price\": 2.50, \"tax_code\": 7 } ] }, { \"id\": 5423, \"name\": \"Book\", \"variants\": [ { \"size\": \"Assorted\", \"price\": 11.00, \"tax_code\": 1 } ] } ]";
        String taxRatesJson = "[ { \"code\": 0, \"name\": \"HST\", \"rate\": 0.13 }, { \"code\": 1, \"name\": \"HST - Books\", \"rate\": 0.05 }, { \"code\": 7, \"name\": \"EXEMPT - Food\", \"rate\": 0 } ]";
        String orderJson = "[ { \"product\": 3000, \"variant\": 1, \"quantity\": 1 }, { \"product\": 3100, \"variant\": 1, \"quantity\": 1 } ]";

        Gson gson = new Gson();

        // 解析库存列表
        List<Product> productList = gson.fromJson(inventoryJson, new TypeToken<List<Product>>(){}.getType());
        // 解析税率列表
        List<TaxRate> taxRateList = gson.fromJson(taxRatesJson, new TypeToken<List<TaxRate>>(){}.getType());
        // 解析订单列表
        List<OrderItem> orderItems = gson.fromJson(orderJson, new TypeToken<List<OrderItem>>(){}.getType());

第三步：构建快速查找的索引（优化性能） #

为了避免每次找产品或税率都遍历整个列表，咱们把数据存到HashMap里，用产品ID/税码当key，这样查找时间直接降到O(1)，效率高很多：

// 构建产品ID到产品对象的映射
        Map<Integer, Product> productMap = new HashMap<>();
        for (Product product : productList) {
            productMap.put(product.getId(), product);
        }

        // 构建税码到税率对象的映射
        Map<Integer, TaxRate> taxRateMap = new HashMap<>();
        for (TaxRate taxRate : taxRateList) {
            taxRateMap.put(taxRate.getCode(), taxRate);
        }

第四步：计算总账单 #

现在遍历每个订单条目，依次找到对应的产品、变体、税率，计算每笔费用后累加得到总账单：

double totalBill = 0.0;

        for (OrderItem item : orderItems) {
            // 1. 根据产品ID找到对应的产品
            Product product = productMap.get(item.getProduct());
            if (product == null) {
                System.out.println("找不到产品ID：" + item.getProduct());
                continue;
            }

            // 2. 根据变体索引找到对应的变体（注意索引从0开始）
            List<Variant> variants = product.getVariants();
            if (item.getVariant() < 0 || item.getVariant() >= variants.size()) {
                System.out.println("产品" + product.getId() + "的变体索引无效：" + item.getVariant());
                continue;
            }
            Variant variant = variants.get(item.getVariant());

            // 3. 根据税码找到对应的税率
            TaxRate taxRate = taxRateMap.get(variant.getTax_code());
            if (taxRate == null) {
                System.out.println("找不到税码：" + variant.getTax_code());
                continue;
            }

            // 4. 计算这笔订单的费用：单价 * 数量 * (1 + 税率)
            double itemTotal = variant.getPrice() * item.getQuantity() * (1 + taxRate.getRate());
            totalBill += itemTotal;

            // 打印订单明细，方便调试核对
            System.out.printf("产品：%s，变体：%s，数量：%d，单价：%.2f，税率：%.2f%%，小计：%.2f%n",
                    product.getName(), variant.getSize(), item.getQuantity(),
                    variant.getPrice(), taxRate.getRate()*100, itemTotal);
        }

        // 打印最终总账单
        System.out.printf("总账单：%.2f%n", totalBill);
    }
}

验证计算结果 #

针对你提供的订单，咱们手动核对一下：

• 第一个订单：产品3000（Eggs），变体1对应size12，单价2.25，税码1对应5%税率，费用为 2.25 * 1 * 1.05 = 2.3625
• 第二个订单：产品3100（Apples），变体1对应size10，单价2.50，税码7对应0%税率，费用为 2.50 * 1 * 1 = 2.50
• 总账单：2.3625 + 2.50 = 4.8625，最终显示为4.86或4.87（取决于小数保留方式）

小提示：引入GSON依赖 #

别忘了在项目里引入GSON依赖，比如：

• Maven（pom.xml）：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 用最新稳定版即可 -->
</dependency>

• Gradle（build.gradle）：

implementation 'com.google.code.gson:gson:2.10.1'

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