2. 程式人生 > 其它 >java解決if-else多分支技巧

java解決if-else多分支技巧

阿新 • • 發佈：2022-04-13

1、分支邏輯提前return

    if (CollectionUtils.isEmpty(newDataList)) {
        // 提前判斷，返回業務邏輯
        return;
    }
    TestCodeData newData = newDataList.stream().filter(p -> {
        if (p.getIsHoliday() == 1) {
            return true;
        }
        return false;
    }).findFirst().orElse(null);

2、switch case

OuterPlatformCodeEnum codeEnum = OuterPlatformCodeEnum.getByCode(req.getExtChannelCode());
switch (codeEnum) {
	case ZKL:
		return zklPushAuditResultService.afterSaleAudit(req);
	case REDBOOK:
		return @@@;
	case TIKTOK:
		return @@@;
	case KWAI:
		return @@@;
	default:
		log.error("afterSaleAudit當前渠道還未對接{}", JSON.toJSONString(req));
		return Response.ok();
}

3、列舉

public enum TimeEnum {

    AM("am", "上午") {
        @Override
        public void setCity(TestCodeData data, List<TestCodeData> oldDataList) {
            TestCodeData po = oldDataList.stream().filter(p -> p.getStartTime() == 0
                    && (p.getEndTime() == 12 || p.getEndTime() == 24)).findFirst().orElse(null);
            if (null != po) {
                data.setCity(po.getCity());
            }
        }
    },
    PM("pm", "下午") {
        @Override
        public void setCity(TestCodeData data, List<TestCodeData> oldCollect) {
            TestCodeData po = oldCollect.stream().filter(
                    p -> (p.getStartTime() == 12 || p.getStartTime() == 0)
                            && p.getEndTime() == 24).findFirst().orElse(null);
            if (po != null) {
                data.setCity(po.getCity());
            }
        }
    },
    DAY("day", "全天") {
        @Override
        public void setCity(TestCodeData data, List<TestCodeData> oldCollect) {
            TestCodeData po = oldCollect.stream().filter(
                    p -> p.getStartTime() == 0 && p.getEndTime() == 24).findFirst().orElse(null);
            if (po == null) {
                po = oldCollect.stream().filter(
                        p -> p.getStartTime() == 0 && p.getEndTime() == 12).findFirst().orElse(null);
            }
            if (po == null) {
                po = oldCollect.stream().filter(
                        p -> p.getStartTime() == 12 && p.getEndTime() == 24).findFirst().orElse(null);
            }
            if (po != null) {
                data.setCity(po.getCity());
            }
        }
    },
    HOUR("hour", "小時") {
        @Override
        public void setCity(TestCodeData data, List<TestCodeData> oldCollect) {
            TestCodeData po = oldCollect.stream().filter(
                    e -> e.getTimeUnit().equals(Integer.valueOf(1))).findFirst().orElse(null);
            if (po != null) {
                data.setCity(po.getCity());
            }
        }
    };
    public TimeEnum valueOf(String code) {
         TimeEnum [] values = values();
            for (TimeEnum value : values) {
                if (code.equals(value.getCode())) {
                    return value.getName();
                }
            }
    }

    public abstract void setCity(TestCodeData data, List<TestCodeData> oldCollect);

    private String code;
    private String desc;

    TimeEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

for (TestCodeData data : newCollect) {
      String code = "am";  // 這裡假設 code 變數是從 data 中獲取的
      TimeEnum.valueOf(code).setCity(data, oldCollect);
}

4、函式式介面

@Service
public class KwaiAfterSaleAuditService {
    private static final Logger logger = LoggerFactory.getLogger(KwaiAfterSaleAuditService.class);
    private Map<Integer, BiFunction<KwaiExtchCfg, AfterSaleAuditReq, Response<Boolean>>> sourceMap = new HashMap<>();

    @Resource
    private KwaiApiService kwaiApiService;

    @PostConstruct
    private void dispatcher() {
        sourceMap.put(10, this::approve);
        sourceMap.put(-10, this::reject);
    }

    public Response<Boolean> auditDeal(KwaiExtchCfg kwaiExtchCfg, AfterSaleAuditReq req) {
        BiFunction<KwaiExtchCfg, AfterSaleAuditReq, Response<Boolean>> source = sourceMap.get(req.getAuditResult());
        return source.apply(kwaiExtchCfg, req);
    }

    private Response<Boolean> approve(KwaiExtchCfg kwaiExtchCfg, AfterSaleAuditReq req) {
        OpenSellerOrderRefundReturngoodsApproveResponse response = kwaiApiService.returnGoodsApprove(kwaiExtchCfg, req, 788L);
        logger.info("{}, OpenSellerOrderRefundReturngoodsApproveResponse:{}", req.getReturnsId(), JSON.toJSONString(response));
        if (null != response && response.getResult() == 1) {
            return Response.ok(true);
        } else {
            return Response.fail(response != null ? response.getErrorMsg() : "退貨稽核結果推送失敗，返回null");
        }
    }

    private Response<Boolean> reject(KwaiExtchCfg kwaiExtchCfg, AfterSaleAuditReq req) {
        OpenRefundRejectReasonResponse reasonResponse = kwaiApiService.rejectReason(kwaiExtchCfg, Long.parseLong(req.getReturnsId()));
        logger.info("reasonResponse:{}", JSON.toJSONString(reasonResponse));
        OpenRefundRejectResponse response = kwaiApiService.refundReject(kwaiExtchCfg, Long.parseLong(req.getReturnsId()), 12, 788L);
        logger.info("{}, OpenRefundRejectResponse:{}", req.getReturnsId(), JSON.toJSONString(response));
        if (null != response && response.getResult() == 1) {
            return Response.ok();
        } else {
            return Response.fail(response != null ? response.getErrorMsg() : "退貨稽核結果推送失敗，返回null");
        }
    }
}

5、設計模式
工廠模式

自定義註解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtchSynData {
    String[] value();
}

工廠類
@Component
public class McoServiceFactory {

    private static final Logger logger = LoggerFactory.getLogger(McoServiceFactory.class);

    /**
     * 資料日誌及備份 service登錄檔
     */
    private Map<String, ExtchDataSaveService> extchDataSaveServiceMap = Maps.newConcurrentMap();

    @PostConstruct
    private void init() {
        initExtchDataSaveService();
    }

    /**
     * 初始化資料日誌及備份 service登錄檔
     */
    private void initExtchDataSaveService() {
        Map<String, ExtchDataSaveService> result = SpringBeanUtil.getApplicationContext().getBeansOfType(ExtchDataSaveService.class);
        if (CollectionUtils.isEmpty(result)) {
            logger.warn("初始化獲取失敗，沒有發現策略實現 bean。");
            throw new RuntimeException("初始化資料日誌及備份");
        }
        for (Map.Entry<String, ExtchDataSaveService> entry : result.entrySet()) {
            String beanName = entry.getKey();
            ExtchDataSaveService value = entry.getValue();

            ExtchSynData dataAnnotation = value.getClass().getAnnotation(ExtchSynData.class);
            if (null != dataAnnotation) {
                for (String string : dataAnnotation.value()) {
                    extchDataSaveServiceMap.put(string, value);
                }
            } else {
                logger.info("初始化,operateType is null, bean:{}", beanName);
            }
        }
    }
    public ExtchDataSaveService getExtchDataSaveService(String operateType) {
        if (operateType == null) {
            logger.error("[McoServiceFactory.getExtchDataSaveService] the input param is null, return [null].");
            return null;
        }
        return extchDataSaveServiceMap.get(operateType);
    }
}
// 方法呼叫
ExtchDataSaveService extchDataSaveService = mcoServiceFactory.getExtchDataSaveService(methodName);
Response<Boolean> response = extchDataSaveService.beforeDataHandler(className, methodName, joinPoint.getArgs());

模板模式：

抽象模板類
@Service
public abstract class BaseMessageService {

    private static final Logger logger = LoggerFactory.getLogger(BaseMessageService.class);

    /**
     * Description: 資料處理
     * Date: 2021/9/15 11:17
     * @Param: [parentMessage] 訊息體
     * @Return: com.gome.retail.boot.model.Response<java.lang.Boolean>
     */
    protected abstract Response<Boolean> dataHandle(KwaiParentMessage parentMessage);

    /**
     * Description: 任務執行 先處理資料再進行業務處理
     * Date: 2021/9/15 11:13
     * @Param: [parentMessage]
     * @Return: com.gome.retail.boot.model.Response<java.lang.Boolean>
     */
    public Response<Boolean> execute(KwaiParentMessage parentMessage) {
        Response<Boolean> kwaiParentMessageResponse = dataHandle(parentMessage);
        if (!kwaiParentMessageResponse.isOk()) {
            logger.error(kwaiParentMessageResponse.getMsg());
            return Response.fail("引數解析失敗");
        }
        return bussiness(parentMessage);
    }

    /**
     * Description: 業務處理
     * Date: 2021/9/15 11:17
     * @Param: [parentMessage]
     * @Return: com.gome.retail.boot.model.Response<java.lang.Boolean>
     */
    protected abstract Response<Boolean> bussiness(KwaiParentMessage parentMessage);
}

// 分支業務類
@KwaiEvent({"kwaishop_order_statusChange"})
@Service
public class KwaiOrderMessageService extends BaseMessageService {

    private static final Logger logger = LoggerFactory.getLogger(KwaiOrderMessageService.class);

    @Resource
    private KwaiApiService kwaiApiService;

    @Resource
    private KwaiExtchCfgService kwaiExtchCfgService;

    @Resource
    private KwaiMcoOrderService kwaiMcoOrderService;

    @Override
    protected Response<Boolean> dataHandle(KwaiParentMessage parentMessage) {
        try {
            if (StringUtils.isEmpty(parentMessage.getInfo())) {
                logger.error("缺少訊息詳細資訊：{}", JSON.toJSONString(parentMessage));
                return Response.fail("缺少訊息體");
            }
            KwaiMessageOrder kwaiMessageOrder = JSON.parseObject(parentMessage.getInfo(), KwaiMessageOrder.class);
            parentMessage.setKwaiMessage(kwaiMessageOrder);
        } catch (Exception e) {
            logger.error("引數解析失敗message:{}", JSON.toJSONString(parentMessage), e);
            return Response.fail("引數解析失敗");
        }
        return Response.ok();
    }

    @Override
    protected Response<Boolean> bussiness(KwaiParentMessage parentMessage) {
        KwaiExtchCfg kwaiExtchCfg = kwaiExtchCfgService.obtainCacheExtchCfg(String.valueOf(parentMessage.getUserId()));
        KwaiMessageOrder kwaiMessageOrder = (KwaiMessageOrder) parentMessage.getKwaiMessage();
        logger.info("訊息單個訂單獲取 oid:{}", kwaiMessageOrder.getOid());
        if (!(Constants.PULL_ORDER_STATUS_30 == kwaiMessageOrder.getStatus()
                || Constants.PULL_ORDER_STATUS_40 == kwaiMessageOrder.getStatus()
                || Constants.PULL_ORDER_STATUS_50 == kwaiMessageOrder.getStatus()
                || Constants.PULL_ORDER_STATUS_70 == kwaiMessageOrder.getStatus())) {
            return Response.ok();
        }
        OpenOrderCursorListResponse response = kwaiApiService.obtainOrderDetail(kwaiMessageOrder.getOid(), kwaiExtchCfg);
        logger.info("訊息單個訂單獲取返回 oid:{} response:{}", kwaiMessageOrder.getOid(), JSON.toJSONString(response));
        if (response.isSuccess() && null != response.getData() && null != response.getData().getOrderList() && response.getData().getOrderList().length > 0) {
            OrderList orderList = response.getData().getOrderList()[0];
            Response<Boolean> singleResponse = kwaiMcoOrderService.singleOrderByOrderList(orderList, kwaiExtchCfg, null);
            logger.info("訊息單個訂單處理結果oid:{}, res:{}", kwaiMessageOrder.getOid(), JSON.toJSONString(singleResponse));
        }
        return Response.ok();
    }
}

// 快取服務類工廠
@Component
public class KwaiAcceptServiceFactory {

    private static final Logger logger = LoggerFactory.getLogger(KwaiAcceptServiceFactory.class);

    /**
     * 訊息service登錄檔
     */
    private Map<String, BaseMessageService> messageServiceMap;

    @PostConstruct
    private void init() {
        messageServiceMap = new HashMap<>(8);
        initMessageService();
    }

    /**
     * 初始化service登錄檔
     */
    private void initMessageService() {
        Map<String, BaseMessageService> result = SpringBeanUtil.getApplicationContext().getBeansOfType(BaseMessageService.class);
        if (CollectionUtils.isEmpty(result)) {
            logger.warn("初始化獲取失敗，沒有發現策略實現 bean。");
            throw new RuntimeException("初始化訊息處理類失敗");
        }
        for (Map.Entry<String, BaseMessageService> entry : result.entrySet()) {
            String beanName = entry.getKey();
            BaseMessageService value = entry.getValue();

            KwaiEvent dataAnnotation = value.getClass().getAnnotation(KwaiEvent.class);
            if (null != dataAnnotation) {
                for (String string : dataAnnotation.value()) {
                    messageServiceMap.put(string, value);
                }
            } else {
                logger.info("初始化,operateType is null, bean:{}", beanName);
            }
        }
    }

    /**
     * Description: 獲取訊息處理類
     * Date: 2021/9/14 19:21
     *
     * @Param: [operateType]
     * @Return: cn.com.gome.scot.alamein.mco.kwai.job.business.domain.message.BaseMessageService
     */
    public BaseMessageService obtainMessageService(String operateType) {
        if (operateType == null) {
            logger.error("[McoServiceFactory.getExtchDataSaveService] the input param is null, return [null].");
            return null;
        }
        return messageServiceMap.get(operateType);
    }
}

相關推薦

java解決if-else多分支技巧

1、分支邏輯提前return if (CollectionUtils.isEmpty(newDataList)) { // 提前判斷，返回業務邏輯

策略模式：助你消除醜陋的 if else 多分支程式碼

開發場景舉例 讓我們以一個實際開發場景來切入這篇文章的正題。現在，假設需要開發這樣一個需求：購物車商品結算時需要根據使用者會員等級進行打折。

Java優化if-else程式碼幾個解決方案

https://www.cnblogs.com/jeremylai7/p/15291165.html 前言 開發系統一些狀態，比如訂單狀態：資料庫儲存是數字或字母，但是需要顯示中文或英文,一般用到if-else程式碼判斷，但這種判斷可讀性比較差，也會影響後

詳解如何把Java中if-else程式碼重構成高質量程式碼

為什麼我們寫的程式碼都是if-else？ 程式設計師想必都經歷過這樣的場景：剛開始自己寫的程式碼很簡潔，邏輯清晰，函式精簡，沒有一個if-else，

策略模式（上）：如何避免冗長的if-else/switch分支判斷程式碼？

模板模式主要起到程式碼複用和擴充套件的作用。除此之外，我們還講到了回撥，它跟模板模式的作用類似，但使用起來更加靈活。它們之間的主要區別在於程式碼實現，模板模式基於繼承來實現，回撥基於組合來實現。

java如何消除太多的if else判斷示例程式碼

1.簡介 if判斷語句是很多程式語言的重要組成部分。但是，若我們最終編寫了大量巢狀的if語句，這將使得我們的程式碼更加複雜和難以維護。

if else 太多？看我用 Java 8 輕鬆幹掉！

之前我用 Java 8 寫了一段邏輯，就是類似下面這樣的例子： /* * 來源公眾號：Java技術棧

9個小技巧讓你的Java if else看起來更優雅

前言 if else 是我們寫程式碼時，使用頻率最高的關鍵詞之一，然而有時過多的 if else 會讓我們感到腦殼疼，例如下面這個虛擬碼：

Java程式設計技巧：if-else優化實踐總結歸納

文/朱季謙 說實話，其實我很討厭在程式碼裡大量使用if-else，一是因為該類程式碼屬於面向過程的，二嘛，則是會顯得程式碼過於冗餘。這篇筆記，主要記錄一些自己在工作實踐當中針對if-else的優化心得，將會不定期地長

Java-多個if和if-else if的不同之處

if是條件判斷常用的語法，適用於單一條件判斷 //條件滿足，進入方法體 if(true){

Java中的多分支 if較單分支if的優點

單分支 if 語句表述形式為：if(條件1){輸出1}     if(條件2){輸出2}……如此往復;

聊聊java中一些減少if else 的編碼習慣

前言 前段時間在閱讀別人所寫的程式碼的時候,發現其中一些業務相關的方法體內,出現了比較多的if-else語句多層巢狀的情況. 首先我個人不是不提倡寫if-else語句,不得不說,很多時候,在寫某些邏輯 使用if-else 去做判斷,

Java通過Scanner瞭解if...else if語句

這篇文章主要介紹了Java通過Scanner瞭解if...else if語句,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

如何在java 8 stream表示式實現if/else邏輯

簡介 在Stream處理中，我們通常會遇到if/else的判斷情況，對於這樣的問題我們怎麼處理呢？

JS 邏輯判斷不要只知道用 if-else 和 switch條件判斷(小技巧)

我們在編寫 JS 程式碼時，經常會遇到邏輯判斷複雜的情況。一般情況下，可以用 if/else 或 switch 來實現多個條件判斷，但會出現一個問題：隨著邏輯複雜度的增加，程式碼中的 if/else 和 switch 會越來越臃腫。本文將

java 流程控制基礎之if else

分支結構 根據條件選擇性執行某段程式碼；有if...else和switch-case兩種分支 迴圈結構

分支結構（if/else，switch選擇判斷）

分支結構 Note：switch中支援的型別為byte，short，int，char，String(JDK7+)，列舉共6種，不支援浮點型

java-if-else-使用scanner獲取資料並顯示

一、使用scanner從鍵盤獲取int型資料 1.從鍵盤輸入成績，判斷成績等級. 如果成績大於等於90分小於等於100，為優秀

分支結構-if-else與switch-case的轉換

根據鍵盤讀取成績輸出成績等級 例：編寫程式：從鍵盤上讀取一個學生成績，存放在變數score中，根據score的值輸出其對應的成績等級。

Python多分支if語句的使用

注意：if語句程式碼是從上往下執行的，當執行到滿足條件的語句時，程式碼會停止往下執行