JAVA代码优化

通过常用的设计模式优化常见的ifelse

策略模式优化

策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化

假设当前有个报表查询需求，需要根据不同的日期选择走不同的查询逻辑，比如历史查询，当天实时查询，历史+当天的混合查询。

业务代码

// 
public interface ReportDetailService<T> {
	/**
	 * 查询报表查询时间类型 
	 */
    String queryTimeType();

    /**
     * 处理分页查询出来商品数据
     */
    DataPage<T> handleProductInfo(ProductReportDTO productReportDto, Page page);
}

@Component
@Slf4j
public class ReportDetailCurrentServiceImpl implements ReportDetailService<ReportDetailVO>{
    //获取报表查询类型
    @Override
    public String queryTimeType() {
        return ReportQueryTimeTypeEnum.CURRENT.getKey();
    }
    
    //具体查询方法
    @Override
    public DataPage<ReportDetailVO> handleProductInfo(ProductReportDTO productReportDto, Page page) {
        DataPage<ReportDetailVO> now = biz.query(productReportDto,page)
        return now;
    }

@Component
@Slf4j
public class ReportDetailHistoryServiceImpl implements ReportDetailService<ReportDetailVO>{
    //获取报表查询类型
    @Override
    public String queryTimeType() {
        return ReportQueryTimeTypeEnum.HISTORY.getKey();
    }
    
    //具体查询方法
    @Override
    public DataPage<ReportDetailVO> handleProductInfo(ProductReportDTO productReportDto, Page page) {
        DataPage<ReportDetailVO> history = biz.query(productReportDto,page)
        return history;
    }
    
@Component
@Slf4j
public class ReportDetailMixServiceImpl implements ReportDetailService<ReportDetailVO>{
    //获取报表查询类型
    @Override
    public String queryTimeType() {
        return ReportQueryTimeTypeEnum.MIX.getKey();
    }
    
    //具体查询方法
    @Override
    public DataPage<ReportDetailVO> handleProductInfo(ProductReportDTO productReportDto, Page page) {
        DataPage<ReportDetailVO> mix= biz.query(productReportDto,page)
        return mix;
    }

策略核心代码

@Component
@Slf4j
public class ReportDetailFactory implements ApplicationContextAware {

    /**
     * 策略实现类map
     */
    private Map<String, ReportDetailService> concurrentHashMap = new ConcurrentHashMap<>(8);

    /**
     * 策略实现类注入到map
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, ReportDetailService> tempMap = applicationContext.getBeansOfType(ReportDetailService.class);
         tempMap.values().forEach(service ->
                concurrentHashMap.put(service.queryTimeType(), service));
    }

  public DataPage<ReportDetailVO> handleProductInfo(String queryTimeType,ProductReportDTO productReportDto, Page page) {
        ReportDetailService report = concurrentHashMap.get(queryTimeType);
        DataPage<ReportDetailService> page = new DataPage<>();
        if (report != null) {
            page = report.handleProductInfo(productReportDto, page);
        }else {
            log.error("未找到报表查询策略");
        }
        return page;
    }

实际调用伪代码

@Service
public class ProductReportServiceImpl{
   @Autowired
   private ReportDetailFactory factory;

   public DataPage<ReportDetailVO> queryMethod(ProductReportDTO productReportDto, Page page){
     if (hisFlag) {
       return factory.handleProductInfo(ReportQueryTimeTypeEnum.HISTORY.getKey(), page);
     } else if(CurFlag){
       return factory.handleProductInfo(ReportQueryTimeTypeEnum.CURRENT.getKey(), page);
     } else {
       return factory.handleProductInfo(ReportQueryTimeTypeEnum.MIX.getKey(), page);
     }
  
   }
}

工厂模式优化

假设当前有个支付需求，需要根据不同的支付方式走不同的支付逻辑，比如现金支付，三方支付，刷卡支付。
业务代码

public interface OrderPayService {
    /**
     * 获取对应订单支付模块相关的操作枚举
     **/
    PayTypeOperateEnum getPayTypeOperateEnum();

    /**
     *  处理不同类型支付订单
     */
    ApiResponse handlePayData(Long payType, OrderInfo order);
}

@Service
public class OrderPayCashServiceImpl implements OrderPayService {
    //获取对应订单支付相关的操作枚举
    @Override
    public PayTypeOperateEnum getPayTypeOperateEnum() {
        return PayTypeOperateEnum.CASH_PAY;
    }

    @Override
    public ApiResponse handlePayData(Long payType,OrderInfo order) {
      // 处理实际订单支付业务代码
    }
}

@Service
public class OrderPayThirdServiceImpl implements OrderPayService {
    //获取对应订单支付相关的操作枚举
    @Override
    public PayTypeOperateEnum getPayTypeOperateEnum() {
        return PayTypeOperateEnum.THIRD_PAY;
    }

    @Override
    public ApiResponse handlePayData(Long payType,OrderInfo order) {
      // 处理实际订单支付业务代码
    }
}

@Service
public class OrderPayCardServiceImpl implements OrderPayService {
    //获取对应订单支付相关的操作枚举
    @Override
    public PayTypeOperateEnum getPayTypeOperateEnum() {
        return PayTypeOperateEnum.CARD_PAY;
    }

    @Override
    public ApiResponse handlePayData(Long payType,OrderInfo order) {
      // 处理实际订单支付业务代码
    }
}

工厂核心代码

/**
 * 描述：订单类型服务工厂
 */
public interface OrderPayTypeFactory {
    /**
     * 获取订单支付服务
     **/
    OrderPayService getOrderPayServiceByPayType(Long payType);
}


/**
 * 描述：订单类型服务工厂
 */
@Component
public class OrderPayTypeFactoryImpl implements OrderPayTypeFactory, BeanPostProcessor {
    /**
     * 订单支付服务工厂
     */
    private ConcurrentHashMap<Long, OrderPayService> orderServiceHolder = new ConcurrentHashMap<>(8);

    @Override
    public OrderPayService getOrderPayUnionServiceByPayType(Long payType) {
        EnumsUtil.notNull(PayTypeOperateEnum.getPayTypeForType(payType), "操作类型不匹配，获取订单服务失败");
        return orderServiceHolder.get(payType);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof OrderPayService) {
            OrderPayService orderService = (OrderPayService) bean;
            orderServiceHolder.put(orderService.getPayTypeOperateEnum().getType(), orderService);
        }
        return bean;
    }
}

实际调用伪代码

@Service
public class OrderInfoServiceImpl {
    @Autowired
    private OrderPayTypeFactory orderPayTypeFactory;
    
    @Transactional(rollbackFor = Exception.class)
    public ApiResponse pay(Long payType,OrderInfo order) {
        // 第三方支付
        if (payType.longValue() == payTypeEnum.THIRD.getType().longValue() ) {
            OrderPayService orderPayService = orderPayTypeFactory.getOrderPayServiceByPayType(payType);
            return orderPayService .handlePayData( payType,order);
        }

        // 现金支付
        if (payType.longValue() == payTypeEnum.CASH.getType().longValue() ) {
            OrderPayService orderPayService = orderPayTypeFactory.getOrderPayServiceByPayType(payType);
            return orderPayService .handlePayData(payType,order);
        }

        // 刷卡
        if (payType.longValue() == payTypeEnum.CARD.getType().longValue() ) {
            OrderPayService orderPayService = orderPayTypeFactory.getOrderPayServiceByPayType(payType);
            return orderPayService .handlePayData(payType,order);
        }
}

持续更新…