在使用moco API的時候，發現文件中的一些功能並不能滿足構建測試服務的需求，需要自己開發一些功能。之前兩篇主要講了moco本身的補充，本篇說說moco文件之外的功能：limit。 主要是用於限制訪問次數，並不針對某個session或者同一個使用者（本人暫時沒有這方面的需求，故沒有開發）。 使用場景的話：小遊戲的裡面的抽獎，訂單提交，耗時較長的功能等。在實際的業務邏輯中，很可能會有短時間內不允許提交多次，請求多次的需求。

下面上程式碼：

package com.fun.moco.support;

import com.fun.utils.Time;
import com.github.dreamhead.moco.HttpRequest;
import com.github.dreamhead.moco.MocoConfig;
import com.github.dreamhead.moco.ResponseHandler;
import com.github.dreamhead.moco.handler.AbstractResponseHandler;
import com.github.dreamhead.moco.internal.SessionContext;
import com.github.dreamhead.moco.model.MessageContent;
import com.google.common.base.Function;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 迴圈的responsehandle
 */
@SuppressWarnings("all")
public class LimitHandle extends AbstractResponseHandler {


    private final ResponseHandler limit;

    private final ResponseHandler unlimit;

    private Map<String, Long> tatal = new ConcurrentHashMap<>();

    private int interval;

    private LimitHandle(final ResponseHandler limit, final ResponseHandler unLimit, int interval) {
        this.limit = limit;
        this.unlimit = unLimit;
        this.interval = interval;
    }

    public static ResponseHandler newSeq(final ResponseHandler limit, final ResponseHandler unLimit, int interval) {
        return new LimitHandle(limit, unLimit, interval);
    }

    /**
     * 返回響應
     *
     * @param context
     */
    @Override
    public void writeToResponse(final SessionContext context) {
        HttpRequest request = (HttpRequest) context.getRequest();
        String uri = request.getUri();
        MessageContent content = request.getContent();
        (limited(uri + content) ? limit : unlimit).writeToResponse(context);
    }

    @Override
    public ResponseHandler apply(final MocoConfig config) {
        if (config.isFor(MocoConfig.RESPONSE_ID)) {
            return super.apply(config);
        }
        return new LimitHandle(limit, unlimit, interval);
    }

    private Function<ResponseHandler, ResponseHandler> applyConfig(final MocoConfig config) {
        return new Function<ResponseHandler, ResponseHandler>() {
            @Override
            public ResponseHandler apply(final ResponseHandler input) {
                return input.apply(config);
            }
        };
    }

    /**
     * 判斷是否被限制
     * <p>
     * 通過記錄每一次響應的時間戳，判斷兩次請求間隔達到limit目的
     * </p>
     *
     * @param info
     * @return
     */
    public boolean limited(String info) {
        long fresh = Time.getTimeStamp();
        long old = tatal.containsKey(info) ? tatal.get(info) : 0L;
        tatal.put(info, fresh);
        return fresh - old > interval;
    }
}
 

使用方法如下：

/**
 * 限制請求頻次，預設1000ms
 * @param limit
 * @param unlimit
 * @return
 */
    static ResponseHandler limit(String limited, String unlimited) {
        limit contentResponse(limited), contentResponse(unlimited)
    }

    static ResponseHandler limit(JSONObject limited, JSONObject unlimited) {
        limit jsonResponse(limited), jsonResponse(unlimited)
    }

    static ResponseHandler limit(ResponseHandler limited, ResponseHandler unlimited) {
        limit limited, unlimited, 1000
    }

/**
 * 限制請求頻次
 * @param limit
 * @param unlimit
 * @param interval 單位ms
 * @return
 */
    static ResponseHandler limit(String limited, String unlimited, int interval) {
        limit contentResponse(limited), contentResponse(unlimited), interval
    }

    static ResponseHandler limit(JSONObject limited, JSONObject unlimited, int interval) {
        limit limited.toString(), unlimited.toString(), interval
    }

    static ResponseHandler limit(ResponseHandler limit, ResponseHandler unlimit, int interval) {
        LimitHandle.newSeq(limit, unlimit, interval)
    }
 

• groovy是一種基於JVM的動態語言，我覺得最大的優勢有兩點，第一：於java相容性非常好，大部分時候吧groovy的檔案字尾改成java直接可以用，反之亦然。java的絕大部分庫，groovy都是可以直接拿來就用的。這還帶來了另外一個有點，學習成本低，非常低，直接上手沒問題，可以慢慢學習groovy不同於Java的語法；第二：編譯器支援變得更好，現在用的intellij的ide，總體來說已經比較好的支援groovy語言了，寫起程式碼來也是比較順滑了，各種基於groovy的框架工具也比較溜，特別是Gradle構建工具，比Maven爽很多。----此段文字為了撐字數強加的，與內容無關。