策略模式及使用Spring實現策略模式+工廠模式

一、策略模式

策略模式定義了一組算法，將每個算法都封裝起來，並且使它們之間可以互換

1、策略模式主要角色

主要角色如下：

• 封裝角色（Context）：也叫做上下文角色，起承上啓下封裝作用，屏蔽高層模塊對策略、算法的直接訪問，封裝可能存在的變化
• 抽象策略角色（Strategy）：策略家族的抽象，通常爲接口，定義每個策略或算法必須具有的方法和屬性
• 具體策略角色（ConcreteStrategy）：實現抽象策略中的操作，該類含有具體的算法

2、實現策略模式

//抽象策略角色
public interface Strategy {
    //策略模式的運算法則
    void doSomething();
}

//具體策略角色
public class ConcreteStrategy1 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("具體策略1的運算法則...");
    }
}

//具體策略角色
public class ConcreteStrategy2 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("具體策略2的運算法則...");
    }
}

//封裝角色
public class Context {
    //抽象策略
    private Strategy strategy;

    //構造函數設置具體策略
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //封裝後的策略方法
    public void doAnything() {
        this.strategy.doSomething();
    }
}

public class Client {
    public static void main(String[] args) {
        //聲明一個具體的策略
        Strategy strategy = new ConcreteStrategy1();
        //聲明上下文對象
        Context context = new Context(strategy);
        //執行封裝後的方法
        context.doAnything();
    }
}

執行結果如下：

具體策略1的運算法則...

二、使用Spring實現策略模式+工廠模式

1、實現策略類

public interface Strategy {
    //策略模式的運算法則
    void doSomething();
}

@Component
public class ConcreteStrategy1 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("具體策略1的運算法則...");
    }

    @Override
    public String toString() {
        return "具體策略1";
    }
}

@Component
public class ConcreteStrategy2 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("具體策略2的運算法則...");
    }

    @Override
    public String toString() {
        return "具體策略2";
    }
}

@Component
public class DefaultStrategy implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("默認策略的運算法則...");
    }

    @Override
    public String toString() {
        return "默認策略";
    }
}

2、實現工廠類

@Component
public class StrategyFactory {
    //Spring會自動將Strategy接口的實現類注入到這個Map中，key爲bean id，value值則爲對應的策略實現類
    @Autowired
    private Map<String, Strategy> strategyMap;

    public Strategy getBy(String strategyName) {
        return strategyMap.get(strategyName);
    }
}

Spring會自動將Strategy接口的實現類注入到這個Map中（前提是實現類得是交給Spring 容器管理的），這個Map的key爲bean id，可以用@Component(value = "xxx")的方式設置，如果直接用默認的方式的話，就是首字母小寫。value值則爲對應的策略實現類

測試類：

@SpringBootTest
class SpringbootDemoApplicationTests {

    @Autowired
    private ApplicationContext context;

    @Test
    public void test() {
        context.getBean(StrategyFactory.class).getBy("concreteStrategy1").doSomething();
        context.getBean(StrategyFactory.class).getBy("concreteStrategy2").doSomething();
    }

}

執行結果如下：

具體策略1的運算法則...
具體策略2的運算法則...

3、別名轉換

上面測試類調用的使用使用的bean id，實際業務中應該是將傳入的code轉義成對應的策略類的bean id

@Component
@PropertySource("classpath:application.properties")
@ConfigurationProperties(prefix = "strategy")
public class StrategyAliasConfig {
    private HashMap<String, String> aliasMap;

    public static final String DEFAULT_STATEGY_NAME = "defaultStrategy";

    public HashMap<String, String> getAliasMap() {
        return aliasMap;
    }

    public void setAliasMap(HashMap<String, String> aliasMap) {
        this.aliasMap = aliasMap;
    }

    public String of(String entNum) {
        return aliasMap.get(entNum);
    }
}

配置文件application.properties

strategy.aliasMap.strategy1=concreteStrategy1
strategy.aliasMap.strategy2=concreteStrategy2

@Component
public class StrategyFactory {
    @Autowired
    private StrategyAliasConfig strategyAliasConfig;

    //Spring會自動將Strategy接口的實現類注入到這個Map中，key爲bean id，value值則爲對應的策略實現類
    @Autowired
    private Map<String, Strategy> strategyMap;

    //找不到對應的策略類，使用默認的
    public Strategy getBy(String strategyName) {
        String name = strategyAliasConfig.of(strategyName);
        if (name == null) {
            return strategyMap.get(StrategyAliasConfig.DEFAULT_STATEGY_NAME);
        }
        Strategy strategy = strategyMap.get(name);
        if (strategy == null) {
            return strategyMap.get(StrategyAliasConfig.DEFAULT_STATEGY_NAME);
        }
        return strategy;

    }
}

測試類：

@SpringBootTest
class SpringbootDemoApplicationTests {

    @Autowired
    private ApplicationContext context;

    @Test
    public void test() {
        context.getBean(StrategyFactory.class).getBy("strategy1").doSomething();
        context.getBean(StrategyFactory.class).getBy("strategy2").doSomething();
    }

}

執行結果如下：

具體策略1的運算法則...
具體策略2的運算法則...

參考：

《設計模式之禪》

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