设计模式觉醒系列(04)策略模式 | 简单工厂模式的升级版-优快云博客

读书笔记：在国际关系、公司发展、人际关系等领域，经常可以看到竞争关系。竞争关系一旦被确认，将出现严重的胜负欲，各自不断强调自身的正确性(也可能被迫认定对方是错的)，为了取得胜利，不择手段竞争打压对方。

竞争的关系，不能双赢，失败的很可能选择复仇报复。

而选择合作伙伴的关系，追求卓越，将给各自带来持续的良性成长机会。

一、前言背景

二、简单工厂模式

2.1 Demo案例

三、策略模式

3.1 Demo案例

四、简单工厂+策略模式->【策略工厂】融合实践

【公众号搜索：拉丁解牛说技术】欢迎一起交流讨论。

一、前言背景

在之前系列(3)里分享了工厂模式的工厂方法、抽象工厂，此外还有一个简单工厂模式没有分享。简单工厂模式是很多经典书籍里第一个分享的案例，是设计模式里最简单的模式之一。由于简单工厂模式和策略模式非常相似，今天他们结合一次讲完，如此系列2、3、4就讲完了最简单常见的10个设计模式。

二、简单工厂模式

简单工厂模式（Simple Factory pattern），又被称为静态工厂方法模式，属于创建型设计模式。当你代码里有比较多的if else，Switch的时候，就可以考虑简单工厂模式去实例化对象，或者处理不同业务逻辑。

简单工厂模式，通常用于创建实例对象。如果创建的对象比较少，可以通过工厂模式将对象的创建和使用进行分离，对客户端隐藏对象创建过程，达到解耦目标。

2.1 Demo案例

比如支付模块，根据不同支付方式进行处理。但是具体支持逻辑，需要对客户端隐藏。

支付模块：

package lading.java.designpattern.simplefactory;

/**
 * 支付接口
 */
public interface Payment {
    void pay(double amount);
}

/**
 * 阿里支付
 */
public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付: " + amount + "元");
    }
}

/**
 * 微信支付
 */
public class WechatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付: " + amount + "元");
    }
}

简单工厂方法选择支付方式：

package lading.java.designpattern.simplefactory;

/**
 * 简单工厂类
 */
public class PaymentFactory {
    public static Payment createPayment(String type) {
        if ("alipay".equalsIgnoreCase(type)) {
            return new Alipay();
        } else if ("wechatpay".equalsIgnoreCase(type)) {
            return new WechatPay();
        }
        throw new IllegalArgumentException("不支持的支付类型: " + type);
    }

    //客户端调用
    public static void main(String[] args) {
        Payment payment = PaymentFactory.createPayment("alipay");
        payment.pay(100.0);
    }
}

简单工厂模式，在创建处理逻辑对象较少的时候，非常轻便。如果是要新增更多的类型逻辑，就要修改工厂Factory，违反了开闭原则。

三、策略模式

策略模式(Strategy Pattern)属于行为型模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户，支持客户端动态切换。

相比简单工厂的扩展，策略模式更加灵活和低耦合。

3.1 Demo案例

支付策略：

package lading.java.designpattern.strategy;
/**
 * 支付策略接口
 */
public interface PaymentStrategy {
    void pay(double amount);
}


/**
 * 支付宝策略
 */
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付: " + amount + "元");
        // 具体的支付宝支付逻辑
    }
}

/**
 * 微信支付策略
 */
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付: " + amount + "元");
        // 具体的微信支付逻辑
    }
}

支付上下文和客户端调用：

package lading.java.designpattern.strategy;

/**
 * 支付上下文
 */
public class PaymentContext {
    private PaymentStrategy strategy;

    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void executePayment(double amount) {
        strategy.pay(amount);
    }

    // 可以动态切换策略
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 模拟客户端
     * @param args
     */
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext(new AlipayStrategy());
        context.executePayment(100.0);

        // 动态切换策略
        context.setStrategy(new WechatPayStrategy());
        context.executePayment(200.0);
    }
}

策略模式，成功避免工厂方法的多重条件判断、支持策略自由切换，它扩展性好，符合开闭原则。但是也有缺点，比如扩展后，策略类也会增多，而且所有策略类都需要对外暴露。

四、简单工厂+策略模式->【策略工厂】融合实践

在实际实践当中，我们可以融合简单工厂隐藏实现+策略模式支持动态切换的【策略工厂】。这种结合方式既保持了策略模式的灵活性，又通过工厂模式简化了策略对象的创建过程。

首先，基于之前的策略模式，建立一个策略工厂类：

package lading.java.designpattern.strategyfactory;

import lading.java.designpattern.strategy.AlipayStrategy;
import lading.java.designpattern.strategy.PaymentStrategy;
import lading.java.designpattern.strategy.WechatPayStrategy;

/**
 * 支付策略工厂
 */
public class PaymentStrategyFactory {
    public static PaymentStrategy createStrategy(String type) {
        if ("alipay".equalsIgnoreCase(type)) {
            return new AlipayStrategy();
        } else if ("wechatpay".equalsIgnoreCase(type)) {
            return new WechatPayStrategy();
        }
        throw new IllegalArgumentException("不支持的支付类型: " + type);
    }
}

然后构建一个策略工厂上下文，支持客户端调用：

package lading.java.designpattern.strategyfactory;

import lading.java.designpattern.strategy.PaymentStrategy;

/**
 * 结合简单工厂和策略模式
 */
public class PaymentContextWithFactory {
    private PaymentStrategy strategy;

    public PaymentContextWithFactory(String type) {
        this.strategy = PaymentStrategyFactory.createStrategy(type);
    }

    public void executePayment(double amount) {
        strategy.pay(amount);
    }

    /**
     * 模拟客户端
     * @param args
     */
    public static void main(String[] args) {
        PaymentContextWithFactory paymentFactory = new PaymentContextWithFactory("alipay");
        paymentFactory.executePayment(1000D);
    }
}

最后总结一下，简单工厂模式关注对象的创建，策略模式关注行为的封装和切换。两者结合使用可以创建出灵活且易于维护的系统。我们研发人员理解并合理运用这些设计模式，对代码质量和开发效率提升有明显帮助。

在实际项目中，没有完美的设计模式，我们需要根据具体场景选择合适的设计模式，甚至组合多种模式来解决问题。不要为了使用模式而使用模式，而是要让模式服务于我们的业务需求。