初識策略模式

首先談談本身對策略模式的理解：

假如業務需求中須要根據不一樣的任務種類（假設A B等等）做出不一樣的處理方式，咱們是否要採用if else的方式，逐個判斷呢？

if(type=="A"){
    //A的處理邏輯
}else if(type=="B"){
    //B的處理邏輯
}
//........

 

以上寫法實現功能天然沒有問題，可是隨着任務種類的增長，咱們須要不停的添加或者修改if else判斷語句，以及添加或修改相應的處理邏輯，方法也會很是臃腫，亦不符合面向對象的對修改關閉，對拓展開放的原則。

由此，引入策略模式來解決這個問題。

 

如下是我簡單模擬的一個策略模式的代碼輪廓，實際應用可能要複雜一些，只代表策略模式的思想： 忘記是參考的哪篇博客了.....

 

Handle接口，做爲任務處理器的一個簡單抽象，定義來返回類型接口 getType 和 處理任務方法 process ，全部的任務處理類都實現Handle接口，根據不一樣的類型，對應不一樣的處理邏輯

TypeEnums 枚舉則做爲任務類型定義全部的任務種類

public interface Handle<T> {

    /**
     * 處理方法
     * @param t
     */
    void process(T t);

    /**
     * 獲取類型
     */
    TypeEnums getType();
}

public enum TypeEnums {

    TYPEA("A", "typeA"),
    TYPEB("B", "typeB");

    @Setter
    @Getter
    private String type;

    @Setter
    @Getter
    private String desc;

    TypeEnums(String type, String desc) {
        this.type = type;
        this.desc = desc;
    }
}

ApplicationContextHelper負責獲取spring 的容器，經過該容器能夠獲取到全部實現Handle接口的實現類，也就是全部任務類型的處理器

@Component
public class ApplicationContextHelper implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    public <T> Map<String, T> getBeansOfType(Class<T> clazz) {
        return applicationContext.getBeansOfType(clazz);
    }
}

@Component
public class Client<T> implements InitializingBean {

    @Autowired
    private ApplicationContextHelper applicationContextHelper;

    /**
    * 負責存儲全部處理器
    **/
    private Map<String, Handle> handleMap = new ConcurrentHashMap<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        Map<String, Handle> handles = applicationContextHelper.getBeansOfType(Handle.class);
        for (Map.Entry<String, Handle> m : handles.entrySet()) {
            handleMap.put(m.getValue().getType().getType(), m.getValue());
        }
        System.out.println();
    }
    /**
    * 關鍵的方法，根據類型得到處理器，執行對應的process方法
    */
    public void doHandler(String tag, T t) {
        handleMap.get(tag).process(t);
    }
}

 

public void strategyModel(Client client) {

        StatementDto dto1 = new StatementDto();
        dto1.setType("AHandler");
        client.doHandler(TypeEnums.TYPEA.getType(), dto1);

        StatementDto dto2 = new StatementDto();
        dto2.setType("BHandler");
        client.doHandler(TypeEnums.TYPEB.getType(), dto2);
    }

//運行結果:

AHandler
BHandler

 

策略模式的好處在於若是需求出現變化，如新增任務類型，則添加一個類去實現Handle接口，實現對應的process方法便可，不須要修改原方法