关于springboot:干掉-重复代码-的技巧有哪些

软件工程师和码农最大的区别就是平时写代码时习惯问题，码农很喜爱写反复代码而软件工程师会利用各种技巧去干掉反复的冗余代码。
业务同学埋怨业务开发没有技术含量，用不到设计模式、Java 高级个性、OOP，平时写代码都在堆 CRUD，个人成长无从谈起。
其实，我认为不是这样的。设计模式、OOP 是前辈们在大型项目中积攒下来的教训，通过这些方法论来改善大型项目的可维护性。反射、注解、泛型等高级个性在框架中大量应用的起因是，框架往往须要以同一套算法来应答不同的数据结构，而这些个性能够帮忙缩小反复代码，晋升我的项目可维护性。
在我看来，可维护性是大型项目成熟度的一个重要指标，而晋升可维护性十分重要的一个伎俩就是缩小代码反复。那为什么这样说呢？

如果多处反复代码实现完全相同的性能，很容易批改一处遗记批改另一处，造成 Bug
有一些代码并不是齐全反复，而是类似度很高，批改这些相似的代码容易改（复制粘贴）错，把本来有区别的中央改为了一样。

明天，我就从业务代码中最常见的三个需要开展，聊聊如何应用 Java 中的一些高级个性、设计模式，以及一些工具打消反复代码，能力既优雅又高端。通过明天的学习，也心愿扭转你对业务代码没有技术含量的认识。

1. 利用工厂模式 + 模板办法模式，打消 if…else 和反复代码
   假如要开发一个购物车下单的性能，针对不同用户进行不同解决：

普通用户须要收取运费，运费是商品价格的 10%，无商品折扣；
VIP 用户同样须要收取商品价格 10% 的快递费，但购买两件以上雷同商品时，第三件开始享受肯定折扣；
外部用户能够免运费，无商品折扣。

咱们的指标是实现三种类型的购物车业务逻辑，把入参 Map 对象（Key 是商品 ID，Value 是商品数量），转换为出参购物车类型 Cart。
先实现针对普通用户的购物车解决逻辑：
// 购物车
@Data
public class Cart {
  // 商品清单
  private List<Item> items = new ArrayList<>();
  // 总优惠
  private BigDecimal totalDiscount;
  // 商品总价
  private BigDecimal totalItemPrice;
  // 总运费
  private BigDecimal totalDeliveryPrice;
  // 应酬总价
  private BigDecimal payPrice;
}
// 购物车中的商品
@Data
public class Item {
  // 商品 ID
  private long id;
  // 商品数量
  private int quantity;
  // 商品单价
  private BigDecimal price;
  // 商品优惠
  private BigDecimal couponPrice;
  // 商品运费
  private BigDecimal deliveryPrice;
}
// 普通用户购物车解决
public class NormalUserCart {
  public Cart process(long userId, Map<Long, Integer> items) {
      Cart cart = new Cart();
​
      // 把 Map 的购物车转换为 Item 列表
      List<Item> itemList = new ArrayList<>();
      items.entrySet().stream().forEach(entry -> {
          Item item = new Item();
          item.setId(entry.getKey());
          item.setPrice(Db.getItemPrice(entry.getKey()));
          item.setQuantity(entry.getValue());
          itemList.add(item);
      });
      cart.setItems(itemList);
​
      // 解决运费和商品优惠
      itemList.stream().forEach(item -> {
          // 运费为商品总价的 10%
          item.setDeliveryPrice(item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())).multiply(new BigDecimal(“0.1”)));
          // 无优惠
          item.setCouponPrice(BigDecimal.ZERO);
      });
​
      // 计算商品总价
      cart.setTotalItemPrice(cart.getItems().stream().map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 计算运费总价
      cart.setTotalDeliveryPrice(cart.getItems().stream().map(Item::getDeliveryPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 计算总优惠
      cart.setTotalDiscount(cart.getItems().stream().map(Item::getCouponPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 应酬总价 = 商品总价 + 运费总价 - 总优惠
      cart.setPayPrice(cart.getTotalItemPrice().add(cart.getTotalDeliveryPrice()).subtract(cart.getTotalDiscount()));
      return cart;
  }
}
复制代码
而后实现针对 VIP 用户的购物车逻辑。与普通用户购物车逻辑的不同在于，VIP 用户能享受同类商品多买的折扣。所以，这部分代码只须要额定解决多买折扣局部：
public class VipUserCart {
​
​
  public Cart process(long userId, Map<Long, Integer> items) {
      …
​
​
      itemList.stream().forEach(item -> {
          // 运费为商品总价的 10%
          item.setDeliveryPrice(item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())).multiply(new BigDecimal(“0.1”)));
          // 购买两件以上雷同商品，第三件开始享受肯定折扣
          if (item.getQuantity() > 2) {
              item.setCouponPrice(item.getPrice()
                      .multiply(BigDecimal.valueOf(100 – Db.getUserCouponPercent(userId)).divide(new BigDecimal(“100”)))
                      .multiply(BigDecimal.valueOf(item.getQuantity() – 2)));
          } else {
              item.setCouponPrice(BigDecimal.ZERO);
          }
      });
​
​
      …
      return cart;
  }
}
复制代码
最初是免运费、无折扣的外部用户，同样只是解决商品折扣和运费时的逻辑差别：
public class InternalUserCart {
​
​
  public Cart process(long userId, Map<Long, Integer> items) {
      …
​
      itemList.stream().forEach(item -> {
          // 免运费
          item.setDeliveryPrice(BigDecimal.ZERO);
          // 无优惠
          item.setCouponPrice(BigDecimal.ZERO);
      });
​
      …
      return cart;
  }
}
复制代码
比照一下代码量能够发现，三种购物车 70% 的代码是反复的。起因很简略，尽管不同类型用户计算运费和优惠的形式不同，但整个购物车的初始化、统计总价、总运费、总优惠和领取价格的逻辑都是一样的。
正如咱们开始时提到的，代码反复自身不可怕，可怕的是漏改或改错。比方，写 VIP 用户购物车的同学发现商品总价计算有 Bug，不应该是把所有 Item 的 price 加在一起，而是应该把所有 Item 的 price*quantity 加在一起。
这时，他可能会只批改 VIP 用户购物车的代码，而疏忽了普通用户、外部用户的购物车中，反复的逻辑实现也有雷同的 Bug。
有了三个购物车后，咱们就须要依据不同的用户类型应用不同的购物车了。如下代码所示，应用三个 if 实现不同类型用户调用不同购物车的 process 办法：
@GetMapping(“wrong”)
public Cart wrong(@RequestParam(“userId”) int userId) {
  // 依据用户 ID 取得用户类型
  String userCategory = Db.getUserCategory(userId);
  // 普通用户解决逻辑
  if (userCategory.equals(“Normal”)) {
      NormalUserCart normalUserCart = new NormalUserCart();
      return normalUserCart.process(userId, items);
  }
  //VIP 用户解决逻辑
  if (userCategory.equals(“Vip”)) {
      VipUserCart vipUserCart = new VipUserCart();
      return vipUserCart.process(userId, items);
  }
  // 外部用户解决逻辑
  if (userCategory.equals(“Internal”)) {
      InternalUserCart internalUserCart = new InternalUserCart();
      return internalUserCart.process(userId, items);
  }
​
  return null;
}
复制代码
电商的营销玩法是多样的，当前势必还会有更多用户类型，须要更多的购物车。咱们就只能一直减少更多的购物车类，一遍一遍地写反复的购物车逻辑、写更多的 if 逻辑吗？
当然不是，雷同的代码应该只在一处呈现！
如果咱们熟记抽象类和形象办法的定义的话，这时或者就会想到，是否能够把反复的逻辑定义在抽象类中，三个购物车只有别离实现不同的那份逻辑呢？
其实，这个模式就是模板办法模式。咱们在父类中实现了购物车解决的流程模板，而后把须要非凡解决的中央留空白也就是留形象办法定义，让子类去实现其中的逻辑。因为父类的逻辑不残缺无奈独自工作，因而须要定义为抽象类。
如下代码所示，AbstractCart 抽象类实现了购物车通用的逻辑，额定定义了两个形象办法让子类去实现。其中，processCouponPrice 办法用于计算商品折扣，processDeliveryPrice 办法用于计算运费。
public abstract class AbstractCart {
  // 解决购物车的大量反复逻辑在父类实现
  public Cart process(long userId, Map<Long, Integer> items) {
​
      Cart cart = new Cart();
​
      List<Item> itemList = new ArrayList<>();
      items.entrySet().stream().forEach(entry -> {
          Item item = new Item();
          item.setId(entry.getKey());
          item.setPrice(Db.getItemPrice(entry.getKey()));
          item.setQuantity(entry.getValue());
          itemList.add(item);
      });
      cart.setItems(itemList);
      // 让子类解决每一个商品的优惠
      itemList.stream().forEach(item -> {
          processCouponPrice(userId, item);
          processDeliveryPrice(userId, item);
      });
      // 计算商品总价
      cart.setTotalItemPrice(cart.getItems().stream().map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 计算总运费
      cart.setTotalDeliveryPrice(cart.getItems().stream().map(Item::getDeliveryPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 计算总折扣
      cart.setTotalDiscount(cart.getItems().stream().map(Item::getCouponPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
      // 计算应酬价格
      cart.setPayPrice(cart.getTotalItemPrice().add(cart.getTotalDeliveryPrice()).subtract(cart.getTotalDiscount()));
      return cart;
  }
​
  // 解决商品优惠的逻辑留给子类实现
  protected abstract void processCouponPrice(long userId, Item item);
  // 解决配送费的逻辑留给子类实现
  protected abstract void processDeliveryPrice(long userId, Item item);
}
复制代码
有了这个抽象类，三个子类的实现就非常简单了。普通用户的购物车 NormalUserCart，实现的是 0 优惠和 10% 运费的逻辑：
@Service(value = “NormalUserCart”)
public class NormalUserCart extends AbstractCart {
​
  @Override
  protected void processCouponPrice(long userId, Item item) {
      item.setCouponPrice(BigDecimal.ZERO);
  }
​
  @Override
  protected void processDeliveryPrice(long userId, Item item) {
      item.setDeliveryPrice(item.getPrice()
              .multiply(BigDecimal.valueOf(item.getQuantity()))
              .multiply(new BigDecimal(“0.1”)));
  }
}
复制代码
VIP 用户的购物车 VipUserCart，间接继承了 NormalUserCart，只须要批改多买优惠策略：
@Service(value = “VipUserCart”)
public class VipUserCart extends NormalUserCart {
​
  @Override
  protected void processCouponPrice(long userId, Item item) {
      if (item.getQuantity() > 2) {
          item.setCouponPrice(item.getPrice()
                  .multiply(BigDecimal.valueOf(100 – Db.getUserCouponPercent(userId)).divide(new BigDecimal(“100”)))
                  .multiply(BigDecimal.valueOf(item.getQuantity() – 2)));
      } else {
          item.setCouponPrice(BigDecimal.ZERO);
      }
  }
}
复制代码
外部用户购物车 InternalUserCart 是最简略的，间接设置 0 运费和 0 折扣即可：
@Service(value = “InternalUserCart”)
public class InternalUserCart extends AbstractCart {
  @Override
  protected void processCouponPrice(long userId, Item item) {
      item.setCouponPrice(BigDecimal.ZERO);
  }
​
  @Override
  protected void processDeliveryPrice(long userId, Item item) {
      item.setDeliveryPrice(BigDecimal.ZERO);
  }
}