【接口】Java传对象到指定接口并返回json数据

在做项目中遇到一个问题就是发送对象到服务器请求接口数据，多次尝试失败，换作创建RestTemplate对象发送后顺利成功

之前是这样的方式：

 Map<String, Object> map = new HashMap();
        try {
        	//拼接产品接口URL地址
            String url = userResource + "/userresource/user/data/" + userid;
            //发送请求并返回结果
            String result = new SimpleRequest(url).get().send();
            Map<String, Object> hashMap = JSONObject.parseObject(result, HashMap.class);
            return (Map<String, Object>) hashMap.get("data");
        } catch (Exception e) {
            map.put("success", false);
            return map;
        }

成功之后：

    public Map<String, Object> updateUserInfo(UserForPasswordEntity bean, HttpServletRequest request) {
        Map<String, Object> map = new HashMap();
        try {
            String token = oAuthService.getOAuthCenterToken();
            String url = userResource + "/userresource/user/password?access_token=" + token;
            //创建RestTemplate对象可自动转换JSON数据
            RestTemplate restTemplate = new RestTemplate();
            //把URL地址与需要传递对象进行封装并发送POST请求到指定接口并返回结果
            String ret = restTemplate.postForObject(url, bean, String.class);
            Map<String, Object> hashMap = JSONObject.parseObject(ret, HashMap.class);
            String rest = hashMap.get("data").toString();
            map.put("success", true);
            map.put("data", rest);
            return map;
        } catch (Exception e) {
            map.put("success", false);
            return map;
        }
    }

 

SimpleRequest.java

package com.zx.st.core.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

/**
 * example：
 * <code>new SimpleRequest(url).get().param(...).header().send(...)</code>
 *
 * @version 1.0.0
 * @since on 2019-05-29.
 */
public class SimpleRequest {

    private static final int DEFAULT_CONNECT_TIMEOUT = 5000 * 60;
    private static final int DEFALUT_READ_TIMEOUT = 5000 * 60;
    private String url;

    private String method;

    private Map<String, String> params;

    private Map<String, Object> headerMap;

    private boolean isSSL;

    private TrustManager[] trustManagers;

    /**
     * SimpleRequest request = new SimpleRequest(url).method(get).addHeader(key, value).param().body().connect();
     *
     * @param url
     */
    public SimpleRequest(String url) {
        get();
        this.url = url;
        if (url.startsWith("https://")) {
            this.isSSL = true;
        }
    }

    public SimpleRequest useSSL() {
        this.isSSL = true;
        return this;
    }

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

    public SimpleRequest get() {
        this.method = "GET";
        return this;
    }

    public SimpleRequest post() {
        this.method = "POST";
        return this;
    }

    public SimpleRequest addHeader(String key, Object value) {
        if (headerMap == null) {
            headerMap = new HashMap<>();
        } else {
            headerMap.put(key, value);
        }

        return this;
    }

    public SimpleRequest param(String key, String value) {
        if (params == null) {
            params = new HashMap<>();
        } else {
            params.put(key, value);
        }

        return this;
    }

    public String send() {
        return send(null);
    }

    public String send(byte[] data) {
        if (isSSL) {
            return sendHttps(data);
        } else {
            return sendHttp(data);
        }
    }

    private String sendHttps(byte[] data) {
        // 凭证管理器
        if (trustManagers == null) {
            trustManagers = new TrustManager[]{new UnsecureX509TrustManager()};
            HttpsURLConnection.setDefaultHostnameVerifier(new IgnoreHostNameVerifier());
        }

        HttpsURLConnection conn;
        try {
            conn = (HttpsURLConnection) getURL().openConnection();
            conn.setSSLSocketFactory(getSslSocketFactory());
        } catch (KeyManagementException | IOException e) {
            throw new RuntimeException(e);
        }

        conn.setDoOutput(true);
        if (!isGetMethod()) {
            conn.setDoInput(true);
        }
        conn.setUseCaches(false);
        try {
            conn.setRequestMethod(method.toUpperCase());
        } catch (ProtocolException e) {
            throw new RuntimeException(e);
        }


        OutputStream out = null;
        try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            if (data != null) {
                out = conn.getOutputStream();
                // 注意编码格式
                out.write(data);
                out.close();
            }

            // 从输入流读取返回内容
            String line;
            StringBuilder builder = new StringBuilder();
            while ((line = in.readLine()) != null) {
                builder.append(line);
            }

            return builder.toString();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            conn.disconnect();
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    private SSLSocketFactory getSslSocketFactory() throws KeyManagementException {
        SSLContext sslContext = null;

        try {
            sslContext = SSLContext.getInstance("SSL", "SunJSSE");
        } catch (NoSuchAlgorithmException | NoSuchProviderException e) {
            throw new RuntimeException(e);
        }

        // 创建 SSLContext 对象，并使用我们指定的信任管理器初始化
        sslContext.init(null, trustManagers, new java.security.SecureRandom());
        // 获取得到 SSLSocketFactory 对象
        return sslContext.getSocketFactory();
    }

    private URL getURL() {
        try {
            return new URL(url + getParam());
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    private boolean isGetMethod() {
        return method.equalsIgnoreCase("get");
    }

    private String sendHttp(byte[] data) {
        URL realUrl = getURL();

        // 打开和URL之间的连接
        URLConnection conn;
        try {
            conn = realUrl.openConnection();
            conn.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
            conn.setReadTimeout(DEFALUT_READ_TIMEOUT);

            // 设置通用的请求属性
            if (headerMap != null) {
                String property = (String) headerMap.get("Content-Type");
                if (property == null || property.length() == 0) {
                    headerMap.put("Content-Type", "application/json");
                }

                for (Map.Entry<String, Object> entry : headerMap.entrySet()) {
                    conn.setRequestProperty(entry.getKey(), String.valueOf(entry.getValue()));
                }
            }

            ((HttpURLConnection) conn).setRequestMethod(method);
            conn.setDoInput(true);
            if (!isGetMethod()) {
                // 本行被设置后会被强制改成 POST 请求，请注意
                conn.setDoOutput(true);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        OutputStream out = null;
        try (// 定义BufferedReader输入流来读取URL的响应
             BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {

            if (data != null) {
                // 获取URLConnection对象对应的输出流
                out = conn.getOutputStream();
                // 针对小数据
                out.write(data);
                out.flush();
            }

            StringBuilder result = new StringBuilder();
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }

            return result.toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    private String getParam() {
        if (params != null && params.size() > 0) {
            StringBuilder builder = new StringBuilder("?");
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
            }
            builder.substring(0, builder.length() - 1);
            return builder.toString();
        } else {
            return "";
        }
    }

    /**
     * 不安全的凭证管理器，它会忽略所有凭证管理
     */
    private static class UnsecureX509TrustManager implements X509TrustManager {
        /**
         * 检查客户端证书
         */
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

        }

        /**
         * 检查服务器端证书
         */
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String s) throws CertificateException {

        }

        /**
         * 返回受信任的X509证书数组
         */
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }

    /**
     * 解决问题：java.security.cert.CertificateException: No subject alternative names present
     */
    private static class IgnoreHostNameVerifier implements HostnameVerifier {

        /**
         * (non-Javadoc)
         *
         * @see javax.net.ssl.HostnameVerifier#verify(java.lang.String, javax.net.ssl.SSLSession)
         */
        @Override
        public boolean verify(String arg0, SSLSession arg1) {
            return true;
        }
    }

    /**
     * URL编码（utf-8）
     *
     * @param source
     * @return
     */
    public static String urlEncodeUTF8(String source) {
        String result = source;
        try {
            result = java.net.URLEncoder.encode(source, "utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
}