一、傳統的實現方式

先說一下具體的需求：公司推廣入口很多，每一個下單來源在下單時都做特殊的邏輯處理，可能每兩天就會加一個來源。

那麼按照傳統的實現方式代碼就是如下：

<code>public class OrderServiceImpl implements IOrderService {
    @Override
    public String handle(OrderDTO dto) {
        String type = dto.getType();
        if ("1".equals(type)) {
            return "處理普通訂單";
        } else if ("2".equals(type)) {
            return "處理團購訂單";
        } else if ("3".equals(type)) {
            return "處理促銷訂單";
        }
        return null;
    }
}/<code>

為什麼非得寫的這麼臃腫？很多同事會說：“哎呀，沒辦法呀，業務催的緊，這樣開發效率快省事”。的確是句大實話，很多時候業務方確實像催命鬼一樣的讓你趕工期，想快速實現功能，這樣寫是最好的選擇。

上邊的代碼看似還算清晰，可如果我告訴你公司訂單來源有上百種，你想象一下那種臃腫的if-else，去翻代碼時是什麼感受？

二、策略模式的實現方式

策略模式是oop中最著名的設計模式之一，是對方法行為的抽象，可以歸類為行為設計模式，也是oop中interface經典的應用。其特點簡單又實用，是我最喜歡的模式之一。

策略模式定義了一個擁有共同行為的算法族，每個算法都被封裝起來，可以互相替換，獨立於客戶端而變化。

不少人說：Java的設計模式背了很多，可日常還不就是寫if-else的業務，根本就不用到。其實不是用不到是沒有用到合適的位置！

1、策略模式的使用場景：

• 針對同一問題的多種處理方式，僅僅是具體行為有差別時；
• 需要安全地封裝多種同一類型的操作時；
• 同一抽象類有多個子類，而客戶端需要使用if-else 或者 switch-case 來選擇具體子類時。

這個是用策略模式修改後代碼：

<code>@Component
@OrderHandlerType(16)
public class DispatchModeProcessor extends AbstractHandler{ 


\t@Autowired
\tprivate OrderStencilledService orderStencilledService;
\t
\t@Override
\tpublic void handle(OrderBO orderBO) {
\t\t
\t\t/**
    \t * 訂單完結廣播通知(1 - 支付完成)
    \t */
    \torderStencilledService.dispatchModeFanout(orderBO);
\t\t
    \t/**
    \t *  SCMS 出庫單
    \t */
    \torderStencilledService.createScmsDeliveryOrder(orderBO.getPayOrderInfoBO().getLocalOrderNo());
\t}
}/<code>

每個訂單來源都有自己單獨的邏輯實現類，而每次需要添加訂單來源，直接新建實現類，修改@OrderHandlerType(16)的數值即可，再也不用去翻那幾百行的if-lese，一勞永逸！

2、具體的實現過程：

1、定義一個標識訂單來源的註解

<code>@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface OrderHandlerType {
\tint value() default 0;
}/<code>

2、抽象出來一個具體的業務處理器

<code>public abstract class AbstractHandler {
\tabstract public void handle(OrderBO orderBO);
}/<code>

3、項目啟動掃描 handler 入口

<code>@Component
@SuppressWarnings({"unused","rawtypes"})
public class HandlerProcessor implements BeanFactoryPostProcessor {
\t
\tprivate String basePackage = "com.ecej.order.pipeline.processor";
\t
    public static final Logger log = LoggerFactory.getLogger(HandlerProcessor.class);
\t
\t@Override
\tpublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
\t\t
\t\tMap<integer> map = new HashMap<integer>();
\t\t
\t\tClassScaner.scan(basePackage, OrderHandlerType.class).forEach(x ->{
\t\t\tint type = x.getAnnotation(OrderHandlerType.class).value();
\t\t\tmap.put(type,x);
\t\t});
\t\t
\t\tbeanFactory.registerSingleton(OrderHandlerType.class.getName(), map);
\t\t
\t\tlog.info("處理器初始化{}", JSONObject.toJSONString(beanFactory.getBean(OrderHandlerType.class.getName())));
\t}
}/<integer>/<integer>/<code>

4、掃描需要用到的工具類

<code>public class ClassScaner {
\tprivate ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();

\tprivate final List<typefilter> includeFilters = new ArrayList<typefilter>();

\tprivate final List<typefilter> excludeFilters = new ArrayList<typefilter>();

\tprivate MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
\t
\t/**
\t * 添加包含的Fiter 

\t * @param includeFilter
\t */
\tpublic void addIncludeFilter(TypeFilter includeFilter) {
\t\tthis.includeFilters.add(includeFilter);
\t}

\t/**
\t * 添加排除的Fiter
\t * @param includeFilter
\t */
\tpublic void addExcludeFilter(TypeFilter excludeFilter) {
\t\tthis.excludeFilters.add(excludeFilter);
\t}
\t
\t/**
\t * 掃描指定的包，獲取包下所有的Class
\t * @param basePackage 包名
\t * @param targetTypes 需要指定的目標類型,可以是pojo,可以是註解
\t * @return Set<class>>
\t */
\tpublic static Set<class>> scan(String basePackage,
\t\t\tClass>... targetTypes) {
\t\tClassScaner cs = new ClassScaner();
\t\tfor (Class> targetType : targetTypes){
\t\t\tif(TypeUtils.isAssignable(Annotation.class, targetType)){
\t\t\t\tcs.addIncludeFilter(new AnnotationTypeFilter((Class extends Annotation>) targetType));
\t\t\t}else{
\t\t\t\tcs.addIncludeFilter(new AssignableTypeFilter(targetType));
\t\t\t}
\t\t}
\t\treturn cs.doScan(basePackage);
\t}
\t
\t/**
\t * 掃描指定的包，獲取包下所有的Class
\t * @param basePackages 包名,多個
\t * @param targetTypes 需要指定的目標類型,可以是pojo,可以是註解
\t * @return Set<class>>
\t */
\tpublic static Set<class>> scan(String[] basePackages,
\t\t\tClass>... targetTypes) {
\t\tClassScaner cs = new ClassScaner();
\t\tfor (Class> targetType : targetTypes){ 

\t\t\tif(TypeUtils.isAssignable(Annotation.class, targetType)){
\t\t\t\tcs.addIncludeFilter(new AnnotationTypeFilter((Class extends Annotation>) targetType));
\t\t\t}else{
\t\t\t\tcs.addIncludeFilter(new AssignableTypeFilter(targetType));
\t\t\t}
\t\t}
\t\tSet<class>> classes = new HashSet<class>>();
\t\tfor (String s : basePackages){
\t\t\tclasses.addAll(cs.doScan(s));
\t\t}
\t\treturn classes;
\t}
\t
\t/**
\t * 掃描指定的包，獲取包下所有的Class
\t * @param basePackages 包名
\t * @return Set<class>>
\t */
\tpublic Set<class>> doScan(String [] basePackages) {
\t\tSet<class>> classes = new HashSet<class>>();
\t\tfor (String basePackage :basePackages) {
\t\t\tclasses.addAll(doScan(basePackage));
\t\t}
\t\treturn classes;
\t}
\t
\t/**
\t * 掃描指定的包，獲取包下所有的Class
\t * @param basePackages 包名
\t * @return Set<class>>
\t */
\tpublic Set<class>> doScan(String basePackage) {
\t\tSet<class>> classes = new HashSet<class>>();
\t\ttry {
\t\t\tString packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
\t\t\t\t\t+ ClassUtils.convertClassNameToResourcePath(
\t\t\t\t\t\t\tSystemPropertyUtils.resolvePlaceholders(basePackage))+"/**/*.class";
\t\t\tResource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
\t\t\tfor (int i = 0; i < resources.length; i++) {
\t\t\t\tResource resource = resources[i];
\t\t\t\tif (resource.isReadable()) {
\t\t\t\t\tMetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
\t\t\t\t\tif ((includeFilters.size() == 0 && excludeFilters.size() == 0)|| matches(metadataReader)) {
\t\t\t\t\t\ttry {
\t\t\t\t\t\t\tclasses.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
\t\t\t\t\t\t} catch (ClassNotFoundException ignore) {}
\t\t\t\t\t} 

\t\t\t\t}
\t\t\t}
\t\t} catch (IOException ex) {
\t\t\tthrow new RuntimeException("I/O failure during classpath scanning", ex);
\t\t}
\t\treturn classes;
\t}
\t
\t/**
\t * 處理 excludeFilters和includeFilters
\t * @param metadataReader
\t * @return boolean
\t * @throws IOException
\t */
\tprivate boolean matches(MetadataReader metadataReader) throws IOException {
\t\tfor (TypeFilter tf : this.excludeFilters) {
\t\t\tif (tf.match(metadataReader, this.metadataReaderFactory)) {
\t\t\t\treturn false;
\t\t\t}
\t\t}
\t\tfor (TypeFilter tf : this.includeFilters) {
\t\t\tif (tf.match(metadataReader, this.metadataReaderFactory)) {
\t\t\t\treturn true;
\t\t\t}
\t\t}
\t\treturn false;
\t}
}/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<class>/<typefilter>/<typefilter>/<typefilter>/<typefilter>/<code>

5、 根據類型實例化抽象類

<code>
@Component
public class HandlerContext {

\t@Autowired
\tprivate ApplicationContext beanFactory;

\tpublic  AbstractHandler getInstance(Integer type){
\t\t
\t\tMap<integer> map = (Map<integer>) beanFactory.getBean(OrderHandlerType.class.getName());
\t\t
\t\treturn (AbstractHandler)beanFactory.getBean(map.get(type));
\t}
\t
}/<integer>/<integer>/<code>

6、調用入口，我這裡是接的MQ消息，會批量的處理多個訂單來源

<code>@Component
@RabbitListener(queues = "OrderPipelineQueue")
public class PipelineSubscribe{
 
\tprivate final Logger LOGGER = LoggerFactory.getLogger(PipelineSubscribe.class);
\t
\t@Autowired
\tprivate HandlerContext HandlerContext;
\t
\t@Autowired
\tprivate OrderValidateService orderValidateService;
\t
    @RabbitHandler
    public void subscribeMessage(MessageBean bean){
    \t
    \tOrderBO orderBO = JSONObject.parseObject(bean.getOrderBO(), OrderBO.class);
    \t
    \tif(null != orderBO &&CollectionUtils.isNotEmpty(bean.getType()))
    \t{
    \t\tfor(int value:bean.getType())
    \t\t{
       \t\t AbstractHandler handler = HandlerContext.getInstance(value);
       \t\t handler.handle(orderBO);
    \t\t}
\t\t}
\t}
}/<code>

接收實體 MessageBean 類代碼

<code>public class MessageBean implements Serializable {
    private static final long serialVersionUID = 5454831432308782668L;
    private String cachKey;
    private List<integer> type;
    private String orderBO;

    public MessageBean(List<integer> type, String orderBO) {
        this.type = type;
        this.orderBO = orderBO;
    }
}/<integer>/<integer>/<code>

三、策略模式的優缺點

優點

• 易於擴展，增加一個新的策略只需要添加一個具體的策略類即可，基本不需要改變原有的代碼，符合開放封閉原則
• 避免使用多重條件選擇語句，充分體現面向對象設計思想 策略類之間可以自由切換，由於策略類都實現同一個接口，所以使它們之間可以自由切換
• 每個策略類使用一個策略類，符合單一職責原則 客戶端與策略算法解耦，兩者都依賴於抽象策略接口，符合依賴反轉原則
• 客戶端不需要知道都有哪些策略類，符合最小知識原則

缺點

• 策略模式，當策略算法太多時，會造成很多的策略類
• 客戶端不知道有哪些策略類，不能決定使用哪個策略類，這點可以通過封裝common公共包解決，也可以考慮使IOC容器和依賴注入的方式來解決。

以下是訂單來源策略類的一部分，不得不說策略類確實比較多。

總結：

凡事都有他的兩面性，if-else多層嵌套和也都有其各自的優缺點：

if-else的有點就是簡單，想快速迭代功能，邏輯嵌套少且不會持續增加，if-else更好些，缺點也是顯而易見，代碼臃腫繁瑣不便於維護。

策略模式 將各個場景的邏輯剝離出來維護，同一抽象類有多個子類，需要使用if-else 或者 switch-case 來選擇具體子類時，建議選策略模式，他的缺點就是會產生比較多的策略類文件。

兩種實現方式各有利弊，如何選擇還是要依據具體業務場景，還是那句話設計模式不是為了用而用，一定要用在最合適的位置。

今天就說這麼多，如果本文對您有一點幫助，希望能得到您一個點贊哦

作者：程序員內點事
鏈接：https://juejin.im/post/5e79f1715188255e374d8097

閱讀更多 Java大數據高級架構師 的文章

關鍵字: 設計模式 可以很 算法