类、闭包与可调用对象：抽象类调用子类自定义方法的实现

嘿，这场景我太熟了！你要实现的就是经典的模板方法模式——让抽象类定义通用的持久化流程骨架，把需要子类自定义的特定处理逻辑留作抽象方法或钩子方法，这样抽象类在执行通用流程时，就能自动调用子类的专属逻辑啦。

1. 设计抽象持久化类 #

首先，抽象类负责封装所有模型共用的持久化逻辑（比如参数校验、DB连接管理、通用保存操作），然后把需要子类定制的部分抽成抽象方法（强制子类实现）或钩子方法（子类可选重写）。

举个Java代码示例（其他语言思路完全一致）：

// 通用抽象持久化类
public abstract class BaseModelPersistence<T> {

    // 核心模板方法：定义完整的持久化流程，用final防止子类篡改通用流程
    public final void persist(T model) {
        // 通用步骤1：校验模型合法性
        validateModel(model);
        // 通用步骤2：调用子类专属前置处理
        prePersist(model);
        // 通用步骤3：执行通用保存逻辑
        doPersist(model);
        // 通用步骤4：调用子类专属后置处理
        postPersist(model);
        // 通用步骤5：清理资源
        cleanUpResources();
    }

    // 通用模型校验：所有模型共用，子类不能修改
    private void validateModel(T model) {
        if (model == null) {
            throw new IllegalArgumentException("待持久化模型不能为空");
        }
        // 这里可以加更多通用校验规则，比如必填字段检查等
    }

    // 通用DB保存逻辑：封装ORM框架调用或JDBC操作
    private void doPersist(T model) {
        // 示例：调用JPA的save方法
        // entityManager.persist(model);
        System.out.println("执行通用持久化操作：" + model.getClass().getSimpleName());
    }

    // 通用资源清理：关闭连接、释放缓存等
    private void cleanUpResources() {
        // 示例：关闭DB连接
        // connection.close();
        System.out.println("清理持久化相关资源");
    }

    // 抽象方法：子类必须实现的前置特定处理（比如订单生成单号、用户加密密码）
    protected abstract void prePersist(T model);

    // 钩子方法：子类可选重写的后置特定处理（默认空实现，比如发送通知、更新统计）
    protected void postPersist(T model) {
        // 默认无操作，子类按需扩展
    }
}

2. 子类实现专属逻辑 #

子类继承抽象类，只需要实现抽象方法（或重写钩子方法），专注于自己的特定处理即可：

// 订单模型的专属持久化子类
public class OrderPersistence extends BaseModelPersistence<Order> {

    @Override
    protected void prePersist(Order order) {
        // 订单专属前置处理：生成唯一订单号、计算总价
        order.setOrderNo("ORD-" + System.currentTimeMillis());
        order.setTotalAmount(calculateTotal(order.getItems()));
        System.out.println("订单专属前置处理完成：生成订单号" + order.getOrderNo());
    }

    @Override
    protected void postPersist(Order order) {
        // 订单专属后置处理：发送下单短信、扣减库存
        sendOrderNotification(order);
        deductStock(order.getItems());
        System.out.println("订单专属后置处理完成：通知用户+更新库存");
    }

    // 订单专属工具方法
    private BigDecimal calculateTotal(List<OrderItem> items) {
        return items.stream()
                .map(OrderItem::getPrice)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private void sendOrderNotification(Order order) {
        // 模拟发送短信/推送逻辑
    }

    private void deductStock(List<OrderItem> items) {
        // 模拟库存扣减逻辑
    }
}

3. 使用方式 #

调用时直接实例化子类，调用抽象类定义的persist()方法即可，流程会自动触发子类的专属处理：

public class Demo {
    public static void main(String[] args) {
        Order testOrder = new Order();
        testOrder.setItems(List.of(new OrderItem("笔记本电脑", new BigDecimal("5999"))));

        BaseModelPersistence<Order> orderPersistence = new OrderPersistence();
        orderPersistence.persist(testOrder);
    }
}

核心优势 #

• 通用性保障：所有模型的通用持久化逻辑都在抽象类里统一维护，避免重复代码。
• 扩展性灵活：子类只需要关注自己的特殊逻辑，不影响整体流程。
• 流程一致性：模板方法用final修饰，确保所有模型的持久化流程不会被子类随意修改。

这样设计完全适配你的需求：抽象类搞定通用持久化，子类负责超出通用范围的特定处理，完美解耦～

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