Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
cn.net.wanmo.common.send.SendUtil Maven / Gradle / Ivy
package cn.net.wanmo.common.send;
import cn.net.wanmo.common.http.apache.HttpApacheResult;
import cn.net.wanmo.common.http.apache.HttpApacheUtil;
import cn.net.wanmo.common.http.jdk.HttpJdkUtil;
import cn.net.wanmo.common.http.jdk.pojo.ResData;
import cn.net.wanmo.common.result.HttpResult;
import cn.net.wanmo.common.util.DateUtil;
import cn.net.wanmo.common.util.ObjectUtil;
import com.google.common.collect.Maps;
import org.apache.http.HttpStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@Deprecated
public class SendUtil {
private static final Logger logger = LoggerFactory.getLogger(SendUtil.class);
/**
* 发送 get 请求，请求体的 toString() 应该是 name1=value1&name2=value2 的形式
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj get(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.GET, title, url, req, res, header);
}
/**
* 发送 get 请求，请求体的 toString() 应该是 name1=value1&name2=value2 的形式
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj getFile(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.GET_FILE, title, url, req, res, header);
}
/**
* 发送 post 请求，请求体的 toString() 应该是 json 字符串。例如： {name1:value1,name2:value2}
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj post(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.POST, title, url, req, res, header);
}
/**
* 发送 post 请求，请求体的 toString() 应该是 form 字符串。例如： name1=value1&name2=value2
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj postForm(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.POST_FORM, title, url, req, res, header);
}
/**
* 发送 post 请求，请求体的 toString() 应该是 json 字符串。例如： {name1:value1,name2:value2}
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj postFile(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.POST_FILE, title, url, req, res, header);
}
/**
* 发送 upload 请求，请求体的 toString() 应该是 json 字符串。例如： {name1:value1,name2:value2}
*
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj upload(
String title, String url, ReqObj req, ResObj res, Map header) {
return exec(SendWay.UPLOAD, title, url, req, res, header);
}
/**
* 发送 http 请求
*
* @param sendWay 请求方式
* @param title 接口名称
* @param url 请求地址
* @param req 请求对象
* @param res 响应对象
* @param header 通用的请求属性
* @param 请求对象类型
* @param 响应对象类型
* @return 响应数据
*/
public static ResObj exec(
SendWay sendWay, String title, String url, ReqObj req, ResObj res, Map header) {
if (header == null || header.isEmpty()) {
header = Maps.newHashMap();
}
res.setTitle(title);
try {
MyHttpRes myHttpRes = getMyRes01(sendWay, title, url, req, header);
{
res.setErrCode(ObjectUtil.cast(myHttpRes.code));
res.setErrMsg(myHttpRes.msg);
res.setHeaders(myHttpRes.headers);
res.setSuccessHttp(myHttpRes.ok);
}
if (myHttpRes.ok) { // 请求 HTTP 成功
logger.debug(title + "接口响应头：{}", myHttpRes.headers);
logger.debug(title + "接口响应体：{}", myHttpRes.body);
res.setBody(myHttpRes.body); // 设置响应体的同时， 会将响应的 错误码和错误内容 解析到 res 中, 并根据默认的成功码 判断是否执行成功
if (res.isSuccessData()) { // 接口响应成功数据
logger.debug(title + "接口成功：{}", res.toJSONString());
} else { // 接口响应失败数据
logger.warn(title + "接口失败：{}", res.toJSONString());
}
} else { // 请求 HTTP 失败
logger.warn(title + "请求 HTTP 失败：{} {}", myHttpRes.code, myHttpRes.msg);
}
} catch (Exception e) { // 执行异常
res.setErrCode(ObjectUtil.cast(500));
res.setErrMsg("请求 HTTP 异常");
logger.error(title + res.getErrMsg(), e);
}
{
res.setResTime(DateUtil.nowLong()); // 设置响应时间
res.setConsumeTime(res.getResTime() - req.getReqTime()); // 计算耗时
}
return res;
}
private static MyHttpRes getMyRes01(
SendWay sendWay, String title, String url, ReqObj req, Map header) {
MyHttpRes myRes = new MyHttpRes();
HttpResult httpResult = null;
{ // 执行 HTTP 请求
logger.debug(title + "接口URL：{}", url);
switch (sendWay) {
case GET:
{
httpResult = HttpJdkUtil.get(url).header(header).send();
break;
}
case GET_FILE:
{
httpResult = HttpJdkUtil.get(url).header(header).send(true);
break;
}
case POST:
{
logger.debug(title + "接口请求体：{}", req.getBody());
httpResult = HttpJdkUtil.post(url).header(header).body(req.getBody()).send();
break;
}
case POST_FORM:
{
logger.debug(title + "接口请求体：{}", HttpJdkUtil.toParamStr(req.getParams()));
HttpJdkUtil jdkUtil = HttpJdkUtil.post(url).header(header);
Map reqParams = req.getParams();
if (reqParams != null && !reqParams.isEmpty()) {
for (Map.Entry entry : reqParams.entrySet()) {
jdkUtil.form(entry.getKey(), entry.getValue());
}
}
jdkUtil.send();
break;
}
case POST_FILE:
{
logger.debug(title + "接口请求体：{}", req.getBody());
httpResult = HttpJdkUtil.post(url).header(header).body(req.getBody()).send(true);
break;
}
case UPLOAD:
{
HttpJdkUtil httpJdkUtil = HttpJdkUtil.post(url).header(header);
BaseReq.ReqFile reqFile = req.getFile();
if (Objects.nonNull(reqFile)) {
httpJdkUtil.form(reqFile.getName(), reqFile.getFile(), reqFile.getFilename());
}
httpResult = httpJdkUtil.send();
break;
}
default:
{
httpResult = new HttpResult<>();
httpResult.error("该 HTTP 请求方式不支持");
}
}
}
myRes.code = httpResult.getCode();
myRes.msg = httpResult.getMsg();
myRes.ok = httpResult.isSuccess();
if (httpResult.isSuccess()) {
ResData data = httpResult.getData();
myRes.body = data.getBody();
myRes.headers = data.getHeaders();
}
return myRes;
}
private static MyHttpRes getMyRes02(
SendWay sendWay, String title, String url, ReqObj req, Map header) {
MyHttpRes myRes = new MyHttpRes();
HttpApacheResult result = null;
{ // 执行 HTTP 请求
logger.debug(title + "接口URL：{}", url);
switch (sendWay) {
case GET:
{
result = HttpApacheUtil.get(url).header(header).execute();
break;
}
case GET_FILE:
{
result = HttpApacheUtil.get(url).header(header).execute(true);
break;
}
case POST:
{
logger.debug(title + "接口请求体：{}", req.getBody());
result = HttpApacheUtil.post(url).header(header).body(req.getBody()).execute();
break;
}
case POST_FORM:
{
logger.debug(title + "接口请求体：{}", HttpJdkUtil.toParamStr(req.getParams()));
HttpApacheUtil apacheUtil = HttpApacheUtil.post(url).header(header);
Map reqParams = req.getParams();
if (reqParams != null && !reqParams.isEmpty()) {
for (Map.Entry entry : reqParams.entrySet()) {
apacheUtil.form(entry.getKey(), entry.getValue());
}
}
result = apacheUtil.execute();
break;
}
case POST_FILE:
{
logger.debug(title + "接口请求体：{}", req.getBody());
result = HttpApacheUtil.post(url).header(header).body(req.getBody()).execute(true);
break;
}
case UPLOAD:
{
HttpApacheUtil apacheUtil = HttpApacheUtil.post(url).header(header);
BaseReq.ReqFile reqFile = req.getFile();
if (Objects.nonNull(reqFile)) {
apacheUtil.form(reqFile.getName(), reqFile.getFile(), reqFile.getFilename());
}
result = apacheUtil.execute();
break;
}
default:
{
result = new HttpApacheResult();
result.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);
result.setMessage("该 HTTP 请求方式不支持");
}
}
}
myRes.code = result.getStatusCode();
myRes.msg = result.getMessage();
myRes.ok = result.isOk();
if (result.isOk()) {
myRes.body = result.body();
myRes.headers = result.headers();
}
return myRes;
}
static class MyHttpRes {
private Integer code;
private String msg;
private boolean ok;
private String body;
private Map> headers;
}
}
