7.调用HTTP接口

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 工具类 - 调用接口
 * 
 * @author swd
 *
 */
public class HttpUtil {


    /**
     * 发送请求(限制时间)
     * 
     * @param url
     *            URL
     * @param parameterMap
     *            参数Map
     * @param requestMode
     *            请求方式(POST/GET)
     * @param timeOut
     *            超时时间(ms)
     * @param timeOutStr
     *            超时后返回的字符串
     * @return 调用接口返回数据(或者是timeOutStr)
     * @throws InterruptedException
     */
    public static String sendCtrlTime(String url, Map<String, String> parameterMap, String requestMode, long timeOut,
            String timeOutStr) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return send(url, parameterMap, requestMode);
            }
        });

        StringBuffer sb = new StringBuffer();
        try {
            sb.append(future.get(timeOut, TimeUnit.MILLISECONDS));
        } catch (ExecutionException e) {
            future.cancel(true);
            e.printStackTrace();
        } catch (TimeoutException e) {
            future.cancel(true);// 取消没有执行完的任务,设置为ture说明任务能被中断,否则执行中的任务要完成
            return timeOutStr;
        } finally {
            executorService.shutdown();
        }
        return sb.toString();
    }

    /**
     * 发送请求,调用接口,获得数据
     * 
     * @param url
     *            HTTPURL -可接收URL格式:
     *            A:"http://IP:PORT/X/XX/XXXX?para1=para1&para2=para2&..."
     *            B:"http://IP:PORT/X/XX/XXXX/para1/para2/..."
     * @param parameterMap
     *            参数集合 如果url为A类型,当无参时需传空map或者null 如果url为B类型,参数集合传null
     * @param requestMode
     *            请求方式 (限定GET/POST)
     * @return 接口返回的数据
     * @throws Exception
     */

    public static String send(String url, Map<String, String> parameterMap, String requestMode) throws Exception {
        StringBuffer sb = new StringBuffer();
        try {
            String params = getRequestParameters(parameterMap);
            if ("POST".equalsIgnoreCase(requestMode)) {
                sb.append(sendPost(url, params));
            } else if ("GET".equalsIgnoreCase(requestMode)) {
                sb.append(sendGet(url, params));
            } else {
                return "{\"ERROR\":\"请求方式限定为GET\\POST\"}";
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return sb.toString();
    }

    /**
     * 处理请求参数集合
     * 
     * @param parameterMap
     *            请求参数集合
     * @return
     * @throws UnsupportedEncodingException
     */
    private static String getRequestParameters(Map<String, String> parameterMap) throws UnsupportedEncodingException {
        StringBuffer sb = new StringBuffer();
        String params;
        int parameterNum;
        if (parameterMap == null) {
            parameterNum = 0;
        } else {
            parameterNum = parameterMap.size();
        }
        switch (parameterNum) {
        case 0:
            params = "";
            break;
        case 1:
            for (String key : parameterMap.keySet()) {
                sb.append(key).append("=").append(URLEncoder.encode(parameterMap.get(key), "UTF-8"));
            }
            params = sb.toString();
            break;
        default:
            for (String key : parameterMap.keySet()) {
                sb.append(key).append("=").append(URLEncoder.encode(parameterMap.get(key), "UTF-8")).append("&");
            }
            String temp_params = sb.toString();
            params = temp_params.substring(0, temp_params.length() - 1);
            break;
        }
        return params;
    }

    /**
     * 获得URL连接对象
     */
    private static HttpURLConnection getHttpURLconn(String url) throws MalformedURLException, IOException {
        // 创建URL对象
        URL connURL = new URL(url);
        // 打开URL连接
        HttpURLConnection httpConn = (HttpURLConnection) connURL.openConnection();
        // 设置通用属性
        httpConn.setRequestProperty("Accept", "*/*");
        httpConn.setRequestProperty("Connection", "Keep-Alive");
        httpConn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
        // 设置POST方式
        httpConn.setDoInput(true);
        httpConn.setDoOutput(true);
        return httpConn;
    }

    /**
     * 发送GET请求
     * 
     * @param url
     *            URL
     * @param params
     *            参数
     * @return 结果
     * @throws Exception
     */
    private static String sendGet(String url, String params) throws Exception {

        BufferedReader in = null;
        StringBuffer resultBuffer = new StringBuffer();
        try {
            url = url + "?" + params;
            HttpURLConnection httpConn = getHttpURLconn(url);
            in = new BufferedReader(new InputStreamReader(httpConn.getInputStream(), "UTF-8"));
            String line = null;
            while ((line = in.readLine()) != null) {
                resultBuffer.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            try {
                if (in != null)
                    in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return resultBuffer.toString();
    }

    /**
     * 发送POST请求
     * 
     * @param url
     *            URL
     * @param params
     *            参数
     * @return 结果
     * @throws Exception
     */
    private static String sendPost(String url, String params) throws Exception {
        StringBuffer resultBuffer = new StringBuffer();
        PrintWriter out = null;
        BufferedReader in = null;
        try {
            HttpURLConnection httpConn = getHttpURLconn(url);
            // 获取HttpURLConnection对象对应的输出流
            out = new PrintWriter(httpConn.getOutputStream());
            // 发送请求参数
            out.write(params);
            // flush输出流的缓冲
            out.flush();
            in = new BufferedReader(new InputStreamReader(httpConn.getInputStream(), "UTF-8"));
            String line = null;
            while ((line = in.readLine()) != null) {
                resultBuffer.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            try {
                if (in != null)
                    in.close();
                if (out != null)
                    out.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        return resultBuffer.toString();
    }

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值