響應式編程

響應式編程（reactive programming）是一種基於數據流（data stream）和變化傳遞（propagation of change）的聲明式（declarative）的編程範式
在命令式編程(咱們的平常編程模式)下，式子a=b+c，這就意味着a的值是由b和c計算出來的。若是b或者c後續有變化，不會影響到a的值
在響應式編程下，式子a:=b+c，這就意味着a的值是由b和c計算出來的。但若是b或者c的值後續有變化，會影響到a的值
我認爲上面的例子已經能夠幫助咱們理解變化傳遞（propagation of change）

lambda:

函數式編程接口:
@FunctionalInterface



其中在函數式接口中有一些只適合在函數式中使用的官方封裝好的接口方法
如BiFunction,Tuple
BiFunction適用於兩個參數,而Function適用於一個參數
Function的使用:

/**
     * 一個參數的調用返回
     *
     * @param option
     * @param funOptionService
     * @return
     */
    public static Mono<ServerResponse> oneOptionalParams(Optional<String> option,
                                                         Function<Optional<String>, Mono<JSONObject>> funOptionService,
                                                         String judgeParam) {
        //option is not Present and the judgeParams not null then badRequest
        if (!option.isPresent() && (null != judgeParam) && judgeParam != "") {
            return (Mono<ServerResponse>) ServerResponseBuild.badRequestMsg("參數" + judgeParam + "不能爲空");
        }
        Mono<JSONObject> jsonObjectMono = funOptionService.apply(option);
        return jsonObjectMono.flatMap(
                resultJson -> {
                    if (resultJson.getInteger("errcode") != 0) {
                        return ServerResponseBuild.badRequestMsg(resultJson.getString("errmsg"));
                    }
                    log.info("\n返回數據:{}", resultJson);
                    return ServerResponseBuild.okRequestObj(resultJson, JSONObject.class);
                }
        ).switchIfEmpty(ServerResponseBuild.badRequestMsg("請求錯誤")
        ).onErrorResume(error -> ServerResponseBuild.badRequestMsg(error.getMessage()));
    }

BiFunction兩個參數的

/**
     * 兩個參數的調用返回
     * @param option1
     * @param option2
     * @param funBiOptionService
     * @param judgeParams
     * @return
     */
    public static Mono<ServerResponse> twoOptionalParams(Optional<String> option1, Optional<String> option2,
                                                         BiFunction<Optional<String>, Optional<String>, Mono<JSONObject>> funBiOptionService,
                                                         String... judgeParams) {
        //省略judgeParams...
        Mono<JSONObject> jsonObjectMono = null;
        try {
            jsonObjectMono = funBiOptionService.apply(option1, option2);
        } catch (Exception e) {
            return Mono.error(e);
        }
        return jsonObjectMono.flatMap(
                resultJson -> {
                    if (resultJson.getInteger("errcode") != 0) {
                        return ServerResponseBuild.badRequestMsg(resultJson.getString("errmsg"));
                    }
                    log.info("\n返回數據:{}", resultJson);
                    return ServerResponseBuild.okRequestObj(resultJson, JSONObject.class);
                }
        ).switchIfEmpty(ServerResponseBuild.badRequestMsg("請求錯誤")
        ).onErrorResume(error -> ServerResponseBuild.badRequestMsg(error.getMessage()));
    }

函數式調用

這樣寫起來確實看上去簡潔了許多
且這樣調用能夠調用接收多個參數
一個參數:

/**
     * 獲取訪問用戶身份
     *
     * @param request
     * @return
     */
    public Mono<ServerResponse> getuserInfo(ServerRequest request) {
        return ServerResponseBuild.oneOptionalParams(request.queryParam("code"),
                option -> manIdentityVerifyService.getUserInfo(option),
                "code");
    }

上面的寫法能夠改成:

/**
     * 獲取訪問用戶身份
     *
     * @param request
     * @return
     */
    public Mono<ServerResponse> getuserInfo(ServerRequest request) {
        return ServerResponseBuild.oneOptionalParams(request.queryParam("code"),
                manIdentityVerifyService::getUserInfo,
                "code");
    }

兩個參數的一樣可使用::方式來調用方法

/**
     * ~~~~不給你看註釋
     * @return
     */
    public Mono<ServerResponse> getConversations(ServerRequest request) {
        return ServerResponseBuild.twoOptionalParams(
                request.queryParam("seq"),
                request.queryParam("limit"),
                chatMsgSaveService::monoGetChatContent,
                "seq", "limit");
    }