1. 内外网代理
1.1 需要在代码http请求初始化之前添加
1.1.1 pom依赖
<!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.12.0</version>
<exclusions>
<exclusion>
<groupId>com.squareup.okio</groupId>
<artifactId>okio</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.squareup.okio</groupId>
<artifactId>okio</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>logging-interceptor</artifactId>
<version>4.12.0</version>
</dependency>
1.1.2 代码设置代理属性
// 开启代理---开始
String proxyHost = "10.81.159.61";
String proxyPort = "9090";
System.setProperty("http.proxyHost", proxyHost);
System.setProperty("http.proxyPort", proxyPort);
System.setProperty("https.proxyHost", proxyHost);
System.setProperty("https.proxyPort", proxyPort);
// 开启代理---结束
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
1.1.3 代码演示
1.1.3.1 代码演示，okhttp 网络请求
package com.dahua.evo.channel.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dahua.evo.channel.common.constant.Constants;
import com.dahua.evo.channel.job.dto.thirdDto.*;
import okhttp3.*;
import okhttp3.logging.HttpLoggingInterceptor;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.formula.functions.T;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketTimeoutException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* @author fuwu314
* @describe：
* @date 2024/8/23
*/
public class OkHttpUtil {
protected static final Logger logger = LoggerFactory.getLogger(OkHttpUtil.class);
private static volatile OkHttpClient client;
private static final String DEFAULT_MEDIA_TYPE = "application/json; charset=utf-8";
// private final static String httpHeaderMediaType = "application/json;charset=utf-8";
// private final static String httpHeaderContentType = "Content-Type";
private final static String DEFAULT_CONTENT_TYPE = "Content-Type";
private static final int CONNECT_TIMEOUT = 15;
private static final int READ_TIMEOUT = 17;
private static final int writeTimeout = 17;
private static int maxIdleConnections = 200;
private static long keepAliveDuration = 300;
private static final String GET = "GET";
private static final String POST = "POST";
private OkHttpUtil() {
}
/**
* 单例模式 获取类实例
*
* @return client
*/
private static OkHttpClient getInstance() {
if (client == null) {
synchronized (OkHttpClient.class) {
if (client == null) {
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
client = new OkHttpClient.Builder()
.connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
.readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
.writeTimeout(writeTimeout, TimeUnit.SECONDS)
.hostnameVerifier(new OkHttpUtil.TrustAllHostnameVerifier())
.sslSocketFactory(createSSLSocketFactory(), new OkHttpUtil.TrustAllCerts())
.connectionPool(new ConnectionPool(maxIdleConnections, keepAliveDuration, TimeUnit.SECONDS))
.retryOnConnectionFailure(true)
.addInterceptor(loggingInterceptor)
.build();
}
}
}
return client;
}
public static void main2(String[] args) throws Exception {
String url = "https://yq.damaiiot.com/yq-api-third/resource/enterprisePage";
String param = "{\"identity\":\"DaHua\",\"nonceStr\":\"egaqn5iv\",\"pageNum\":1,\"pageSize\":100,\"sign\":\"7A093835CE0A9F18C4AA35C31AF69BC8\",\"timestamp\":\"1732775532544\",\"yq\":\"ykzglt\"} ";
RequestBody body = RequestBody.create(
MediaType.parse("application/json"), param);
Request request = new Request.Builder().url(url).post(body).build();
Response response = getInstance().newCall(request).execute();
// 开启代理---开始
String proxyHost = "10.81.159.61";
String proxyPort = "9090";
System.setProperty("http.proxyHost", proxyHost);
System.setProperty("http.proxyPort", proxyPort);
System.setProperty("https.proxyHost", proxyHost);
System.setProperty("https.proxyPort", proxyPort);
// 开启代理---结束
int mobile_code = (int)((Math.random()*9+1)*100000);
String tokenVal = "2aa8edfda3e143ecbb95c4e75e300126";
String content = new String("您的验证码是：" + mobile_code + "。请不要把验证码泄露给其他人。");
// String URL = "http://106.ihuyi.com/webservice/sms.php?method=Submit&account=C23420345&password=c3e0320fa2fc6fd26b95f5c4d7608733&mobile=19957193200&content="+content;
// String Url = "http://106.ihuyi.com/webservice/sms.php?method=Submit&account=C74372401&password=791c7a6bc30225cb5250ef72eef87fda&mobile=18735653932&content=尊敬的短信测试先生/女士，你有一条新的预约提醒，请您前往https://fk.chengxinzhiyuan.com:8448/visitor/static/H5/index.html进行审核，谢谢！";
String Url = "http://183.129.241.212:8027/dolphinscheduler/teacherBaseInfo/bizjzgjbxx/exportSelectedUrl?id=2aa8edfda3e143ecbb95c4e75e300126";
ThirtHttpRespResult<ThridClassDto> datastr = (ThirtHttpRespResult<ThridClassDto>) doGet(Url,tokenVal, ThridClassDto.class);
System.out.println(datastr);
}
public static void main3(String[] args) throws Exception {
String jsstr = " {\n" +
" \"msg\": \"success\",\n" +
" \"total\": 4380,\n" +
" \"code\": 200,\n" +
" \"resultList\": [\n" +
" {\n" +
" \"bjmc\": \"高中二年级(16)班\",\n" +
" \"student_name\": \"吴睿峣\",\n" +
" \"nj_id\": \"1e0b7d41906f4d3db5940a67bc43e1f8\",\n" +
" \"bj_id\": \"d9eedcf36a6a47529211b2eabc06648d\",\n" +
" \"xnxq\": \"2024-2025学年第一学期\",\n" +
" \"student_id\": \"b8def514233a43bebbbe05adf3d633eb\",\n" +
" \"id\": \"db7c6907fa40434bb2441bd546bfd140\",\n" +
" \"xnxq_id\": \"2512a7f25f4e471284d4954b36bbf10c\",\n" +
" \"identity_no\": \"330102200801042755\",\n" +
" \"nj\": \"高二\",\n" +
" \"bnbh\": \"\",\n" +
" \"update_date\": \"2024-08-18 11:49:33\"\n" +
" }]}";
// doGet(jsstr,ThirtHttpRespResult.class);
ThirtHttpRespResult<ThridClassDto> clsass = (ThirtHttpRespResult<ThridClassDto>) doGet(jsstr,ThridClassDto.class);
System.out.println("-------"+ clsass);
}
public static ThirtHttpRespResult<?> doGet(String json, Class clazz) throws Exception {
ThirtHttpRespResult respResult = (ThirtHttpRespResult)JSONObject.parseObject(json, ThirtHttpRespResult.class);
if (respResult.getTotal() > 0) {
if (Constants.CLASS_THIRDGRADE.equals(clazz.getTypeName())) {
List<ThirdGradeDto> gradeList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThirdGradeDto ddt = (ThirdGradeDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
gradeList.add(ddt);
}
respResult.setResultList(gradeList);
return respResult;
}
if (Constants.CLASS_THIRDCLASS.equals(clazz.getTypeName())) {
List<ThridClassDto> classList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridClassDto ddt = (ThridClassDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
classList.add(ddt);
}
respResult.setResultList(classList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENTCLASS.equals(clazz.getTypeName())) {
List<ThridStudentClassDto> classstudentList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentClassDto ddt = (ThridStudentClassDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
classstudentList.add(ddt);
}
respResult.setResultList(classstudentList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENT.equals(clazz.getTypeName())) {
List<ThridStudentDto> tudentList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentDto ddt = (ThridStudentDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
tudentList.add(ddt);
}
respResult.setResultList(tudentList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENTFAMILY.equals(clazz.getTypeName())) {
List<ThridStudentFamilyDto> familyList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentFamilyDto ddt = (ThridStudentFamilyDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
familyList.add(ddt);
}
respResult.setResultList(familyList);
return respResult;
}
}
return respResult;
}
public static ThirtHttpRespResult<?> doGet(String url, String tokenVal, Class clazz) throws Exception {
logger.info("doGet.url= {} tokenVal = {}", url, tokenVal);
Request request = new Request.Builder().addHeader("token", tokenVal).url(url).build();
// 创建一个请求
Response response = getInstance().newCall(request).execute();
logger.info("doGet.url= {} response = {}", url, response);
int httpCode = response.code();
if (200 == httpCode) {
JSONObject bodyJson = JSON.parseObject(new String(response.body().bytes()));
logger.info("url= {} restdata = {}", url, JSONObject.toJSONString(bodyJson));
ThirtHttpRespResult respResult = (ThirtHttpRespResult)JSONObject.parseObject(JSON.toJSONString(bodyJson), ThirtHttpRespResult.class);
if (respResult.getTotal() > 0) {
if (Constants.CLASS_THIRDGRADE.equals(clazz.getTypeName())) {
List<ThirdGradeDto> gradeList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThirdGradeDto ddt = (ThirdGradeDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
gradeList.add(ddt);
}
respResult.setResultList(gradeList);
return respResult;
}
if (Constants.CLASS_THIRDCLASS.equals(clazz.getTypeName())) {
List<ThridClassDto> classList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridClassDto ddt = (ThridClassDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
classList.add(ddt);
}
respResult.setResultList(classList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENTCLASS.equals(clazz.getTypeName())) {
List<ThridStudentClassDto> classstudentList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentClassDto ddt = (ThridStudentClassDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
classstudentList.add(ddt);
}
respResult.setResultList(classstudentList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENT.equals(clazz.getTypeName())) {
List<ThridStudentDto> tudentList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentDto ddt = (ThridStudentDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
tudentList.add(ddt);
}
respResult.setResultList(tudentList);
return respResult;
}
if (Constants.CLASS_THIRDSTUDENTFAMILY.equals(clazz.getTypeName())) {
List<ThridStudentFamilyDto> familyList = new ArrayList<>();
for (Object obj : respResult.getResultList()) {
ThridStudentFamilyDto ddt = (ThridStudentFamilyDto) JSONObject.parseObject(JSON.toJSONString(obj), clazz);
familyList.add(ddt);
}
respResult.setResultList(familyList);
return respResult;
}
}
return respResult;
} else {
throw new Exception("exception in OkHttpUtil,response body is null httpCode = " + httpCode);
}
}
public static String doGet(String url,String tokenVal) throws Exception{
try {
long startTime = System.currentTimeMillis();
Request request = new Request.Builder().addHeader("token",tokenVal).url(url).build();
// 创建一个请求
Response response = getInstance().newCall(request).execute();
int httpCode = response.code();
String result= StringUtils.EMPTY;
if (200 == httpCode){
ResponseBody body = response.body();
result = body.string();
addResponseLog(httpCode, result, startTime);
} else {
throw new Exception("exception in OkHttpUtil,response body is null httpCode = "+httpCode);
}
return handleHttpResponse(httpCode, result);
} catch (Exception ex) {
throw new Exception("http请求异常");
}
}
public static InputStream doGet(String url) throws Exception{
long startTime = System.currentTimeMillis();
Request request = new Request.Builder().url(url).build();
// 创建一个请求
Response response = getInstance().newCall(request).execute();
int httpCode = response.code();
InputStream result= null;
if (200 == httpCode){
ResponseBody body = response.body();
result = body.byteStream();
} else {
throw new Exception("exception in OkHttpUtil,response body is null httpCode = "+httpCode);
}
return result;
}
public static InputStream doGetImg(String url,String tokenVal) throws Exception{
long startTime = System.currentTimeMillis();
Request request = new Request.Builder().addHeader("token",tokenVal).url(url).build();
// 创建一个请求
Response response = getInstance().newCall(request).execute();
int httpCode = response.code();
InputStream result= null;
if (200 == httpCode){
ResponseBody body = response.body();
result = body.byteStream();
} else {
throw new Exception("exception in OkHttpUtil,response body is null httpCode = "+httpCode);
}
return result;
}
public static String doPost(Request request) throws Exception{
try {
long startTime = System.currentTimeMillis();
// 创建一个请求
Response response = getInstance().newCall(request).execute();
int httpCode = response.code();
String result;
ResponseBody body = response.body();
if (body != null) {
result = body.string();
addResponseLog(httpCode, result, startTime);
} else {
throw new Exception("exception in OkHttpUtil,response body is null");
}
return handleHttpResponse(httpCode, result);
} catch (Exception ex) {
throw new Exception("http请求异常");
}
}
// public static void main(String[] args) throws Exception {
// String url = "https://10.81.119.225/evo-apigw/evo-oauth/1.0.0/oauth/extend/token";
// JSONObject param = JSONObject.parseObject("{\"grant_type\": \"client_credentials\",\"client_id\": \"system\",\"client_secret\": \"ea250018-94a4-4e70-8f7d-268c7e190e4c\"}");
// System.out.println();
//
// }
public static String doIccToken(String httpUrl, JSONObject param) throws Exception{
String iccToken = StringUtils.EMPTY;
RequestBody requestBody = RequestBody.create(MediaType.parse(DEFAULT_MEDIA_TYPE), param.toJSONString());
Request request = new Request.Builder()
.addHeader(DEFAULT_CONTENT_TYPE, DEFAULT_MEDIA_TYPE)
.addHeader("Accept", DEFAULT_MEDIA_TYPE)
.post(requestBody)
.url(httpUrl)
.build();
Response signRsp = null;
try {
signRsp = getInstance().newCall(request).execute();
if (signRsp.isSuccessful()) {
String body = signRsp.body().string();
System.out.println(body);
JSONObject respBody = JSONObject.parseObject(body);
//{"success":true,"data":{"access_token":"lGDN724Aq4h6IgQa6fAjqiOzaHx8o599","magicId":"EinlHMcgcrRVKRA245MjIrEyzBsB265A","scope":"supplier","token_type":"bearer","expires_in":7199},"code":"0","errMsg":""}
if (respBody.getBoolean("success")) {
String accessToken = respBody.getJSONObject("data").getString("access_token");
System.out.println(respBody.getJSONObject("data").getString("access_token"));
// bearer 1:ZUo3HpAQjSKr6OJ94tx6TAFyhK88X95k
if(StringUtils.isNotEmpty(accessToken)){
iccToken = Constants.TOKEN_PREFIX_SYSTEM+accessToken;
}
} else {
logger.error("Http连接OpenapiAPi地址：openapiLoginUrl 失败,MSG= {}", respBody.getString("msg"));
throw new Exception(JSONObject.toJSONString(respBody));
}
}
} catch (IOException e) {
logger.error("Http连接OpenapiAPi地址：openapiLoginUrl 失败", e);
throw new Exception(e);
}
return iccToken;
}
private static void addResponseLog(int httpCode, String result, long startTime) {
long endTime = System.currentTimeMillis();
}
private static String handleHttpResponse(int httpCode, String result) throws Exception {
if (httpCode == HttpStatus.OK.value()) {
return result;
}
throw new Exception("invalid_token");
}
private static ThirtHttpRespResult<?> handleHttpResponse(int httpCode, String result, Class clazz) throws Exception {
if (httpCode == HttpStatus.OK.value()) {
ThirtHttpRespResult respResult = JSONObject.parseObject(result,ThirtHttpRespResult.class);
List<T> resultList = respResult.getResultList();
List<T> resultList1 = new ArrayList<>();
if(respResult.getTotal()>0){
for(T obj:resultList){
T ddt = (T) JSONObject.parseObject(String.valueOf(obj), clazz);
resultList1.add(ddt);
}
}
respResult.setResultList(resultList1);
return respResult;
}
throw new Exception("invalid_token");
}
private static void handleHttpThrowable(Exception ex, String url) throws Exception {
if (ex instanceof Exception) {
throw (Exception) ex;
}
if (ex instanceof SocketTimeoutException) {
throw new RuntimeException("request time out of OkHttp when do url:" + url);
}
throw new RuntimeException(ex);
}
static class TrustAllCerts implements X509TrustManager {
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
}
static class TrustAllHostnameVerifier implements HostnameVerifier {
public boolean verify(String hostname, SSLSession session) {
return true;
}
}
private static SSLSocketFactory createSSLSocketFactory() {
SSLSocketFactory ssfFactory = null;
try {
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());
ssfFactory = sc.getSocketFactory();
} catch (Exception e) {
e.printStackTrace();
}
return ssfFactory;
}
}
1.1.3.2 代码演示，okhttp 图片下载
private byte[] getFileDataByUrl(String imageUrl) throws IOException {
// Long startTime = (new Date()).getTime();
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url(imageUrl)
.get()
.build();
try (
Response response = client.newCall(request).execute()) {
if (!response.isSuccessful()) {
// throw new IOException("Unexpected code: " + response);
logger.error("{} 【青岛违法过车数据】图片拉流失败 => {}", imageUrl,JSONObject.toJSONString(response));
return null;
}
// 读取响应体 3M
byte[] buffer = new byte[3145728];
int bytesRead;
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
while ((bytesRead = response.body().byteStream().read(buffer)) != -1) {
outStream.write(buffer, 0, bytesRead);
}
byte[] data = outStream.toByteArray();
return data;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
1.1.3.3 代码演示，httputils
package org.dromara.integration.utils;
import okhttp3.*;
import okhttp3.logging.HttpLoggingInterceptor;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.security.SecureRandom;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* OkHttp 工具类，兼容 SSL 配置
*/
public class OkHttpUtils {
private static OkHttpClient client;
/**
* 连接超时时间（秒）
*/
private static final int CONNECT_TIMEOUT = 10;
/**
* 读取超时时间（秒）
*/
private static final int READ_TIMEOUT = 30;
/**
* 写入超时时间（秒）
*/
private static final int WRITE_TIMEOUT = 30;
static {
initClient();
}
/**
* 初始化 OkHttpClient，配置 SSL 兼容
*/
private static void initClient() {
// 日志拦截器
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient.Builder builder = new OkHttpClient.Builder()
.connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
.readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
.writeTimeout(WRITE_TIMEOUT, TimeUnit.SECONDS)
.addInterceptor(loggingInterceptor);
// 配置 SSL 兼容，信任所有证书（适用于自签名证书场景，如果需要严格校验请修改）
trustAllCertificates(builder);
client = builder.build();
}
/**
* 信任所有证书，解决 SSL 证书校验问题
*/
private static void trustAllCertificates(OkHttpClient.Builder builder) {
try {
// 创建不验证证书的 X509TrustManager
X509TrustManager trustManager = new X509TrustManager() {
@Override
public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {
}
@Override
public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {
}
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return new java.security.cert.X509Certificate[]{};
}
};
// 创建不验证主机名的 HostnameVerifier
HostnameVerifier hostnameVerifier = (hostname, session) -> true;
// 创建 SSLContext
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, new X509TrustManager[]{trustManager}, new SecureRandom());
// 配置 SSL
builder.sslSocketFactory(sslContext.getSocketFactory(), trustManager);
builder.hostnameVerifier(hostnameVerifier);
} catch (Exception e) {
throw new RuntimeException("SSL 初始化失败", e);
}
}
/**
* GET 请求
*/
public static String get(String url) throws IOException {
return get(url, null);
}
/**
* GET 请求带请求头
*/
public static String get(String url, Map<String, String> headers) throws IOException {
Request.Builder requestBuilder = new Request.Builder().url(url);
if (headers != null && !headers.isEmpty()) {
headers.forEach(requestBuilder::addHeader);
}
Request request = requestBuilder.build();
try (Response response = client.newCall(request).execute()) {
return response.isSuccessful() && response.body() != null ? response.body().string() : null;
}
}
/**
* POST 请求 JSON
*/
public static String postJson(String url, String json) throws IOException {
return postJson(url, json, null);
}
/**
* POST 请求 JSON 带请求头
*/
public static String postJson(String url, String json, Map<String, String> headers) throws IOException {
MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
RequestBody body = RequestBody.create(json, mediaType);
Request.Builder requestBuilder = new Request.Builder()
.url(url)
.post(body);
if (headers != null && !headers.isEmpty()) {
headers.forEach(requestBuilder::addHeader);
}
Request request = requestBuilder.build();
try (Response response = client.newCall(request).execute()) {
return response.isSuccessful() && response.body() != null ? response.body().string() : null;
}
}
/**
* POST 请求表单
*/
public static String postForm(String url, Map<String, String> params) throws IOException {
return postForm(url, params, null);
}
/**
* POST 请求表单带请求头
*/
public static String postForm(String url, Map<String, String> params, Map<String, String> headers) throws IOException {
FormBody.Builder formBuilder = new FormBody.Builder();
if (params != null && !params.isEmpty()) {
params.forEach(formBuilder::add);
}
Request.Builder requestBuilder = new Request.Builder()
.url(url)
.post(formBuilder.build());
if (headers != null && !headers.isEmpty()) {
headers.forEach(requestBuilder::addHeader);
}
Request request = requestBuilder.build();
try (Response response = client.newCall(request).execute()) {
return response.isSuccessful() && response.body() != null ? response.body().string() : null;
}
}
/**
* 获取原生 OkHttpClient 实例，支持自定义扩展
*/
public static OkHttpClient getClient() {
return client;
}
public static void main(String[] args) throws IOException {
String url = "https://gnapi.zyhh.store/device/deviceLock/list?pageNum=1&pageSize=10";
Map<String, String> headers = new HashMap<>();
headers.put("Authorization", "Bearer " + "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJ2TzJaOWlLeFl3Rkg0dVNUdmExaEQ2MTVKY0NMVFQyNiIsImNsaWVudGlkIjoiZTVjZDdlNDg5MWJmOTVkMWQxOTIwNmNlMjRhN2IzMmUiLCJ0ZW5hbnRJZCI6IjAwMDAwMCIsInVzZXJJZCI6MSwidXNlck5hbWUiOiJhZG1pbiIsImRlcHRJZCI6MTAzLCJkZXB0TmFtZSI6IueglOWPkemDqOmXqCIsImRlcHRDYXRlZ29yeSI6IiJ9.qCwHDRHNwRslJT8PlnkI7i9lcQl6GG_peKSMpsTU2e4");
headers.put("Clientid", "e5cd7e4891bf95d1d19206ce24a7b32e");
String resp = OkHttpUtils.get(url, headers);
System.out.println(resp);
}
}
1.2 idea 中需要将jvm 参数设置
-Djava.net.useSystemProxies=true
-Dhttp.proxyHost=10.81.159.61
-Dhttp.proxyPort=9090
-Dhttps.proxyHost=10.81.159.61
-Dhttps.proxyPort=9090
1.3 spring--- RestTemplate
//网络代理：
@Autowired
private RestTemplate restTemplate;
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory ();
factory.setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("10.30.6.49", 9090)));
restTemplate.setRequestFactory(factory);
//ssl 禁用
SSLUtil.disableSSLVerification();
import javax.net.ssl.*;
import java.security.cert.X509Certificate;
public class SSLUtil {
/**
* 禁用SSL验证
* <p>
* 它通过设置默认的TrustManager和HostnameVerifier来实现这一点。
* </p>
*/
public static void disableSSLVerification() {
try {
TrustManager[] trustAllCerts = new TrustManager[]{
new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
}
};
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HostnameVerifier allHostsValid = (hostname, session) -> true;
HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
} catch (Exception e) {
e.printStackTrace();
}
}
}
1.3.1 restTemplateUtil
import com.alibaba.fastjson.JSONObject;
import com.dahua.evo.edu.tpcs.service.thirdsync.acquire.ThirdTokenService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
import java.util.Map;
@Component
@Slf4j(topic = "custom-logger")
public class ThirdRequestUtil {
@Autowired
protected ThirdTokenService thirdTokenService;
@Autowired
private RestTemplate restTemplate;
/**
* 发送POST请求并处理响应
*
* @param url 请求的URL
* @param jsonObject 请求体中的JSON对象
* @return 响应结果字符串
*/
public String postUrl(String url, JSONObject jsonObject) {
String token = thirdTokenService.getToken();
log.info("参数：{}", jsonObject);
JSONObject body = getBody(url, jsonObject, token);
if (body == null) {
return null;
}
//如果是登录过期
if (100 == body.getIntValue("code")){
token = thirdTokenService.getToken();
body = getBody(url, jsonObject, token);
}
if (body == null) {
return null;
}
JSONObject result = body.getJSONObject("result");
if (body.getIntValue("status") == 0 || result == null) {
return null;
}
return result.getString("list");
}
/**
* 发送POST请求并处理响应
*
* @param url 请求的URL
* @param jsonObject 请求体中的JSON对象
* @return 响应结果字符串
*/
public String postLessonUrl(String url, JSONObject jsonObject) {
String token = thirdTokenService.getLessonToken();
log.info("参数：{}", jsonObject);
JSONObject body = getBody(url, jsonObject, token);
if (body == null) {
return null;
}
//如果是登录过期
if (100 == body.getIntValue("code")){
token = thirdTokenService.getLessonToken();
body = getBody(url, jsonObject, token);
}
if (body == null) {
return null;
}
JSONObject result = body.getJSONObject("result");
if (body.getIntValue("status") == 0 || result == null) {
return null;
}
return result.getString("list");
}
public String getLessonUrl(String url, Map<String,Object> param) {
String token = thirdTokenService.getLessonToken();
if(StringUtils.isEmpty(token)){
for (int i = 0; i < 3; i++) {
token = thirdTokenService.getLessonToken();
if(StringUtils.isNotEmpty(token)){
break;
}
}
}
log.info("参数：{}", url);
JSONObject body = httpGetBody(url, token, param);
if (body == null) {
return null;
}
//如果是登录过期
if (100 == body.getIntValue("code")){
token = thirdTokenService.getLessonToken();
body = httpGetBody(url, token, param);
}
if (body == null) {
return null;
}
JSONObject result = body.getJSONObject("result");
if (body.getIntValue("status") == 0 || result == null) {
return null;
}
return result.getString("list");
}
/**
* 发送POST请求并获取响应体
*
* @param url 请求的URL
* @param jsonObject 请求体中的JSON对象
* @param token 认证令牌
* @return 响应体中的JSON对象，如果请求失败或响应为空，则返回null
*/
public JSONObject getBody(String url, JSONObject jsonObject, String token) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.set(HttpHeaders.AUTHORIZATION, token);
HttpEntity<JSONObject> httpEntity = new HttpEntity<>(jsonObject, headers);
SSLUtil.disableSSLVerification();
// SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory ();
// factory.setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("10.81.159.61", 9090)));
ResponseEntity<String> response = null;
try {
response = restTemplate.postForEntity(url, httpEntity, String.class);
} catch (RestClientException e) {
log.error("httpError.url:{}",url);
log.error("httpError.headers:{}",JSONObject.toJSONString(headers));
log.error("httpError.param:{}",JSONObject.toJSONString(httpEntity));
log.error("httpError.response:{}",JSONObject.toJSONString(response));
log.error("httpError.error:"+e);
throw new RuntimeException(e);
}
if (!HttpStatus.OK.equals(response.getStatusCode())) {
log.error("response is empty!");
return null;
}
return JSONObject.parseObject(response.getBody());
}
/**
* 发送POST请求并获取响应体
*
* @param url 请求的URL
// * @param jsonObject 请求体中的JSON对象
* @param token 认证令牌
* @return 响应体中的JSON对象，如果请求失败或响应为空，则返回null
*/
public JSONObject httpGetBody(String url, String token, Map<String,Object> param) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.set(HttpHeaders.AUTHORIZATION, token);
HttpEntity<String> httpentity = new HttpEntity<>(headers);
// SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory ();
// factory.setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("10.81.159.61", 9090)));
// restTemplate.setRequestFactory(factory);
SSLUtil.disableSSLVerification();
ResponseEntity<String> response = null;
try {
response = restTemplate.exchange(
url,
HttpMethod.GET,
httpentity,
String.class,
param);
} catch (RestClientException e) {
log.error("httpGetError.url:{}",url);
log.error("httpGetError.headers:{}",JSONObject.toJSONString(headers));
log.error("httpGetError.param:{}",JSONObject.toJSONString(param));
log.error("httpGetError.response:{}",JSONObject.toJSONString(response));
log.error("httpGetError.error:"+e);
throw new RuntimeException(e);
}
if (!HttpStatus.OK.equals(response.getStatusCode())) {
log.error("response is empty!");
return null;
}
return JSONObject.parseObject(response.getBody());
}
}
1.4 spring--- RestTemplate封装
@Component
@Slf4j
public class HttpClientUtils {
private static final String HTTP = "http";
private static final String HTTPS = "https";
private static SSLConnectionSocketFactory sslsf = null;
private static PoolingHttpClientConnectionManager cm = null;
private static SSLContextBuilder builder = null;
public static Map<String, String> commonHeader = new HashMap();
static {
commonHeader.put("Accept", "application/*;charset=utf-8");
commonHeader.put("Accept-Charset", "UTF-8");
try {
builder = new SSLContextBuilder();
// 全部信任 不做身份鉴定
builder.loadTrustMaterial(null, new TrustStrategy() {
@Override
public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
return true;
}
});
sslsf = new SSLConnectionSocketFactory(builder.build(),
new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
.register(HTTP, new PlainConnectionSocketFactory()).register(HTTPS, sslsf).build();
cm = new PoolingHttpClientConnectionManager(registry);
cm.setMaxTotal(200);// max connection
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* httpClient post请求
*
* @param url 请求url
* @param header 头部信息
* @param param 请求参数 form提交适用
* @param entity 请求实体 json/xml提交适用
* @return 可能为空 需要处理
* @throws Exception
*/
public static String doXmlPost(String url, Map<String, String> header, Map<String, Object> param, StringEntity entity)
throws Exception {
String result = "";
CloseableHttpClient httpClient = null;
try {
httpClient = getHttpClient();
//HttpGet httpPost = new HttpGet(url);//get请求
HttpPost httpPost = new HttpPost(url);//Post请求
// 设置头信息
if (MapUtils.isNotEmpty(header)) {
for (Map.Entry<String, String> entry : header.entrySet()) {
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
// 设置请求参数
if (MapUtils.isNotEmpty(param)) {
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
for (Map.Entry<String, Object> entry : param.entrySet()) {
// 给参数赋值
formparams.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
httpPost.setEntity(urlEncodedFormEntity);
}
// 设置实体 优先级高
if (entity != null) {
httpPost.addHeader("Content-Type", "text/xml");
httpPost.setEntity(entity);
}
HttpResponse httpResponse = httpClient.execute(httpPost);
int statusCode = httpResponse.getStatusLine().getStatusCode();
System.out.println("状态码：" + statusCode);
if (statusCode == HttpStatus.SC_OK) {
HttpEntity resEntity = httpResponse.getEntity();
result = EntityUtils.toString(resEntity);
} else {
readHttpResponse(httpResponse);
}
} catch (Exception e) {
throw e;
} finally {
if (httpClient != null) {
httpClient.close();
}
}
return result;
}
public static CloseableHttpClient getHttpClient() {
CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).setConnectionManager(cm)
.setConnectionManagerShared(true).build();
return httpClient;
}
public static CloseableHttpClient getCredsHttpClient(String userName, String password) {
CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
UsernamePasswordCredentials creds = new UsernamePasswordCredentials(userName, password);
credentialsProvider.setCredentials(AuthScope.ANY, creds);
CloseableHttpClient httpClient = HttpClients.custom().setDefaultCredentialsProvider(credentialsProvider)
.setSSLSocketFactory(sslsf).setConnectionManager(cm)
.setConnectionManagerShared(true).build();
return httpClient;
}
public static String readHttpResponse(HttpResponse httpResponse) throws ParseException, IOException {
StringBuilder builder = new StringBuilder();
// 获取响应消息实体
HttpEntity entity = httpResponse.getEntity();
// 响应状态
builder.append("status:" + httpResponse.getStatusLine());
builder.append("headers:");
HeaderIterator iterator = httpResponse.headerIterator();
while (iterator.hasNext()) {
builder.append("\t" + iterator.next());
}
// 判断响应实体是否为空
if (entity != null) {
String responseString = EntityUtils.toString(entity);
builder.append("response length:" + responseString.length());
builder.append("response content:" + responseString.replace("\r\n", ""));
}
return builder.toString();
}
public static String doPost(String url, String body, Map<String, String> header) {
HttpPost httpPost = new HttpPost(url);
String result = "";
CloseableHttpResponse response = null;
try {
if (null != header && header.size() > 0) {
header.putAll(commonHeader);
Iterator var7 = header.entrySet().iterator();
while(var7.hasNext()) {
Map.Entry map = (Map.Entry)var7.next();
httpPost.setHeader(map.getKey().toString(), map.getValue().toString());
}
}
if (null != body) {
StringEntity paramEntity = new StringEntity(body, "UTF-8");
paramEntity.setContentType("application/json");
httpPost.setEntity(paramEntity);
}
response = getHttpClient().execute(httpPost);
if (null != response) {
result = EntityUtils.toString(response.getEntity());
}
} catch (IOException var17) {
log.error("http-POST请求异常,地址:{},异常信息:{}", url, var17.getMessage());
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException var16) {
log.error("连接释放异常,异常信息:{}", var16.getMessage());
}
}
return result;
}
public String doGet(String url, Map<String, String> header) {
String result = "";
HttpGet httpGet = new HttpGet(url);
if (null != header && header.size() > 0) {
header.putAll(commonHeader);
Iterator var6 = header.entrySet().iterator();
while(var6.hasNext()) {
Map.Entry map = (Map.Entry)var6.next();
httpGet.setHeader(map.getKey().toString(), map.getValue().toString());
}
}
CloseableHttpResponse response = null;
try {
response = getHttpClient().execute(httpGet);
if (null != response) {
result = EntityUtils.toString(response.getEntity());
}
} catch (IOException var17) {
log.error("http-GET请求异常,地址:{},异常信息:{}", url, var17.getMessage());
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException var16) {
log.error("连接释放异常,异常信息:{}", var16.getMessage());
}
}
return result;
}
public static void main(String[] args) {
String url = "http://10.35.144.155:9200/cuOption";
try {
StringEntity entity = new StringEntity("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" +
"<QueryAlarmIPCStatus>\n" +
"<DevId>1000000</DevId>\n" +
"<nChannelNum>11</nChannelNum>\n" +
"</QueryAlarmIPCStatus>", "UTF-8"); //<span style="color:rgb(85,85,85);font-family:'宋体', 'Arial Narrow', arial, serif;font-size:14px;">不指定参数名的方式来POST数据</span>
Map<String, String> header = new HashMap<>();
header.put("CFL_Asynch", "operation=cuOption&session=0&sequence=170&unit=OP_CLIENT&id=100002");
String responseContent = doXmlPost(url, header, null, entity);
System.out.println(responseContent);
} catch (Exception e) {
e.printStackTrace();
}
}
}
2. IPutil
public class IPUtil {
public IPUtil() {
}
public static HostPortDto getHostAndPort(String url) {
if (StringUtils.isBlank(url)) {
return null;
} else {
String hostAndPortStr = ReUtil.get("(?<=//|)((\\w)+\\.)+\\w+(:\\d{0,5})?", url, 0);
if (!hostAndPortStr.contains(":")) {
return url.startsWith("https") ? new HostPortDto(hostAndPortStr, 443) : new HostPortDto(hostAndPortStr, 80);
} else {
String[] hostAndPortArr = hostAndPortStr.split(":");
return new HostPortDto(hostAndPortArr[0], Integer.parseInt(hostAndPortArr[1]));
}
}
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class HostPortDto{
private String ip;
private int port;
}
/**
* 测试IP/端口是否通
* @param hostPortDto
* @return
*/
public static boolean testNetWork(HostPortDto hostPortDto) {
boolean networkAble = false;
String ipAddress = hostPortDto.getIp(); int port =hostPortDto.getPort();
try (Socket socket = new Socket(hostPortDto.getIp(), hostPortDto.getPort())) {
System.out.println("Port " + port + " on " + ipAddress + " is open.");
networkAble = true;
} catch (IOException e) {
log.error("testNetWork",e);
System.out.println("Port " + port + " on " + ipAddress + " is not open.");
}
return networkAble;
}
}
扫一扫
4760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
