com.hecloud.runtime.common.restful.RestClient Maven / Gradle / Ivy

Go to download
package com.hecloud.runtime.common.restful;

import com.hecloud.runtime.common.enums.HttpMethod;
import com.hecloud.runtime.common.enums.PostDataFormat;
import com.hecloud.runtime.common.model.Result;
import org.apache.http.client.methods.*;
import org.apache.http.util.Asserts;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import static com.hecloud.runtime.common.utils.Common.ERROR;
import static com.hecloud.runtime.common.utils.Common.SUCCESS;

/**
 * 通用的HTTP请求客户端 主要有post,get,delete,put,patch,trace,doPost和doGet等几个方法，
 *
 * @author LoveinBJ
 */
public class RestClient extends AbstractRestClient {

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

    public RestClient(int timeout) {
        super(timeout);
    }

    public RestClient() {
        super();
    }

    public RestClient(String[] supportedProtocols) {
        super(supportedProtocols);
    }

    /**
     * @param dataFormat 数据格式
     */
    public RestClient(PostDataFormat dataFormat) {
        super(dataFormat);
    }

    /**
     * 有代理的构造方法
     *
     * @param host 代理Ip地址
     * @param port 代理端口
     */
    public RestClient(String host, Integer port) {
        super(host, port);
    }

    /**
     * @param timeout    超时时间
     * @param dataFormat 数据格式
     */
    public RestClient(Integer timeout, PostDataFormat dataFormat) {
        super(timeout, dataFormat);
    }

    /**
     * http的Post方法
     *
     * @param header 请求头部消息体
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回{"success":false,"message":"异常信息"}
     */
    @Override
    public Result post(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        httpPost = new HttpPost(uri);
        logger.debug("uri is = {} | params is {}", uri, params);
        // 设置请求和传输超时时间
        httpPost.setConfig(config);
        buildHeader(httpPost, header);
        buildEntity(httpPost, params);
        remoteInvoke(httpPost);
        return result;
    }

    @Override
    public Result post(Map header, String params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        httpPost = new HttpPost(uri);
        // 设置请求和传输超时时间
        httpPost.setConfig(config);
        buildHeader(httpPost, header);
        buildEntity(httpPost, params);
        remoteInvoke(httpPost);
        return result;
    }

    /**
     * http的PUT方法
     *
     * @param header 请求头部消息体
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回{"success":false,"message":"异常信息"}
     */
    @Override
    public Result put(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        logger.debug("uri is = {} | params is {}", uri, params);
        httpPut = new HttpPut(uri);
        httpPut.setConfig(config);
        buildHeader(httpPut, header);
        buildEntity(httpPut, params);
        remoteInvoke(httpPut);
        return result;
    }

    /**
     * http的Delete方法
     *
     * @param header 请求头部消息体
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回{"success":false,"message":"异常信息"}
     */
    @Override
    public Result delete(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        logger.debug("uri is = {} | params is {}", uri, params);
        uri = buildURL(uri, params);
        httpDelete = new HttpDelete(uri);
        buildHeader(httpDelete, header);
        httpDelete.setConfig(config);
        remoteInvoke(httpDelete);
        return result;
    }

    /**
     * http的path方法
     *
     * @param header 请求头部消息体
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回{"success":false,"message":"异常信息"}
     */
    @Override
    public Result patch(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        logger.debug("uri is = {} | params is {}", uri, params);
        httpPatch = new HttpPatch(uri);
        httpPatch.setConfig(config);
        buildHeader(httpPatch, header);
        buildEntity(httpPatch, params);
        remoteInvoke(httpPatch);
        return result;
    }

    @Override
    public Result patch(Map header, String params, String uri) {
        logger.debug("uri is = {} | params is {}", uri, params);
        httpPatch = new HttpPatch(uri);
        httpPatch.setConfig(config);
        buildHeader(httpPatch, header);
        buildEntity(httpPatch, params);
        remoteInvoke(httpPatch);
        return result;
    }

    /**
     * http的trace方法
     *
     * @param header 请求头部消息体
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回{"success":false,"message":"异常信息"}
     */
    @Override
    public Result trace(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        // 设置请求和传输超时时间
        logger.debug("uri is = {} | params is {}", uri, params);
        uri = buildURL(uri, params);
        httpTrace = new HttpTrace(uri);
        httpTrace.setConfig(config);
        buildHeader(httpTrace, header);
        remoteInvoke(httpTrace);
        return result;
    }

    @Override
    public Result get(String uri) {
        return this.get(null, null, uri);
    }

    /**
     * Get方法
     *
     * @param params 请求参数
     * @param uri    请求路径
     * @return 返回的response，异常情况时返回null
     */
    @Override
    public Result get(Map header, Map params, String uri) {
        Asserts.notBlank(uri, "URI IS EMPTY！");
        logger.debug("Uri is{} and Param is {}", uri, params);
        uri = buildURL(uri, params);
        httpGet = new HttpGet(uri);
        buildHeader(httpGet, header);
        httpGet.setConfig(config);
        remoteInvoke(httpGet);
        return result;
    }

    @Override
    public Map request(Map header, Map param, String url,
                                       HttpMethod method) {
        Map response = null;
        switch (method) {
            case GET:
                response = doGet(header, param, url);
                break;
            case POST:
                response = doPost(header, param, url);
                break;
            default:
                response = new HashMap<>(2);
                response.put(SUCCESS, false);
                response.put(ERROR, "暂不支持");
                break;
        }
        return response;
    }

    @Override
    public String request4String(Map header, Map param, String url,
                                 HttpMethod method) {
        String response = null;
        switch (method) {
            case GET:
                response = get(header, param, url).getMessage();
                break;
            case POST:
                response = post(header, param, url).getMessage();
                break;
            default:
                break;
        }
        return response;
    }

    /**
     * 远程调用
     *
     * @param request
     */
    private void remoteInvoke(HttpUriRequest request) {
        try {
            response = httpClient.execute(request);
            handleResponse();
        } catch (IOException e) {
            logger.error("RestClient IOException:", e);
            result = new Result(false, e.getMessage());
        } finally {
            close();
        }
    }

}