数字农业WMS库存操作重构及思考

一  问题背景

二  模板方法

// 「获取操作」伪代码While(synchronization state does not allow acquire) { // * 骨架扩展点  enqueue current thread if not already queued; // 线程结点入队  possibly block current thread; // 阻塞当前线程}dequeue current thread if it was queued; // 线程结点出队
// 「释放操作」伪代码update synchronization state // * 骨架扩展点if (state may permit a blocked thread to acquire) { // * 骨架扩展点  unblock one or more queued threads; // 唤起被阻塞的线程}

// AQS acquire/release 操作算法骨架代码public abstract class AbstractQueuedSynchronizer    extends AbstractOwnableSynchronizer    implements java.io.Serializable {
  // 同步状态 synchronization state     private volatile int state; 
    // 排他式「获取操作」    public final void acquire(int arg) {        if (!tryAcquire(arg) && // * 骨架扩展点            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 线程结点入队            selfInterrupt();    }      // 针对已入队线程结点的排他式「获取操作」    final boolean acquireQueued(final Node node, int arg) {        boolean failed = true;        try {            boolean interrupted = false;            for (;;) {                final Node p = node.predecessor();                if (p == head && tryAcquire(arg)) { // * 骨架扩展点                    setHead(node); // 线程结点出队（队列head为哑结点）                    p.next = null;                    failed = false;                    return interrupted;                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt()) // 阻塞当前线程                    interrupted = true;            }        } finally {            if (failed)                cancelAcquire(node);        }    }
    // 排他式「释放操作」    public final boolean release(int arg) {        if (tryRelease(arg)) { // * 骨架扩展点            Node h = head;            if (h != null && h.waitStatus != 0)                unparkSuccessor(h); // 唤起被阻塞的线程            return true;        }        return false;    }
    // * 排他式「获取操作」骨架扩展点    protected boolean tryAcquire(int arg) {        throw new UnsupportedOperationException();    }
    // * 排他式「释放操作」骨架扩展点    protected boolean tryRelease(int arg) {        throw new UnsupportedOperationException();    }
}

三  回调方式

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {      // 管道模式命令执行，RedisCallback    @Override  public List<Object> executePipelined(RedisCallback<?> action, @Nullable RedisSerializer<?> resultSerializer) {
    return execute((RedisCallback<List<Object>>) connection -> {      connection.openPipeline(); // * 扩展点：开启管道模式      boolean pipelinedClosed = false;      try {        Object result = action.doInRedis(connection); // * 扩展点：回调执行用户自定义操作        if (result != null) {          throw new InvalidDataAccessApiUsageException(              "Callback cannot return a non-null value as it gets overwritten by the pipeline");        }        List<Object> closePipeline = connection.closePipeline(); // * 扩展点：关闭管道模式        pipelinedClosed = true;        return deserializeMixedResults(closePipeline, resultSerializer, hashKeySerializer, hashValueSerializer);      } finally {        if (!pipelinedClosed) {          connection.closePipeline();        }      }    });  }        // 事务+管道模式命令执行    @Override  public List<Object> executePipelined(SessionCallback<?> session, @Nullable RedisSerializer<?> resultSerializer) {        // 具体代码省略    }    }

类似地，在数农WMS的库存操作重构中，我们定义了ContainerInventoryOperationTemplate「模板类」，作为承载库存操作业务逻辑的框架。下述为其中的库存操作核心代码片段。可以看到，框架统一定义了库存操作流程，并对其中的通用逻辑提供了支持，使各类不同的库存操作得以复用：如构建库存操作明细、持久化操作明细及同步任务、并发冲突重试等；而对于其中随不同库存操作类型变动的逻辑 —— 如操作库存数据、确认前置操作、持久化库存数据等 —— 则通过对ContainerInventoryOperationHandler接口实例的回调实现，它们可以被看作是库存操作框架代码中的扩展点。接口由不同类型的库存操作分别实现，如库存增加、库存占用、库存转移、库存释放等等。如此，如果我们后续需要添加某种新类型的库存操作，只需要实现ContainerInventoryOperationHandler接口中定义的个性化逻辑即可；而如果我们需要对整个库存操作流程进行迭代，也只需要修改ContainerInventoryOperationTemplate中的框架代码，而不是像先前那样，需要同时修改多处代码（这里模板类和库存操作handler的命名均以Container作为前缀，是因为数农WMS以容器托盘作为基本的库存管理单元）。

@Servicepublic class ContainerInventoryOperationTemplate {        private Boolean doOperateInTransaction(OperationContext context) {        final Boolean transactionSuccess = transactionTemplate.execute(transactionStatus -> {            try {                ContainerInventoryOperationHandler handler = context.getHandler(); // 库存操作回调handler                handler.getAndCheckCurrentInventory(context); // 获取并校验库存数据                buildInventoryDetail(context); // 构建库存操作明细                handler.operateInventory(context); // * 扩展点：操作库存数据                handler.confirmPreOperationIfNecessary(context); // * 扩展点：确认前置操作（如库存占用）                    handler.persistInventoryOperation(context); // * 扩展点：持久化库存数据                persistInventoryDetailAndSyncTask(context); // 持久化操作明细及同步任务                        doSyncOperationIfNecessary(context); // 库存同步操作                return Boolean.TRUE;            } catch (WhException we) {                context.setWhException(we);                // 遇到并发冲突异常，需要重试                if (Objects.equals(we.getErrorCode(), ErrorCodeEnum.CAS_SAVE_ERROR.getCode())) {                    context.setCanRetry(true);                }            }            // 省略部分代码            transactionStatus.setRollbackOnly();            return Boolean.FALSE;        });        // 省略部分代码        return transactionSuccess;    }    }

四  组合与继承

1. 继承打破封装性：《Effective Java》在《第18条：复合优先于继承》中提到，继承是实现代码重用的有力手段，但它并非永远是完成这项工作的最佳工具。使用不当会导致软件变得很脆弱。与方法调用不同的是，继承打破了封装性。换句话说，子类依赖于其超类中特定功能的实现细节。超类的实现有可能会随着发行版本的不同而有所变化，如果真的发生了变化，子类可能会遭到破坏，即使它的代码完全没有改变。同时，子类可能继承了定义在父类，但其自身并不需要的方法，有违最小知识原则（Least Knowledge Principle）。子类可能因此错误地覆盖并改变了父类中的方法实现，导致父类功能的封装性被破坏。而如果我们使用对象间组合的方式，则可以避免此类问题的出现。
   
   
2. 接口优于抽象类：仍旧是《Effective Java》，在《第20条：接口优于抽象类》中提到，因为Java只允许单继承，所以用抽象类（模板方法便是基于抽象类实现）作为类型定义受到了限制。而现有的类可以很容易被更新，以实现新的接口。接口是定义混合类型（mixin）的理想选择，允许构造非层次结构的类型框架。与之相反的做法是编写一个臃肿的类层次，对于每一种要被支持的属性组合，都包含一个单独的类。如果整个类型系统中有n个属性，那么就必须支持2n种可能的组合，这种现象被称为「组合爆炸」，即需要定义过多的类。
   
   
3. 组合替代继承：最后，王争的《设计模式之美》中提到，继承主要有三个作用：表示is-a关系，支持多态性，以及代码复用。而这三个作用都可以通过其他手段达成：is-a关系可以通过组合和接口的has-a关系来替代；多态性可以利用接口来实现；代码复用则可以通过组合和委托来实现。因此从理论上讲，通过组合、接口、委托三个技术手段，我们可以替换掉继承，在项目中不用或者少用复杂的继承关系。这种对象间组合的设计方式比类间继承的方式更加符合开闭原则（Open-Closed Principle）（注4）。

五  再论重构

// 库存增加并占用@Componentpublic class IncreaseAndOccupyOperationHandler implements ContainerInventoryOperationHandler {
    @Resource    private IncreaseOperationHandler increaseOperationHandler; // 组合「库存增加」操作handler
    @Resource    private OccupyOperationHandler occupyOperationHandler; // 组合「库存占用」操作handler
    // 委托「库存占用」操作handler进行前置操作校验，判断是否单据占用已存在    @Override    public void checkPreOperationIfNecessary(ContainerInventoryOperationTemplate.OperationContext context) {        occupyOperationHandler.checkPreOperationIfNecessary(context);     }    // 委托「库存增加」操作handler进行库存信息校验    @Override    public void getAndCheckCurrentInventory(ContainerInventoryOperationTemplate.OperationContext context) {        increaseOperationHandler.getAndCheckCurrentInventory(context);    }      // 委托「库存增加」、「库存占用」操作handler进行「库存增加并占用」操作    @Override    public void operateInventory(ContainerInventoryOperationTemplate.OperationContext context) {        increaseOperationHandler.operateInventory(context);        occupyOperationHandler.operateInventory(context);    }        // 其余代码略
}

六  结语

代码重构并且总结成文的过程要求不断地学习、思辨和实践，也让自己获益良多。

注解

1. 对AQS使用了模板方法设计模式的「官方论断」可见于其作者Doug Lea在The java.util.concurrent Synchronizer Framework一文中的论述：Class AbstractQueuedSynchronizer ties together the above functionality and serves as a "template method pattern" base class for synchronizers. Subclasses define only the methods that implement the state inspections and updates that control acquire and release. 此外，文中还包含了对等待线程FIFO队列（CLH变体）、公平性、框架性能等方面的详细讨论。
   http://gee.cs.oswego.edu/dl/papers/aqs.pdf
2. 参考维基百科Callback词条：In object-oriented programming languages without function-valued arguments, such as in Java before its 8 version, callbacks can be simulated by passing an instance of an abstract class or interface, of which the receiver will call one or more methods, while the calling end provides a concrete implementation. Such objects are effectively a bundle of callbacks, plus the data they need to manipulate. They are useful in implementing various design patterns such as Visitor, Observer, and Strategy.
   https://en.wikipedia.org/wiki/Callback_(computer_programming)
3. Stack Overflow上的某个问答可作为参考：I concur - JdbcTemplate isn't an example of template method design pattern. The design pattern used is callback. Note that the goal and effect of both patterns is very similar, the main difference is that template method uses inheritance while callback uses composition (sort of) - by Jiri Tousek
   https://stackoverflow.com/questions/33153252/why-is-jdbctemplate-an-example-of-the-template-method-design-pattern
4. 参考维基百科Strategy pattern词条：The strategy pattern uses composition instead of inheritance. In the strategy pattern, behaviors are defined as separate interfaces and specific classes that implement these interfaces. This allows better decoupling between the behavior and the class that uses the behavior. The behavior can be changed without breaking the classes that use it, and the classes can switch between behaviors by changing the specific implementation used without requiring any significant code changes. This is compatible with the open/closed principle (OCP), which proposes that classes should be open for extension but closed for modification.
   https://en.wikipedia.org/wiki/Strategy_pattern
5. Doug Lea在The java.util.concurrent Synchronizer Framework中提到：The heart of the framework is maintenance of queues of blocked threads, which are restricted here to FIFO queues. Thus, the framework does not support priority-based synchronization.
   http://gee.cs.oswego.edu/dl/papers/aqs.pdf

参考资料

• 《设计模式》
  https://book.douban.com/subject/1052241/
• The java.util.concurrent Synchronizer Framework
  http://gee.cs.oswego.edu/dl/papers/aqs.pdf
• 《Java并发编程实战》
  https://book.douban.com/subject/10484692/
• 维基百科Callback词条
  https://en.wikipedia.org/wiki/Callback_(computer_programming)
• why is jdbctemplate an example of the template method design pattern
  https://stackoverflow.com/questions/33153252/why-is-jdbctemplate-an-example-of-the-template-method-design-pattern
• 《Effective Java 3》
  https://book.douban.com/subject/27047716/
• 《设计模式之美》
  https://time.geekbang.org/column/intro/250
• 维基百科Strategy pattern词条
  https://en.wikipedia.org/wiki/Strategy_pattern

Hadoop 分布式计算框架 MapReduce

点击阅读原文查看详情！