JavaWeb跨服务器请求API

参考：https://blog.csdn.net/buyaopingbixiazai/article/details/80680009

需求：一个服务器请求另一个服务器资源

两种请求方式

第一种请求方式

1、创建 HttpUtils 类

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.net.ssl.X509TrustManager;

import org.apache.log4j.Logger;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

public class HttpUtils {
    
    /** Log4j日志处理(@author: victor) */
    private static final Logger log = Logger.getLogger(HttpUtils.class);
    
    /** 证书信任管理(用于https请求)   */
    public static class TrustManager implements X509TrustManager {
        
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            
        }
        
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            
        }
        
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
        
    }
    
    /**
     * @description GET请求 默认是 utf-8 编码
     * @param url
     * @param params
     * @return
     */
    public static String get(String url, String params) {
        return get(url, params, Charset.forName("utf-8"));
    }
    
    /**
     * @description GET请求 
     * @author victor
     * @created 2018年10月12日 11:20:30
     * @param url
     * @return
     */
    public static String get(String url, String params, Charset charset) {
        String result = "";
        InputStream in = null;
        if (null != params && !params.equals("")) {
            // 包含?,后面加&直接添加
            if (url.contains("?")) {
                url += "&" + params;
            } else {
                url += "?" + params;
            }
        }
        try {
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();
            // 设置通用请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            conn.connect();
            in = conn.getInputStream();
            result = readInputStream(charset, in);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        log.info("result= " + result);
        return result;
    }
    
    /**
     * @description POST请求  默认是 utf-8 编码
     * @param url
     * @return
     */
    public static String post(String url, String params) {
        return post(url, params, Charset.forName("utf-8"));
    }
    
    /**
     * @description POST请求 
     * @author victor
     * @created 2018年10月12日 09:29:21
     * @param param 请求参数，请求参数格式 name1=value1&name2=value2
     * @return
     */
    public static String post(String url, String param, Charset charset) {
        PrintWriter out = null;
        InputStream in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();
            
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.print(param);
            out.flush();
            
            in = conn.getInputStream();
            result = readInputStream(charset, in);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                try {
                    if (out != null) {
                        out.close();
                    }
                } finally {
                    if (in != null) {
                        in.close();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * @description 读取返回结果集
     * @param charset
     * @param in
     * @return
     */
    private static String readInputStream(Charset charset, InputStream in) {
        // 定义BufferedReader输入流来读取URL的响应  
        InputStreamReader reader = null;
        BufferedReader bufferedReader = null;
        String line = null;
        StringBuffer resultBuffer = new StringBuffer();
        try {
            reader = new InputStreamReader(in, charset);
            bufferedReader = new BufferedReader(reader);
            while ((line = bufferedReader.readLine()) != null) {
                resultBuffer.append(line);
                resultBuffer.append("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
            if (reader != null) {
                try {
                    reader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return resultBuffer.toString();
        
    }
    
    /**
     * @description 处理结果集(一)
     * @param data 要处理的结果集
     * @param listName json对应的“键”
     * @return
     */
    public static List<Map<String, Object>> proceResult(String data, String listName) {
        Gson gson = new Gson();
        JsonParser parser = new JsonParser();
        // Json 转对象
        JsonObject jsonObject=(JsonObject) parser.parse(data);
        // 根据发过来的数据格式 需要再转一次 json 看自己的数据格式，如果只嵌套一层是不用这一步的，如果嵌套多层 还需要多次转 json 
        // JsonObject objectRepet = (JsonObject) parser.parse(jsonObject.get("json").toString());
        // 获取dataName 对象的对象 里面的list集合
        List<Map<String, Object>> dataList = gson.fromJson(jsonObject.get(listName).toString(),new TypeToken<List<Map<String, Object>>>() {}.getType());
        
        return dataList;
    }
    
    /**
     * @description 处理结果集(二)
     * @param data 要处理的结果集
     * @param listName json对应的“键”
     * @return
     */
    public static List<Map<String, Object>> proceResultTwo(String data, String listName) {
        // 用于接收远程发来的数据集合
        List<Map<String, Object>> dataLists = new ArrayList<Map<String,Object>>();
        JsonParser parser = new JsonParser();
        // Json 转对象
        JsonObject jsonObject=(JsonObject) parser.parse(data);
        // 根据发过来的数据格式 需要再转一次 json 看自己的数据格式，如果只嵌套一层是不用这一步的，如果嵌套多层 还需要多次转 json 
        // JsonObject objectRepet = (JsonObject) parser.parse(jsonObject.get("json").toString());
        // 获取listName 对象的对象 里面的list集合
        JsonArray array = jsonObject.get(listName).getAsJsonArray();
        // 循环listName 集合里面的数据并且放到lists里面
        for (int i = 0; i < array.size(); i++) {
            //获取一个subObject
            JsonObject subObject = array.get(i).getAsJsonObject();
            //获取属性
            String id = subObject.get("id").toString();
            String maintePerson = subObject.get("maintePerson").toString();
            //保存属性
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("id", id);
            map.put("maintePerson", maintePerson);
            //存到list
            dataLists.add(map);
        }
        return dataLists;
    }
}

注意：这里 用到 Gson ，Java对象和Json之间的互转，一般用的比较多的两个类库是Jackson和Gson

使用Maven管理依赖，pom.xml导入Gson的依赖

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.2</version>
</dependency>

调用：

    /**
     * @description 请求外汇行情
     * @resource https://www.webdomain.com
     * @author victor
     * @return
     */
    @RequestMapping(value="/getForeMarket", method = RequestMethod.GET, produces = "application/json")
    @IgnoreSecurity
    public Response getRequest(HttpServletResponse res) {
        Long timeStamp = System.currentTimeMillis();
        String data = HttpUtils.get("https://www.webdomain.com/dom/getpricesnapshot.do", "id=Saxo2&rawsym=EURUSD,GBPUSD,EURJPY,USDJPY,XAUUSD&refresh=" + timeStamp);
        
        // 分割字符串中特殊字符 “（）”
        data = data.substring(1, data.length() - 2);
        // 处理结果集
        List<Map<String, Object>> dataList = HttpUtils.proceResult(data, "symbols");
        log.debug("获取指定API ：" + dataList);
        return new Response().success(dataList, 200);
    }

 

第二种请求方式

创建 ProxyRequest 类

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import java.util.Map.Entry;

public class ProxyRequest {

    /**
     * @description 代理请求接口
     * @param url: 请求路径
     * @param type: 请求类型
     * @param parameterMap: 请求参数
     * @return
     */
    public static String getRequestResult(String newUrl,String type,Map<String, Object> map) throws IOException {
            
            InputStream inputStream = null;
            InputStreamReader reader = null;
            BufferedReader bufferedReader = null;
            StringBuffer resultBuffer = new StringBuffer();
            String tempLine = null;
            
            try {
                // 统一资源
                URL url = new URL(newUrl);
                // http的连接类
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                // 设定请求的方法，默认是GET
                connection.setRequestMethod(type);
                // 设置是否向Connection输出
                connection.setDoOutput(true);
                // 设置是否从connection读入,默认情况下是true
                connection.setDoInput(true);
                connection.setConnectTimeout(3000);
                // Post 请求不能使用缓存
                connection.setUseCaches(false);
                // 设置字符编码连接参数
                connection.setRequestProperty("Connection", "Keep-Alive");
                // 设置字符编码
                connection.setRequestProperty("charset", "UTF-8");
                
                if(map!=null && map.size()>0) {
                    // 发送请求参数
                    DataOutputStream out = new DataOutputStream(connection.getOutputStream());
                    StringBuffer buffer = new StringBuffer();
                    for (Entry<String, Object> entry : map.entrySet()) {
                        Object params = entry.getValue();
                        Object name = entry.getKey();
                        buffer.append(name+"="+params+"&");
                    }
                    String param = buffer.toString();
                    param = param.substring(0,param.length()-1);
                    out.writeBytes(param);
                    out.flush();
                    out.close();
                }
                
                inputStream = connection.getInputStream();
                reader = new InputStreamReader(inputStream);
                bufferedReader = new BufferedReader(reader);
                while ((tempLine = bufferedReader.readLine()) != null) {
                    resultBuffer.append(tempLine);
                    resultBuffer.append("\n");
                }
                
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            
            return resultBuffer.toString();
        }
}