如何从业务代码中抽离出可复用的微组件

背景

很多业务代码,掺杂着一些通用的大段逻辑;容易导致的后果是,当需要类似功能时,不得不重新写一道,或者复制出几乎相同的代码块,让系统的无序性蹭蹭蹭往上涨。

具有良好抽象思维的有心的开发者,则会仔细观察到这种现象,将这些通用的大块逻辑抽离出来,做成一个可复用的微组件,使得以后再做类似的事情,只需要付出很小的工作即可。

那么,如何从业务代码中抽离出可复用的微组件,使得一类事情只需要做一次,今后可以反复地复用呢? 本文将以一个例子来说明。

在业务开发中,常常需要根据一批 id 查到相对应的 name 。比如根据一批员工ID查到员工的姓名,根据一批类目ID查到类目的名称,诸如此类。从叙述上看,就能感受到其中的相似性,那么如何将这种相似性抽离出来呢?

初步代码

假设要根据一批类目ID来获取相应的类目名称。大多数开发者都可以写出满足业务需求的代码:

@Component("newCategoryCache")
public class NewCategoryCache {
  private static Logger logger = LoggerFactory.getLogger(NewCategoryCache.class);

  /**
   * 类目ID与名称映射关系的缓存
   * 假设每个类目信息 50B , 总共 50000 个类目,
   * 那么总占用空间 2500000B = 2.38MB 不会造成影响
   */
  private Map<Long, String> categoryCache = new ConcurrentHashMap<>();

  @Resource
  private CategoryBackService categoryBackService;

  @Resource
  private MultiTaskExecutor multiTaskExecutor;

  public Map<Long, String> getCategoryMap(List<Long> categoryIds) {

    List<Long> undupCategoryIds = ListUtil.removeDuplicate(categoryIds);

    List<Long> unCached = new ArrayList<>();
    Map<Long,String> resultMap = new HashMap<>();
    for (Long categoryId: undupCategoryIds) {
      String categoryName = categoryCache.get(categoryId);
      if (StringUtils.isNotBlank(categoryName)) {
        resultMap.put(categoryId, categoryName);
      }
      else {
        unCached.add(categoryId);
      }
    }

    if (CollectionUtils.isEmpty(unCached)) {
      return resultMap;
    }

    Map<Long,String> uncacheCategoryMap = getCategoryMapFromGoods(unCached);
    categoryCache.putAll(uncacheCategoryMap);
    logger.info("add new categoryMap: {}", uncacheCategoryMap);
    resultMap.putAll(uncacheCategoryMap);

    return resultMap;

  }

  private Map<Long,String> getCategoryMapFromGoods(List<Long> categoryIds) {
    List<CategoryBackModel> categoryBackModels = multiTaskExecutor.exec(categoryIds,
        subCategoryIds -> getCategoryInfo(subCategoryIds), 30);
    return StreamUtil.listToMap(categoryBackModels, CategoryBackModel::getId, CategoryBackModel::getName);
  }

  private List<CategoryBackModel> getCategoryInfo(List<Long> categoryIds) {
    CategoryBackParam categoryBackParam = new CategoryBackParam();
    categoryBackParam.setIds(categoryIds);
    ListResult<CategoryBackModel> categoryResult = categoryBackService.findCategoryList(categoryBackParam);
    logger.info("categoryId: {}, categoryResult:{}", categoryIds, JSON.toJSONString(categoryResult));
    if (categoryResult == null || !categoryResult.isSuccess()) {
      logger.warn("failed to fetch category: categoryIds={}", categoryIds);
      return new ArrayList<>();
    }
    return categoryResult.getData();
  }
}

这里有两点要注意:

  1. 由于批量查询接口 CategoryBackService.findCategoryList 对参数传入的 ids 数目有限制,因此要对所有要查询的 ids 进行划分,串行或并发地去获取;
  2. 这里使用了一个线程安全的本地缓存,因为会存在多个线程同时写或读这个缓存; 之所以不用 guava 的 cache,是因为缓存的 key 只是个字符串,不是一个创建开销很大的对象。

复用改造

上述代码是典型的混合了业务和缓存微组件的样例。如果想要根据员工ID和员工姓名的映射,就不得不把上面的一部分复制出来,再写到另一个类里。这样会有不少重复工作量,而且还需要仔细编辑,把业务变量的名字替换掉,不然维护者会发现变量命名和业务含义对不上。你懂的。

有没有办法将缓存小组件的部分抽离出来呢? 要做到这一点,需要有对业务和通用组件的敏锐 sense ,能很好地将这两者区分开。

语义分离

首先要从语义上将业务和通用技术组件的逻辑分离开。

对于这个例子,可以先来审视业务部分,涉及到:

  • 一个类目对象 CategoryBackModel ,包含 id, name 属性和 getter 方法;
  • 获取一批类目对象的方法:categoryBackService.findCategoryList。
    其它的都是缓存相关的逻辑。

其次,看业务的部分多还是通用的部分多。如果是业务的部分多,就把通用的部分抽到另一个类里;如果是通用的部分多,就把业务的部分抽到另一个类。

在这个例子里,NewCategoryCache 缓存的部分占了大多数,实际上只依赖一个业务服务调用。因此,可以业务的部分抽出去。

通用抽离

模板方法是分离通用的部分与业务的部分的妙法。

接上述,getCategoryInfo 是业务部分,应该放在子类里,作为回调传给基类。可以先将这个方法抽象成 getList ,贴切表达了这个依赖要做的事情,是根据一个 id 列表获取到一个对象列表:

protected abstract List<Domain> getList(List<Long> ids);

这里 Domain 必须有 id, name 方法,因此,将 Domain 定义为一个接口:

public interface Domain {
    Long getId();
    String getName();
  }

这样,getCategoryMapFromGoods 可以写成如下形式,只依赖自己定义的接口,而不依赖具体的业务调用:

private Map<Long,String> getMapFromService(List<Long> ids) {
    List<Domain> models = multiTaskExecutor.exec(ids,
        subIds -> getList(subIds), 30);
    return StreamUtil.listToMap(models, Domain::getId, Domain::getName);
  }

然后将 NewCategoryCache 中所有的具有业务含义的名字部分(Category)去掉,就变成了:

public abstract class AbstractCache {

  private static Logger logger = LoggerFactory.getLogger(AbstractCache.class);

  @Resource
 protected MultiTaskExecutor multiTaskExecutor;

  public Map<Long, String> getMap(List<Long> ids) {

    List<Long> undupIds = ListUtil.removeDuplicate(ids);

    List<Long> unCached = new ArrayList<>();
    Map<Long,String> resultMap = new HashMap<>();
    for (Long id: undupIds) {
      String name = getCache().get(id);
      if (StringUtils.isNotBlank(name)) {
        resultMap.put(id, name);
      }
      else {
        unCached.add(id);
      }
    }

    if (CollectionUtils.isEmpty(unCached)) {
      return resultMap;
    }

    Map<Long,String> uncacheMap = getMapFromService(unCached);
    getCache().putAll(uncacheMap);
    logger.info("add new cacheMap: {}", uncacheMap);
    resultMap.putAll(uncacheMap);

    return resultMap;

  }

  private Map<Long,String> getMapFromService(List<Long> ids) {
    List<Domain> models = multiTaskExecutor.exec(ids,
        subIds -> getList(subIds), 30);
    return StreamUtil.listToMap(models, Domain::getId, Domain::getName);
  }

  protected abstract List<Domain> getList(List<Long> ids);

  protected abstract ConcurrentMap<Long,String> getCache();

  public interface Domain {
    Long getId();
    String getName();
  }

}

AbstractCache 这个类不再具有任何业务语义了。

注意: 之所以抽离出一个 getCache() 的抽象方法,是因为通常情况下不同业务的缓存是不能混用的。当然,如果 key 是带有业务前缀名字空间的值,从而有全局一致性的话,是可以只用一个缓存的。

业务抽离

接下来,可以把业务的部分新建一个类:

@Component("newCategoryCacheV2")
public class NewCategoryCacheV2 extends AbstractCache {

  private static Logger logger = LoggerFactory.getLogger(NewCategoryCacheV2.class);

  /**
   * 类目ID与名称映射关系的缓存
   * 假设每个类目信息 50B , 总共 50000 个类目,
   * 那么总占用空间 2500000B = 2.38MB 不会造成影响
   */
  private ConcurrentMap<Long, String> categoryCache = new ConcurrentHashMap<>();

  @Resource
  private CategoryBackService categoryBackService;

  public Map<Long,String> getCategoryMap(List<Long> categoryIds) {
    return getMap(categoryIds);
  }

  @Override
  public List<Domain> getList(List<Long> ids) {
    CategoryBackParam categoryBackParam = new CategoryBackParam();
    categoryBackParam.setIds(ids);
    ListResult<CategoryBackModel> categoryResult = categoryBackService.findCategoryList(categoryBackParam);
    logger.info("categoryId: {}, categoryResult:{}", ids, JSON.toJSONString(categoryResult));
    if (categoryResult == null || !categoryResult.isSuccess()) {
      logger.warn("failed to fetch category: categoryIds={}", ids);
      return new ArrayList<>();
    }
    return categoryResult.getData().stream().map( categoryBackModel -> new Domain() {
      @Override
      public Long getId() {
        return categoryBackModel.getId();
      }
      @Override
      public String getName() {
        return categoryBackModel.getName();
      }
    }).collect(Collectors.toList());
  }

  @Override
  protected ConcurrentMap<Long, String> getCache() {
    return categoryCache;
  }
}

这样,就大功告成了 ! 是不是有做成一道菜的感觉?

值得提及的是,为了彰显业务语义, newCategoryCacheV2 提供了一个 getMap 的适配包装,保证了对外服务的一致性。

单测

单测很重要。 这里贴出了上述 newCategoryCacheV2 的单测,供参考:

class NewCategoryCacheV2Test extends Specification {

    NewCategoryCacheV2 newCategoryCache = new NewCategoryCacheV2()

    CategoryBackService categoryBackService = Mock(CategoryBackService)
    MultiTaskExecutor multiTaskExecutor = new MultiTaskExecutor()

    def setup() {
        Map<Long, String> categoryCache = new ConcurrentHashMap<>()
        categoryCache.put(3188L, "qin")
        categoryCache.put(3125L, 'qun')

        newCategoryCache.categoryCache = categoryCache
        newCategoryCache.categoryBackService = categoryBackService

        ExportThreadPoolExecutor exportThreadPoolExecutor = ExportThreadPoolExecutor.getInstance(5,5,1L,1, "export")
        multiTaskExecutor.generalThreadPoolExecutor = exportThreadPoolExecutor
        newCategoryCache.multiTaskExecutor = multiTaskExecutor

    }

    @Test
    def "tesGetCategoryMap"() {
        given:
        def categoryList = [
                new CategoryBackModel(id: 1122L, name: '衣服'),
                new CategoryBackModel(id: 2233L, name: '食品')
        ]
        categoryBackService.findCategoryList(_) >> [
                code: 200,
                message: 'success',
                success: true,
                data: categoryList,
                count: 2
        ]
        categoryList

        when:
        def categoryIds = [3188L, 3125L, 3125L, 3188L, 1122L, 2233L]


        def categoryMap = newCategoryCache.getCategoryMap(categoryIds)

        then:
        categoryMap[3188L] == 'qin'
        categoryMap[3125L] == 'qun'
        categoryMap[1122L] == '衣服'
        categoryMap[2233L] == '食品'
    }
}

小结

本文用一个示例说明了,如何从业务代码中抽离出可复用的微组件,使得一类事情只需要做一次,今后可以反复地复用。这种思维和技能是可以通过持续训练强化的,对提升设计能力是很有助益的。

posted @ 2019-09-30 21:45  琴水玉  阅读(1497)  评论(0编辑  收藏  举报