設計模式（二十二）——狀態模式（APP抽獎活動+借貸平臺原始碼剖析）

十四lin發表於2021-02-11

設計模式APP原始碼

24.1 APP 抽獎活動問題

請編寫程式完成 APP 抽獎活動具體要求如下:

1) 假如每參加一次這個活動要扣除使用者 50 積分，中獎概率是 10%

2) 獎品數量固定，抽完就不能抽獎

3) 活動有四個狀態: 可以抽獎、不能抽獎、發放獎品和獎品領完

4) 活動的四個狀態轉換關係圖(下圖)

24.1 狀態模式基本介紹

基本介紹

1) 狀態模式（State Pattern）：它主要用來解決物件在多種狀態轉換時，需要對外輸出不同的行為的問題。狀態和行為是一一對應的，狀態之間可以相互轉換

2) 當一個物件的內在狀態改變時，允許改變其行為，這個物件看起來像是改變了其類

24.2 狀態模式的原理類圖

對原理類圖的說明-即(狀態模式的角色及職責)

1) Context 類為環境角色, 用於維護 State 例項,這個例項定義當前狀態

2) State 是抽象狀態角色,定義一個介面封裝與 Context 的一個特點介面相關行為

3) ConcreteState 具體的狀態角色，每個子類實現一個與 Context 的一個狀態相關行為

24.1 狀態模式解決 APP 抽獎問

1) 應用例項要求

完成 APP 抽獎活動專案，使用狀態模式.

2) 思路分析和圖解(類圖)

定義出一個介面叫狀態介面，每個狀態都實現它。
介面有扣除積分方法、抽獎方法、發放獎品方法

3)程式碼實現

package com.lin.state;
    
    /**
     * 狀態抽象類
     * 
     * @author Administrator
     *
     */
public abstract class State {

    // 扣除積分 - 50
    public abstract void deductMoney();

    // 是否抽中獎品
    public abstract boolean raffle();

    // 發放獎品
    public abstract void dispensePrize();

}

package com.lin.state;

/**
 * 抽獎活動 //
 *
 * @author Administrator
 *
 */
public class RaffleActivity {

    // state 表示活動當前的狀態，是變化
    State state = null;

    // 獎品數量
    int count = 0;

    // 四個屬性，表示四種狀態
    State noRafflleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);

    State dispenseState = new DispenseState(this);
    State dispensOutState = new DispenseOutState(this);

    // 構造器
    // 1. 初始化當前的狀態為 noRafflleState（即不能抽獎的狀態）
    // 2. 初始化獎品的數量
    public RaffleActivity(int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    // 扣分, 呼叫當前狀態的 deductMoney
    public void debuctMoney() {
        state.deductMoney();

    }

    // 抽獎
    public void raffle() {
        // 如果當前的狀態是抽獎成功

        if (state.raffle()) {
            // 領取獎品state.dispensePrize();
        }

    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    // 這裡請大家注意，每領取一次獎品，count--
    public int getCount() {
        int curCount = count;
        count--;
        return curCount;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public State getNoRafflleState() {
        return noRafflleState;
    }

    public void setNoRafflleState(State noRafflleState) {
        this.noRafflleState = noRafflleState;
    }

    public State getCanRaffleState() {
        return canRaffleState;
    }

    public void setCanRaffleState(State canRaffleState) {
        this.canRaffleState = canRaffleState;
    }

    public State getDispenseState() {
        return dispenseState;
    }

    public void setDispenseState(State dispenseState) {
        this.dispenseState = dispenseState;
    }

    public State getDispensOutState() {
        return dispensOutState;

    }

    public void setDispensOutState(State dispensOutState) {
        this.dispensOutState = dispensOutState;
    }
}

package com.lin.state;


    /**
    *不能抽獎狀態
    *@author Administrator
    *
    */

public class NoRaffleState extends State {

    // 初始化時傳入活動引用，扣除積分後改變其狀態
    RaffleActivity activity;


    public NoRaffleState(RaffleActivity activity) { 
        this.activity = activity;
    }

    // 當前狀態可以扣積分 , 扣除後，將狀態設定成可以抽獎狀態
    @Override
    public void deductMoney() {
        System.out.println("扣除 50 積分成功，您可以抽獎了"); activity.setState(activity.getCanRaffleState());
    }


    // 當前狀態不能抽獎
    @Override
    public boolean raffle() {
        System.out.println("扣了積分才能抽獎喔！"); return false;
    }

    // 當前狀態不能發獎品
    @Override
    public void dispensePrize() {
        System.out.println("不能發放獎品");
    }
    
}

package com.lin.state;

    /**
     * 發放獎品的狀態
     * 
     * @author Administrator
     *
     */
public class DispenseState extends State {

    // 初始化時傳入活動引用，發放獎品後改變其狀態
    RaffleActivity activity;

    public DispenseState(RaffleActivity activity) {
        this.activity = activity;
    }

    //

    @Override
    public void deductMoney() {
        System.out.println("不能扣除積分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽獎");
        return false;
    }

    //發放獎品 @Override
    public void dispensePrize() {
        if (activity.getCount() > 0) {
            System.out.println("恭喜中獎了");
            // 改變狀態為不能抽獎
            activity.setState(activity.getNoRafflleState());
        } else {
            System.out.println("很遺憾，獎品傳送完了");
            // 改變狀態為獎品傳送完畢, 後面我們就不可以抽獎
            activity.setState(activity.getDispensOutState());
            //System.out.println("抽獎活動結束");
            //System.exit(0);
        }

    }
}

package com.lin.state;

    /**
     * 獎品發放完畢狀態 說明，當我們 activity 改變成 DispenseOutState， 抽獎活動結束
     * 
     * @author Administrator
     *
     */
public class DispenseOutState extends State {

    // 初始化時傳入活動引用
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("獎品傳送完了，請下次再參加");
    }

    @Override
    public boolean raffle() {
        System.out.println("獎品傳送完了，請下次再參加");
        return false;

    }

    @Override
    public void dispensePrize() {
        System.out.println("獎品傳送完了，請下次再參加");
    }
}

package com.lin.state;

import java.util.Random;

/**
 * 可以抽獎的狀態
 * 
 * @author Administrator
 *
 */
public class CanRaffleState extends State {

    RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    // 已經扣除了積分，不能再扣 @Override
    public void deductMoney() {
        System.out.println("已經扣取過了積分");
    }

    // 可以抽獎, 抽完獎後，根據實際情況，改成新的狀態
    @Override
    public boolean raffle() {
        System.out.println("正在抽獎，請稍等！");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中獎機會
        if (num == 0) {
            // 改 變 活 動 狀 態 為 發 放 獎 品 context 
            activity.setState(activity.getDispenseState());
            return true;
        } else {
            System.out.println("很遺憾沒有抽中獎品！");
            // 改變狀態為不能抽獎
            activity.setState(activity.getNoRafflleState());
            return false;
        }
    }

    // 不能發放獎品
    @Override
    public void dispensePrize() {
        System.out.println("沒中獎，不能發放獎品");
    }
}

package com.lin.state;

    /**
     * 狀態模式測試類
     * 
     * @author Administrator
     *
     */
public class Client {

    public static void main(String[] args) {
        // 建立活動物件，獎品有 1 個獎品
        RaffleActivity activity = new RaffleActivity(1);

        // 我們連續抽 300 次獎
        for (int i = 0; i < 40; i++) {
            System.out.println("--------第" + (i + 1) + "次抽獎----------");
            // 參加抽獎，第一步點選扣除積分
            activity.debuctMoney();

            // 第二步抽獎
            activity.raffle();
        }
    }

}

24.1 狀態模式在實際專案-借貸平臺原始碼剖析

1) 借貸平臺的訂單，有稽核-釋出-搶單等等步驟，隨著操作的不同，會改變訂單的狀態, 專案中的這個模組實現就會使用到狀態模式

2) 通常通過 if/else 判斷訂單的狀態，從而實現不同的邏輯，虛擬碼如下

3)程式碼實現

package com.lin.state.project;

/**
 * 狀態介面
 * 
 * @author Administrator
 *
 */
public interface State {

    /**
     * 電 審
     */
    void checkEvent(Context context);

    /**
     * 電審失敗
     */
    void checkFailEvent(Context context);

    /**
     * 定價釋出
     */
    void makePriceEvent(Context context);

    /**
     * 接 單
     * 
     * 
     */
    void acceptOrderEvent(Context context);

    /**
     * 無人接單失效
     */
    void notPeopleAcceptEvent(Context context);

    /**
     * 付 款
     */
    void payOrderEvent(Context context);

    /**
     * 接單有人支付失效
     */
    void orderFailureEvent(Context context);

    /**
     * 反 饋
     */
    void feedBackEvent(Context context);

    String getCurrentState();
}

package com.lin.state.project;

    /**
     * 狀態列舉類
     * 
     * @author Administrator
     *
     */
public enum StateEnum {

    //訂單生成
    GENERATE(1, "GENERATE"),

    //已稽核
    REVIEWED(2, "REVIEWED"),
    
    //已釋出
    PUBLISHED(3, "PUBLISHED"),

    //待付款
    NOT_PAY(4, "NOT_PAY"),

    //已付款
    PAID(5, "PAID"),

    //已完結

    FEED_BACKED(6, "FEED_BACKED");

    private int key;
    private String value;

    StateEnum(int key, String value) {
        this.key = key;
        this.value = value;
    }

    public int getKey() {
        return key;
    }

    public String getValue() {
        return value;
    }
}

package com.lin.state.project;

public abstract class AbstractState implements State {

    protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允許");

    //抽象類，預設實現了 State 介面的所有方法
    //該類的所有方法，其子類(具體的狀態類)，可以有選擇的進行重寫

    @Override
    public void checkEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void checkFailEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void makePriceEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void acceptOrderEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        throw EXCEPTION;
    }

    @Override

    public void payOrderEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void orderFailureEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void feedBackEvent(Context context) {
        throw EXCEPTION;
    }
}

package com.lin.state.project;

    //環境上下文
public class Context extends AbstractState {
    //當前的狀態 state, 根據我們的業務流程處理，不停的變化
    private State state;

    @Override
    public void checkEvent(Context context) {
        state.checkEvent(this);
        getCurrentState();
    }

    @Override
    public void checkFailEvent(Context context) {
        state.checkFailEvent(this);
        getCurrentState();
    }

    @Override
    public void makePriceEvent(Context context) {
        state.makePriceEvent(this);
        getCurrentState();
    }

    @Override
    public void acceptOrderEvent(Context context) {
        state.acceptOrderEvent(this);
        getCurrentState();
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        state.notPeopleAcceptEvent(this);
        getCurrentState();
    }

    @Override
    public void payOrderEvent(Context context) {
        state.payOrderEvent(this);
        getCurrentState();
    }

    @Override

    public void orderFailureEvent(Context context) {
        state.orderFailureEvent(this);
        getCurrentState();
    }

    @Override
    public void feedBackEvent(Context context) {
        state.feedBackEvent(this);
        getCurrentState();
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    @Override
    public String getCurrentState() {
        System.out.println("當前狀態 : " + state.getCurrentState());
        return state.getCurrentState();
    }
}

package com.lin.state.project;

    //各種具體狀態類
public class FeedBackState extends AbstractState {

    @Override
    public String getCurrentState() {
        return StateEnum.FEED_BACKED.getValue();
    }
}

class GenerateState extends AbstractState {

    @Override
    public void checkEvent(Context context) {
        context.setState(new ReviewState());
    }

    @Override
    public void checkFailEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.GENERATE.getValue();
    }
}

class NotPayState extends AbstractState {

    @Override
    public void payOrderEvent(Context context) {
        context.setState(new PaidState());
    }

    @Override

    public void feedBackEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.NOT_PAY.getValue();
    }
}

class PaidState extends AbstractState {

    @Override
    public void feedBackEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PAID.getValue();
    }
}

class PublishState extends AbstractState {

    @Override

    public void acceptOrderEvent(Context context) {
    //把當前狀態設定為    NotPayState。。。
    //至於應該變成哪個狀態，有流程圖來決定
        context.setState(new NotPayState());
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PUBLISHED.getValue();
    }
}

class ReviewState extends AbstractState {

    @Override
    public void makePriceEvent(Context context) {
        context.setState(new PublishState());
    }

    @Override
    public String getCurrentState() {

        return StateEnum.REVIEWED.getValue();
    }

}

package com.lin.state.project;

    /** 測試類 */
public class Client {

    public static void main(String[] args) {
        //建立 context 物件
        Context context = new Context();
        //將當前狀態設定為 PublishState 
        context.setState(new PublishState());
        System.out.println(context.getCurrentState());

        //        //publish --> not pay 
        context.acceptOrderEvent(context);
        //        //not pay --> paid 
        context.payOrderEvent(context);
        //    // 失敗, 檢測失敗時，會丟擲異常
        //    try {
        //    context.checkFailEvent(context);
        //    System.out.println("流程正常..");
        //    } catch (Exception e) {
        
        //    // TODO: handle exception
        //    System.out.println(e.getMessage());
        //    }
    }

}

24.1 狀態模式的注意事項和細節

1) 程式碼有很強的可讀性。狀態模式將每個狀態的行為封裝到對應的一個類中

2) 方便維護。將容易產生問題的 if-else 語句刪除了，如果把每個狀態的行為都放到一個類中，每次呼叫方法時都要判斷當前是什麼狀態，不但會產出很多 if-else 語句，而且容易出錯

3) 符合“開閉原則”。容易增刪狀態

4) 會產生很多類。每個狀態都要一個對應的類，當狀態過多時會產生很多類，加大維護難度

5) 應用場景：當一個事件或者物件有很多種狀態，狀態之間會相互轉換，對不同的狀態要求有不同的行為的時候，可以考慮使用狀態模式

僅供參考，有錯誤還請指出！

有什麼想法，評論區留言，互相指教指教。

覺得不錯的可以點一下右邊的推薦喲！

軟體設計模式系列之二十二——狀態模式
2023-10-04
設計模式
活動抽獎元件設計
2019-07-17
元件
設計模式-狀態模式
2021-05-01
設計模式
設計模式：狀態模式
2019-01-27
設計模式
設計模式（十五）狀態模式
2019-01-22
設計模式
設計模式之——狀態模式
2020-11-11
設計模式
javascript設計模式狀態模式
2017-04-12
JavaScript設計模式
設計模式（六）：狀態模式
2016-01-08
設計模式
PHP 設計模式之狀態模式
2020-01-07
PHP設計模式
簡說設計模式——狀態模式
2019-05-26
設計模式
設計模式之狀態模式（State）
2021-09-09
設計模式
設計模式-狀態模式（State Pattern）
2018-09-05
設計模式
python設計模式狀態模式
2019-01-03
Python設計模式
設計模式20之狀態模式
2020-11-23
設計模式
極簡設計模式-狀態模式
2021-12-10
設計模式
GoLang設計模式14 - 狀態模式
2021-11-13
Golang設計模式
Python設計模式-狀態模式
2017-06-26
Python設計模式
Java設計模式之狀態模式
2016-11-30
Java設計模式
設計模式——20狀態模式（State）
2017-12-11
設計模式
設計模式系列之「狀態模式」
2017-12-02
設計模式
23種設計模式(七)-狀態設計模式
2021-07-07
設計模式
設計模式第八講-狀態模式
2019-01-19
設計模式
設計模式漫談之狀態模式
2018-08-05
設計模式
python設計模式【9】-狀態模式
2020-11-27
Python設計模式
《Head First 設計模式》：狀態模式
2020-09-21
設計模式
C#設計模式之狀態模式
2018-06-03
C#設計模式
設計模式系列9--狀態模式
2016-12-13
設計模式
設計模式系列之十二狀態模式
2016-12-24
設計模式
設計模式之狀態模式---State Pattern
2016-08-05
設計模式
我學設計模式之狀態模式
2010-09-22
設計模式
設計模式--直譯器模式和狀態模式
2020-10-27
設計模式
NFT模式APP原始碼開發|NFT交易平臺
2021-10-15
模式APP原始碼
折騰Java設計模式之狀態模式
2019-04-04
Java設計模式
Unity【話大】設計模式之狀態模式
2019-01-31
Unity設計模式
C#設計模式系列：狀態模式（State）
2014-04-09
C#設計模式
設計模式--狀態模式State(行為型）
2014-04-14
設計模式
JAVA設計模式之狀態模式【State Pattern】
2014-11-12
Java設計模式
用設計模式去掉沒必要的狀態變數 —— 狀態模式
2019-06-12
設計模式變數