使用工厂模式提高代码的可扩展性

在软件开发过程中，我们经常会面临需求改变或新功能添加的情况。为了更好地应对这些变化，代码的可扩展性是非常重要的。而使用工厂模式是提高代码可扩展性的一种常用技巧。本文将介绍工厂模式的概念和使用场景，并通过代码重构的示例来说明如何使用工厂模式提高代码的可扩展性。

什么是工厂模式？

工厂模式是一种创建型设计模式，它提供了一种将对象的创建过程封装起来的方式。通过将对象的创建交给工厂类来处理，客户端可以通过调用工厂类的方法而不需要直接实例化对象。这样做有以下几个优点：

• 解耦：客户端不需要知道具体的产品类，只需要与工厂类进行交互即可。
• 可扩展性：在需要添加新产品时，只需要修改工厂类而不需要修改客户端代码。
• 单一职责：工厂类负责创建对象，客户端负责使用对象，各自担当一个职责。

工厂模式的使用场景

工厂模式通常适用于以下场景：

• 当一个类的创建逻辑比较复杂，需要动态地根据条件来创建不同的实例。
• 当客户端需要通过一个统一的接口来创建对象，但不关心具体的实现细节。
• 当需要对客户端隐藏具体产品的实现细节。

代码重构示例

假设我们正在开发一个电商平台，需要实现一个购物车模块。最初的代码实现如下：

public class ShoppingCart {
    private Map<String, Integer> items;
    
    public ShoppingCart() {
        items = new HashMap<>();
    }
    
    public void addItem(String productId, int quantity) {
        if (items.containsKey(productId)) {
            items.put(productId, items.get(productId) + quantity);
        } else {
            items.put(productId, quantity);
        }
    }
    
    public void removeItem(String productId) {
        items.remove(productId);
    }
    
    public void checkout() {
        // 实现购物车结算逻辑
    }
}

这段代码实现了一个购物车类，简单地管理了商品和数量的关系。然而，随着业务的发展，我们需要实现多种类型的购物车，比如普通购物车、VIP购物车、限时折扣购物车等。如果简单地在购物车类中添加条件判断来处理这些不同的购物车类型，将会使代码变得复杂且难以维护。

为了提高代码的可扩展性，我们可以使用工厂模式来重构购物车类的代码。首先，定义一个通用的购物车接口：

public interface ShoppingCart {
    void addItem(String productId, int quantity);
    void removeItem(String productId);
    void checkout();
}

然后，创建不同类型购物车的具体实现类：

public class NormalShoppingCart implements ShoppingCart {
    private Map<String, Integer> items;
    
    public NormalShoppingCart() {
        items = new HashMap<>();
    }
    
    @Override
    public void addItem(String productId, int quantity) {
        if (items.containsKey(productId)) {
            items.put(productId, items.get(productId) + quantity);
        } else {
            items.put(productId, quantity);
        }
    }
    
    @Override
    public void removeItem(String productId) {
        items.remove(productId);
    }
    
    @Override
    public void checkout() {
        // 实现普通购物车的结算逻辑
    }
}

public class VipShoppingCart implements ShoppingCart {
    private Map<String, Integer> items;
    
    public VipShoppingCart() {
        items = new HashMap<>();
    }
    
    @Override
    public void addItem(String productId, int quantity) {
        if (items.containsKey(productId)) {
            items.put(productId, items.get(productId) + quantity);
        } else {
            items.put(productId, quantity);
        }
    }
    
    @Override
    public void removeItem(String productId) {
        items.remove(productId);
    }
    
    @Override
    public void checkout() {
        // 实现VIP购物车的结算逻辑
    }
}

最后，创建一个工厂类来统一创建购物车对象：

public class ShoppingCartFactory {
    public static ShoppingCart createShoppingCart(String type) {
        switch (type) {
            case "normal":
                return new NormalShoppingCart();
            case "vip":
                return new VipShoppingCart();
            default:
                throw new IllegalArgumentException("Unsupported shopping cart type: " + type);
        }
    }
}

有了工厂模式后，客户端代码可以通过工厂类来创建购物车对象，而不需要直接实例化具体的实现类：

public class Client {
    public static void main(String[] args) {
        ShoppingCart normalCart = ShoppingCartFactory.createShoppingCart("normal");
        normalCart.addItem("12345", 2);
        normalCart.checkout();
        
        ShoppingCart vipCart = ShoppingCartFactory.createShoppingCart("vip");
        vipCart.addItem("67890", 5);
        vipCart.checkout();
    }
}

这样，当需要新增购物车类型时，只需要在工厂类中添加相应的创建逻辑即可，而不需要修改客户端的代码，实现了代码的可扩展性。

总结：工厂模式通过将对象的创建过程封装起来，实现了代码的解耦、可扩展性和单一职责。通过代码重构示例，我们看到了工厂模式是如何提高代码的可扩展性。使用工厂模式可以帮助我们更好地应对需求变化和新增功能的情况，使代码更加灵活和易于维护。

本文来自极简博客，作者：科技前沿观察，转载请注明原文链接：使用工厂模式提高代码的可扩展性