背景

在公司的项目开发中，有时候需要用到其他同学封装的lib，由于结果比较特殊需要调用这个方法才才可以，不能直接Mock掉这个lib (由于核心是调用lib，mock后就只剩下组装参数了)，这样意义就不大了。
举例如下: 核心就在于 write 的过程了，如果 mock 之后，就没有测试的必要了，验证不了正确性。

  1. public class GlobalLogUtil {
  3.     public static final String AK_GLOBAL_TAG = "ak_global_tag";
  4.     public static final String MODULE_CODE = "module.product";
  5.     public static final String PAGE_CODE = "page.product.manager";
  6.     public static final String BASIC = "basic";
  7.     public static final String PC = "PC";
  8.     public static final String EDIT = "action.edit";
  10.     @Resource
  11.     public GlobalLogWriter logWriter;
  13.     @Async("asyncExecutor")
  14.     public void insertEditLog(LogBean logBean) {
  16.         LogTemplateRequest request = new LogTemplateRequest();
  17.         request.setTemplateCode("template.product.local.edit");
  18.         request.setAction(EDIT);
  19.         base(logBean.companyId, logBean.userId, request, logBean.relationId);
  20.         request.setTemplateType(LogTemplateType.DYNAMIC.getCode());
  21.         request.setUserName(logBean.userName);
  22.         request.setTerminalType(PC);
  23.         request.setTemplateValueList(this.buildList(logBean));
  24.         logWriter.write(request);
  25.     }
  27.     private void base(Long companyId, Long userId, LogTemplateRequest request, String relationId) {
  28.         request.setCompanyId(companyId);
  29.         request.setBusiness(BASIC);
  30.         request.setBusinessCode(AK_GLOBAL_TAG);
  31.         request.setModuleCode(MODULE_CODE);
  32.         request.setPageCode(PAGE_CODE);
  34.         request.setBusinessId(relationId);
  35.         request.setUserId(userId);
  36.         request.setDatetime(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS"));
  37.     }
  39.     private List<TemplateValue> buildList(LogBean logBean) {
  40.         List<TemplateValue> templateValueList = new ArrayList<>();
  42.         templateValueList.add(this.buildNameValue(logBean));
  43.         final DynamicLogBody first = this.buildListValue("新增标签", logBean.addList);
  44.         final DynamicLogBody second = this.buildListValue("移除标签", logBean.deleteList);
  46.         final List<DynamicLogBody> dynamicLogBodyList = Lists.newArrayList(first, second);
  47.         //插入操作日志
  48.         TemplateValue v2 = new TemplateValue();
  49.         v2.setType(LogValueType.DYNAMIC.getCode());
  50.         v2.setDynamicLogBodyList(dynamicLogBodyList);
  51.         templateValueList.add(v2);
  52.         return templateValueList;
  53.     }
  55.     private TemplateValue buildNameValue(LogBean logBean) {
  56.         TemplateValue value = new TemplateValue();
  57.         value.setType(LogValueType.ORDINARY.getCode());
  58.         value.setValue(logBean.productName);
  59.         return value;
  60.     }
  62.     private DynamicLogBody buildListValue(String key, final List<String> tagList) {
  64.         StringBuilder stringBuilder = new StringBuilder();
  65.         if (CollUtil.isNotEmpty(tagList)) {
  66.             stringBuilder.append(tagList.get(0));
  67.             if (tagList.size() != 1) {
  68.                 stringBuilder.append("】");
  69.             }
  70.             for (int i = 1; i < tagList.size() - 1; i++) {
  71.                 final String s = tagList.get(i);
  72.                 stringBuilder.append("【").append(s).append("】");
  73.             }
  74.             if (tagList.size() > 1) {
  75.                 stringBuilder.append("【").append(tagList.get(tagList.size() - 1));
  76.             }
  77.         }
  79.         List<DynamicLogValue> dynamicLogValueList = new ArrayList<>();
  80.         DynamicLogValue dynamicLogValue = new DynamicLogValue();
  81.         dynamicLogValue.setValue(stringBuilder.toString());
  82.         dynamicLogValue.setValueType(0);
  83.         dynamicLogValueList.add(dynamicLogValue);
  85.         DynamicLogBody dynamicLogBody = new DynamicLogBody();
  86.         dynamicLogBody.setKey(key);
  87.         dynamicLogBody.setValueList(dynamicLogValueList);
  89.         return dynamicLogBody;
  90.     }
  92.     @Getter
  93.     @Setter
  94.     @ToString
  95.     @Builder
  96.     @AllArgsConstructor
  97.     @NoArgsConstructor
  98.     public static class LogBean {
  99.         public String productName;
  100.         public String relationId;
  101.         public Long companyId;
  102.         public Long userId;
  103.         public String userName;
  104.         public List<String> addList;
  105.         public List<String> deleteList;
  106.     }
  107. }

然后write的内部代码逻辑是这样的

  1. @Configuration
  2. public class MessageUtil implements MessageSourceAware {
  3.     private static MessageSource messageSource;
  5.     public void setMessageSource(MessageSource messageSource) {
  6.         MessageUtil.messageSource = messageSource;
  7.     }
  9.     public static String getMessage(String message, Object[] args) {
  10.         Locale locale = LocaleContextHolder.getLocale();
  11.         return messageSource.getMessage(message, args, message, locale);
  12.     }
  13. }

这里其实就是利用的 Spring#MessageSource ， 但是在单元测试的时候因为没有被 Spring 接管，所以必然会出现空指针。

为了解决这个问题，我提前将默认的messageSource设置进去，这样即使没有被Spring接管，他也不会出现空指针，从而达到跑通单元测试的效果。

尽管这次通过这种提前到设置可以跑通，但是如果下次我们遇到的 **ResourceBundleMessageSource** 类不是public的呢，如果下次遇到的内部类怎么办。

  1. class GlobalLogUtilTest {
  2.     @Spy
  3.     private GlobalLogWriter globalLogWriter;
  4.     @InjectMocks
  5.     GlobalLogUtil globalLogUtil;
  7.     @BeforeEach
  8.     void setUp() {
  9.         MockitoAnnotations.openMocks(this);
  10.     }
  12.     @Test
  13.     void testInsertEditLog() {
  14.         //
  15.         ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
  16.         messageSource.setDefaultEncoding("UTF-8");
  17.         messageSource.addBasenames("i18n.messages");
  19.         MessageUtil messageUtil = new MessageUtil();
  20.         messageUtil.setMessageSource(messageSource);
  22.         {
  23.             final GlobalLogUtil.LogBean logBean = GlobalLogUtil.LogBean.builder()
  24.                     .productName("笑嘻嘻sku")
  25.                     .relationId("relationId")
  26.                     .companyId(911L)
  27.                     .userId(911L)
  28.                     .userName("陈顺")
  29.                     .addList(Lists.newArrayList("第三个"))
  30.                     .deleteList(Lists.newArrayList("删除第一个", "删除第三个"))
  31.                     .build();
  33.             globalLogUtil.insertEditLog(logBean);
  34.         }
  35.     }
  36. }

总结

其实我真实想要表达的是，如果对于整体的逻辑过程没有一个庖丁解牛般的认识，那么总会遇到各种各样的错误，遇到错误的时候，解决方案一定要灵活，黑猫白猫，抓到老鼠就是好猫。

今天只是一个静态字段没有设置的空指针可以提前设置上，后天如果对象不是内部类，是运行时生成的，那么该怎么去处理呢。再推而广之，今天碰到的是这样的问题，明天后天碰到其他的问题呢，解决问题要头脑灵活，要天马行空(但是要有效)。但是灵活，天马行空又是对日常问题的结果积累，思考总结。

虽然写完了，但感觉没有把我想表达的含义表述出来，也许后边我自己再来回顾也不能理解自己为什么要这么写。