KKSU
2024-12-17 288e2a2ca2e7c2f7158507174a42f8a417380d23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package cc.mrbird.febs.mall.chain.trcCoin;
 
import okhttp3.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
 
public class OkHttpUtil2 {
    protected final static Logger logger = LoggerFactory.getLogger(OkHttpUtil2.class);
    private static Dispatcher dispatcher = new Dispatcher();
 
    static {
        dispatcher.setMaxRequests(200);
        dispatcher.setMaxRequestsPerHost(100);
    }
 
    private static OkHttpClient httpClient = new OkHttpClient.Builder().dispatcher(dispatcher).build();
 
    public static byte[] doGet(String url, Map<String, String[]> header, Map<String, String[]> params, String expectContentType) {
        Request.Builder builder = new Request.Builder();
        addHeader(builder, header);
        addUrlParam(builder, url, params);
        return requestExec(builder.build(), expectContentType);
    }
 
    public static byte[] doGetSingle(String url, Map<String, String> header, Map<String, String> params, String expectContentType) {
        Request.Builder builder = new Request.Builder();
        addHeaderSingle(builder, header);
        addUrlParamSingle(builder, url, params);
        return requestExec(builder.build(), expectContentType);
    }
 
    public static byte[] doPost(String url, Map<String, String[]> header, Map<String, String[]> body, String expectContentType) {
        Request.Builder builder = new Request.Builder().url(url);
        addHeader(builder, header);
        addBodyParam(builder, body, "POST");
        return requestExec(builder.build(), expectContentType);
    }
 
 
 
    private static void addHeaderSingle(Request.Builder builder, Map<String, String> header) {
        if (header == null) {
            return;
        }
        for (String key : header.keySet()) {
            String value = header.get(key);
            if (value != null) {
                builder.addHeader(key, value);
            }
        }
    }
 
    private static void addHeader(Request.Builder builder, Map<String, String[]> header) {
        if (header == null) {
            return;
        }
        for (String key : header.keySet()) {
            String[] values = header.get(key);
            if (values != null) {
                for (String value : values) {
                    builder.addHeader(key, value);
                }
            }
        }
    }
 
    private static void addUrlParam(Request.Builder builder, String url, Map<String, String[]> params) {
        if (params == null) {
            return;
        }
        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        for (String key : params.keySet()) {
            String[] values = params.get(key);
            if (values != null) {
                for (String value : values) {
                    urlBuilder.addQueryParameter(key, value);
                }
            }
        }
        builder.url(urlBuilder.build());
    }
 
    private static void addUrlParamSingle(Request.Builder builder, String url, Map<String, String> params) {
        if (params == null) {
            return;
        }
        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        for (String key : params.keySet()) {
            String value = params.get(key);
            if (value != null) {
                urlBuilder.addQueryParameter(key, value);
            }
        }
        builder.url(urlBuilder.build());
    }
 
    private static void addBodyParam(Request.Builder builder, Map<String, String[]> body, String method) {
        if (body == null) {
            return;
        }
        FormBody.Builder formBodyBuilder = new FormBody.Builder(StandardCharsets.UTF_8);
        for (String key : body.keySet()) {
            String[] values = body.get(key);
            if (values != null) {
                for (String value : values) {
                    formBodyBuilder.add(key, value);
                }
            }
        }
        builder.method(method, formBodyBuilder.build());
    }
 
    private static byte[] requestExec(Request request, String expectContentType) {
        Objects.requireNonNull(request, "okHttp request is null");
 
        try (Response response = httpClient.newCall(request).execute()) {
            if (response.code() == 200) {
                ResponseBody body = response.body();
                if (body != null) {
                    byte[] bytes = body.bytes();
                    String contentType = response.header("Content-Type");
                    if (contentType != null && !contentType.contains(expectContentType)) {
                        String res = new String(bytes, StandardCharsets.UTF_8);
                        System.out.println(res);
                        return bytes;
                    }
                    return bytes;
                }
                logger.error("response body is null");
                System.out.println("response body is null");
            } else {
                ResponseBody body = response.body();
                String res = "";
                byte[] bytes = null;
                if (body != null) {
                    bytes = body.bytes();
                    String contentType = response.header("Content-Type");
                    if (contentType != null && !contentType.contains(expectContentType)) {
                        //res = new String(body.bytes(), StandardCharsets.UTF_8);
                        //return body.bytes();
                    }
                    res = new String(bytes, StandardCharsets.UTF_8);
 
                }
                logger.error("request failed, http code:{},responseBody:{} ", response.code(), res);
                System.out.println("request failed, http code: " + response.code());
 
                return bytes;
            }
        } catch (IOException ioException) {
            logger.error("request exec error:", ioException);
            System.out.println("request exec error: " + ioException.getMessage());
        }
        return null;
    }
}