三魚網教你一招搞定京東申請刪單疑問，助你店鋪不被扣分

很多人會問我店鋪申請刪單之后，店鋪分數就被扣完了，導致店鋪只能暫時性關閉，那么這就是犯了常見的錯誤。京東刪單是商家由于各種原因向后臺提出刪單申請，刪除訂單可以更好的保障店鋪運營基本不受影響。但是具體哪些情況下能刪單，刪單時會遇到哪些疑問，這些都是很大問題。都知道當遇到批量下單、敲詐勒索、差價/運費/贈品鏈接、套取利益這四類場景情況時，自然能提交異常訂單刪除。如果不是這些情況，還能有什么方法刪單呢。

1、除京東異常刪單，還有什么情況能刪單？

還有一種情況是協商刪單，這種僅限貨到付款訂單。使用場景有4種，下面分別舉例。

第一種，商家聯系客戶，客戶同意取消訂單。例如商品脫銷/超賣/有瑕疵，商家可預先聯系客戶解釋，征得客戶同意的前提下，提交刪單申請，并注明刪單原因。第二種，商家聯系客戶，客戶同意取消訂單。例如：貨到付款訂單用戶拒收，賣家聯系用戶，確認商品拒收取消后提交刪單申請。第三種，聯系不上客戶或客戶同意取消訂單。例如：用戶下單不符合購買規則或地址不詳無法配送，商家聯系用戶確認訂單異常點，是否可以修改訂單，如無法修改是否同意取消訂單。第四種，客戶要求取消訂單。例如：用戶原因取消訂單申請刪單，用戶通過咚咚/400電話聯系商家告知要求取消訂單。

2、京東協商刪單具體怎么操作？

具體操作路徑：權益服務 >維權管理>刪單申請 > 協商刪單>添加刪單。

3、申請京東刪單后，訂單多久之后就會刪除？

商家提交刪單申請后，系統自動觸發短信至消費者，告知訂單已被申請刪除。如消費者反饋未與商家達成一致，則刪單申請被駁回；如消費者未提出異議，訂單在48小時后自動刪除。

4、京東惡意訂單申請刪單記錄在哪里查？

商家登錄商家后臺—權益服務—維權管理—申請刪單—異常刪單/協商刪單內，默認展示申請刪單歷史記錄，或者您也可以選擇對應的篩選框選項進行查詢。

5、違規申請刪單，平臺將會給予哪種處罰？

對未經消費者同意申請協商刪單、遭消費者投訴的的商家，平臺將按《京東開放平臺商家積分管理規則》中“違背承諾”進行處理，每次扣12分。

ttps://v.qq.com/x/page/k3208z8fdh6.html

乘客取消訂單的原因有千千萬

責任劃分怎么算

跟乘客溝通的過程很重要

有一些字眼千萬不能說

否則無責變有責

【那你取消吧】

但凡是你給乘客傳達出這樣的語句

那么一定是司機有責

而且！

乘客看到取消后要付空接費后更不爽，隨便找個理由去投訴，結果服務分被扣了，你說冤不冤呢？

還有一些情況，也屬于誘導乘客取消的行為

以下語句都會被判有責

以臨時有事為由

你好，我是咱們滴滴司機，我要去吃飯呢，要不您換個車？

以車有問題為由

你好，我是咱們滴滴司機，我車出現一點問題，不能去接您，要不您換個車？
以車有問題為由而實際上車并沒問題，這個理由也是不成立的。

以距離太遠為由

你好，我是咱們滴滴司機，我距離你那里太遠了，你重新叫一輛車吧。

以堵車為由

你好，我是咱們滴滴司機，這會兒很堵車，我過去接您估計要半個小時，要不您重新叫一輛車？

要求加價

你好，我是滴滴司機，我接你這一單不賺錢還得空跑回來，你看我去接你的話能不能加一下空駛補償和過路費。

所以，各位司機師傅們，溝通過程中

要【表達自己的接駕意愿】

不要【說出誘導乘客取消訂單的話】

記住了嗎

skr~

態機簡介：

狀態機是有限狀態自動機的簡稱，是現實事物運行規則抽象而成的一個數學模型。【規則的抽象】

有限狀態機一般都有以下特點：

（1）可以用狀態來描述事物，并且任一時刻，事物總是處于一種狀態；

（2）事物擁有的狀態總數是有限的；

（3）通過觸發事物的某些行為，可以導致事物從一種狀態過渡到另一種狀態；

（4）事物狀態變化是有規則的，A狀態可以變換到B，B可以變換到C，A卻不一定能變換到C；

（5）同一種行為，可以將事物從多種狀態變成同種狀態，但是不能從同種狀態變成多種狀態。

狀態機這種描述客觀世界的方式就是將事物抽象成若干狀態，然后所有的事件和規則導致事物在這些狀態中游走。最終使得事物“自圓其說”。

很多通信協議的開發都必須用到狀態機；一個健壯的狀態機可以讓你的程序，不論發生何種突發事件都不會突然進入一個不可預知的程序分支。

狀態機示例：

四大概念：

狀態（state）

一個狀態機至少要包含兩個狀態。

分為：現態（源狀態）、次態（目標狀態）

狀態可以理解為一種結果，一種穩態形式，沒有擾動會保持不變的。

狀態命名形式：

1.副詞+動詞；例如：待審批、待支付、待收貨

這種命名方式體現了：狀態機就是事件觸發狀態不斷遷徙的本質。表達一種待觸發的感覺。

2.動詞+結果；例如：審批完成、支付完成

3.已+動詞形式；例如：已發貨、已付款

以上兩種命名方式體現了：狀態是一種結果或者穩態的本質。表達了一種已完成的感覺。

角色很多的時候，為了表示清晰，可以加上角色名：例如：待財務審批、主管批準

命名考慮從用戶的理解的角度出發。

事件（event）

觸發條件

又稱為“條件”，就是某個操作動作的觸發條件或者口令。當一個條件滿足時，就會觸發一個動作，或者執行一次狀態遷徙

這個事件可以是外部調用、監聽到消息、或者各種定時到期等觸發的事件。

對于燈泡，“打開開關”就是一個事件。

條件命名形式：動詞+結果；例如：支付成功、下單時間>5分鐘

動作（action）

事件發生以后要執行動作。例如：事件=“打開開關指令”，動作=“開燈”。一般就對應一個函數。

條件滿足后執行動作。動作執行完畢后，可以遷移到新的狀態，也可以仍舊保持原狀態。

動作不是必需的，當條件滿足后，也可以不執行任何動作，直接遷移到新狀態。

那么如何區分“動作”和“狀態”？

“動作”是不穩定的，即使沒有條件的觸發，“動作”一旦執行完畢就結束了；

而“狀態”是相對穩定的，如果沒有外部條件的觸發，一個狀態會一直持續下去。

變換（transition）

即從一個狀態變化到另外一個狀態

例如：“開燈過程”就是一個變化

狀態機其他表達方式：

狀態機的設計：

信息系統中有很多狀態機，例如：業務訂單的狀態。

狀態機的設計存在的問題：什么是狀態？到底有多少個狀態？要細分到什么程度？

　　信息系統是現實世界的一種抽象和描述。而業務領域中那些已經發生的事件就是事實，信息系統就是將這些事實以信息的形式存儲到數據庫中，即：信息就是一組事實

信息系統就是存儲這些事實，對這些事實進行管理與追蹤，進而起到提高工作效率的作用。

信息系統就是記錄已經發生的事實，信息系統中的狀態基本和事實匹配。即：標識某個事實的完成度。

業務系統，根據實際業務，具體會有哪些發生的事實需要記錄，基本上這些事實就至少對應一個狀態。需要記錄的事實就是一種穩態，一種結果。

例如：【待支付】->【已支付】->【已收貨】->【已評價】

這些都是系統需要記錄的已發生的客觀事實。而這些事實就對應了狀態，而發生這些事實的事件就對應了觸發狀態機的轉換的事件。

根據自己的業務實際進行分析，并畫出狀態圖即可。

狀態機實現方式：狀態模式

下面是經典的自動販賣機例子來說明狀態模式的用法，狀態圖如下：

分析一個這個狀態圖：

a、包含4個狀態（我們使用4個int型常量來表示）
b、包含3個暴露在外的方法（投幣、退幣、轉動手柄、(發貨動作是內部方法，售賣機未對外提供方法，售賣機自動調用)）
c、我們需要處理每個狀態下，用戶都可以觸發這三個動作。

我們可以做沒有意義的事情，在【未投幣】狀態，試著退幣，或者同時投幣兩枚，此時機器會提示我們不能這么做。

實現邏輯：

　　　　任何一個可能的動作，我們都要檢查，看看我們所處的狀態和動作是否合適。

狀態機使用if-else或switch實現

測試自動售賣機

使用if-else/switch的方式實現狀態有如下問題：

沒有遵守【開閉】原則，沒有【封裝變化】，所以沒有彈性，應對需求變更非常吃力。

　　例如：現在增加一個狀態。每個方法都需要添加if-else語句。

狀態如何轉換看得不是很清楚，隱藏在if-else/switch邏輯中。

升級策略：

【封裝變化】，局部化每個狀態的行為，將每個狀態的行為放到各自類中，每個狀態只要實現自己的動作就可以了。

販賣機只要將動作委托給代表當前狀態的狀態對象即可。

public interface State
{
    /**
     * 放錢
     */
    public void insertMoney();
    /**
     * 退錢
     */
    public void backMoney();
    /**
     * 轉動曲柄
     */
    public void turnCrank();
    /**
     * 出商品
     */
    public void dispense();
}

public class NoMoneyState implements State
{
 
    private VendingMachine machine;
 
    public NoMoneyState(VendingMachine machine)
    {
        this.machine=machine;
        
    }
    
    @Override
    public void insertMoney()
    {
        System.out.println("投幣成功");
        machine.setState(machine.getHasMoneyState());
    }
 
    @Override
    public void backMoney()
    {
        System.out.println("您未投幣，想退錢？...");
    }
 
    @Override
    public void turnCrank()
    {
        System.out.println("您未投幣，想拿東西么？...");
    }
 
    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }
 
}

public class HasMoneyState implements State
{
 
    private VendingMachine machine;
 
    public HasMoneyState(VendingMachine machine)
    {
        this.machine=machine;
    }
 
    @Override
    public void insertMoney()
    {
        System.out.println("您已經投過幣了，無需再投....");
    }
 
    @Override
    public void backMoney()
    {
        System.out.println("退幣成功");
            machine.setState(machine.getNoMoneyState());
    }
 
    @Override
    public void turnCrank()
    {
        System.out.println("你轉動了手柄");
        machine.setState(machine.getSoldState());
    }
 
    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }
 
}

public class SoldOutState implements State
{
 
    private VendingMachine machine;
 
    public SoldOutState(VendingMachine machine)
    {
        this.machine=machine;
    }
 
    @Override
    public void insertMoney()
    {
        System.out.println("投幣失敗，商品已售罄");
    }
 
    @Override
    public void backMoney()
    {
        System.out.println("您未投幣，想退錢么？...");
    }
 
    @Override
    public void turnCrank()
    {
        System.out.println("商品售罄，轉動手柄也木有用");
    }
 
    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }
 
}

public class SoldState implements State
{
 
    private VendingMachine machine;
 
    public SoldState(VendingMachine machine)
    {
        this.machine=machine;
    }
 
    @Override
    public void insertMoney()
    {
        System.out.println("正在出貨，請勿投幣");
    }
 
    @Override
    public void backMoney()
    {
        System.out.println("正在出貨，沒有可退的錢");
    }
 
    @Override
    public void turnCrank()
    {
        System.out.println("正在出貨，請勿重復轉動手柄");
    }
 
    @Override
    public void dispense()
    {
        machine.releaseBall();
        if (machine.getCount() > 0)
        {
            machine.setState(machine.getNoMoneyState());
        } else
        {
            System.out.println("商品已經售罄");
            machine.setState(machine.getSoldOutState());
        }
    }
}

public class VendingMachine
{
    private State noMoneyState;
    private State hasMoneyState;
    private State soldState;
    private State soldOutState;
    private State winnerState ; 


    private int count=0;
    private State currentState=noMoneyState;
 
    public VendingMachine(int count)
    {
        noMoneyState=new NoMoneyState(this);
        hasMoneyState=new HasMoneyState(this);
        soldState=new SoldState(this);
        soldOutState=new SoldOutState(this);
        winnerState=new WinnerState(this);
 
              if (count > 0)
             {
            this.count=count;
            currentState=noMoneyState;
             }
    }
 
       //將這些動作委托給當前狀態.
    public void insertMoney()
    {
        currentState.insertMoney();
    }
 
    public void backMoney()
    {
        currentState.backMoney();
    }
       
        // 機器不用提供dispense動作,因為這是一個內部動作.用戶不可以直 
        //接要求機器發放糖果.我們在狀態對象的turnCrank()方法中調用 
        //dispense方法;

       //dispense無論如何，即使在nomoney狀態也會被執行.
       //讓不合法的情形下，dispense拋出異常處理。
    public void turnCrank()
    {
        currentState.turnCrank();
            currentState.dispense();
    }
 

    public void releaseBall()
    {
        System.out.println("發出一件商品...");
        if (count !=0)
        {
            count -=1;
        }
    }
 
    public void setState(State state)
    {
        this.currentState=state;
    }
 
    //getter setter omitted ...
 
}

我們之前說過，if-else/switch實現方式沒有彈性，那現在按照這種實現模式，需求變更修改起來會輕松點嗎？

紅色部分標記了我們的需求變更：當用戶每次轉動手柄的時候，有10%的幾率贈送一瓶。

實現方式：

我們遵守了【開閉】原則，只要新建一個WinnerState的類即可。然后有限的修改has_money的轉向即可。

為什么WinnerState要獨立成一個狀態，其實它和sold狀態一模一樣。我把代碼寫在SoldState中不行嗎？

第一個原因就是上面說的信息系統的本質就是記錄【事實】，中獎是需要記錄的事實，它應該是一個狀態。
第二個原因：【單一職責】問題，我們一個類的責任是明確的。

　　　如果sold需求變化不一定影響到winner代碼實現，winner需求變化時，也不一定要修改sold，比如促銷方案結束了，中獎概率變了等。

　　　如果他們的變化不是一定互相影響到彼此的，那我們就該將他們分離，即是【隔離變化】也是遵守【單一職責】的原則。

public class WinnerState implements State
{
 
    private VendingMachine machine;
 
    public WinnerState(VendingMachine machine)
    {
        this.machine=machine;
    }
 
    @Override
    public void insertMoney()
    {
        throw new IllegalStateException("非法狀態");
    }
 
    @Override
    public void backMoney()
    {
        throw new IllegalStateException("非法狀態");
    }
 
    @Override
    public void turnCrank()
    {
        throw new IllegalStateException("非法狀態");
    }
 
    @Override
    public void dispense()
    {
        System.out.println("你中獎了，恭喜你，將得到2件商品");
        machine.releaseBall();
 
    if (machine.getCount()==0)
    {
        System.out.println("商品已經售罄");
        machine.setState(machine.getSoldOutState());
    } else
    {
        machine.releaseBall();
        if (machine.getCount() > 0)
        {
            machine.setState(machine.getNoMoneyState());
        } else
        {
            System.out.println("商品已經售罄");
            machine.setState(machine.getSoldOutState());
        }
        
    }
 
    }
 
}

public class HasMoneyState implements State
{
 
    private VendingMachine machine;
    private Random random=new Random();
 
    public HasMoneyState(VendingMachine machine)
    {
        this.machine=machine;
    }
 
    @Override
    public void insertMoney()
    {
        System.out.println("您已經投過幣了，無需再投....");
    }
 
    @Override
    public void backMoney()
    {
        System.out.println("退幣成功");
 
    machine.setState(machine.getNoMoneyState());
    }
 
    @Override
    public void turnCrank()
    {
        System.out.println("你轉動了手柄");
        int winner=random.nextInt(10);
        if (winner==0 && machine.getCount() > 1)
        {
            machine.setState(machine.getWinnerState());
        } else
        {
            machine.setState(machine.getSoldState());
        }
    }
 
    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }
 
}

總結狀態模式：

狀態模式：允許對象在內部狀態改變時改變它的行為，對象看起來好像修改了他的類。

解釋：

狀態模式將狀態封裝成為獨立的類,并將動作委托到代表當前狀態的對象。
所以行為會隨著內部狀態改變而改變。
我們通過組合簡單引用不同狀態對象來造成類改變的假象.

狀態模式策略模式

1.行為封裝的n個狀態中，不同狀態不用行為。

2.context的行為委托到不同狀態中。

3.[當前狀態]在n個狀態中游走，context的行為也隨之[當前狀態]的改變而改變。

4.用戶對context的狀態改變渾然不知。

5.客戶不會直接和state交互，只能通過context暴露的方法交互，state轉換是context內部事情。

6.state可以是接口也可以是抽象類，取決于有沒公共功能可以放進抽象類中。抽象類方便，因為可以后續加方法。

可以將重復代碼放入抽象類中。例如:"你已投入25元，不能重復投" 這種通用代碼放入抽象類中。

7.context可以決定狀態流轉，如果這個狀態流轉是固定的，就適合放在context中進行。但是如果狀態流轉是動態的就適合放在狀態中進行。

例如通過商品的剩余數目來決定流向[已售完]或[等待投幣]，這個時候放在狀態類中，因為dispense要根據狀態判斷流轉。

這個寫法決定了，有新需求時候，你是改context還是改state類。

8.可以共享所有的state對象，但是需要修改context的時候時候，需要handler中傳入context引用

1.context主動指定需要組合的策略對象是哪一個。

2.可以在啟動的時候通過工廠動態指定具體是哪個策略對象，但是沒有在策略對象之間游走，即:只組合了一個策略對象。

3.策略作為繼承之外一種彈性替代方案。因為繼承導致子類繼承不適用的方法，且每個類都要維護，策略模式通過不同對象組合來改變行為。

4.策略模式聚焦的是互換的算法來創建業務。

狀態機典型應用：訂單狀態控制

建表語句

如上圖所示：

一種典型的訂單設計。業務訂單和支付退款訂單組合，他們分別有自己的狀態機。

業務訂單狀態機負責業務邏輯，并和支付退款狀態機聯動。
一切以業務狀態機為主。例如：業務狀態已經【關單】，此時收到支付成功通知，需要進行退款
每個狀態有自己的過期時間。異常訂單的撈取通過過期時間判斷。

狀態機模式實現訂單狀態機：

日常開發過程中，狀態機模式應用場景之一的就是訂單模型中的狀態控制。但是區別于狀態模式的點有以下幾個：

狀態模式，所有的操作都在內存。而訂單狀態機是要落庫的。為了防止訂單的并發操作，更新訂單的時候需要使用樂觀鎖機制。
狀態模式的狀態對象是新建狀態機的時候初始化進去的。在實際開發中，狀態對象要復用，被spring管理。
而訂單狀態機對象對應了一條數據庫中實體的訂單，是要每次從數據庫中查出來的即時新建對象，所以必須將該新建的訂單狀態機對象傳入到狀態對象中。使用狀態對象處理該訂單狀態機對象。

以支付訂單為例：

/*
   Title: PaymentInfo Description:
　　支付訂單狀態機
   該類不可被spring管理，需要new出來，一個類就對應一條數據庫中支付訂單記錄
   本文來自博客園，作者：wanglifeng，轉載請注明原文鏈接：https://www.cnblogs.com/wanglifeng717/p/16214122.html
   
   @author wanglifeng
 */


public class PaymentStateMachine {

    // 數據庫中當前支付訂單實體
    private SapoPayment payment;

    // 當前狀態
    private PaymentState currentState;

    // 需要更新入庫的支付訂單實體。與payment屬性配合，payment為當前數據庫中訂單實體,用于樂觀鎖的前置內容校驗。
    private SapoPayment paymentForUpdate;

    /* 將最新內容(含狀態)更新入庫，并當前狀態機狀態 */
    public void updateStateMachine() {

        // 從Spring容器中獲取操作數據的dao
        SapoDao dao=SpringUtil.getBean(SapoDao.class);

        // 更新數據庫，樂觀鎖機制：帶前置內容數據校驗，其中payment為前置內容，paymentForUpdate為要更新的內容，如果更新結果=0，說明該訂單被其他線程修改過。拋異常，放棄此次修改。
        dao.updateSapoPaymentByNull(paymentForUpdate, payment);

        // 記錄訂單操作流水
        dao.insertSapoOrderStatusLog(SapoOrderStatusLog.getInstance().setOrderId(paymentForUpdate.getId())
                .setOrderType(SapoOrderStatusLog.ORDER_TYPE_PAYMENT).setStatus(paymentForUpdate.getStatus()));

        // 更新當前PaymentStateMachine狀態機
        this.setPayment(paymentForUpdate);
        this.setCurrentState(paymentForUpdate.getStatus());
    }

    // 通過條件獲取一個支付訂單PaymentStateMachine實體
    public static PaymentStateMachine getInstance(SapoPayment sapoPaymentForQuery) {
        // 1.從spring容器中獲取dao；
        SapoDao dao=SpringUtil.getBean(SapoDao.class);

        // 2.查出該支付訂單
        SapoPayment paymentResult=dao.getSapoPayment(sapoPaymentForQuery);

        // 3.初始化訂單狀態機
        PaymentStateMachine paymentStateMachine=new PaymentStateMachine();
        paymentStateMachine.setPayment(paymentResult);
        paymentStateMachine.setCurrentState(paymentResult.getStatus());
        paymentStateMachine.setPaymentForUpdate(SapoPayment.getInstance(paymentResult));

        return paymentStateMachine;
    }

    // 設置當前狀態機的狀態。輸入數據庫中status字段，映射成對應的狀態類實體。
    public void setCurrentState(Integer status) {

        PaymentState currentState=null;

        // status數字，映射成對應的狀態類實體
        if (SapoPayment.STATUS_APPLY.equals(status)) {
            currentState=SpringUtil.getBean(PaymentStateApply.class);
        } else if (SapoPayment.STATUS_WAIT_PAY.equals(status)) {
            currentState=SpringUtil.getBean(PaymentStateWaitPay.class);
        } else if (SapoPayment.STATUS_PAY_FINISH.equals(status)) {
            currentState=SpringUtil.getBean(PaymentStatePayFinish.class);
        } else if (SapoPayment.STATUS_FAIL.equals(status)) {
            currentState=SpringUtil.getBean(PaymentStateFail.class);
        } else if (SapoPayment.STATUS_CANCEL.equals(status)) {
            currentState=SpringUtil.getBean(PaymentStateCancel.class);
        } else {
            throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(),
                    "status not in state machine ,status: " + status);
        }

        this.currentState=currentState;
    }

    // TODO 待實現，申請支付訂單
    public void apply() {
        // 委托給當前狀態執行,將當前訂單狀態機對象傳進去，使用狀態對象處理訂單
        currentState.apply(this);
    }

    // TODO 待實現，通知支付結果
    public void resultNotify() {
        // 委托給當前狀態執行
        currentState.resultNotify(this);
    }

    // TODO 同步給當前狀態執行
    public void sync() {
        // 委托給當前狀態執行
        currentState.sync(this);
    }

    // 取消訂單
    public void cancel() {
        // 委托給當前狀態執行
        currentState.cancel(this);
    }


}

public  interface PaymentState {

    public void apply(PaymentStateMachine paymentStateMachine);

    public void resultNotify(PaymentStateMachine paymentStateMachine);
    
    public void sync(PaymentStateMachine paymentStateMachine);
    
    public void cancel(PaymentStateMachine paymentStateMachine);

}

@Service
public class PaymentStateApply extends BaseLogger implements PaymentState {

    @Autowired
    FmPayClientService fmPayClientService;

    @Autowired
    SapoDao dao;

    @Autowired
    private JacksonComponent jacksonComponent;

    public void apply(PaymentStateMachine paymentStateMachine) {

       

    }

    public void sync(PaymentStateMachine paymentStateMachine) {

    }

    public void resultNotify(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void cancel(PaymentStateMachine paymentStateMachine) {
        
        SapoPayment sapoPaymentForUpdate=paymentStateMachine.getPaymentForUpdate();
        sapoPaymentForUpdate.setStatus(SapoPayment.STATUS_CANCEL);
        sapoPaymentForUpdate.setExpireTime(null);
        
        paymentStateMachine.updateStateMachine();
        
        

    }

}

@Service
public class PaymentStateCancel extends BaseLogger implements PaymentState {

    public void apply(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void resultNotify(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void sync(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void cancel(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

}

@Service
public class PaymentStateFail extends BaseLogger implements PaymentState {

    public void apply(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void resultNotify(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void sync(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void cancel(PaymentStateMachine paymentStateMachine) {
        throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(), "fail status can not cancel");

    }

}

@Service
public class PaymentStatePayFinish extends BaseLogger implements PaymentState {

    public void apply(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void resultNotify(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void sync(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void cancel(PaymentStateMachine paymentStateMachine) {
        throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(), "payfinish status can not cancel");

    }

}

@Service
public class PaymentStateWaitPay extends BaseLogger implements PaymentState {

    @Autowired
    FmPayClientService fmPayClientService;

    @Autowired
    SapoDao dao;

    @Autowired
    private JacksonComponent jacksonComponent;

    public void payResultNotify() {
        // TODO implement here
    }

    public void apply(PaymentStateMachine paymentStateMachine) {
        throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(),
                "applyPayPlatform not match payment state machine,currentStatus:"
                        + paymentStateMachine.getPayment().getStatus());

    }

    public void sync(PaymentStateMachine paymentStateMachine) {


        // TODO 過期去統一支付查詢

        String payStatus=queryPayResultResponse.getPayStatus();

        // 1：初始化輸入 2：支付中 3：支付成功 4：支付失敗 5：撤銷
        if (QueryPayResultResponse.PAY_STATUS_INIT.equals(payStatus)) {
            throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(),
                    "FMpay queryPay return init status ,we are waitpay");
        }

        if (QueryPayResultResponse.PAY_STATUS_ING.equals(payStatus)) {
            return;
        }

        SapoPayment sapoPaymentForUpdate=paymentStateMachine.getPaymentForUpdate();

        if (QueryPayResultResponse.PAY_STATUS_CANCEL.equals(payStatus)) {
            sapoPaymentForUpdate.setStatus(SapoPayment.STATUS_CANCEL);

        } else if (QueryPayResultResponse.PAY_STATUS_FAIL.equals(payStatus)) {
            sapoPaymentForUpdate.setStatus(SapoPayment.STATUS_FAIL);

        } else if (QueryPayResultResponse.PAY_STATUS_SUCCESS.equals(payStatus)) {
            sapoPaymentForUpdate.setStatus(SapoPayment.STATUS_PAY_FINISH);

        }
        sapoPaymentForUpdate.setExpireTime(null);

        paymentStateMachine.updateStateMachine();

    }

    public void resultNotify(PaymentStateMachine paymentStateMachine) {
        // TODO Auto-generated method stub

    }

    public void cancel(PaymentStateMachine paymentStateMachine) {
        throw new BusinessException(ResultInfo.SYS_INNER_ERROR.getCode(), "wait pay status can not cancel");

    }

}

文章來自https://www.cnblogs.com/wanglifeng717/p/16214122.html

在線咨詢

上一篇：怎樣通過font屬性控制CSS字體樣式？
下一篇：NutUI Bingo - 基于 Vue 3.0 的

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。

整合營銷服務商

三魚網教你一招搞定京東申請刪單疑問，助你店鋪不被扣分

您的項目需求