设计基础产品上线套餐的架构-代码实现

当然，我会在每个表的定义中添加注释，以便更好地理解设计意图。

1. 数据库结构设计

基础产品表 (products)

CREATE TABLE products (
    product_id INT PRIMARY KEY AUTO_INCREMENT, -- 产品唯一标识
    product_name VARCHAR(255) NOT NULL, -- 产品名称
    description TEXT, -- 产品描述
    price DECIMAL(10, 2) NOT NULL, -- 产品价格
    valid_from DATE, -- 产品有效期开始日期
    valid_to DATE, -- 产品有效期结束日期
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 产品创建时间
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP -- 产品更新时间（自动更新）
);

套餐表 (packages)

CREATE TABLE packages (
    package_id INT PRIMARY KEY AUTO_INCREMENT, -- 套餐唯一标识
    package_name VARCHAR(255) NOT NULL, -- 套餐名称
    description TEXT, -- 套餐描述
    price DECIMAL(10, 2), -- 套餐价格，可能是基础产品价格的合计
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 套餐创建时间
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP -- 套餐更新时间（自动更新）
);

套餐产品关联表 (package_products)

CREATE TABLE package_products (
    id INT PRIMARY KEY AUTO_INCREMENT, -- 关联唯一标识
    package_id INT NOT NULL, -- 关联的套餐ID
    product_id INT NOT NULL, -- 关联的产品ID
    quantity INT DEFAULT 1, -- 产品在套餐中的数量
    FOREIGN KEY (package_id) REFERENCES packages(package_id), -- 套餐ID外键约束
    FOREIGN KEY (product_id) REFERENCES products(product_id) -- 产品ID外键约束
);

规则表 (rules)

CREATE TABLE rules (
    rule_id INT PRIMARY KEY AUTO_INCREMENT, -- 规则唯一标识
    rule_name VARCHAR(255) NOT NULL, -- 规则名称
    rule_type ENUM('MUTEX', 'DEPENDENCY') NOT NULL, -- 规则类型：互斥（MUTEX）或依赖（DEPENDENCY）
    rule_expression TEXT NOT NULL, -- 规则表达式，定义规则的逻辑
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 规则创建时间
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP -- 规则更新时间（自动更新）
);

套餐规则关联表 (package_rules)

CREATE TABLE package_rules (
    id INT PRIMARY KEY AUTO_INCREMENT, -- 关联唯一标识
    package_id INT NOT NULL, -- 关联的套餐ID
    rule_id INT NOT NULL, -- 关联的规则ID
    FOREIGN KEY (package_id) REFERENCES packages(package_id), -- 套餐ID外键约束
    FOREIGN KEY (rule_id) REFERENCES rules(rule_id) -- 规则ID外键约束
);

2. Java 后端架构设计

2.1 项目结构

采用经典的分层架构，通常包括以下几个层次：

Controller 层：
- 负责处理 HTTP 请求，调用 Service 层的服务，并返回结果给前端。
- Controller 层通过 RESTful API 对外提供服务。
Service 层：
- 业务逻辑处理层，负责业务规则的执行，如套餐和基础产品的组合、价格计算等。
- 调用 Repository 层获取或保存数据。
Repository 层（DAO 层）：
- 数据访问层，负责与数据库交互，使用 JPA 或 MyBatis 等 ORM 工具操作数据库表。
- 通过实体类和接口定义数据操作方法。
Domain 模型：
- 包含业务实体（如 Product, Package, Rule）及其之间的关系。
- 实体类与数据库表结构相对应。
规则引擎集成：
- 使用 Drools 或 Liteflow 进行规则的编排和执行。
- 将规则与业务逻辑解耦，方便规则的维护和更新。

2.2 示例代码

以下是一些关键组件的代码示例：

Controller 示例：

@RestController
@RequestMapping("/api/packages")
public class PackageController {

    @Autowired
    private PackageService packageService;

    @PostMapping
    public ResponseEntity<PackageDTO> createPackage(@RequestBody PackageDTO packageDTO) {
        PackageDTO createdPackage = packageService.createPackage(packageDTO);
        return new ResponseEntity<>(createdPackage, HttpStatus.CREATED);
    }

    @GetMapping("/{id}")
    public ResponseEntity<PackageDTO> getPackage(@PathVariable Long id) {
        PackageDTO packageDTO = packageService.getPackageById(id);
        return ResponseEntity.ok(packageDTO);
    }
}

Service 层示例：

@Service
public class PackageService {

    @Autowired
    private PackageRepository packageRepository;

    @Autowired
    private RuleEngineService ruleEngineService;

    public PackageDTO createPackage(PackageDTO packageDTO) {
        // 执行业务逻辑，例如验证规则
        if (ruleEngineService.validatePackageRules(packageDTO)) {
            // 保存套餐到数据库
            Package savedPackage = packageRepository.save(convertToEntity(packageDTO));
            return convertToDTO(savedPackage);
        } else {
            throw new BusinessException("Package rules validation failed");
        }
    }

    public PackageDTO getPackageById(Long id) {
        Package pkg = packageRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("Package not found"));
        return convertToDTO(pkg);
    }

    // 转换方法：DTO <-> Entity
}

Repository 层示例：

public interface PackageRepository extends JpaRepository<Package, Long> {
    // JPA 提供了常用的数据访问方法，无需额外实现
}

规则引擎集成示例（使用 Drools 或 Liteflow）：

@Service
public class RuleEngineService {

    @Autowired
    private KieContainer kieContainer; // Drools 的 KIE 容器

    public boolean validatePackageRules(PackageDTO packageDTO) {
        KieSession kieSession = kieContainer.newKieSession();
        kieSession.insert(packageDTO);
        return kieSession.fireAllRules() > 0;
    }
}

总结

这套设计结合了灵活的数据库结构和分层架构，能够有效地管理基础产品与套餐的关系，支持复杂的业务规则处理和扩展。通过使用 Drools 或 Liteflow 的规则引擎，可以将复杂的业务逻辑与代码解耦，使系统更易于维护和扩展。同时，利用 Spring Boot 的特性，开发效率也能得到提升。

菜单

分享