普通策略模式

我是小懒猴，人狠话不多，直接上才艺。

常规的策略模式

步骤：

• 数据DTO类
• 策略接口
• 实现策略类
• 执行器（经典的Context类）
• 实现类

数据DTO类

@Data
public class Stock {  
  
    // 股票交易代码  
    private String code;  
  
    // 现价  
    private Double price;  
  
    // 涨幅  
    private Double rise;  
}  

策略接口

public interface Strategy {
  
    /**  
     * 将股票列表排序  
     *  
     * @param source 源数据  
     * @return 排序后的榜单  
     */  
    List<Stock> sort(List<Stock> source);
}  

实现策略类

/**
 * 高价榜  
 */  
public class HighPriceRank implements Strategy {
  
    @Override  
    public List<Stock> sort(List<Stock> source) {
        return source.stream()  
                .sorted(Comparator.comparing(Stock::getPrice).reversed())
                .collect(Collectors.toList());
    }  
}  

/**
 * 高涨幅榜  
 */  
public class HighRiseRank implements Strategy {
  
    @Override  
    public List<Stock> sort(List<Stock> source) {
        return source.stream()  
                .sorted(Comparator.comparing(Stock::getRise).reversed())
                .collect(Collectors.toList());
    }  
}  

/**
 * 低价榜  
 */  
public class LowPriceRank implements Strategy {
  
    @Override  
    public List<Stock> sort(List<Stock> source) {
        return source.stream()  
                .sorted(Comparator.comparing(Stock::getPrice))
                .collect(Collectors.toList());
    }  
}  

执行器

public class Context {

    private Strategy strategy;  
      
    public void setStrategy(Strategy strategy) {  
        this.strategy = strategy;  
    }  
  
    public List<Stock> getRank(List<Stock> source) {
        return strategy.sort(source);  
    }  
} 

实现类

@Service
public class RankServiceImpl {  
  
    /**  
     * dataService.getSource() 提供原始的股票数据 来源于数据库
     */  
//    @Resource
//    private DataService dataService;
  
    /**  
     * 前端传入榜单类型, 返回排序完的榜单  
     *  
     * @param rankType 榜单类型  
     * @return 榜单数据  
     */  
    public List<Stock> getRank(String rankType) {
        // 创建上下文  
        Context context = new Context();
        // 这里选择策略  
        switch (rankType) {  
            case "HighPrice":  
                context.setStrategy(new HighPriceRank());  
                break;  
            case "LowPrice":  
                context.setStrategy(new LowPriceRank());  
                break;  
            case "HighRise":  
                context.setStrategy(new HighRiseRank());  
                break;  
            default:  
                throw new IllegalArgumentException("rankType not found");  
        }  
        // 然后执行策略  
        return context.getRank(new ArrayList<Stock>());
    }  
}  

--------------------------------------------------------------------------------

改造后的enum实现策略模式

步骤：

• 枚举策略类
• 实例RankServiceImpl

实现类

public enum RankEnum {
    // 以下三个为策略实例  
    HighPrice {  
        @Override  
        public List<Stock> sort(List<Stock> source) {
            return source.stream()  
                    .sorted(Comparator.comparing(Stock::getPrice).reversed())
                    .collect(Collectors.toList());
        }  
    },  
    LowPrice {  
        @Override  
        public List<Stock> sort(List<Stock> source) {  
            return source.stream()  
                    .sorted(Comparator.comparing(Stock::getPrice))  
                    .collect(Collectors.toList());  
        }  
    },  
    HighRise {  
        @Override  
        public List<Stock> sort(List<Stock> source) {  
            return source.stream()  
                    .sorted(Comparator.comparing(Stock::getRise).reversed())  
                    .collect(Collectors.toList());  
        }  
    };  
  
    // 这里定义了策略接口  
    public abstract List<Stock> sort(List<Stock> source);  
}  

实例RankServiceImpl

@Service
public class RankServiceImpl {  
  
//    /**
//     * dataService.getSource() 提供原始的股票数据
//     */
//    @Resource
//    private DataService dataService;
  
    /**  
     * 前端传入榜单类型, 返回排序完的榜单  
     *  
     * @param rankType 榜单类型 形似 RankEnum.HighPrice.name()  
     * @return 榜单数据  
     */  
    public List<Stock> getRank(String rankType) {
        // 获取策略，这里如果未匹配会抛 IllegalArgumentException异常  
        RankEnum rank = RankEnum.valueOf(rankType);  
        // 然后执行策略  
        return rank.sort(new ArrayList<>());
    }  
}