http请求工具类

1，httpUtils工具类

public class HttpUtils {
    public HttpUtils() {
    }

    public static String sendGet(String url, Map<String, String> parameters) {
        String result = "";
        BufferedReader in = null;
        StringBuffer sb = new StringBuffer();
        String params = "";

        try {
            Iterator var6;
            String name;
            String full_url;
            if (parameters.size() == 1) {
                var6 = parameters.keySet().iterator();

                while(var6.hasNext()) {
                    name = (String)var6.next();
                    if (parameters.get(name) != null) {
                        sb.append(name).append("=").append(URLEncoder.encode((String)parameters.get(name), "UTF-8"));
                    }
                }

                params = sb.toString();
            } else {
                var6 = parameters.keySet().iterator();

                while(var6.hasNext()) {
                    name = (String)var6.next();
                    if (parameters.get(name) != null) {
                        sb.append(name).append("=").append(URLEncoder.encode((String)parameters.get(name), "UTF-8")).append("&");
                    }
                }

                full_url = sb.toString();
                params = full_url.substring(0, full_url.length() - 1);
            }

            full_url = url + "?" + params;
            System.out.println(full_url);
            URL connURL = new URL(full_url);
            HttpURLConnection httpConn = (HttpURLConnection)connURL.openConnection();
            httpConn.setRequestProperty("Accept", "*/*");
            httpConn.setRequestProperty("Connection", "Keep-Alive");
            httpConn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
            httpConn.connect();
            Map<String, List<String>> headers = httpConn.getHeaderFields();
            Iterator var10 = headers.keySet().iterator();

            while(var10.hasNext()) {
                String key = (String)var10.next();
                System.out.println(key + "\t：\t" + headers.get(key));
            }

            String line;
            for(in = new BufferedReader(new InputStreamReader(httpConn.getInputStream(), "UTF-8")); (line = in.readLine()) != null; result = result + line) {
            }
        } catch (Exception var20) {
            var20.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException var19) {
                var19.printStackTrace();
            }

        }

        return result;
    }

    public static String sendPost(String url, Map<String, String> parameters) {
        String result = "";
        BufferedReader in = null;
        PrintWriter out = null;
        StringBuffer sb = new StringBuffer();
        String params = "";

        try {
            Iterator var7;
            String name;
            if (parameters.size() == 1) {
                var7 = parameters.keySet().iterator();

                while(var7.hasNext()) {
                    name = (String)var7.next();
                    if (parameters.get(name) != null && parameters.get(name) != null) {
                        sb.append(name).append("=").append(URLEncoder.encode((String)parameters.get(name), "UTF-8")).append("&");
                    }
                }

                params = sb.toString();
            } else {
                var7 = parameters.keySet().iterator();

                while(var7.hasNext()) {
                    name = (String)var7.next();
                    if (parameters.get(name) != null) {
                        sb.append(name).append("=").append(URLEncoder.encode((String)parameters.get(name), "UTF-8")).append("&");
                    }
                }

                String temp_params = sb.toString();
                params = temp_params.substring(0, temp_params.length() - 1);
            }

            URL connURL = new URL(url);
            HttpURLConnection httpConn = (HttpURLConnection)connURL.openConnection();
            httpConn.setRequestProperty("Accept", "*/*");
            httpConn.setRequestProperty("Connection", "Keep-Alive");
            httpConn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
            httpConn.setDoInput(true);
            httpConn.setDoOutput(true);
            out = new PrintWriter(httpConn.getOutputStream());
            out.write(params);
            out.flush();

            String line;
            for(in = new BufferedReader(new InputStreamReader(httpConn.getInputStream(), "UTF-8")); (line = in.readLine()) != null; result = result + line) {
            }
        } catch (Exception var18) {
            var18.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }

                if (in != null) {
                    in.close();
                }
            } catch (IOException var17) {
                var17.printStackTrace();
            }

        }

        return result;
    }
}
2，HttpclientX工具类

public class HttpclientX {
    private static final Logger logger = LoggerFactory.getLogger(HttpclientX.class);
    private String userAgent = BrowserUtils.getRandomBrowser();
    private SSLs.SSLProtocolVersion sslProtocolVersion;
    private static Integer retryTime = 5;
    private static Integer poolMaxTotal = 500;
    private static Integer defaultMaxPerRoute = 100;
    private Integer connectionRequestTimeout;
    private Integer connectTimeout;
    private Integer socketTimeout;
    private Map<String, String> headers;
    private String cookies;
    private static PoolingHttpClientConnectionManager cm = null;
    private RequestConfig reqConfig;
    private CredentialsProvider credsProvider;
    private HttpClientContext localContext;
    private HttpMethods httpMethods;
    private static HCB hcb = HCB.custom();
    private ProxyX proxyX;
    private Proxy proxy;
    private Authenticator proxyAuthenticator;

    public HttpclientX setProxyX(final ProxyX proxyX) {
        this.proxyX = proxyX;
        if (proxyX != null) {
            System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
            AuthCache authCache = new BasicAuthCache();
            authCache.put(proxyX.getProxy(), new BasicScheme());
            this.localContext = HttpClientContext.create();
            this.localContext.setAuthCache(authCache);
            this.proxy = new Proxy(Type.HTTP, new InetSocketAddress(proxyX.getHostname(), proxyX.getPort()));
            if (proxyX.isNeedUserPsd()) {
                this.credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(proxyX.getProxyUser(), proxyX.getProxyPassword()));
                java.net.Authenticator.setDefault(new java.net.Authenticator() {
                    private final PasswordAuthentication authentication = new PasswordAuthentication(proxyX.getProxyUser(), proxyX.getProxyPassword().toCharArray());

                    protected PasswordAuthentication getPasswordAuthentication() {
                        return this.authentication;
                    }
                });
                this.proxyAuthenticator = new Authenticator() {
                    public Request authenticate(Route route, Response response) throws IOException {
                        String credential = Credentials.basic(proxyX.getProxyUser(), proxyX.getProxyPassword());
                        return response.request().newBuilder().header("Proxy-Authorization", credential).build();
                    }
                };
            }
        }

        return this;
    }

    public HttpclientX setSSL(SSLs.SSLProtocolVersion sslProtocolVersion) {
        this.sslProtocolVersion = sslProtocolVersion;
        return this;
    }

    public HttpclientX setHeaders(Map<String, String> headers) {
        this.headers = headers;
        return this;
    }

    public HttpclientX setUserAgent(String userAgent) {
        this.userAgent = userAgent;
        return this;
    }

    public HttpclientX setCookies(String cookies) {
        this.cookies = cookies;
        return this;
    }

    public HttpclientX setTimeOut(Integer time) {
        this.connectionRequestTimeout = time;
        this.connectTimeout = time;
        this.socketTimeout = time;
        return this;
    }

    public HttpclientX setConnectionRequestTimeout(Integer time) {
        this.connectionRequestTimeout = time;
        return this;
    }

    public HttpclientX setConnectTimeout(Integer time) {
        this.connectTimeout = time;
        return this;
    }

    public HttpclientX setSocketTimeout(Integer time) {
        this.socketTimeout = time;
        return this;
    }

    public void setHttpMethods(HttpMethods httpMethods) {
        this.httpMethods = httpMethods;
    }

    private HttpclientX() {
        this.sslProtocolVersion = SSLProtocolVersion.SSLv3;
        this.connectionRequestTimeout = 10000;
        this.connectTimeout = 10000;
        this.socketTimeout = 10000;
        this.reqConfig = null;
        this.credsProvider = new BasicCredentialsProvider();
        this.localContext = null;
        this.httpMethods = HttpMethods.GET;
    }

    public static HttpclientX create() {
        return new HttpclientX();
    }

    public HttpConfig config() throws Exception {
        HttpHeader httpHeader = HttpHeader.custom().userAgent(this.userAgent);
        if (this.headers != null && this.headers.size() > 0) {
            Iterator var2 = this.headers.entrySet().iterator();

            while(var2.hasNext()) {
                Map.Entry<String, String> entry = (Map.Entry)var2.next();
                httpHeader.other((String)entry.getKey(), (String)entry.getValue());
            }
        }

        if (StringUtils.isNotBlank(this.cookies)) {
            httpHeader.cookie(this.cookies);
        }

        Header[] headers = httpHeader.build();
        hcb = hcb.sslpv(this.sslProtocolVersion).ssl().retry(retryTime);
        RequestConfig.Builder requestConfigBuilder = RequestConfig.custom().setConnectionRequestTimeout(this.connectionRequestTimeout).setConnectTimeout(this.connectTimeout).setSocketTimeout(this.socketTimeout).setExpectContinueEnabled(false);
        HttpClientBuilder httpClientBuilder = hcb.setUserAgent(this.userAgent).setConnectionManager(cm);
        httpClientBuilder.disableAutomaticRetries();
        if (this.proxyX != null) {
            requestConfigBuilder = requestConfigBuilder.setProxy(this.proxyX.getProxy());
            if (this.proxyX.isNeedUserPsd()) {
                httpClientBuilder.setDefaultCredentialsProvider(this.credsProvider);
            }
        }

        this.reqConfig = requestConfigBuilder.build();
        HttpClient client = httpClientBuilder.build();
        HttpConfig config = HttpConfig.custom().headers(headers).timeout(this.reqConfig).encoding("utf-8").client(client);
        if (this.httpMethods != null) {
            config.method(this.httpMethods);
        }

        if (this.proxyX != null) {
            config.context(this.localContext);
        }

        if (config.map() != null) {
            config.map().clear();
        }

        return config;
    }

    public String doGet(String url) {
        try {
            return HttpClientUtil.get(this.config().url(url));
        } catch (Exception var3) {
            logger.error("get错误", var3);
            return null;
        }
    }

    public String doGet(String url, Map<String, Object> params) {
        try {
            return HttpClientUtil.get(this.config().url(this.getFullUrl(url, params)));
        } catch (Exception var4) {
            logger.error("get错误", var4);
            return null;
        }
    }

    public HttpResult doGetAndGetResponse(String url, Map<String, Object> params) {
        try {
            return HttpClientUtil.executeResult(this.config().method(HttpMethods.GET).url(url).map(params));
        } catch (Exception var4) {
            logger.error("get错误", var4);
            return null;
        }
    }

    public HttpResult doPostAndGetResponse(String url, Map<String, Object> params) {
        try {
            return HttpClientUtil.executeResult(this.config().method(HttpMethods.POST).url(url).map(params));
        } catch (Exception var4) {
            logger.error("post错误", var4);
            return null;
        }
    }

    public HttpResult doPostAndGetResponse(String url, String json) {
        try {
            return HttpClientUtil.executeResult(this.config().method(HttpMethods.POST).url(url).json(json));
        } catch (Exception var4) {
            logger.error("post错误", var4);
            return null;
        }
    }

    public String doPost(String url, Map<String, Object> params) {
        try {
            return HttpClientUtil.post(this.config().url(url).map(params));
        } catch (Exception var4) {
            logger.error("post错误", var4);
            return null;
        }
    }

    public String doPost(String url, String json) {
        try {
            return HttpClientUtil.post(this.config().url(url).json(json));
        } catch (Exception var4) {
            logger.error("post错误", var4);
            return null;
        }
    }

    public String doGetJsonp(String url, Map<String, Object> parameters) {
        try {
            return HttpClientUtil.get(this.config().url(this.getFullUrl(url, parameters)));
        } catch (Exception var4) {
            logger.error("get错误", var4);
            return null;
        }
    }

    private String getFullUrl(String url, Map<String, Object> parameters) {
        String params = (String)Optional.ofNullable(parameters).map((ps) -> {
            return (String)ps.entrySet().stream().map((entry) -> {
                return (String)entry.getKey() + "=" + StringUtil.urlEncode((String)Optional.ofNullable(entry.getValue()).map((v) -> {
                    return v.toString();
                }).orElse(""));
            }).collect(Collectors.joining("&"));
        }).orElse("");
        if (StrUtil.isNotEmpty(params)) {
            url = url + "?" + params;
        }

        return url;
    }

    public String doGetJsonpReturnJson(String url, Map<String, Object> parameters) {
        return this.doGetJsonpReturnJson(url, parameters, (String)null);
    }

    public String doGetJsonpReturnJson(String url, Map<String, Object> parameters, String callbackKey) {
        if (StringUtils.isBlank(callbackKey)) {
            callbackKey = "callback";
        }

        if (parameters.get(callbackKey) == null) {
            return null;
        } else {
            String callback = parameters.get(callbackKey).toString();
            String result = this.doGetJsonp(url, parameters);
            String jsonStr = result.replace(callback, "");
            if (!StringUtils.isBlank(jsonStr) && jsonStr.contains("(")) {
                jsonStr = jsonStr.substring(jsonStr.indexOf("(") + 1, jsonStr.lastIndexOf(")"));
                return jsonStr;
            } else {
                return null;
            }
        }
    }

    public static Map<String, Object> addJsonpCallback(Map<String, Object> parameters) {
        String time = String.valueOf((new Date()).getTime());
        String callback = "jQuery351018003419644615448_" + time;
        parameters.put("callback", callback);
        parameters.put("_", time);
        return parameters;
    }

    public boolean download(String url, File file) {
        FileOutputStream fileOutputStream = null;

        boolean var5;
        try {
            makeFolderExists(file.getParentFile());
            fileOutputStream = new FileOutputStream(file);
            HttpClientUtil.down(this.config().url(url).out(fileOutputStream));
            if (file.exists()) {
                boolean var4 = true;
                return var4;
            }

            return false;
        } catch (Exception var16) {
            logger.error("download错误,URL=" + url, var16);
            var5 = false;
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (Exception var15) {
                logger.error("download错误,URL=" + url, var15);
            }

        }

        return var5;
    }

    public OutputStream download(String url, FileOutputStream fileOutputStream) {
        Object var4;
        try {
            HttpClientUtil.down(this.config().url(url).out(fileOutputStream));
            FileOutputStream var3 = fileOutputStream;
            return var3;
        } catch (Exception var14) {
            logger.error("download错误,URL=" + url, var14);
            var4 = null;
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (Exception var13) {
                logger.error("download错误,URL=" + url, var13);
            }

        }

        return (OutputStream)var4;
    }

    public OutputStream customDownload(String url, FileOutputStream fileOutputStream) {
        Object var4;
        try {
            HttpClientUtil.down(HttpConfig.custom().url(url).out(fileOutputStream));
            FileOutputStream var3 = fileOutputStream;
            return var3;
        } catch (Exception var14) {
            logger.error("download错误", var14);
            var4 = null;
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (Exception var13) {
                logger.error("download错误", var13);
            }

        }

        return (OutputStream)var4;
    }

    public boolean hutoolDownload(String url, File file) {
        HttpResponse response = null;

        try {
            boolean var5;
            try {
                makeFolderExists(file.getParentFile());
                HttpRequest request = HttpRequest.get(url).setConnectionTimeout(this.connectTimeout).setReadTimeout(this.socketTimeout).setFollowRedirects(true).setMaxRedirectCount(5);
                if (MapUtil.isNotEmpty(this.headers)) {
                    request.headerMap(this.headers, true);
                }

                if (this.proxy != null) {
                    request.setProxy(this.proxy);
                }

                response = request.executeAsync();
                if (response.isOk()) {
                    response.writeBody(file);
                    if (file.exists()) {
                        var5 = true;
                        return var5;
                    }
                }

                var5 = false;
                return var5;
            } catch (Exception var9) {
                logger.error("hutoolDownload下载失败,URL=" + url, var9);
                var5 = false;
                return var5;
            }
        } finally {
            IoUtil.close(response);
        }
    }

    public boolean fastDownload(String url, File file) {
        InputStream is = null;

        try {
            makeFolderExists(file.getParentFile());
            FastHttpClientBuilder fastHttpClientBuilder = FastHttpClient.newBuilder().connectTimeout((long)this.connectTimeout, TimeUnit.MILLISECONDS).readTimeout((long)this.connectTimeout, TimeUnit.MILLISECONDS);
            if (this.proxyX != null) {
                fastHttpClientBuilder.proxy(this.proxy).proxyAuthenticator(this.proxyAuthenticator);
            }

            GetBuilder builder = (GetBuilder)fastHttpClientBuilder.build().get().url(url);
            if (this.headers != null && this.headers.size() > 0) {
                Iterator var6 = this.headers.entrySet().iterator();

                while(var6.hasNext()) {
                    Map.Entry<String, String> entry = (Map.Entry)var6.next();
                    builder.addHeader((String)entry.getKey(), (String)entry.getValue());
                }
            }

            io.itit.itf.okhttp.Response response = builder.build().execute();
            boolean var15;
            if (response.isSuccessful()) {
                FileUtil.saveContent((InputStream)is, file);
                if (file.exists()) {
                    var15 = true;
                    return var15;
                }
            }

            var15 = false;
            return var15;
        } catch (Exception var11) {
            logger.error("fastDownload下载失败,URL=" + url, var11);
            boolean var5 = false;
            return var5;
        } finally {
            IoUtil.close((Closeable)is);
        }
    }

    public static void makeFolderExists(File folder) {
        if (!folder.exists()) {
            folder.mkdirs();
        }

    }

    static {
        try {
            hcb = HCB.custom().timeout(1000).pool(poolMaxTotal, defaultMaxPerRoute);
            ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
            LayeredConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(SSLContexts.custom().loadTrustMaterial((KeyStore)null, new TrustSelfSignedStrategy()).build(), NoopHostnameVerifier.INSTANCE);
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.create().register("http", plainsf).register("https", sslsf).build();
            cm = new PoolingHttpClientConnectionManager(registry);
            cm.setMaxTotal(poolMaxTotal);
            cm.setDefaultMaxPerRoute(defaultMaxPerRoute);
        } catch (Exception var3) {
            logger.error("HCB静态初始化错误", var3);
        }

    }

    public static class ProxyX {
        private HttpHost proxy;
        private String hostname;
        private int port;
        private String proxyUser;
        private String proxyPassword;
        private boolean needUserPsd = false;

        public ProxyX(String hostname, int port, String scheme) {
            this.proxy = new HttpHost(hostname, port, scheme);
        }

        public ProxyX(HttpHost proxy) {
            this.proxy = proxy;
        }

        public ProxyX(HttpHost proxy, String proxyUser, String proxyPassword) {
            this.proxy = proxy;
            this.proxyUser = proxyUser;
            this.proxyPassword = proxyPassword;
            this.needUserPsd = true;
        }

        public ProxyX(String hostname, int port, String scheme, String proxyUser, String proxyPassword) {
            this.proxy = new HttpHost(hostname, port, scheme);
            this.hostname = hostname;
            this.port = port;
            this.proxyUser = proxyUser;
            this.proxyPassword = proxyPassword;
            this.needUserPsd = true;
        }

        public HttpHost getProxy() {
            return this.proxy;
        }

        public void setProxy(HttpHost proxy) {
            this.proxy = proxy;
        }

        public String getProxyUser() {
            return this.proxyUser;
        }

        public void setProxyUser(String proxyUser) {
            this.proxyUser = proxyUser;
        }

        public String getProxyPassword() {
            return this.proxyPassword;
        }

        public void setProxyPassword(String proxyPassword) {
            this.proxyPassword = proxyPassword;
        }

        public boolean isNeedUserPsd() {
            return this.needUserPsd;
        }

        public void setNeedUserPsd(boolean needUserPsd) {
            this.needUserPsd = needUserPsd;
        }

        public String getHostname() {
            return this.hostname;
        }

        public void setHostname(String hostname) {
            this.hostname = hostname;
        }

        public int getPort() {
            return this.port;
        }

        public void setPort(int port) {
            this.port = port;
        }
    }
}
 

3，封装统一请求工具类，用到上面的httpUtils，HttpclientX两个工具类。

public class HttpRequestCommandExe {

    @SneakyThrows
    public PageResult executeGet(String requestUrl, Map params, Class<? extends PageResult> resultType) {

        if ( Objects.isNull(params)){
            params = new HashMap();
        }
        log.info("请求url={},params={}", requestUrl, params);
        String resultString = "";
        JSONObject resultJSON = new JSONObject();
        //防止请求出错
        try {
            //防止请求出错
            resultString = HttpUtils.sendGet(requestUrl,params);
            //解析json结果防止报错
            resultJSON = JSONObject.parseObject(resultString);
            //判断是否请求200
            if (Objects.nonNull(resultJSON)) {
                boolean successRequest = Objects.equals(RequestConstant.SUCCUESS_CODE, resultJSON.getInteger("code"));
                if (!successRequest) {
                    log.error("请求出错，请求的url是{},参数是{},结果是{}", requestUrl, params, resultString);
                    return resultType.newInstance();
                }
            }

            //进入正式的业务
            String dataStr = null;
            if (Objects.nonNull(resultJSON))
             dataStr = resultJSON.getString("data");
            return JSON.parseObject(dataStr, PageResult.class);
        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, params, resultString, e);

            return resultType.newInstance();
        }
    }

    public <T> List<T> executeGetPageResultList(String requestUrl, Map params, Class<T> resultType) {
        if (Objects.isNull(params)) {
            params = new HashMap();
        }
        log.info("请求url={},params={}", requestUrl, params);
        String resultString = "";
        JSONObject resultJSON = null;
        try {
            //防止请求出错
            resultString = HttpUtils.sendGet(requestUrl, params);
            //解析json结果防止报错
            resultJSON = JSONObject.parseObject(resultString);
            //判断是否请求200，非500则安徽才能得到正确业务
            if (Objects.nonNull(resultJSON)) {
                boolean successRequest = Objects.equals(RequestConstant.SUCCUESS_CODE, resultJSON.getInteger("code"));
                if (!successRequest) {
                    log.error("请求出错，请求的url是{},参数是{},结果是{}", requestUrl, params, resultString);
                    return Collections.emptyList();
                }
            }

            //进入正式的业务
            String data = null;
            if (Objects.nonNull(resultJSON)){
                 data = resultJSON.getString("data");
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject = JSONObject.parseObject(data);
            String dataArray = jsonObject.getString("rows");
            return JSON.parseArray(dataArray, resultType);
        } catch (JSONException e) {
            log.error("json解析出错，请求的url是{},参数是,结果是{},异常是{}", requestUrl, params, resultString, e);

            return Collections.emptyList();
        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, params, resultString, e);

            log.error("", e);
            return Collections.emptyList();
        }

    }

    public R<?> executePostResult(String requestUrl, String paramJson) {
        if (Objects.isNull(paramJson)) {
            paramJson="{}";
        }
        try {
            String resultString = HttpclientX.create().setConnectTimeout(30000).doPost(requestUrl, paramJson);

            //解析json结果为R
            return JSON.parseObject(resultString, R.class);

        } catch (JSONException e) {
            log.error("json解析出错，请求的url是{},参数是,结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

        }
        return R.fail();
    }

    public <T> List<T> executePostPageResultList(String requestUrl, String paramJson, Class<T> resultType) {
        if (Objects.isNull(paramJson)) {
            paramJson="{}";
        }
        try {
            String resultString="";
            JSONObject resultJSON= new JSONObject();
            //防止请求出错
            resultString = HttpclientX.create().setConnectTimeout(30000).doPost(requestUrl, paramJson);
            //解析json结果防止报错
            resultJSON = JSONObject.parseObject(resultString);
            //判断是否请求200，非500则安徽才能得到正确业务
            if (Objects.nonNull(resultJSON)) {
                boolean successRequest = Objects.equals(RequestConstant.SUCCUESS_CODE, resultJSON.getInteger("code"));
                if (!successRequest) {
                    log.error("请求出错，请求的url是{},参数是{},结果是{}", requestUrl, paramJson, resultString);
                    return Collections.emptyList();
                }
            }
            //进入正式业务
            String data = null;
            if (Objects.nonNull(resultJSON)){
                data = resultJSON.getString("data");
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject = JSONObject.parseObject(data);
            String dataArray = jsonObject.getString("rows");
            return JSON.parseArray(dataArray, resultType);
        } catch (JSONException e) {
            log.error("json解析出错，请求的url是{},参数是,结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

            return Collections.emptyList();
        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

            return Collections.emptyList();
        }
    }

    public <T> List<T> executeGetList(String requestUrl, Map params, Class<T> resultType) {
        if (Objects.isNull(params)) {
            params = new HashMap();
        }
        log.info("请求url={},params={}", requestUrl, params);
        String resultString = "";
        JSONObject resultJSON = null;
        try {
            //防止请求出错
            resultString = HttpclientX.create().doGet(requestUrl, params);
            //解析json结果防止报错
            resultJSON = JSON.parseObject(resultString);
            //判断是否请求200，非500则安徽才能得到正确业务
            if (Objects.nonNull(resultJSON)) {
                boolean successRequest = Objects.equals(RequestConstant.SUCCUESS_CODE, resultJSON.getInteger("code"));
                if (!successRequest) {
                    log.error("请求出错，请求的url是{},参数是{},结果是{}", requestUrl, params, resultString);
                    return Collections.emptyList();
                }
            }

            //进入正式的业务
            String data = null;
            if (Objects.nonNull(resultJSON)){
                 data = resultJSON.getString("data");
            }
            return JSON.parseArray(data, resultType);
        } catch (JSONException e) {
            log.error("json解析出错，请求的url是{},参数是,结果是{},异常是{}", requestUrl, params, resultString, e);

            return Collections.emptyList();
        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, params, resultString, e);

            log.error("", e);
            return Collections.emptyList();
        }

    }

    public <T> List<T> executePostGetList(String requestUrl, String paramJson, Class<T> resultType) {
        if (Objects.isNull(paramJson)) {
            paramJson="{}";
        }
        try {
            String resultString="";
            JSONObject resultJSON= new JSONObject();
            //防止请求出错
            resultString = HttpclientX.create().setConnectTimeout(30000).doPost(requestUrl, paramJson);
            //解析json结果防止报错
            resultJSON = JSONObject.parseObject(resultString);
            //判断是否请求200，非500则安徽才能得到正确业务
            if (Objects.nonNull(resultJSON)) {
                boolean successRequest = Objects.equals(RequestConstant.SUCCUESS_CODE, resultJSON.getInteger("code"));
                if (!successRequest) {
                    log.error("请求出错，请求的url是{},参数是{},结果是{}", requestUrl, paramJson, resultString);
                    return Collections.emptyList();
                }
            }
            //进入正式业务
            //进入正式的业务
            String data = null;
            if (Objects.nonNull(resultJSON)){
                 data = resultJSON.getString("data");
            }
            return JSON.parseArray(data, resultType);
        } catch (JSONException e) {
            log.error("json解析出错，请求的url是{},参数是,结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

            return Collections.emptyList();
        } catch (Exception e) {
            log.error("请求出错，请求的url是{},参数是{},结果是{},异常是{}", requestUrl, paramJson, paramJson, e);

            return Collections.emptyList();
        }
    }

}
 

4，在你的业务代码调用；

  @ApiOperation(value = "xxxxxxxxxxx接口", notes = "xxxxxxxxxxx接口", httpMethod = "GET")
  @GetMapping("/xxxxxxxMethod")
    public R<List<xxxxxxDTO>> getRegionTreeByLevelForRpc(@RequestParam("areaLevel") Integer areaLevel) {
        String url = XXXXXHost + "/XXXXX/XXXX/XXXX/XXXXX";
        Map map = new HashMap<>();
        map.put("areaLevel",areaLevel);
        log.info("请求URL是{},接口的请求报文为={}", url, map);
        HttpRequestCommandExe requestCommandExe = new HttpRequestCommandExe();
        List<xxxxxxDTO> result = requestCommandExe.executeGetList(url, map, xxxxxxDTO.class);
        log.info("接口请求第三方返回值为={}", result);
        return R.ok(result);
    }