【设计模式】- 策略模式-优快云博客

概念：

策略模式定义了一系列算法，并将每一个算法封装起来，使每个算法可以相互替代，使算法本身和使用算法的客户端分割开来，相互独立

工厂模式是属于创建型设计模式，主要用来针对不同类型创建不同的对象，达到解偶类对象。
策略模式是属于行为型设计模式，主要是针对不同的策略做出对应行为，达到行为解偶

结构

策略接口角色 IStrategy：用来约束一系列具体的策略算法，策略上下文角色ConcreteStategty使用此策略接口来调用具体策略所实现的算法
具体策略实现角色ConcreteStrategy：具体的策略实现，即具体的算法实现
策略上下文角色 StrategyContext：策略上下文，负责和具体的策略实现交互，通常策略上下文对象会持有一个真正的策略实现对象，策略上下文还可以让具体的策略实现从其中获取相关数据，回调策略上下文对象的方法

在这里插入图片描述

策略模式的作用

策略模式的作用：
就是把各个平等的具体实现进行抽象、封装成独立的算法类（if else中就是平等的），然后通过上下文和具体的算法类来进行交互。正是由于各个算法的平等性，所以他们才是可以相互替换的。虽然可以动态的切换各个策略，但是同一时刻只能使用一个策略

代码实现：

策略接口

//策略接口
public interface IStrategy {
    //定义的抽象算法方法 来约束具体的算法实现方法
    public void algorithmMethod();
}

具体的策略实现：

 // 具体的策略实现2
public class ConcreteStrategy2 implements IStrategy {
     //具体的算法实现
    @Override
    public void algorithmMethod() {
        System.out.println("this is ConcreteStrategy2 method...");
    }
}

 // 具体的策略实现2
public class ConcreteStrategy2 implements IStrategy {
     //具体的算法实现
    @Override
    public void algorithmMethod() {
        System.out.println("this is ConcreteStrategy2 method...");
    }
}

策略上下文

/**
 * 策略上下文
 */
public class StrategyContext {
    //持有一个策略实现的引用
    private IStrategy strategy;
    //使用构造器注入具体的策略类
    public StrategyContext(IStrategy strategy) {
        this.strategy = strategy;
    }
 
    public void contextMethod(){
        //调用策略实现的方法
        strategy.algorithmMethod();
    }
}

策略和上下文关系
策略模式中，一般情况下都是上下文持有策略的引用，以进行对具体策略的调用。但具体的策略对象也可以从上下文中获取所需数据，可以将上下文当做参数传入到具体策略中，具体策略通过回调上下文中的方法来获取所需数据

外部客户端

//外部客户端
public class Client {
    public static void main(String[] args) {
        //1.创建具体测策略实现
        IStrategy strategy = new ConcreteStrategy2();
        //2.在创建策略上下文的同时，将具体的策略实现对象注入到策略上下文当中
        StrategyContext ctx = new StrategyContext(strategy);
        //3.调用上下文对象的方法来完成对具体策略实现的回调
        ctx.contextMethod();
    }
}

策略模式的优缺点：

优点：

通过抽象、封装定义一系列算法（可相互替换平等的），为这些算法定义一个公共接口，以约束这些算法的功能实现。如果这些算法具有公共的功能，可以将接口变为抽象类，将公共功能放到抽象父类里
扩展性好：扩展策略模式只需要新增一个策略实现类，然后在策略实现的地方，使用这个新的策略实现就好了

缺点：

如果客户端来决定使用何种算法，那客户端必须知道所有的策略，清楚各个策略的功能和不同（这会暴露策略的具体实现）
增加的对象的数量：将每个具体的算法都单独封装为一个策略类，如果可选的策略有很多的话，那对象的数量也会很多

工厂模式和策略模式代码结合示例

@Data
public class ShareFactory {
		// 定义策略枚举
    enum ShareType {
        SINGLE("single", "单商品"),
        MULTI("multi", "多商品"),
        ORDER("order", "下单");
        // 场景对应的编码
        private String code;
       
        // 业务场景描述
        private String desc;
        ShareType(String code, String desc) {
            this.code = code;
            this.desc = desc;
        }
        public String getCode() {
            return code;
        }
       // 省略 get set 方法
    }
		// **定义策略map缓存，这样就可以避免if else的方式**
    private static final Map<String, ShareStrategy> shareStrategies = new       HashMap<>();
    static {
        shareStrategies.put("order", new OrderItemShare());
        shareStrategies.put("single", new SingleItemShare());
        shareStrategies.put("multi", new MultiItemShare());
    }
    // 获取指定策略
    public static ShareStrategy getShareStrategy(String type) {
        if (type == null || type.isEmpty()) {
            throw new IllegalArgumentException("type should not be empty.");
        }
        return shareStrategies.get(type);
    }
	
    public static void main(String[] args) {
        // 测试demo
        String shareType = "order";
        ShareStrategy shareStrategy = ShareFactory.getShareStrategy(shareType);
        shareStrategy.shareAlgorithm("order");
        // 输出结果：当前分享图片是order
    }
}