設計模式之策略模式

在一個收銀系統中，如果普通使用者、中級會員、高階會員分別對應著不同的優惠策略，常規程式設計就要使用一系列的判斷語句，判斷使用者型別，這種情況下就可以使用策略模式。

一、概念理解

策略模式的概念很好理解，它將物件和行為分開，將行為定義為一個行為介面和具體行為的實現，每個if判斷都可以理解為一個策略。

如果在收銀系統中使用策略模式，要將普通、中級、高階會員分別定義一個具體策略類，並實現各自的方法，定義一個環境類，持有策略類的參照，由參照呼叫相應的策略類方法，使用者端傳入相應的具體策略物件就會呼叫各自的策略方法。

學過了狀態模式，很多人也把狀態模式和狀態模式搞混，現在就可以考慮一下為什麼不使用狀態模式？

各個策略之間並不存在流轉（比如：狀態1234切換）關係，都是各自的演演算法實現各自的邏輯，使用者端控制呼叫哪個策略，如果使用狀態模式就變成了，先呼叫普通會員的策略，再呼叫中級會員的策略，再呼叫高階會員的策略，看到最後的優惠使用者估計會樂瘋吧！

和狀態模式一樣，策略模式也應包含三個角色：

抽象策略類：策略是一個介面，該介面定義若干個演演算法標識，即定義了若干個抽象方法

具體策略類：具體策略是實現策略介面的類

環境類 /上下文類：上下文提供一個方法，持有一個策略類的參照，最終給使用者端呼叫。

相比於狀態模式，策略模式各個角色的職責更簡單，我們基於收銀案例實現策略模式demo。

二、案例實現

抽象策略類：

定義業務抽象方法，我們主要是計算價格

/**
 * 策略抽象類
 * @author tcy
 * @Date 21-09-2022
 */
public interface AbstractMemberStrategy {
    // 一個計算價格的抽象方法
    //price商品的價格 n商品的個數
    public double calcPrice(double price, int n);
}

具體策略-高階會員：

各個具體策略實現各自的計算方法

/**高階會員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyAdvanceMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n *0.8;
        return money;
    }
}

具體策略-中級會員：

/**
 * 中級會員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyIntermediateMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n*0.9;
        return money;
    }
}

具體策略-普通會員：

/**
 * 初級會員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyPrimaryMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        return price * n;
    }
}

環境類：

持有策略類的參照，呼叫時傳入相應的具體策略物件，就會呼叫策略各自的方法。

/**環境類
 * @author tcy
 * @Date 21-09-2022
 */
public class Context {
    // 使用者折扣策略介面
    private AbstractMemberStrategy memberStrategy;

    // 注入構造方法
    public Context(AbstractMemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }

    // 計算價格
    public double qoutePrice(double goodsPrice, int n){
        // 通過介面變數呼叫對應的具體策略
        return memberStrategy.calcPrice(goodsPrice, n);
    }

}

使用者端呼叫：

/**
 * @author tcy
 * @Date 21-09-2022
 */
public class Client {
    public static void main(String[] args) {

        // 具體策略類
        AbstractMemberStrategy primaryMemberStrategy = new StrategyPrimaryMember();
        AbstractMemberStrategy intermediateMemberStrategy = new StrategyIntermediateMember();
        AbstractMemberStrategy advanceMemberStrategy = new StrategyAdvanceMember();

        // 使用者選擇不同策略
        Context primaryContext = new Context(primaryMemberStrategy);
        Context intermediateContext = new Context(intermediateMemberStrategy);
        Context advanceContext = new Context(advanceMemberStrategy);

        //一本100塊錢的書
        // 普通會員：100
        System.out.println("普通會員的價格："+ primaryContext.qoutePrice(100,1));
        // 中級會員 90
        System.out.println("中級會員的價格："+ intermediateContext.qoutePrice(100,1));
        // 高階會員 80
        System.out.println("高階會員的價格："+ advanceContext.qoutePrice(100,1));

    }
}

策略模式相對於狀態模式理解起來更沒有任何難度。

三、Jdk中的應用

策略模式的典型應用是Jdk中執行緒池滿之後的拒絕策略，我們在建立一個執行緒池時會傳入以下引數：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
                          TimeUnit unit,BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

其中 RejectedExecutionHandler 是執行緒池滿之後的拒絕策略，jdk中的多執行緒內建了四種拒絕策略，如下圖：

①ThreadPoolExecutor.AbortPolicy 預設拒絕策略，拒絕任務並丟擲任務

②ThreadPoolExecutor.CallerRunsPolicy 使用呼叫執行緒直接執行任務

③ThreadPoolExecutor.DiscardPolicy 直接拒絕任務，不丟擲錯誤

④ThreadPoolExecutor.DiscardOldestPolicy 觸發拒絕策略，只要還有任務新增，一直會丟棄阻塞佇列的最老的任務，並將新的任務加入

這四種拒絕策略就代表策略模式角色中的具體策略角色，ThreadPoolExecutor類我們可以將其看做環境類。

我們知道執行多執行緒中的方法是schedule方法，可以就認為這就是角色中的使用者端：

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    RunnableScheduledFuture<?> t = decorateTask(command,
        new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    delayedExecute(t);
    return t;
}

既然是使用者端，就會有時機呼叫拒絕策略方法，我們點進去看delayedExecute()方法。

private void delayedExecute(RunnableScheduledFuture<?> task) {
    if (isShutdown())
        reject(task);
    else {
        super.getQueue().add(task);
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

接著看reject()方法，該方法時機上呼叫的就是拒絕策略方法。傳入相應的this物件，呼叫不同的拒絕策略。

final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}

呼叫時序如下圖：

何時呼叫何種拒絕策略，由delayedExecute()方法自己來決定，各個拒絕策略有各自的業務邏輯，這就是策略模式的典型應用。

四、策略模式和狀態模式區別

策略模式和狀態模式雖然類圖一模一樣，很多部落格也將他們混為一談，實際上策略模式和狀態模式沒有半毛錢的關係，只有理解了兩種模式的使用場景，在運用時才能遊刃有餘，以下為我總結的四點不同之處，狀態模式的部落格可以參考狀態模式。

①策略模式中的各策略相互之間沒有什麼關係，比如支付方式選擇、優惠策略選擇；狀態模式往往是一套流程，比如訂單狀態流轉、請假流程審批等。

②在策略模式下，呼叫哪個策略由使用者端決定；狀態模式中，使用者端只管呼叫，各個具體狀態類定義切換下一狀態。

③狀態模式強調狀態變化、策略模式強調的是策略的選擇。

五、總結

使用策略模式會讓我們的程式碼更加的「乾淨」，但是如果實際的if判斷中的邏輯很簡單，我們仍然使用策略模式，就變成了為了使用設計模式而使用，這無疑加重系統的複雜程度。

就像商城系統中，微信支付、支付寶支付、銀聯支付，業務邏輯沒那麼簡單的，使用策略模式就是一個好的選擇。

整體來說策略模式在行為型模式中還屬於一種比較簡單的模式，無論是理解起來還是寫起來都屬極簡單，難度堪比結構型設計模式中的單例模式。

設計模式的學習要成體系，推薦你看我往期釋出的設計模式文章。