程式碼如下：

1.TestItemBizService 和TestOrderBizService 這兩個類是真實業務邏輯處理

/**
 *
 * @Author：xuliangliang
 * @Description：模擬訂單業務邏輯處理
 * @Date 2020/8/28
 */
@Service
public class TestOrderBizService {

    /**
     * 業務邏輯1
     * @param order
     * @return
     */
    public ResultResponse bizOne(OrderPO order) {
        
 
//業務邏輯處理
        ResultResponse<OrderPO> resultEntity = new ResultResponse(order.getId()+"業務邏輯1");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(order);
        return resultEntity;
    }

    /**
     * 業務邏輯2
     * @param order
     * 
 
@return
     */
    public ResultResponse bizTwo(OrderPO order) {
        ResultResponse<OrderPO> resultEntity = new ResultResponse(order.getId()+"業務邏輯2");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(order);
        return
 
 resultEntity;
    }

    /**
     * 業務邏輯3
     * @param order
     * @return
     */
    public ResultResponse bizThree(OrderPO order) {
        ResultResponse<OrderPO> resultEntity = new ResultResponse(order.getId()+"業務邏輯3");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(order);
        return resultEntity;
    }
}

/**
 *
 * @Author：xuliangliang
 * @Description：模擬商品業務邏輯處理單元
 * @Date 2020/8/28
 */
@Service
public class TestItemBizService {

    /**
     * 業務邏輯1
     * @param item
     * @return
     */
    public ResultResponse bizOne(ItemPO item) {
        //業務邏輯處理
        ResultResponse<ItemPO> resultEntity = new ResultResponse(item.getId()+"業務邏輯1");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(item);
        return resultEntity;
    }

    /**
     * 業務邏輯2
     * @param item
     * @return
     */
    public ResultResponse bizTwo(ItemPO item) {
        ResultResponse<ItemPO> resultEntity = new ResultResponse(item.getId()+"業務邏輯2");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(item);
        return resultEntity;
    }

    /**
     * 業務邏輯3
     * @param item
     * @return
     */
    public ResultResponse bizThree(ItemPO item) {
        ResultResponse<ItemPO> resultEntity = new ResultResponse(item.getId()+"業務邏輯3");
        resultEntity.setIsSuccess(Boolean.TRUE);
        resultEntity.setErrorCode("200");
        resultEntity.setData(item);
        return resultEntity;
    }
}

2.ItemBizContext 和OrderBizContext 這兩個類是業務處理上下文，主要作用是為了根據傳入引數標識位進行動態選擇不通的業務邏輯處理點

/**
 *
 * @Author：xuLiangLiang
 * @Description：訂單上下文
 * @Date 2020/9/9
 */
@AllArgsConstructor
@Component
public class OrderBizContext implements ContextProxyInterface<OrderPO, ResultResponse> {

    private final TestOrderBizService testOrderBizService;
    /**
     *儲存策略方法 測試訂單業務邏輯
     */
    private Map<ServiceFlagEnum, Function<OrderPO, ResultResponse>> checkResultDispatcherOrderComX = new ConcurrentHashMap<>();


    /**
     * 初始化 業務邏輯分派Map 其中value 存放的是 lambda表示式
     */
    @PostConstruct
    private void checkResultDispatcherComXInit() {
        //訂單業務
        checkResultDispatcherOrderComX.put(ServiceFlagEnum.ORDER_MARK001, order -> testOrderBizService.bizOne(order));
        checkResultDispatcherOrderComX.put(ServiceFlagEnum.ORDER_MARK002, order -> testOrderBizService.bizTwo(order));
        checkResultDispatcherOrderComX.put(ServiceFlagEnum.ORDER_MARK003, order -> testOrderBizService.bizThree(order));
    }

    /**
     * 獲取策略邏輯
     * @param order
     * @param mark
     * @return
     */
    private ResultResponse getCheckResultOrderComX(OrderPO order, String mark) {

        ServiceFlagEnum flagStrategy = ServiceFlagEnum.getFlagStrategy(mark);
        if(flagStrategy == null){
            return new ResultResponse("沒有["+mark+"]標識業務");
        }

        Function<OrderPO, ResultResponse> result = checkResultDispatcherOrderComX.get(flagStrategy);
        if (result != null) {
            //執行這段表示式獲得的結果
            return result.apply(order);
        }

        return new ResultResponse("不在處理的邏輯中返回業務錯誤");
    }

    @Override
    public ResultResponse doExecute(OrderPO orderEntity) {
        return getCheckResultOrderComX(orderEntity, orderEntity.getMark());
    }
}

/**
 *
 * @Author：xuliangliang
 * @Description：商品上下文
 * @Date 2020/8/28
 */
@Component
public class ItemBizContext implements ContextProxyInterface<ItemPO, ResultResponse> {

    @Autowired
    private TestItemBizService testItemBizService;

    /**
     * 儲存策略方法 商品業務邏輯
     */
    private Map<ServiceFlagEnum, ServiceStrategyInterface<ItemPO, ResultResponse>> checkResultDispatcherItemComX = new ConcurrentHashMap<>();

    /**
     * 初始化 業務邏輯分派Map 其中value 存放的是 lambda表示式
     */
    @PostConstruct
    private void checkResultDispatcherComXInit() {
        //商品業務
        checkResultDispatcherItemComX.put(ServiceFlagEnum.ITEM_MARK001, item-> testItemBizService.bizOne(item));
        checkResultDispatcherItemComX.put(ServiceFlagEnum.ITEM_MARK002, item-> testItemBizService.bizTwo(item));
        checkResultDispatcherItemComX.put(ServiceFlagEnum.ITEM_MARK003, item-> testItemBizService.bizThree(item));
    }

    /**
     * 獲取策略邏輯
     * @param order
     * @param mark
     * @return
     */
    private ResultResponse getCheckResultItemComX(ItemPO order, String mark) {

        ServiceStrategyInterface<ItemPO, ResultResponse> result = checkResultDispatcherItemComX.get(ServiceFlagEnum.getFlagStrategy(mark));
        if (result != null) {
            //執行這段表示式獲得的結果
            return result.doExecute(order);
        }

        return new ResultResponse("不在處理的邏輯中返回業務錯誤");
    }

    @Override
    public ResultResponse doExecute(ItemPO itemEntity) {
        return getCheckResultItemComX(itemEntity, itemEntity.getMark());
    }
}

3.ServiceContextProxy這個類的作用是代理多個業務上下文（2），因為實際開發過程中可能會出現不同業務的策略上下文模式

/**
 *
 * @Author：xuLiangLiang
 * @Description：業務上下文代理
 * @Date 2020/9/9
 */
@AllArgsConstructor
@Component
public class ServiceContextProxy<T>{

    private ApplicationContext applicationContext;
    /**
     * 執行業務域
     * @param t
     * @param classBiz
     * @return
     */
    public ResultResponse execute(T t, Class<? extends ContextProxyInterface> classBiz) {

        ContextProxyInterface<T, ResultResponse> contextProxyInterface = applicationContext.getBean(classBiz);

        return contextProxyInterface.doExecute(t);
    }
}

4.TestStrategyBizController 這個類是為了測試，但是也可以是對外開放的Controller或RPC介面

/**
 *
 * @Author：xuliangliang
 * @Description：測試策略模式
 * @Date 2020/8/28
 */
@RestController
public class TestStrategyBizController {
    @Autowired
    private ServiceContextProxy serviceContextProxy;

    @PostMapping(value = "/v1/biz/test/order", produces="application/json")
    public ResultResponse orderTest(OrderPO orderEntity) {
        if(StringUtils.isEmpty(orderEntity.getMark())){
            return new ResultResponse("沒有Mark標識", false);
        }
        ResultResponse resultEntity = serviceContextProxy.execute(orderEntity, OrderBizContext.class);
        return resultEntity;
    }

    @PostMapping(value = "/v1/biz/test/item", produces="application/json")
    public ResultResponse itemTest(ItemPO itemEntity) {
        if(StringUtils.isEmpty(itemEntity.getMark())){
            return new ResultResponse("沒有Mark標識", false);
        }
        ResultResponse resultEntity = serviceContextProxy.execute(itemEntity, ItemBizContext.class);
        return resultEntity;
    }
}

5.以上程式碼是策略模式主要核心程式碼，感興趣的可以拉程式碼學習，這也是我在開發過程中根據業務需求進行編寫的Demo

https://github.com/gitHub-good/strategy_demo.git