工作需要，經常需要實現api介面，但每次都是大同小異，我就考慮是否可以將這種重複性的工作配置化。

我就寫一個模板api,然後所有的HTTP請求過來，根據不同的配置返回不同結果。

最開始考慮的是比較簡單的，來一個api需求，我就去MySQL查一條這個api對應的SQL，然後拿SQL去取結果，返回。

這個不難。

關鍵是實際需求中，有很多api返回的資料很複雜，比如渲染地圖的介面，一般一條SQL搞不定。

那我就想，那我能不能實現api的拼裝呢，你看到我只是呼叫了一個API，但是我給你返回的結果，其實是好幾個API結果拼裝成的。

經過研究，是可以實現的。

首先我們定義一個ApiConfig的模型

@Data
@Table(name 
 
= "api_config")
@AllArgsConstructor
public class ApiConfig implements Serializable {

    @ApiModelProperty("api名稱")
    private String apiName;

    @ApiModelProperty("資料來源名稱")
    private String dsName;

    @ApiModelProperty("SQL")
    private String querySql;

    @ApiModelProperty("結果型別")
    private
 
 String resultType;

    @ApiModelProperty("結果描述")
    private String resultDesc;

    @ApiModelProperty("依賴api")
    private String dependApiName;
}

依賴api格式其實是一個json,它告訴我們，如果你還需要key1和key2的結果，需要分別從其他API（x/y/1，x/y/2)獲取

{"key1":"x/y/1",
"key2":"x/y/2"}

接下來就是我們的實現類，因為是展現可行性，所以我們不分層，在一個Test類中把所有邏輯實現

@Slf4j
 
public class Test {
    //測試資料的初始化
    public static List<ApiConfig> apiConfigList = new ArrayList<>();
    public static Map<String, String> sqlResultMap = ImmutableMap.of("sql1", "{\"a\":\"1\"}", "sql2", "{\"b\":\"2\"}", "sql3", "{\"c\":\"3\"}");

    static {
        ApiConfig api1 = new ApiConfig("p1", "d1", "sql1", "map", "", "{\"b\":\"p1/x1\"}");
        ApiConfig api2 = new ApiConfig("p1/x1", "d1", "sql2", "map", "", "{\"c\":\"p1/x2\"}");
        ApiConfig api3 = new ApiConfig("p1/x2", "d1", "sql3", "map", "", null);
        apiConfigList.add(api1);
        apiConfigList.add(api2);
        apiConfigList.add(api3);
    }

    /**
     * 我要進行http:ip:port/p1這個請求，請返回我相關資料
     * @param args
     */
    public static void main(String[] args) {
        //根據api名稱獲取結果
        String apiName = "p1";
        JSONObject json = doGetResult(apiName);
        //result必須初始化，而且在方法內部不能重新new，以保證遞迴方法內更新的是同一個物件，否則拿不到更新資料後的result
        JSONVO result = null;
        if (json != null) {
            result = new JSONVO(json.toJSONString());
        } else {
            result = new JSONVO("{}");
        }
        //如有需要，遞迴獲取子api的結果，並存入result
        getApiResult(apiName, null, result);
        System.out.println(result);

    }

    /**
     * 從子api查詢結果，並更新到主result
     * @param apiName
     * @param dataKey
     * @param result
     */
    public static void getApiResult(String apiName, String dataKey, JSONVO result) {
        //dataKey在進入方法時是等於null的，第二次進入肯定不應該為null,這個地方是更新result的關鍵位置
        if (dataKey != null) {
            JSONObject json = doGetResult(apiName);
            result.set(dataKey, json);
        }
        //進入遞迴的入口
        String dependApiName = getApiConfig(apiName).getDependApiName();
        if (dependApiName != null) {
            JSONObject dependApi = JSONObject.parseObject(dependApiName);
            Set<String> keySet = dependApi.keySet();
            for (String key : keySet) {
                String subApi = dependApi.getString(key);
                getApiResult(subApi, key, result);
            }

        }
    }

    public static JSONObject doGetResult(String apiName) {
        String querySql = getApiConfig(apiName).getQuerySql();
        return doQuery(querySql);
    }

    /**
     * 根據api名稱獲取apiConfig
     *
     * @param api
     * @return
     */
    public static ApiConfig getApiConfig(String api) {
        for (ApiConfig apiConfig : apiConfigList) {
            if (apiConfig.getApiName().equals(api)) {
                return apiConfig;
            }
        }
        log.error("api not exists!");
        return null;
    }

    /**
     * 根據查詢SQL獲取結果
     *
     * @param sql
     * @return
     */
    public static JSONObject doQuery(String sql) {
        String s = sqlResultMap.get(sql);
        JSONObject jsonObject = JSONObject.parseObject(s);
        return jsonObject;
    }


}

輸出結果：

{"a":"1","b":{"b":"2"},"c":{"c":"3"}}

可以看到，兩層遞迴的子api的資料都查出來了。

從資料庫返回的結果，可能也不一定是JsonObject,這個在實現專案中需要在具體分析。