okhttp

java 复制代码
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.parser.Feature;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import okhttp3.Call;
import okhttp3.Headers;
import okhttp3.HttpUrl;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.Request.Builder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HttpClient {
    private static final Logger log = LoggerFactory.getLogger(HttpClient.class);
    public OkHttpClient okHttpClient;
    protected String content_json_type = "application/json";
    protected static final String empty_param = "{}";

    protected HttpClient(OkHttpClient okHttpClient) {
        this.okHttpClient = okHttpClient;
    }

    public <R> String post(String url, R param) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).post(body).build();
        return this.fire(request);
    }

    protected <R> String postConvertParam(R param) {
        return JSON.toJSONString(param);
    }

    public String post(String url) {
        this.paramLog("{}", url);
        RequestBody body = RequestBody.create("{}", MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).post(body).build();
        return this.fire(request);
    }

    public <R> String post(String url, R param, Map<String, String> headers) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).headers(Headers.of(headers)).post(body).build();
        return this.fire(request);
    }

    public String get(String url) {
        HttpUrl httpUrl = HttpUrl.parse(url);
        if (httpUrl == null) {
            return null;
        } else {
            this.paramLog("", url);
            Request request = (new Builder()).url(url).get().build();
            return this.fire(request);
        }
    }

    public String get(String url, Map<String, String> params) {
        HttpUrl paramBuild = this.getParamBuild(url, params);
        if (paramBuild == null) {
            return "";
        } else {
            Request request = (new Builder()).url(paramBuild).get().build();
            return this.fire(request);
        }
    }

    public String get(String url, Map<String, String> params, Map<String, String> headers) {
        HttpUrl paramBuild = this.getParamBuild(url, params);
        if (paramBuild == null) {
            return "";
        } else {
            Request request = (new Builder()).url(paramBuild).headers(Headers.of(headers)).get().build();
            return this.fire(request);
        }
    }

    private HttpUrl getParamBuild(String url, Map<String, String> params) {
        this.paramLog(JSON.toJSONString(params), url);
        HttpUrl httpUrl = HttpUrl.parse(url);
        if (httpUrl == null) {
            log.error("解析异常url:{}", url);
            return null;
        } else {
            okhttp3.HttpUrl.Builder httpBuilder = httpUrl.newBuilder();
            if (params != null) {
                params.forEach(httpBuilder::addQueryParameter);
            }

            return httpBuilder.build();
        }
    }

    public <R> String put(String url, R param) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).put(body).build();
        return this.fire(request);
    }

    public <R> String delete(String url, R param, Map<String, String> headers) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).headers(Headers.of(headers)).delete(body).build();
        return this.fire(request);
    }

    public String delete(String url) {
        this.paramLog("{}", url);
        RequestBody body = RequestBody.create("{}", MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).delete(body).build();
        return this.fire(request);
    }

    public <R> String put(String url, R param, Map<String, String> headers) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).headers(Headers.of(headers)).put(body).build();
        return this.fire(request);
    }

    public String put(String url, Map<String, String> headers) {
        this.paramLog("{}", url);
        RequestBody body = RequestBody.create("{}", MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).headers(Headers.of(headers)).put(body).build();
        return this.fire(request);
    }

    public String put(String url) {
        this.paramLog("{}", url);
        RequestBody body = RequestBody.create("{}", MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).put(body).build();
        return this.fire(request);
    }

    public <R> String delete(String url, R param) {
        String jsonString = this.postConvertParam(param);
        this.paramLog(jsonString, url);
        RequestBody body = RequestBody.create(jsonString, MediaType.parse(this.content_json_type));
        Request request = (new Builder()).url(url).delete(body).build();
        return this.fire(request);
    }

    public byte[] download(String url) {
        this.paramLog("{}", url);
        Request request = (new Builder()).url(url).get().build();

        try {
            ResponseBody body = this.okHttpClient.newCall(request).execute().body();
            if (body != null) {
                return body.bytes();
            }
        } catch (IOException var4) {
            log.error("下载异常url:{}", url, var4);
        }

        return null;
    }

    public InputStream downloadOssInputStream(String url) {
        this.paramLog("{}", url);
        Request request = (new Builder()).url(url).header("Referer", "http://www.test.com").get().build();

        try {
            ResponseBody body = this.okHttpClient.newCall(request).execute().body();
            if (body != null) {
                return body.byteStream();
            }
        } catch (IOException var4) {
            log.error("下载异常url:{}", url, var4);
        }

        return null;
    }

    public byte[] downloadOss(String url) {
        this.paramLog("{}", url);
        Request request = (new Builder()).url(url).header("Referer", "http://www.test.com").get().build();

        try {
            ResponseBody body = this.okHttpClient.newCall(request).execute().body();
            if (body != null) {
                return body.bytes();
            }
        } catch (IOException var4) {
            log.error("下载异常url:{}", url, var4);
        }

        return null;
    }

    public String upload(String url, String fileKey, String fileName, byte[] bytes) {
        return this.upload(url, fileKey, (Map)null, fileName, bytes);
    }

    public String upload(String url, String fileKey, Map<String, String> params, String fileName, byte[] bytes) {
        this.paramLog("{}", url);
        RequestBody fileBody = RequestBody.create(bytes);
        okhttp3.MultipartBody.Builder builder = (new okhttp3.MultipartBody.Builder()).setType(MultipartBody.FORM).addFormDataPart(fileKey, fileName, fileBody);
        if (params != null) {
            params.forEach(builder::addFormDataPart);
        }

        RequestBody requestBody = builder.build();
        Request request = (new Builder()).url(url).post(requestBody).build();
        return this.fire(request);
    }

    public String fire(Request request) {
        Call call = this.okHttpClient.newCall(request);

        try {
            Response response = call.execute();
            return this.getResult(response);
        } catch (Exception var4) {
            log.error("请求异常url:{}", request.url(), var4);
            return "";
        }
    }

    public static <R> R convert(String str, TypeReference<R> typeReference) {
        return str != null && !str.equals("") ? JSON.parseObject(str, typeReference.getType(), new Feature[0]) : null;
    }

    protected void paramLog(String param, String url) {
        log.info("请求路径:{},参数:{}", url, param);
    }

    private void resultLog(String result) {
        log.info("请求返回:{}", result);
    }

    private String getResult(Response response) throws IOException {
        int code = response.code();
        if (code != 200) {
            log.error("请求异常路径:{},code:{},message:{}", new Object[]{response.request().url().toString(), response.code(), response.message()});
            return "";
        } else {
            ResponseBody body = response.body();
            if (body != null) {
                String result = body.string();
                this.resultLog(result);
                return result;
            } else {
                return "";
            }
        }
    }
}
java 复制代码
import java.util.concurrent.TimeUnit;
import okhttp3.Dispatcher;
import okhttp3.OkHttpClient;
import okhttp3.OkHttpClient.Builder;

public class HttpClientFactory {
    static Dispatcher dispatcher = new Dispatcher();

    public HttpClientFactory() {
    }

    public static HttpClient getInstance(int connectTime, int readTimeOut) {
        OkHttpClient okHttpClient = (new Builder()).connectTimeout((long)connectTime, TimeUnit.SECONDS).readTimeout((long)readTimeOut, TimeUnit.SECONDS).dispatcher(dispatcher).build();
        return new HttpClient(okHttpClient);
    }

    public static FormHttpClient getFormHttpInstance(int connectTime, int readTimeOut) {
        OkHttpClient okHttpClient = (new Builder()).connectTimeout((long)connectTime, TimeUnit.SECONDS).readTimeout((long)readTimeOut, TimeUnit.SECONDS).dispatcher(dispatcher).build();
        return new FormHttpClient(okHttpClient);
    }

    public static HttpClient getInstance(OkHttpClient okHttpClient) {
        return new HttpClient(okHttpClient);
    }

    static {
        dispatcher.setMaxRequests(300);
        dispatcher.setMaxRequestsPerHost(300);
    }
}
java 复制代码
import com.alibaba.fastjson.TypeReference;
import java.io.InputStream;
import java.util.Map;
import okhttp3.Request;

public class CHttpClient {
    public static HttpClient httpClient = HttpClientFactory.getInstance(5, 5);

    public CHttpClient() {
    }

    public static <P> String post(String url, P param) {
        return httpClient.post(url, param);
    }

    public static <R, P> R post(String url, P param, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.post(url, param), typeReference);
    }

    public static String post(String url) {
        return httpClient.post(url);
    }

    public static <R> R post(String url, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.post(url), typeReference);
    }

    public static <P> String post(String url, P param, Map<String, String> headers) {
        return httpClient.post(url, param, headers);
    }

    public static <R, P> R post(String url, P param, Map<String, String> headers, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.post(url, param, headers), typeReference);
    }

    public static String get(String url, Map<String, String> params) {
        return httpClient.get(url, params);
    }

    public static <R> R get(String url, Map<String, String> params, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.get(url, params), typeReference);
    }

    public static String get(String url) {
        return httpClient.get(url);
    }

    public static <R> R get(String url, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.get(url), typeReference);
    }

    public static String get(String url, Map<String, String> params, Map<String, String> headers) {
        return httpClient.get(url, params, headers);
    }

    public static <R> R get(String url, Map<String, String> params, Map<String, String> headers, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.get(url, params, headers), typeReference);
    }

    public static <P> String put(String url, P param, Map<String, String> headers) {
        return httpClient.put(url, param, headers);
    }

    public static <R, P> R put(String url, P param, Map<String, String> headers, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.put(url, param, headers), typeReference);
    }

    public static <R> R put(String url, Map<String, String> headers, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.put(url, headers), typeReference);
    }

    public static <R> R put(String url, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.put(url), typeReference);
    }

    public static String put(String url) {
        return httpClient.put(url);
    }

    public static <P> String delete(String url, P param, Map<String, String> headers) {
        return httpClient.delete(url, param, headers);
    }

    public static String delete(String url) {
        return httpClient.delete(url);
    }

    public static <R> R delete(String url, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.delete(url), typeReference);
    }

    public static <R, P> R delete(String url, P param, Map<String, String> headers, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.delete(url, param, headers), typeReference);
    }

    public static <P> String put(String url, P param) {
        return httpClient.put(url, param);
    }

    public static <R, P> R put(String url, P param, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.put(url, param), typeReference);
    }

    public static <P> String delete(String url, P param) {
        return httpClient.delete(url, param);
    }

    public static <R, P> R delete(String url, P param, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.delete(url, param), typeReference);
    }

    public static byte[] download(String url) {
        return httpClient.download(url);
    }

    public static byte[] downloadOss(String url) {
        return httpClient.downloadOss(url);
    }

    public static InputStream downloadOssInputStream(String url) {
        return httpClient.downloadOssInputStream(url);
    }

    public static String upload(String url, String fileKey, String fileName, byte[] bytes) {
        return httpClient.upload(url, fileKey, fileName, bytes);
    }

    public static <R> R upload(String url, String fileKey, Map<String, String> params, String fileName, byte[] bytes, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.upload(url, fileKey, params, fileName, bytes), typeReference);
    }

    public static String upload(String url, String fileKey, Map<String, String> params, String fileName, byte[] bytes) {
        return httpClient.upload(url, fileKey, params, fileName, bytes);
    }

    public static <R> R upload(String url, String fileKey, String fileName, byte[] bytes, TypeReference<R> typeReference) {
        return HttpClient.convert(httpClient.upload(url, fileKey, fileName, bytes), typeReference);
    }

    public static String fire(Request request) {
        return httpClient.fire(request);
    }
}
java 复制代码
import java.lang.reflect.Field;
import java.util.Map;
import okhttp3.OkHttpClient;

public class FormHttpClient extends HttpClient {
    private static FormHttpClient formHttpClient;

    protected FormHttpClient(OkHttpClient okHttpClient) {
        super(okHttpClient);
        super.content_json_type = "application/x-www-form-urlencoded";
    }

    protected <R> String postConvertParam(R param) {
        if (param instanceof String) {
            return param.toString();
        } else {
            StringBuilder builder = new StringBuilder();
            if (param instanceof Map) {
                ((Map)param).forEach((key, valuex) -> {
                    builder.append(key).append("=").append(valuex).append("&");
                });
            } else {
                Class<?> superClass = param.getClass();

                for(int i = 0; i < 5 && superClass != Object.class; ++i) {
                    Field[] var5 = superClass.getDeclaredFields();
                    int var6 = var5.length;

                    for(int var7 = 0; var7 < var6; ++var7) {
                        Field field = var5[var7];
                        field.setAccessible(true);
                        String fieldName = field.getName();

                        Object value;
                        try {
                            value = field.get(param);
                        } catch (IllegalAccessException var12) {
                            throw new UnsupportedOperationException("参数转换失败");
                        }

                        builder.append(fieldName).append("=").append(value).append("&");
                    }

                    superClass = superClass.getSuperclass();
                }
            }

            return builder.substring(0, builder.length() - 1);
        }
    }

    public static FormHttpClient getInstance() {
        if (formHttpClient == null) {
            formHttpClient = HttpClientFactory.getFormHttpInstance(5, 5);
        }

        return formHttpClient;
    }
}
相关推荐
Jeled1 天前
Retrofit 与 OkHttp 全面解析与实战使用(含封装示例)
android·okhttp·android studio·retrofit
Jeled2 天前
Android 网络层最佳实践:Retrofit + OkHttp 封装与实战
android·okhttp·kotlin·android studio·retrofit
allk555 天前
OkHttp源码解析(一)
android·okhttp
allk555 天前
OkHttp源码解析(二)
android·okhttp
aFakeProgramer5 天前
拆分PDF.html 办公小工具
okhttp
一壶浊酒..6 天前
ajax局部更新
前端·ajax·okhttp
洛克大航海9 天前
Ajax基本使用
java·javascript·ajax·okhttp
whltaoin15 天前
Java 网络请求 Jar 包选型指南:从基础到实战
java·http·okhttp·网络请求·retrofit
华农第一蒟蒻16 天前
谈谈跨域问题
java·后端·nginx·安全·okhttp·c5全栈
一直向钱18 天前
android 基于okhttp的socket封装
android·okhttp