Java設計模式 政策模式

• 政策模式介紹
• • 政策模式定義
  • 政策模式類圖
  • 政策模式角色劃分
  • 政策模式執行個體解析
  • 典型政策模式實作
  • 使用Annotation和簡單工廠模式增強政策模式
  • 政策模式優點
  • 政策模式缺點

政策模式介紹

政策模式定義

政策模式（Strategy Pattern），将各種算法封裝到具體的類中，作為一個抽象政策類的子類，使得它們可以互換。用戶端可以自行決定使用哪種算法。

政策模式類圖

政策模式類圖如下

政策模式角色劃分

Strategy 政策接口或者（抽象政策類），定義政策執行接口

ConcreteStrategy 具體政策類

Context 上下文類，持有具體政策類的執行個體，并負責調用相關的算法

政策模式執行個體解析

本文代碼可從作者Github下載下傳位址

典型政策模式實作

政策接口，定義政策執行接口

package com.jasongj.strategy;

public interface Strategy {

  void strategy(String input);

}
           

具體政策類，實作政策接口，提供具體算法

package com.jasongj.strategy;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@com.jasongj.annotation.Strategy(name="StrategyA")
public class ConcreteStrategyA implements Strategy {

  private static final Logger LOG = LoggerFactory.getLogger(ConcreteStrategyB.class);

  @Override
  public void strategy(String input) {
    LOG.info("Strategy A for input : {}", input);
  }

}
           

package com.jasongj.strategy;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@com.jasongj.annotation.Strategy(name="StrategyB")
public class ConcreteStrategyB implements Strategy {

  private static final Logger LOG = LoggerFactory.getLogger(ConcreteStrategyB.class);

  @Override
  public void strategy(String input) {
    LOG.info("Strategy B for input : {}", input);
  }

}
           

Context類，持有具體政策類的執行個體，負責調用具體算法

package com.jasongj.context;

import com.jasongj.strategy.Strategy;

public class SimpleContext {

  private Strategy strategy;
  
  public SimpleContext(Strategy strategy) {
    this.strategy = strategy;
  }
  
  public void action(String input) {
    strategy.strategy(input);
  }
  
}
           

用戶端可以執行個體化具體政策類，并傳給Context類，通過Context統一調用具體算法

package com.jasongj.client;

import com.jasongj.context.SimpleContext;
import com.jasongj.strategy.ConcreteStrategyA;
import com.jasongj.strategy.Strategy;

public class SimpleClient {

  public static void main(String[] args) {
    Strategy strategy = new ConcreteStrategyA();
    SimpleContext context = new SimpleContext(strategy);
    context.action("Hellow, world");
  }

}
           

使用Annotation和簡單工廠模式增強政策模式

上面的實作中，用戶端需要顯示決定具體使用何種政策，并且一旦需要換用其它政策，需要修改用戶端的代碼。解決這個問題，一個比較好的方式是使用簡單工廠，使得用戶端都不需要知道政策類的執行個體化過程，甚至都不需要具體哪種政策被使用。

如《Java設計模式（一） 簡單工廠模式不簡單》所述，簡單工廠的實作方式比較多，可以結合《Java系列（一）Annotation（注解）》中介紹的Annotation方法。

使用Annotation和簡單工廠模式的Context類如下

package com.jasongj.context;

import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.reflections.Reflections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jasongj.strategy.Strategy;

public class SimpleFactoryContext {

  private static final Logger LOG = LoggerFactory.getLogger(SimpleFactoryContext.class);
  private static Map<String, Class> allStrategies;

  static {
    Reflections reflections = new Reflections("com.jasongj.strategy");
    Set<Class<?>> annotatedClasses =
        reflections.getTypesAnnotatedWith(com.jasongj.annotation.Strategy.class);
    allStrategies = new ConcurrentHashMap<String, Class>();
    for (Class<?> classObject : annotatedClasses) {
      com.jasongj.annotation.Strategy strategy = (com.jasongj.annotation.Strategy) classObject
          .getAnnotation(com.jasongj.annotation.Strategy.class);
      allStrategies.put(strategy.name(), classObject);
    }
    allStrategies = Collections.unmodifiableMap(allStrategies);
  }

  private Strategy strategy;

  public SimpleFactoryContext() {
    String name = null;
    try {
      XMLConfiguration config = new XMLConfiguration("strategy.xml");
      name = config.getString("strategy.name");
      LOG.info("strategy name is {}", name);
    } catch (ConfigurationException ex) {
      LOG.error("Parsing xml configuration file failed", ex);
    }

    if (allStrategies.containsKey(name)) {
      LOG.info("Created strategy name is {}", name);
      try {
        strategy = (Strategy) allStrategies.get(name).newInstance();
      } catch (InstantiationException | IllegalAccessException ex) {
        LOG.error("Instantiate Strategy failed", ex);
      }
    } else {
      LOG.error("Specified Strategy name {} does not exist", name);
    }

  }

  public void action(String input) {
    strategy.strategy(input);
  }

}
           

從上面的實作可以看出，雖然并沒有單獨建立一個簡單工廠類，但它已經融入了簡單工廠模式的設計思想和實作方法。

用戶端調用方式如下

package com.jasongj.client;

import com.jasongj.context.SimpleFactoryContext;

public class SimpleFactoryClient {

  public static void main(String[] args) {
    SimpleFactoryContext context = new SimpleFactoryContext();
    context.action("Hellow, world");
  }

}
           

從上面代碼可以看出，引入簡單工廠模式後，用戶端不再需要直接執行個體化具體的政策類，也不需要判斷應該使用何種政策，可以友善應對政策的切換。

政策模式優點

政策模式提供了對“開閉原則”的完美支援，使用者可以在不修改原有系統的基礎上選擇算法（政策），并且可以靈活地增加新的算法（政策）。

政策模式通過Context類提供了管理具體政策類（算法族）的辦法。

結合簡單工廠模式和Annotation，政策模式可以友善的在不修改用戶端代碼的前提下切換算法（政策）。

`

政策模式缺點

傳統的政策模式實作方式中，用戶端必須知道所有的具體政策類，并須自行顯示決定使用哪一個政策類。但通過本文介紹的通過和Annotation和簡單工廠模式結合，可以有效避免該問題

如果使用不當，政策模式可能建立很多具體政策類的執行個體，但可以通過使用上文《Java設計模式（十一） 享元模式》介紹的享元模式有效減少對象的數量。