设计模式-策略模式

设计模式-策略模式（Stategy Pattern）

 概要

 策略模式是一种行为型模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

 策略模式结构图如下：

 

 一、 涉及的角色

 1）Strategy

定义所有支持的算法的公共接口

public interface DealStrategy {
    /**
     * 定义策略接口
     *
     * @param option 请求参数
     */
    void dealMethod(String option);
}

2）ConcreteStrategy
封装了具体的算法或行为，继承于Strategy

public class DealSina implements DealStrategy{

    /**
     * 定义策略接口
     *
     * @param option 请求参数
     */
    public void dealMethod(String option) {
        System.out.println("分享到新浪");
    }
}

3）Context
用一个ConcreteStrategy 来配置，维护一个对Strategy 对象的引用

public class DealContext {
    private final String type;
    private final DealStrategy deal;

    public DealContext(String type, DealStrategy deal) {
        this.type = type;
        this.deal = deal;
    }

    public DealStrategy getDeal(){
        return deal;
    }

    public boolean options(String type) {
        return this.type.equals(type);
    }
}

客户端调用：

public class Share {

    private static final List<DealContext> ALGORITHMS = new ArrayList<>();

    //静态代码块，先加载所有的策略
    static {
        ALGORITHMS.add(new DealContext("Sina", new DealSina()));
        ALGORITHMS.add(new DealContext("Wechat", new DealWechat()));
    }

    public static void shareOptions(String type) {
        DealStrategy dealStrategy = null;
        for (DealContext deal : ALGORITHMS) {
            if (deal.options(type)) {
                dealStrategy = deal.getDeal();
                break;
            }
        }

        Optional.ofNullable(dealStrategy).ifPresent(s -> s.dealMethod(type));
    }

    public static void main(String[] args) {
        shareOptions("Wechat");
    }
}

UML类图如下：

2.  使用场景
在Java中，比较器接口Comparator就是一个常见的策略模式实践

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

比如 Arrays.sort(numbers, new ReverseComparator());它允许我们传入一个Comparator实例来指定我们想要的策略

public class ReverseComparator implements Comparator{
  public int compare(String s1, String s2) {
      return Integer.compare(s1.length(), s2.length());
 }
}

 二、实际项目中的应用：简单工厂+策略模式结合
 UML类图如下：

定义了一个 ShowDateFactory 工厂类，用于管理和获取不同风格的 ShowDateStrategy 策略对象

public class ShowDateFactory {

    private ShowDateFactory() {}

    private static final Map<ShowDateStyleEnum, ShowDateStrategy> MAP = new HashMap<>();

    public static void setMap(ShowDateStyleEnum strategy, ShowDateStrategy showDateStrategy) {
        MAP.putIfAbsent(strategy, showDateStrategy);
    }

    public static ShowDateStrategy getMap(ShowDateStyleEnum strategy) {
        return MAP.get(strategy);
    }
}

具体策略类 FuzzyDateStyle：

@Service
public class FuzzyDateStyle implements ShowDateStrategy {
    /**
     *  将策略类注册到工厂中，以便后续可以通过工厂类获取相应的策略对象
     *
     */
    @PostConstruct
    public void init() {
        ShowDateFactory.setMap(strategySign(), this);
    }

    /**
     * 模糊时间样式
     *
     * @return String
     */
    @Override
    public ShowDateStyleEnum strategySign() {
        return ShowDateStyleEnum.SHOW_DATE_FUZZY;
    }

}

  说明：上面这段代码这段代码使用了 @PostConstruct 注解，表明该方法会在该类被 Spring 容器初始化时执行。在系统初始化的时候，策略类就会被注册到工厂，而不需要手动在其他地方显式地调用注册方法。这种自动注册的机制使得系统更加灵活，可以动态地添加新的策略类而无需修改工厂类。在使用该策略工厂时，只需要调用工厂类的相应方法就能获取到对应的策略对象。

  除了上面这种方式，还可以进行动态加载配置文件，通过反射动态地加载这些策略类、创建策略对象来实现策略模式

  1. 创建属性文件（例如 strategies.properties）
  creditCard=com.example.CreditCardPayment
  payPal=com.example.PayPalPayment

  2. 定义工厂类：PaymentStrategyFactory，以动态加载配置文件中的策略类信息

public class PaymentStrategyFactory {
    private static final Map<String, Class<? extends PaymentStrategy>> strategies = new HashMap<>();

    static {
        loadStrategies();
    }

    private static void loadStrategies() {
        Properties properties = new Properties();
        try {
            properties.load(PaymentStrategyFactory.class.getClassLoader().getResourceAsStream("strategies.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        for (String strategyName : properties.stringPropertyNames()) {
            String className = properties.getProperty(strategyName);
            try {
                Class<? extends PaymentStrategy> strategyClass = Class.forName(className).asSubclass(PaymentStrategy.class);
                strategies.put(strategyName, strategyClass);
            } catch (ClassNotFoundException | ClassCastException e) {
                e.printStackTrace();
            }
        }
    }

    public static PaymentStrategy getPaymentStrategy(String strategyName) {
        Class<? extends PaymentStrategy> strategyClass = strategies.get(strategyName);
        if (strategyClass == null) {
            throw new IllegalArgumentException("Unknown payment strategy: " + strategyName);
        }

        try {
            return strategyClass.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create payment strategy", e);
        }
    }
}

   三、算法的分析

   1.  策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
   2. 在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
   3. 策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。

  4. 在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象，这本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化地减轻了客户端的职责。

 

  四、 策略模式的使用场景

•   一个项目中有许多类，它们之间的区别仅在于它们的行为，希望动态地让一个对象在许多行为中选择一种行为时;
•   一个项目需要动态地在几种算法中选择一种时；
•   一个对象有很多的行为，不想使用多重的条件选择语句来选择使用哪个行为时。

  通过策略模式将策略的定义、创建、使用解耦，让每一部分都不至于太复杂，也去除了if...else这样的条件判断语句，代码的可维护性和可拓展性都提高了。

 

 

参考链接：

https://mp.weixin.qq.com/s/gB1nM4q9PculNVZJr9NSHA

https://design-patterns.readthedocs.io/zh-cn/latest/behavioral_patterns/strategy.html