个人所得税的APP模拟器，纯java版代码开源，截图录屏都可以【仅供参考】

Ne0inhk

— 18 min read
个人所得税的APP模拟器，纯java版代码开源，截图录屏都可以【仅供参考】

文件下载地址：https://wenshushu.vip/pan/index.php?id=36    提取码：7bf9

给大家分享一个用纯Java实现的个人所得税计算模拟器，包含完整的GUI界面和核心计算逻辑，适合Java学习者和税务计算需求者参考使用。

一、项目简介

这是一个使用Java Swing开发的个人所得税计算模拟器，模拟了官方个税APP的核心功能，包括：

· 综合所得年度汇算计算
· 税率表查询
· 专项扣除项目设置
· 税务计算结果展示

项目特点：

· 100%纯Java实现，无第三方依赖
· 完整GUI界面，支持用户交互
· 详细的代码注释
· 遵循2023年最新个税政策

二、核心代码实现

1. 主程序入口

```java
package com.tax.calculator;

import javax.swing.*;

/**
 * 个人所得税计算模拟器 - 主程序
 * @author TaxDeveloper
 * @version 1.0
 */
public class PersonalIncomeTaxApp {
    public static void main(String[] args) {
        // 使用SwingUtilities确保线程安全
        SwingUtilities.invokeLater(() -> {
            try {
                // 设置系统外观
                UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                
                // 创建并显示主窗口
                TaxCalculatorFrame frame = new TaxCalculatorFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
                
                System.out.println("个人所得税计算模拟器启动成功！");
            } catch (Exception e) {
                e.printStackTrace();
                JOptionPane.showMessageDialog(null, 
                    "程序启动失败: " + e.getMessage(), 
                    "错误", 
                    JOptionPane.ERROR_MESSAGE);
            }
        });
    }
}
```

2. 个税计算核心类

```java
package com.tax.calculator;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;

/**
 * 个人所得税计算器
 * 实现2023年最新个税计算规则
 */
public class TaxCalculator {
    
    // 税率表（年度综合所得）
    private static final TaxBracket[] TAX_BRACKETS = {
        new TaxBracket(0, 36000, 0.03, 0),
        new TaxBracket(36000, 144000, 0.10, 2520),
        new TaxBracket(144000, 300000, 0.20, 16920),
        new TaxBracket(300000, 420000, 0.25, 31920),
        new TaxBracket(420000, 660000, 0.30, 52920),
        new TaxBracket(660000, 960000, 0.35, 85920),
        new TaxBracket(960000, Double.MAX_VALUE, 0.45, 181920)
    };
    
    // 月度专项扣除标准
    private static final Map<String, BigDecimal> SPECIAL_DEDUCTIONS = new HashMap<>();
    
    static {
        // 初始化专项扣除标准（月度）
        SPECIAL_DEDUCTIONS.put("养老", new BigDecimal("1000"));
        SPECIAL_DEDUCTIONS.put("医疗", new BigDecimal("200"));
        SPECIAL_DEDUCTIONS.put("失业", new BigDecimal("50"));
        SPECIAL_DEDUCTIONS.put("住房", new BigDecimal("1200"));
        SPECIAL_DEDUCTIONS.put("子女教育", new BigDecimal("1000"));
        SPECIAL_DEDUCTIONS.put("继续教育", new BigDecimal("400"));
        SPECIAL_DEDUCTIONS.put("大病医疗", new BigDecimal("8000")); // 年度上限
        SPECIAL_DEDUCTIONS.put("房贷利息", new BigDecimal("1000"));
        SPECIAL_DEDUCTIONS.put("住房租金", new BigDecimal("1500"));
        SPECIAL_DEDUCTIONS.put("赡养老人", new BigDecimal("2000"));
    }
    
    /**
     * 计算年度个人所得税
     * @param annualIncome 年度总收入
     * @param specialDeductions 专项扣除金额
     * @param additionalDeductions 专项附加扣除
     * @return 计算结果
     */
    public static TaxResult calculateAnnualTax(
        double annualIncome,
        double specialDeductions,
        double additionalDeductions) {
        
        // 基本扣除费用（年度）
        final double BASIC_DEDUCTION = 60000;
        
        // 转换为BigDecimal确保精度
        BigDecimal income = BigDecimal.valueOf(annualIncome);
        BigDecimal special = BigDecimal.valueOf(specialDeductions);
        BigDecimal additional = BigDecimal.valueOf(additionalDeductions);
        BigDecimal basic = BigDecimal.valueOf(BASIC_DEDUCTION);
        
        // 计算应纳税所得额
        BigDecimal taxableIncome = income
            .subtract(special)
            .subtract(additional)
            .subtract(basic)
            .max(BigDecimal.ZERO); // 不能为负数
        
        // 查找适用税率
        TaxBracket bracket = findTaxBracket(taxableIncome.doubleValue());
        
        // 计算应纳税额
        BigDecimal taxAmount = taxableIncome
            .multiply(BigDecimal.valueOf(bracket.getRate()))
            .subtract(BigDecimal.valueOf(bracket.getQuickDeduction()));
        
        // 确保税额不为负数
        taxAmount = taxAmount.max(BigDecimal.ZERO);
        
        // 计算税后收入
        BigDecimal afterTaxIncome = income.subtract(taxAmount);
        
        return new TaxResult(
            income.doubleValue(),
            taxableIncome.doubleValue(),
            taxAmount.doubleValue(),
            afterTaxIncome.doubleValue(),
            bracket
        );
    }
    
    /**
     * 根据应纳税所得额查找适用税率
     */
    private static TaxBracket findTaxBracket(double taxableIncome) {
        for (TaxBracket bracket : TAX_BRACKETS) {
            if (taxableIncome >= bracket.getLowerBound() && 
                taxableIncome < bracket.getUpperBound()) {
                return bracket;
            }
        }
        return TAX_BRACKETS[TAX_BRACKETS.length - 1];
    }
    
    /**
     * 获取专项扣除标准
     */
    public static Map<String, BigDecimal> getSpecialDeductionStandards() {
        return new HashMap<>(SPECIAL_DEDUCTIONS);
    }
    
    /**
     * 税率档次类
     */
    public static class TaxBracket {
        private final double lowerBound;
        private final double upperBound;
        private final double rate;
        private final double quickDeduction;
        
        public TaxBracket(double lowerBound, double upperBound, 
                         double rate, double quickDeduction) {
            this.lowerBound = lowerBound;
            this.upperBound = upperBound;
            this.rate = rate;
            this.quickDeduction = quickDeduction;
        }
        
        // Getter方法
        public double getLowerBound() { return lowerBound; }
        public double getUpperBound() { return upperBound; }
        public double getRate() { return rate; }
        public double getQuickDeduction() { return quickDeduction; }
        
        @Override
        public String toString() {
            return String.format("税率: %.1f%%, 速算扣除数: %.0f", rate * 100, quickDeduction);
        }
    }
    
    /**
     * 计算结果类
     */
    public static class TaxResult {
        private final double totalIncome;          // 总收入
        private final double taxableIncome;        // 应纳税所得额
        private final double taxAmount;            // 应纳税额
        private final double afterTaxIncome;       // 税后收入
        private final TaxBracket taxBracket;       // 适用税率档次
        
        public TaxResult(double totalIncome, double taxableIncome, 
                        double taxAmount, double afterTaxIncome,
                        TaxBracket taxBracket) {
            this.totalIncome = totalIncome;
            this.taxableIncome = taxableIncome;
            this.taxAmount = taxAmount;
            this.afterTaxIncome = afterTaxIncome;
            this.taxBracket = taxBracket;
        }
        
        // Getter方法
        public double getTotalIncome() { return totalIncome; }
        public double getTaxableIncome() { return taxableIncome; }
        public double getTaxAmount() { return taxAmount; }
        public double getAfterTaxIncome() { return afterTaxIncome; }
        public TaxBracket getTaxBracket() { return taxBracket; }
        
        @Override
        public String toString() {
            return String.format(
                "计算结果:\n" +
                "总收入: ¥%.2f\n" +
                "应纳税所得额: ¥%.2f\n" +
                "应纳税额: ¥%.2f\n" +
                "税后收入: ¥%.2f\n" +
                "适用税率: %s",
                totalIncome, taxableIncome, taxAmount, afterTaxIncome, taxBracket
            );
        }
    }
}
```

3. GUI界面实现

```java
package com.tax.calculator;

import javax.swing.*;
import javax.swing.border.TitledBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
import java.util.Map;

/**
 * 个税计算器主界面
 */
public class TaxCalculatorFrame extends JFrame {
    
    private JTextField incomeField;
    private JTextField specialDeductionField;
    private JTextField additionalDeductionField;
    private JTextArea resultArea;
    private JComboBox<String> deductionTypeCombo;
    private JLabel standardLabel;
    
    public TaxCalculatorFrame() {
        initUI();
        initData();
    }
    
    private void initUI() {
        setTitle("个人所得税计算模拟器 v1.0");
        setSize(800, 600);
        setLocationRelativeTo(null);
        
        // 主面板
        JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
        mainPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        
        // 输入面板
        mainPanel.add(createInputPanel(), BorderLayout.NORTH);
        
        // 结果面板
        mainPanel.add(createResultPanel(), BorderLayout.CENTER);
        
        // 按钮面板
        mainPanel.add(createButtonPanel(), BorderLayout.SOUTH);
        
        add(mainPanel);
    }
    
    private JPanel createInputPanel() {
        JPanel panel = new JPanel(new GridLayout(5, 2, 10, 10));
        panel.setBorder(BorderFactory.createTitledBorder(
            BorderFactory.createLineBorder(Color.GRAY),
            "个税计算参数输入",
            TitledBorder.LEFT,
            TitledBorder.TOP
        ));
        
        // 年度总收入
        panel.add(new JLabel("年度总收入 (¥):"));
        incomeField = new JTextField("120000");
        panel.add(incomeField);
        
        // 专项扣除
        panel.add(new JLabel("三险一金专项扣除 (¥):"));
        specialDeductionField = new JTextField("10000");
        panel.add(specialDeductionField);
        
        // 专项附加扣除
        panel.add(new JLabel("专项附加扣除 (¥):"));
        additionalDeductionField = new JTextField("3000");
        panel.add(additionalDeductionField);
        
        // 扣除标准查询
        panel.add(new JLabel("扣除项目查询:"));
        JPanel queryPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
        deductionTypeCombo = new JComboBox<>();
        queryPanel.add(deductionTypeCombo);
        standardLabel = new JLabel("标准: ¥0");
        queryPanel.add(standardLabel);
        panel.add(queryPanel);
        
        return panel;
    }
    
    private JScrollPane createResultPanel() {
        resultArea = new JTextArea();
        resultArea.setEditable(false);
        resultArea.setFont(new Font("宋体", Font.PLAIN, 14));
        resultArea.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        
        JScrollPane scrollPane = new JScrollPane(resultArea);
        scrollPane.setBorder(BorderFactory.createTitledBorder("计算结果"));
        
        return scrollPane;
    }
    
    private JPanel createButtonPanel() {
        JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 10));
        
        // 计算按钮
        JButton calculateBtn = new JButton("计算个税");
        calculateBtn.setFont(new Font("微软雅黑", Font.BOLD, 14));
        calculateBtn.setBackground(new Color(70, 130, 180));
        calculateBtn.setForeground(Color.WHITE);
        calculateBtn.setPreferredSize(new Dimension(120, 40));
        
        calculateBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                calculateTax();
            }
        });
        
        // 清除按钮
        JButton clearBtn = new JButton("清除结果");
        clearBtn.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        clearBtn.setPreferredSize(new Dimension(120, 40));
        clearBtn.addActionListener(e -> clearResults());
        
        // 税率表按钮
        JButton rateTableBtn = new JButton("查看税率表");
        rateTableBtn.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        rateTableBtn.setPreferredSize(new Dimension(120, 40));
        rateTableBtn.addActionListener(e -> showTaxRateTable());
        
        panel.add(calculateBtn);
        panel.add(clearBtn);
        panel.add(rateTableBtn);
        
        return panel;
    }
    
    private void initData() {
        // 初始化扣除类型下拉框
        Map<String, BigDecimal> standards = TaxCalculator.getSpecialDeductionStandards();
        for (String key : standards.keySet()) {
            deductionTypeCombo.addItem(key);
        }
        
        // 添加下拉框监听
        deductionTypeCombo.addActionListener(e -> {
            String selected = (String) deductionTypeCombo.getSelectedItem();
            if (selected != null) {
                BigDecimal standard = standards.get(selected);
                standardLabel.setText(String.format("标准: ¥%.2f", standard));
            }
        });
        
        // 默认选择第一个
        if (deductionTypeCombo.getItemCount() > 0) {
            deductionTypeCombo.setSelectedIndex(0);
        }
    }
    
    /**
     * 执行个税计算
     */
    private void calculateTax() {
        try {
            // 获取输入值
            double income = Double.parseDouble(incomeField.getText());
            double special = Double.parseDouble(specialDeductionField.getText());
            double additional = Double.parseDouble(additionalDeductionField.getText());
            
            // 验证输入
            if (income < 0 || special < 0 || additional < 0) {
                JOptionPane.showMessageDialog(this,
                    "输入值不能为负数！",
                    "输入错误",
                    JOptionPane.WARNING_MESSAGE);
                return;
            }
            
            // 执行计算
            TaxCalculator.TaxResult result = TaxCalculator.calculateAnnualTax(
                income, special, additional);
            
            // 显示结果
            displayResult(result);
            
        } catch (NumberFormatException ex) {
            JOptionPane.showMessageDialog(this,
                "请输入有效的数字！",
                "输入错误",
                JOptionPane.ERROR_MESSAGE);
        }
    }
    
    /**
     * 显示计算结果
     */
    private void displayResult(TaxCalculator.TaxResult result) {
        StringBuilder sb = new StringBuilder();
        sb.append("=== 个人所得税计算结果 ===\n\n");
        sb.append(String.format("年度总收入: ¥%,.2f\n", result.getTotalIncome()));
        sb.append(String.format("应纳税所得额: ¥%,.2f\n", result.getTaxableIncome()));
        sb.append(String.format("适用税率档次: %s\n", result.getTaxBracket()));
        sb.append(String.format("应纳个人所得税: ¥%,.2f\n", result.getTaxAmount()));
        sb.append(String.format("年度税后收入: ¥%,.2f\n\n", result.getAfterTaxIncome()));
        
        // 计算月度数据
        double monthlyTax = result.getTaxAmount() / 12;
        double monthlyAfterTax = result.getAfterTaxIncome() / 12;
        
        sb.append("=== 月度数据估算 ===\n");
        sb.append(String.format("月度平均纳税: ¥%,.2f\n", monthlyTax));
        sb.append(String.format("月度税后收入: ¥%,.2f\n\n", monthlyAfterTax));
        
        // 添加税务建议
        sb.append("=== 税务优化建议 ===\n");
        if (result.getTaxableIncome() > 0) {
            sb.append("1. 充分利用专项附加扣除项目\n");
            sb.append("2. 合理规划年度收入时间分布\n");
            sb.append("3. 符合条件的捐赠可税前扣除\n");
        } else {
            sb.append("当前收入无需缴纳个人所得税\n");
        }
        
        resultArea.setText(sb.toString());
        resultArea.setCaretPosition(0);
    }
    
    /**
     * 显示税率表
     */
    private void showTaxRateTable() {
        StringBuilder sb = new StringBuilder();
        sb.append("=== 个人所得税税率表（综合所得） ===\n\n");
        sb.append("级数 | 全年应纳税所得额 | 税率 | 速算扣除数\n");
        sb.append("----|-----------------|------|----------\n");
        
        TaxCalculator.TaxBracket[] brackets = new TaxCalculator.TaxBracket[]{
            new TaxCalculator.TaxBracket(0, 36000, 0.03, 0),
            new TaxCalculator.TaxBracket(36000, 144000, 0.10, 2520),
            new TaxCalculator.TaxBracket(144000, 300000, 0.20, 16920),
            new TaxCalculator.TaxBracket(300000, 420000, 0.25, 31920),
            new TaxCalculator.TaxBracket(420000, 660000, 0.30, 52920),
            new TaxCalculator.TaxBracket(660000, 960000, 0.35, 85920),
            new TaxCalculator.TaxBracket(960000, Double.MAX_VALUE, 0.45, 181920)
        };
        
        for (int i = 0; i < brackets.length; i++) {
            TaxCalculator.TaxBracket b = brackets[i];
            String range;
            if (b.getUpperBound() == Double.MAX_VALUE) {
                range = String.format("超过%,.0f元", b.getLowerBound());
            } else {
                range = String.format("%,.0f - %,.0f元", 
                    b.getLowerBound(), b.getUpperBound());
            }
            
            sb.append(String.format("%-4d| %-15s | %.1f%% | %,.0f元\n",
                i + 1, range, b.getRate() * 100, b.getQuickDeduction()));
        }
        
        sb.append("\n注：应纳税所得额 = 年度收入 - 6万元(基本扣除) - 专项扣除 - 专项附加扣除\n");
        
        resultArea.setText(sb.toString());
    }
    
    /**
     * 清除结果
     */
    private void clearResults() {
        resultArea.setText("");
    }
}
```

三、使用说明

1. 运行环境要求

· Java 8或更高版本
· 支持Swing的桌面环境

2. 编译运行

```bash
# 编译所有Java文件
javac -d . com/tax/calculator/*.java

# 运行程序
java com.tax.calculator.PersonalIncomeTaxApp
```

3. 程序功能演示

1. 输入计算参数：
   · 年度总收入
   · 三险一金专项扣除
   · 专项附加扣除
2. 查询扣除标准：
   · 通过下拉框选择不同扣除项目
   · 查看各项目扣除标准
3. 计算个税：
   · 点击"计算个税"按钮
   · 查看详细计算结果
4. 查看税率表：
   · 点击"查看税率表"按钮
   · 了解各级税率信息

四、核心算法说明

1. 计算公式

```
应纳税所得额 = 年度收入 - 60000(基本减除费用) - 专项扣除 - 专项附加扣除
应纳税额 = 应纳税所得额 × 适用税率 - 速算扣除数
```

2. 税率表算法

采用逐级累进计算方式，通过查找表确定适用税率。

五、项目扩展建议

1. 数据持久化：添加文件保存/加载功能
2. 历史记录：记录多次计算结果
3. 导出功能：支持PDF/Excel导出
4. 联网更新：自动更新税率政策
5. 图表展示：使用JFreeChart添加图表

六、注意事项

1. 本程序为模拟器，实际报税请以官方系统为准
2. 税率政策如有更新，需要相应修改代码
3. 计算结果仅供参考，不构成税务建议

七、开源协议

本项目采用MIT开源协议，允许自由使用、修改和分发。

---

项目源码已上传至GitHub：https://github.com/yourusername/tax-calculator

欢迎Star和贡献代码！

八、运行截图

由于无法在本文中直接显示图片，以下是程序运行效果描述：

1. 主界面：包含输入区、结果显示区和功能按钮
2. 计算结果：详细展示各项税务数据
3. 税率表：完整的7级累进税率表

---

作者：TaxDeveloper
邮箱：[email protected]
更新日期：2023年10月
版权声明：本文代码仅供参考学习，转载请注明出处

Read more

Flutter 组件 wilt 适配鸿蒙 HarmonyOS 实战：极简数据序列化，构建边缘计算场景下的轻量级存取矩阵

Flutter 组件 wilt 适配鸿蒙 HarmonyOS 实战：极简数据序列化，构建边缘计算场景下的轻量级存取矩阵

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net Flutter 组件 wilt 适配鸿蒙 HarmonyOS 实战：极简数据序列化，构建边缘计算场景下的轻量级存取矩阵 前言 在鸿蒙（OpenHarmony）生态迈向万物互联、涉及大量传感器快照存取、临时配置缓存或轻量化元服务（Atomic Service）的背景下，如何以极低的算力开销实现数据的序列化与持久化，已成为决定应用启动速度与响应灵敏度的“毛细血管工程”。在鸿蒙设备这类强调微内核效率与极致能耗控制的移动终端上，如果针对每一个微小的临时数据都要动用重型的 SQL 引擎或复杂的 ORM 框架，不仅会由于由于繁重的类加载过程导致首帧渲染延迟，更会由于由于冗余的磁盘 I/O 造成不必要的能源开销。 我们需要一种能够直接操作内存映射、支持动态 Schema 扩展且代码体积极其微小的轻量级存取方案。 wilt 为 Flutter 开发者引入了一套面向边缘计算的极简数据操作范式。它抛弃了复杂的索引预建与繁琐的表结构声明，支持以原生的 Map 结构进行即时持久化

By Ne0inhk
从 App 到 Agent：鸿蒙应用形态正在改变

从 App 到 Agent：鸿蒙应用形态正在改变

子玥酱（掘金 / 知乎 / ZEEKLOG / 简书 同名） 大家好，我是子玥酱，一名长期深耕在一线的前端程序媛 👩‍💻。曾就职于多家知名互联网大厂，目前在某国企负责前端软件研发相关工作，主要聚焦于业务型系统的工程化建设与长期维护。 我持续输出和沉淀前端领域的实战经验，日常关注并分享的技术方向包括前端工程化、小程序、React / RN、Flutter、跨端方案， 在复杂业务落地、组件抽象、性能优化以及多端协作方面积累了大量真实项目经验。 技术方向：前端 / 跨端 / 小程序 / 移动端工程化 内容平台：掘金、知乎、ZEEKLOG、简书 创作特点：实战导向、源码拆解、少空谈多落地 文章状态：长期稳定更新，大量原创输出 我的内容主要围绕 前端技术实战、真实业务踩坑总结、框架与方案选型思考、行业趋势解读 展开。文章不会停留在“API 怎么用”，而是更关注为什么这么设计、在什么场景下容易踩坑、

By Ne0inhk
【教程】如何在WSL2:Ubuntu上部署llama.cpp

【教程】如何在WSL2:Ubuntu上部署llama.cpp

WSL2:Ubuntu部署llama.cpp llama.cpp 是一个完全由 C 与 C++ 编写的轻量级推理框架，支持在 CPU 或 GPU 上高效运行 Meta 的 LLaMA 等大语言模型（LLM），设计上尽可能减少外部依赖，能够轻松在多种后端与平台上运行。 安装llama.cpp 下面我们采用本地编译的方法在设备上安装llama.cpp 克隆llama.cpp仓库 在wsl中打开终端： git clone https://github.com/ggml-org/llama.cpp cd llama.cpp 编译项目 编译项目前，先安装所需依赖项： sudoapt update sudoaptinstall -y build-essential cmake git#

By Ne0inhk
Flutter 三方库 ff_annotation_route 的鸿蒙化适配指南 - 掌握基于注解的自动化路由管理技术、助力鸿蒙大型 HAP 项目构建极速解构且类型安全的页面跳转体系

Flutter 三方库 ff_annotation_route 的鸿蒙化适配指南 - 掌握基于注解的自动化路由管理技术、助力鸿蒙大型 HAP 项目构建极速解构且类型安全的页面跳转体系

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net Flutter 三方库 ff_annotation_route 的鸿蒙化适配指南 - 掌握基于注解的自动化路由管理技术、助力鸿蒙大型 HAP 项目构建极速解构且类型安全的页面跳转体系 前言 在 OpenHarmony 鸿蒙应用向“大规模、模块化、组件化”演进的工程实战中，路由（Routing）管理始终是维护成本最高的环节之一。传统的硬编码路由表（String-based Routes）在面对数百个页面时，极易出现拼写错误、参数透传混乱以及耦合度过高等问题。如何实现“写完页面，路由自动生成”？如何让每一个页面跳转都具备强类型校验？ff_annotation_route 作为一个专注于“注解驱动自动化”的路由生成引擎，旨在为鸿蒙开发者提供一套工业级的路由治理方案。本文将详述其在鸿蒙端的实战技法。 一、原原理分析 / 概念介绍 1.1

By Ne0inhk