工作中巧用了这几个设计模式重构代码，女同事直呼666

public boolean canConsume(String uid, String shopId, String supplierId) {
        /* 获取用户信息，用户信息包含类型（student：学生，teacher：老师，unknown：未知用户）、名族（han：汉族，mg：蒙古族） */
        UserInfo userInfo = getUserInfo(uid);
        /* 获取消费限制信息，限制信息包含是否允许非清真消费、每种类型的用户是否允许消费以及允许消费的次数 */
        ConsumeConfigInfo consumeConfigInfo = getConsumeConfigInfo(shopId, supplierId)


        /* 构造消费限制过滤器链条 */
        ConsumeLimitFilterChain filterChain = new ConsumeLimitFilterChain();
        filterChain.addFilter(new SpecificCardUserConsumeLimitFilter());
        filterChain.addFilter(new DayConsumeTimesConsumeLimitFilter());
        filterChain.addFilter(new MuslimConsumeLimitFilter());
        boolean checkResult = filterChain.doFilter(filterChain, schoolMemberInfo, consumeConfigInfo);

}

  /* filterChain.doFilter方法 */
  public boolean doFilter(ConsumeLimitFilterChain filterChain, UserInfo userInfo,
                          ConsumeConfigInfo consumeConfigInfo) {
    /* 迭代调用过滤器 */
    if (index < filters.size()) {
      return (filters.get(index++).doFilter(filterChain, userInfo, consumeConfigInfo));
    }
  }


  /* SpecificCardUserConsumeLimitFilter.doFilter方法 */
  public boolean doFilter(ConsumeLimitFilterChain filterChain, UserInfo userInfo,
                          ConsumeConfigInfo consumeConfigInfo) {
    /* 获取某一类型的消费限制，比如student允许消费，unknown不允许消费 */
    CardConsumeConfig cardConsumeConfig = findSuitCardConfig(userInfo, consumeConfigInfo);

    /* 判断当前卡用户是否允许消费 */
    if (consumeCardConfig != null) {
      if ((!CAN_PAY.equals(cardConsumeConfig.getEnabledPay()))) {
        return (false);
      }
    }

    /* 其余情况，继续往后传递 */
    return (filterChain.doFilter(filterChain, memberInfo, consumeConfig));
  }


  /* DayConsumeTimesConsumeLimitFilter.doFilter方法 */
  public boolean doFilter(ConsumeLimitFilterChain filterChain, UserInfo userInfo,
                          ConsumeConfigInfo consumeConfigInfo) {
    /* 获取某一类型的消费限制，比如student可以消费2次 */
    CardConsumeConfig cardConsumeConfig = findSuitCardConfig(userInfo, consumeConfigInfo);

    /* 获取当前用户今天的消费次数 */
    int consumeCnt = getConsumeCnt(userInfo)
      if (consumeCnt >= cardConsumeConfig.getDayConsumeTimesLimit()) {
        return (false);
      }

    /* 其余情况，继续往后传递 */
    return (filterChain.doFilter(filterChain, memberInfo, consumeConfig));
  }

/**
 * 推送策略
 */
public interface PushStrategy {
 /**
         @param deviceVO设备对象，包扣设备sn，信鸽pushid
         @param content，推送内容，一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content);
}

IotPushStrategy implements PushStrategy{
        /**
         @param deviceVO设备对象，包扣设备sn，信鸽pushid
         @param content，推送内容，一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content){
            //创建自研推送平台需要的推送报文
            Message message = createPushMsg(deviceVO，content);

            //调用推送平台推送接口
            IotMessageService.pushMsg(message);
        }
}

XingePushStrategy implements PushStrategy{
        /**
         @param deviceVO设备对象，包扣设备sn，信鸽pushid
         @param content，推送内容，一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content){
            //创建信鸽平台需要的推送报文
            JSONObject jsonObject = createPushMsg(content);

            //调用推送平台推送接口
            if(!XinggePush.pushMsg(message)){
                //降级到长轮询
                ...
            }
        }
}

/**
消息推送Service
*/
MessagePushService{
    pushMsg(AppDeviceVO deviceVO, Object content){
        if(A设备){
            XingePushStrategy.push(deviceVO,content);
        } else if(B设备）{
            IotPushStrategy.push(deviceVO,content);
        }
    }
}

abstract class AbstractPushStrategy implements PushStrategy{
    @Override
    public CallResult push(AppDeviceVO deviceVO, Object content) {
        //1.构造span
        Span span = buildSpan();
        //2.具体通道推送逻辑由子类实现
        CallResult callResult = doPush(deviceVO, content);

        //3.是否允许重试逻辑由子类实现，如果允许执行重试逻辑
        if(!callResult.isSuccess() && canRetry()){
            doPush(deviceVO, content);
        }

        //4.trace结束
        span.finish()
    }

    //具体推送逻辑由子类实现
    protected abstract CallResult doPush(AppDeviceVO deviceDO, Object content) ;

    //是否允许重试由子类实现，有些通道之前没有做消息排重，所有不能重试
    protected abstract boolean canRetry(CallResult callResult);

}

XingePushStrategy extends AbstractPushStrategy{
    @Override
    protected CallResult doPush(AppDeviceVO deviceDO, Object content) {
        //执行推送逻辑
    }

    @Override
    protected boolean canRetry(CallResult callResult){
        return false
    }
}

/**
支付回调处理者
*/
PayCallBackController implements ApplicationContextAware {
     private ApplicationContext applicationContext;

    //如果想获取applicationContext需要实现ApplicationContextAware接口，Spring容器会回调setApplicationContext方法将applicationContext注入进来
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        this.applicationContext = applicationContext;
    }
     @RequestMapping(value = "/pay/callback.do")
     public View callback(HttpServletRequest request){
        if(paySuccess(request){
            //构造支付成功事件
            PaySuccessEvent event = buildPaySuccessEvent(...);
            //通过applicationContext发布事件，从而达到通知观察者的目的
            this.applicationContext.publishEvent(event);
        }
    }
}
/**
 * 语音播报处理者
 *
 */
public class VoiceBroadcastHandler implements ApplicationListener<PaySuccessEvent>{
    @Override
    public void onApplicationEvent(PaySuccessEvent event) {
        //语音播报逻辑
    }
}

//其他处理者的逻辑类似

/**
可以自动携带trace上下文的Runnable装饰器
*/
public class TraceRunnableWrapper implements Runnable{
    //被包装的目标对象
    private Runnable task;
    private Span parentSpan = null;

    public TraceRunnableWrapper(Runnable task) {
        //1.获取当前线程的上下文（因为new的时候还没有发生线程切换，所以需要在这里将上下文获取）
        //对这块代码感兴趣的可以查看opentracing API
        io.opentracing.Scope currentScope = GlobalTracer.get().scopeManager().active();
        //2.保存父上下文
        parentSpan = currentScope.span();
        this.task = task;
    }

    @Override
    public void run() {
        //run的时候将父线程的上下文绑定到当前线程
        io.opentracing.Scope scope = GlobalTracer.get().scopeManager().activate(parentSpan,false);
        task.run();
    }
}

//使用者
new Thread(new Runnable(){run(...)}).start()替换为new TraceRunnableWrapper(new Runnable(){run(...)}).start()

使用者：
HttpClient.doPost("/gateway.do","{'method':'trade.create','sign':'wxxaaa','timestamp':'15311111111'},'bizContent':'业务参数'")

GatewayController:
@RequestMapping("/gateway.do")
JSON gateway(HttpServletRequest req){
   //1.组装开放请求
   OpenRequest openRequest = buildOpenRequest(req);

   OpenResponse openResponse = null;
   //2.请求路由
   if("trade.create".equals(openRequest.getMethod()){
       //proxy to trade service by dubbo
       openResponse = TradeFacade.execute(genericParam);
   } else if("iot.message.push".equals(openRequest.getMethod()){
       //proxy to iot service by httpclient
        openResponse = HttpClient.doPost('http://iot.service/generic/execute'genericParam);
   }

   if(openResponse.isSuccess()){
        return {"code":"10000","bizContent":openResponse.getResult()};
   }else{
        return {"code":"20000","bizCode":openResponse.getCode()};
   }


}