第三方接口调用记录

1.调用第三方接口代码片段

   MessageExecute.Request.Builder builder = MessageExecute.Request.builder().method("POST")
                .url(apiDomain + "/findUserBykeyword")
                .addHeader("content-type", "application/json;charset=utf-8");
                builder.addParameter("name",name);
                builder.addParameter("idCard",idCard);
// 如果涉及到日期转换 可以使用这个
GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.registerTypeAdapter(Date.class, new JsonDeserializer<Date>() {
            @Override
            public Date deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
                return new Date(jsonElement.getAsJsonPrimitive().getAsLong());
            }
        });
        Gson gson = gsonBuilder.create();
// 获取返回的值
String response = MessageExecute.execute(builder.build());
// 对返回的值进行指定格式类型的json转换
Response<List<UserByKeyWordResponseInfo>> dataResponse = gson.fromJson(response, new TypeToken<Response<List<UserByKeyWordResponseInfo>>>() {}.getType());

2.代码片段对应的MessageExecute类

package com.huatek.frame.core.context;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.google.gson.JsonObject;
import com.huatek.frame.core.exception.BusinessRuntimeException;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import springfox.documentation.spring.web.json.Json;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Slf4j
public class MessageExecute {

    private static OkHttpClient.Builder clientBuilder ;


    private static ObjectMapper objectMapper;


    public static final String CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";

    public static final String CONTENT_TYPE_JSON = "application/json;charset=utf-8";

    static {
        log.info("初始化http客户端");
        clientBuilder = new OkHttpClient.Builder().callTimeout(180, TimeUnit.SECONDS);
        objectMapper = new ObjectMapper();
        objectMapper
                .setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE)
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false)
                .configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT,true)
                .registerModule(new JavaTimeModule());
    }

    /**
     * 回调信息签名验证 并解析result
     * @param notifyDto
     * @return
     */
    public static <T> T doCheckConvertResult(String notifyDto,Class<T> clazz) {
       return null;
    }

    /**
     *  请求信息 包含请求地址请求方式
     * @author  augus_xu
     * @date    2021-04-03
     */
    @Setter
    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Request<T extends Serializable> implements Serializable {

        private static final long serialVersionUID = 1L;

        // 请求方式
        private String url;
        // 请求类型
        private String method;

        // 请求URL参数
        private Map<String,String> parameters;
        // 请求头信息
        private Map<String,String> headers;

        private T body;
        // 文本类型
        private String contentType = CONTENT_TYPE_FORM;

        public Request addParameter(String key, String value){
            if (parameters==null) parameters = new TreeMap<>();
            parameters.put(key,value);
            return this;
        }
        public Request addHeader(String key, String value){
            if (headers==null) headers = new LinkedHashMap<>();
            headers.put(key,value);
            return this;
        }

        public Request formatUrl(String ... values){
            url = String.format(url,values);
            return this;
        }


        public static Builder builder() {
            return new Builder();
        }

        public static class Builder<T extends Serializable> {
            private String url;
            private String method;
            private Map<String, String> parameters;
            private Map<String, String> headers;

            private T body;

            // 文本类型
            private String contentType = "application/x-www-form-urlencoded";

            Builder() {
            }

            public Builder url(String url) {
                this.url = url;
                return this;
            }

            public Builder method(String method) {
                this.method = method;
                return this;
            }

            public Builder addParameter(String key, String value){
                if (this.parameters==null) this.parameters = new TreeMap<>();
                this.parameters.put(key,value);
                return this;
            }
            public Builder addHeader(String key, String value){
                if (this.headers==null) this.headers = new LinkedHashMap<>();
                this.headers.put(key,value);
                return this;
            }

            public Builder parameters(Map<String, String> parameters) {
                this.parameters = parameters;
                return this;
            }

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

            public Builder body(T body) {
                this.body = body;
                return this;
            }

            public Builder contentType(String contentType) {
                this.contentType = contentType;
                return this;
            }


            public Builder formatUrl(String ... values){
                this.url = String.format(this.url,values);
                return this;
            }

            public Request build() {
                return new Request(this.url, this.method, this.parameters, this.headers,this.body,this.contentType);
            }
        }
    }


    /**
     * 执行请求
     * @param request
     * @return
     */
    public static String execute(Request request){
        return execute(request,String.class);
    }


    /**
     * 执行请求
     * @param request
     * @return
     */
    @SneakyThrows
    public static <T> T execute(Request request,Class<T> clazz){
        okhttp3.Request.Builder httpRequest = getHttpRequest(request);
        OkHttpClient httpClient = clientBuilder.build();
        Response response = httpClient.newCall(httpRequest.build()).execute();
        ResponseBody body = response.body();
        String responseBody = body.string();
//        System.out.println(JSONObject.toJSONString(request.parameters));
        log.info("\n请求地址 {} \n请求方式 {} \n请求头 {} \n请求参数 {}  \n请求体 {} \n返回结果 {}",request.url,request.method,
                JSONObject.toJSONString(request.headers), JSONObject.toJSONString(request.parameters),
                JSONObject.toJSONString(request.body),responseBody);
        if (response.isSuccessful()){
            if (body!=null){
                T responseMessage = null;
                if (StringUtils.isNotBlank(responseBody)) {
                    if(clazz.getSimpleName().equals("String")){
                        return (T) responseBody;
                    }
                    responseMessage =  objectMapper.readValue(responseBody.getBytes(StandardCharsets.UTF_8),clazz);
                }
                return responseMessage;
            }
        }
        throw new BusinessRuntimeException(responseBody);
    }

    /**
     * 获取Http Request
     * @return
     */
    @SneakyThrows
    public static okhttp3.Request.Builder getHttpRequest(Request request) {
        okhttp3.Request.Builder requestBase = null;
        MediaType mediaType =  MediaType.get(request.contentType) ;
        if (request.getMethod().equals("GET")){
            requestBase =  new okhttp3.Request.Builder();
            StringBuilder url = new StringBuilder(request.url);
            if (request.getParameters()!=null && !request.getParameters().isEmpty()){
                url.append("?");
                request.getParameters().forEach((key,value)->{
                    url.append(key).append("=").append(value).append("&");
                });
                request.setUrl(url.subSequence(0,url.length()-1).toString());
            }
            requestBase.get().url(request.getUrl());
        }if (request.getMethod().equals("POST")){
            /*requestBase =  new okhttp3.Request.Builder();
            FormBody.Builder formBuilder = new FormBody.Builder();
            if (request.getParameters()!=null && !request.getParameters().isEmpty()){
                request.getParameters().forEach((key,value)->formBuilder.add((String) key,(String) value));
            }
            requestBase.post(formBuilder.build()).url(request.getUrl());*/
            requestBase =  new okhttp3.Request.Builder();
            if (request.getContentType().equals("application/x-www-form-urlencoded")){
                FormBody.Builder formBuilder = new FormBody.Builder();
                if (request.getParameters()!=null && !request.getParameters().isEmpty()){
                    request.getParameters().forEach((key,value)->formBuilder.add((String) key,(String) value));
                }
                requestBase.post(formBuilder.build()).url(request.getUrl());
            }else{
                String bodyStr = null;
                if(request.getBody() instanceof String){
                    bodyStr = (String) request.getBody();
                }else{
                    bodyStr = JSONObject.toJSONString(request.getBody()); //objectMapper.writeValueAsString(request.getBody());
                }
                RequestBody requestBody = RequestBody.create(mediaType,bodyStr);
                requestBase.post(requestBody).url(request.getUrl());
            }
        }
        if (requestBase!=null){
//            requestBase.addHeader("Accept", "application/json");
            requestBase.addHeader("Content-type",request.getContentType());
            // 添加请求头
            Map<String,String> headers = request.getHeaders();
            if (headers!=null){
                for (String key : headers.keySet()) {
                    requestBase.addHeader(key,headers.get(key));
                }
            }
            return requestBase;
        }
        throw new BusinessRuntimeException("仅支持GET/POST");
    }

    /**
     * 上传图像信息
     * @param image
     * @return
     */
    public static  Map<String,String> uploadImage(File image){
        try {
            return null;
        }catch (Exception e){
            throw new BusinessRuntimeException("上传图像资源失败:"+e.getMessage());
        }finally {
            image.delete();
        }
    }

    /**
     * 从request获取请求参数
     * @param request
     * @param clazz
     * @return
     */
    @SneakyThrows
    public static <T> T readValueFromRequest(final HttpServletRequest request,Class<T> clazz) {
        Map<String, String[]> parameterMap = request.getParameterMap();
//        Enumeration<String> headerNames = request.getHeaderNames();
        String body;
        if (parameterMap!=null && parameterMap.size() > 0){
            /*String element = headerNames.nextElement();
            Map<String,Object> dataMap = new HashMap<>();
            while (element!=null){
                dataMap.put(element,request.getParameter(element));
            }*/
            Map<String,Object> dataMap = new HashMap<>();
            parameterMap.forEach((k,v)->{
                dataMap.put(k,v[0]);
            });
            body = objectMapper.writeValueAsString(dataMap);
        }else{
            body = getBodyData(request);
        }
        return Objects.isNull(body) ? null : objectMapper.readValue(body,clazz);
    }

    /**
     * 将字符串转为对象
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    @SneakyThrows
    public static <T> T convertStr2Object(final String str,Class<T> clazz) {
        return Objects.isNull(str) ? null : objectMapper.readValue(str,clazz);
    }
    /**
     *  获取http body 数据
     * @param request
     * @return
     */
    private static String getBodyData(final HttpServletRequest request) {
        StringBuffer data = new StringBuffer();
        String line = null;
        BufferedReader reader = null;
        try {
            reader = request.getReader();
            while (null != (line = reader.readLine()))
                data.append(line);
        } catch (IOException e) {
            log.error("转换出现异常");
        }
        return data.toString();
    }


}