裁员潮把我搞瞎了
小插曲
最近不是裁员潮火热嘛，了不起差点就嗝屁了。
有个部门裁掉了2个Java开发，就把了不起调过去对接工作了。
业务方向是电商，就是去各大平台拉订单，然后确认，然后发货，然后收钱。
然后我就开始了1个多月的走读代码和写代码，脑袋里充斥着亚马逊、乐天、雅虎、eaby、bigcommerce等等各大国际电商平台。
每天看着前同事维护的大量if-else逻辑，一个方法超过500行多的是，一个service类上万行代码，眼睛真的给我搞瞎了快。
大量if-else
在电商运营的开发部门中，我们需要对接不同的销售平台，每个平台的订单数据格式和处理逻辑都有所不同，这就导致了代码中出现了大量的 if-else 分支。
例如：
public void processOrder(Order order) {
if (order.getPlatform().equals("Amazon")) {
// Amazon订单处理逻辑
} else if (order.getPlatform().equals("BC")) {
// BC订单处理逻辑
} else if (order.getPlatform().equals("Lotte")) {
// Lotte订单处理逻辑
} else if (order.getPlatform().equals("Yahoo")) {
// Yahoo订单处理逻辑
} else if (order.getPlatform().equals("Google")) {
// Google订单处理逻辑
} else if (order.getPlatform().equals("eBay")) {
// eBay订单处理逻辑
} else {
throw new RuntimeException("Unsupported platform: " + order.getPlatform());
}
}
上述代码中，处理每个平台的订单逻辑都被包含在 if-else 分支中，这种代码结构不仅难以阅读和维护，而且容易出现错误。
解决方案
今天了不起就借着这个机会和大家聊一下优化的方式吧。
1. 使用多态和抽象类
我们可以使用多态和抽象类等技术，将不同平台的订单处理逻辑分别封装在不同的类中，从而避免了过多的 if-else 分支，提高了代码的可读性和可维护性。
具体来说，我们可以创建一个抽象类，用于处理所有平台的订单数据。
然后，在该抽象类中，我们可以定义一个抽象方法，用于处理订单数据。
接下来，我们可以为每个平台创建一个具体的子类，在子类中实现抽象方法，并根据平台的特定需求处理订单数据。
例如：
public abstract class OrderProcessor {
public abstract void processOrder(Order order);
}
public class AmazonOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// Amazon订单处理逻辑
}
}
public class BCOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// BC订单处理逻辑
}
}
public class LotteOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// Lotte订单处理逻辑
}
}
public class YahooOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// Yahoo订单处理逻辑
}
}
public class GoogleOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// Google订单处理逻辑
}
}
public class eBayOrderProcessor extends OrderProcessor {
public void processOrder(Order order) {
// eBay订单处理逻辑
}
}
通过这种方式，我们可以将不同平台的订单处理逻辑分别封装在不同的类中，从而避免了过多的 if-else 分支，提高了代码的可读性和可维护性。
2. 使用策略模式
我们可以使用策略模式，将不同平台的订单处理逻辑封装在不同的策略类中，从而避免了过多的 if-else 分支，提高了代码的可读性和可维护性。
具体来说，我们可以创建一个 OrderProcessor 接口，用于处理所有平台的订单数据。
接着，我们可以为每个平台创建一个具体的 OrderProcessor 实现类，在实现类中根据平台的特定需求处理订单数据。
例如：
public interface OrderProcessor {
void processOrder(Order order);
}
public class AmazonOrderProcessor implements OrderProcessor {
publicvoid processOrder(Order order) {
// Amazon订单处理逻辑
}
}
public class BCOrderProcessor implements OrderProcessor {
public void processOrder(Order order) {
// BC订单处理逻辑
}
}
public class LotteOrderProcessor implements OrderProcessor {
public void processOrder(Order order) {
// Lotte订单处理逻辑
}
}
public class YahooOrderProcessor implements OrderProcessor {
public void processOrder(Order order) {
// Yahoo订单处理逻辑
}
}
public class GoogleOrderProcessor implements OrderProcessor {
public void processOrder(Order order) {
// Google订单处理逻辑
}
}
public class eBayOrderProcessor implements OrderProcessor {
public void processOrder(Order order) {
// eBay订单处理逻辑
}
}
接着，我们可以创建一个 OrderProcessorContext 类，用于根据订单平台类型选择对应的 OrderProcessor 实现类，并调用对应的 processOrder 方法处理订单数据。
例如：
public class OrderProcessorContext {
private OrderProcessor orderProcessor;
public OrderProcessorContext(OrderProcessor orderProcessor) {
this.orderProcessor = orderProcessor;
}
public void processOrder(Order order) {
orderProcessor.processOrder(order);
}
}
最后，我们可以在调用 processOrder 方法之前，根据订单平台类型创建对应的 OrderProcessor 实现类，并将其传递给 OrderProcessorContext 对象。
例如：
publicvoidprocessOrder(Order order){
OrderProcessor orderProcessor;
if (order.getPlatform().equals("Amazon")) {
orderProcessor = new AmazonOrderProcessor();
} elseif (order.getPlatform().equals("BC")) {
orderProcessor = new BCOrderProcessor();
} elseif (order.getPlatform().equals("Lotte")) {
orderProcessor = new LotteOrderProcessor();
} elseif (order.getPlatform().equals("Yahoo")) {
orderProcessor = new YahooOrderProcessor();
} elseif (order.getPlatform().equals("Google")) {
orderProcessor = new GoogleOrderProcessor();
} elseif (order.getPlatform().equals("eBay")) {
orderProcessor = new eBayOrderProcessor();
} else {
thrownew RuntimeException("Unsupported platform: " + order.getPlatform());
}
OrderProcessorContext context = new OrderProcessorContext(orderProcessor);
context.processOrder(order);
}
通过这种方式，我们可以根据订单平台类型动态创建对应的 OrderProcessor 实现类，并使用 OrderProcessorContext 对象来调用对应的 processOrder 方法处理订单数据。
这种方式可以避免冗长的 if-else 分支，提高代码的可读性和可维护性。
3. 使用工厂模式
我们可以使用工厂模式，将不同平台的订单处理逻辑封装在不同的工厂类中，从而避免了过多的 if-else 分支，提高了代码的可读性和可维护性。
具体来说，我们可以创建一个 OrderProcessor 接口，用于处理所有平台的订单数据。
接着，我们可以为每个平台创建一个具体的 OrderProcessor 实现类，在实现类中根据平台的特定需求处理订单数据。
然后，我们可以创建一个 OrderProcessorFactory 接口，用于根据订单平台类型选择对应的 OrderProcessor 实现类，并返回相应的 OrderProcessor 对象。
例如：
publicinterfaceOrderProcessorFactory{
OrderProcessor createOrderProcessor();
}
publicclassAmazonOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew AmazonOrderProcessor();
}
}
publicclassBCOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew BCOrderProcessor();
}
}
publicclassLotteOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew LotteOrderProcessor();
}
}
publicclassYahooOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew YahooOrderProcessor();
}
}
publicclassGoogleOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew GoogleOrderProcessor();
}
}
publicclasseBayOrderProcessorFactoryimplementsOrderProcessorFactory{
public OrderProcessor createOrderProcessor(){
returnnew eBayOrderProcessor();
}
}
最后，我们可以在调用 processOrder 方法之前，根据订单平台类型创建对应的 OrderProcessorFactory 实现类，并调用 createOrderProcessor 方法创建对应的 OrderProcessor 对象来处理订单数据。
例如：
publicvoidprocessOrder(Order order){
OrderProcessorFactory factory;
if (order.getPlatform().equals("Amazon")) {
factory = new AmazonOrderProcessorFactory();
} elseif (order.getPlatform().equals("BC")) {
factory = new BCOrderProcessorFactory();
} elseif (order.getPlatform().equals("Lotte")) {
factory = new LotteOrderProcessorFactory();
} elseif (order.getPlatform().equals("Yahoo")) {
factory = new YahooOrderProcessorFactory();
} elseif (order.getPlatform().equals("Google")) {
factory = new GoogleOrderProcessorFactory();
} elseif (order.getPlatform().equals("eBay")) {
factory = new eBayOrderProcessorFactory();
} else {
thrownew RuntimeException("Unsupported platform: " + order.getPlatform());
}
OrderProcessor orderProcessor = factory.createOrderProcessor();
orderProcessor.processOrder(order);
}
通过这种方式，我们可以根据订单平台类型动态创建对应的 OrderProcessor 对象，并使用该对象来处理订单数据。
这种方式可以避免冗长的 if-else 分支，提高代码的可读性和可维护性。
总结
在处理大量的 if-else 分支时，我们可以使用多态和抽象类、策略模式或工厂模式等技术来优化代码，从而提高代码的可读性和可维护性。
在使用多态和抽象类时，我们需要创建一个抽象类，用于处理所有平台的订单数据。
然后，我们可以为每个平台创建一个具体的子类，在子类中实现抽象方法，并根据平台的特定需求处理订单数据。
在使用策略模式时，我们可以创建一个 OrderProcessor 接口，用于处理所有平台的订单数据。接着，我们可以为每个平台创建一个具体的 OrderProcessor 实现类，在实现类中根据平台的特定需求处理订单数据。
然后，我们可以创建一个 OrderProcessorContext 类，用于根据订单平台类型选择对应的 OrderProcessor 实现类，并调用对应的 processOrder 方法处理订单数据。
在使用工厂模式时，我们可以创建一个 OrderProcessorFactory 接口，用于根据订单平台类型选择对应的 OrderProcessor 实现类，并返回相应的 OrderProcessor 对象。
然后，我们可以在调用 processOrder 方法之前，根据订单平台类型创建对应的 OrderProcessorFactory 实现类，并调用 createOrderProcessor 方法创建对应的 OrderProcessor 对象来处理订单数据。
综上所述，我们可以根据具体的业务需求和代码特点来选择适合的优化方式来消灭过多的 if-else 分支，提高代码的可读性和可维护性。
好了，今天了不起就跟大家简单聊了一下通过设计模式消灭多余的if-else，希望对大家有所帮助。
腾讯云开发者
