精华内容
下载资源
问答
  • Http接口封装

    2018-10-18 22:04:16
    是Androd Http通讯类的抽象接口,目的地是有一个封装
  • Android 调用Http接口封装。由于Android要求Http调用必须在线程当中,所以本人就封装了一个工具类,该工具类即支持阻塞/同步调用,也支持异步调用,便于调用Http接口方便。
  • 接口调用传入两个参数:post(url, map)简化接口调用代码
  • c# http请求webapi接口封装
  • 主要介绍了微信小程序HTTP接口请求封装的实现,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1.方法封装(新建文件夹util,工具文件,在文件夹下创建request.js文件,用于对方法封装) request.js: var app = getApp(); //项目URL相同部分,减轻代码量,同时方便项目迁移 //这里因为我是本地调试,所以host...
  • (1) 位置,在src中新建 src/utils/http.js import axios from 'axios' // 引用axios import { MessageBox, Message } ...axios.defaults.timeout = 50000 //设置接口响应时间 // axios.defaults.baseURL = 'https://ea
  • android http请求访问接口封装

    千次阅读 2018-10-12 15:49:25
    public HttpConnection(final String url, final HttpMethod method, final SuccessCallback successCallback, final FailCallback failCallback, final Map, String> map) { new AsyncTask, Void, String>() { ...

    转自 https://www.cnblogs.com/you411305469/p/5212479.html

    里面介绍了实用的两种

    要特别注意,向php请求数据是表单类型的数据
    application/x-www-form-urlencoded

    import android.os.AsyncTask;
    import org.json.JSONObject;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.net.URLConnection;
    import java.util.Map;
    
    /**
     * @author Admin
     * @version $Rev$
     * @des ${TODO}
     * @updateAuthor $Author$
     * @updateDes ${TODO}
     */
    public class HttpConnection {
    
        /**
         * 升级版接口
         *
         * @param url
         * @param method
         * @param successCallback
         * @param failCallback
         * @param map
         */
        public HttpConnection(final String url, final HttpMethod method,
                             final SuccessCallback successCallback,
                             final FailCallback failCallback, final Map<String, String> map) {
            new AsyncTask<Void, Void, String>() {
    
                @Override
                protected String doInBackground(Void... params) {
                    StringBuffer sb = new StringBuffer();
                    String realString = "";
                    for (Map.Entry<String, String> entry : map.entrySet()) {
                        sb.append(entry.getKey()).append("=")
                                .append(entry.getValue()).append("&");
                    }
                    realString = sb.toString().substring(0,
                            sb.toString().length() - 1);
    
                    try {
                        URLConnection uc;
                        switch (method) {
                            case POST:
                                uc = new URL(url).openConnection();
                                uc.setDoOutput(true);
                                uc.setConnectTimeout(5000);
                                BufferedWriter bw = new BufferedWriter(
                                        new OutputStreamWriter(uc.getOutputStream(),
                                                "utf-8"));
                                bw.write(realString);
                                bw.flush();
                                break;
    
                            default:
                                uc = new URL(url + "?" + realString).openConnection();
    
                                uc.setConnectTimeout(5000);
                                uc.setRequestProperty("apikey",
                                        "2f50fafc573e93a725e277b073d9c5dd");
                                break;
                        }
                        System.out.println("Request url:" + uc.getURL());
                        System.out.println("Request date:" + realString);
                        System.out.println("Result status:"
                                + ((HttpURLConnection) uc).getResponseCode());
                        if (((HttpURLConnection) uc).getResponseCode() == 200) {
                            BufferedReader br = new BufferedReader(
                                    new InputStreamReader(uc.getInputStream(),
                                            "utf-8"));
                            StringBuffer result = new StringBuffer();
                            String line = "";
                            while ((line = br.readLine()) != null) {
                                result.append(line);
                            }
                            System.out.println("Result:" + result);
                            return result.toString();
                        } else {
                            System.out.println("Result:"
                                    + ((HttpURLConnection) uc).getResponseCode());
                        }
    
                    } catch (MalformedURLException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return null;
                }
    
                @Override
                protected void onPostExecute(String result) {
                    if (result != null) {
                        try {
                            JSONObject json = new JSONObject(result);
                            if (successCallback != null) {
                                successCallback.onSuccess(result);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
    
                    } else {
                        if (failCallback != null) {
                            failCallback.onFail();
                        }
                    }
                    super.onPostExecute(result);
    
                }
            }.execute();
        }
    
        /**
         * json型接口升级版
         *
         * @param url
         * @param successCallback
         * @param failCallback
         * @param json map
         */
        public HttpConnection(final String url,
                             final SuccessCallback successCallback,
                             final FailCallback failCallback, final String json) {
            new AsyncTask<Void, Void, String>() {
    
                @Override
                protected String doInBackground(Void... params) {
                    try {
                        HttpURLConnection uc = (HttpURLConnection) new URL(url)
                                .openConnection();
                        //打开输出流
                        uc.setDoOutput(true);
                        //打开输入流
                        uc.setDoInput(true);
                        uc.setInstanceFollowRedirects(true);
                        //post方式
                        uc.setRequestMethod("POST");
                        //超时
                        uc.setConnectTimeout(5000);
                        //禁止使用缓存
                        uc.setUseCaches(false);
                        //接收字符串类型数据用json
                        uc.setRequestProperty("Accept", "application/json");
                        //请求的内容为表单类型数据
                        uc.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                        //设置utf8
                        uc.setRequestProperty("Charset", "UTF-8");
    
    //                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(uc.getOutputStream(),"utf-8"));
    //                    bw.write(json);
    //                    bw.flush();
                        /**
                         * 请求数据(表单类型的或json类型的数据)
                         */
                        OutputStreamWriter writer = new OutputStreamWriter(uc.getOutputStream());
                        //发送参数
                        writer.write(json);
                        //清理当前编辑器的左右缓冲区,并使缓冲区数据写入基础流
                        writer.flush();
    
    
    
                        System.out.println("Request url:" + uc.getURL());
                        System.out.println("Request date:" + json);
    
                        //判断接收数据,为json格式
                        if (uc.getResponseCode() == 200) {
                            BufferedReader br = new BufferedReader(
                                    new InputStreamReader(uc.getInputStream(),
                                            "utf-8"));
                            StringBuffer result = new StringBuffer();
                            String line = "";
                            while ((line = br.readLine()) != null) {
                                result.append(line);
                            }
                            System.out.println("Result:" + result);
                            return result.toString();
                        } else {
                            System.out.println("uc.getResponseCode()=="
                                    + uc.getResponseCode());
                            System.out.println("uc.getResponseMessage()=="
                                    + uc.getResponseMessage());
                        }
                    } catch (MalformedURLException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                    return null;
                }
    
                @Override
                protected void onPostExecute(String result) {
                    if (result != null) {
                        if (successCallback != null) {
                            successCallback.onSuccess(result);
                        }
                    } else {
                        if (failCallback != null) {
                            failCallback.onFail();
                        }
                    }
                    super.onPostExecute(result);
    
                }
            }.execute();
        }
    
    
    
        public static interface SuccessCallback {
            void onSuccess(String result);
        }
    
        public static interface FailCallback {
            void onFail();
        }
    
    }
    
    

    以上类需要用到HttpMethod

    public enum HttpMethod {
        POST,GET
    }
    

    以上的类就是http访问接口的类,以下就来举些例子吧:

    /**
         * 积分商品列表
         */
        private void initData(int flag) {
            private String url = "http://192.168.1.11/xxx";
            Map<String, String> params = new HashMap<String, String>();
            params.put("types", "0");
            params.put("isonsail", "0");
            params.put("rowStart",  "0");
            params.put("rowEnd",  "20");
            new NetConnection(url, "post",
                    new NetConnection.SuccessCallback() {
     
                        @Override
                        public void onSuccess(String result) {
                             
                        }
                    }, new NetConnection.FailCallback() {
     
                        @Override
                        public void onFail() {
                             
                        }
                    }, params);
        }
    

    还有一种是json型的入参的:

    /**
         * 发起全车诊断 接口描述:该接口用于向 iOBD设备下发诊断指令
         */
        public void check() {
            JSONObject param = new JSONObject();
            try {
                param.put("appkey", Config.getAppKey(this));
                param.put("imei", Config.getImei(this));
            } catch (Exception e) {
                e.printStackTrace();
            }
            new NetConnection(Config.SERVER_URL + "diagnosis/trigge",
                    new NetConnection.SuccessCallback() {
                        @Override
                        public void onSuccess(String result) {
                             
                        }
                    }, new NetConnection.FailCallback() {
                        @Override
                        public void onFail() {
                             
                        }
                    }, param.toString());
        }
    
    展开全文
  • 微信小程序如何封装api接口 首先创建个http文件夹(可自定义名字) 一:创建个env.js文件用来设置公共访问的url,即环境地址 module.exports = { //开发环境 dev:{baseUrl:http://localhost:3000}, //测试环境 ...
  • Http请求工具类:包含,get,put,post(delete请求与get请求类似) package com.construn.vehicleservice.util; import java.io.IOException; import java.net.URISyntaxException; import java.nio.charset....

    Http请求工具类:包含,get,put,post(delete请求与get请求类似)

    package com.construn.vehicleservice.util;
    
    import java.io.IOException;
    import java.net.URISyntaxException;
    import java.nio.charset.Charset;
    import java.util.Map;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpStatus;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.methods.HttpPut;
    import org.apache.http.client.utils.URIBuilder;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    
    /**
     * @param
     * @return
     * @author chaosgod 2019-04-24 09:24
     * @description : Http请求
     */
    @Slf4j
    public class APIHttpClient {
    
      /** 接口地址 */
      private String apiURL;
    
      private HttpClient httpClient = null;
      private HttpPost httpPost = null;
      private HttpPut httpPut = null;
      private long startTime = 0L;
      private long endTime = 0L;
      private int status = 0;
    
      /**
       * 接口地址
       *
       * @param url
       */
      public APIHttpClient(String url) {
        if (url != null) {
          apiURL = url;
          httpClient = HttpClients.createDefault();
          httpPost = new HttpPost(apiURL);
          httpPut = new HttpPut(apiURL);
        }
      }
    
      /**
       * 调用 API
       *
       * @param parameters
       * @return
       */
      public String post(String parameters) {
        String body = null;
        log.info("parameters:{}", parameters);
        // 创建一个返回值对象
        if (httpPost != null & parameters != null && !"".equals(parameters.trim())) {
          try {
            // 建立一个NameValuePair数组,用于存储欲传送的参数
            httpPost.addHeader("Content-type", "application/json; charset=utf-8");
            httpPost.setHeader("Accept", "application/json");
            httpPost.setEntity(new StringEntity(parameters, Charset.forName("UTF-8")));
            startTime = System.currentTimeMillis();
            HttpResponse response = httpClient.execute(httpPost);
            endTime = System.currentTimeMillis();
            int statusCode = response.getStatusLine().getStatusCode();
            log.info("statusCode:" + statusCode);
            log.info("调用API:{} 花费时间(单位:毫秒):{}", httpPost.getURI(), (endTime - startTime));
            if (statusCode != HttpStatus.SC_OK) {
              log.error("httpPost failed:" + response.getStatusLine());
              status = 1;
            }
            // Read the response body
            body = EntityUtils.toString(response.getEntity());
          } catch (IOException e) {
            // 网络错误
            status = 3;
            log.error("连接失败,网络错误");
          } catch (Exception e) {
            log.info("遇到错误");
          } finally {
            log.info("调用接口状态:" + status);
          }
        }
        return body;
      }
    
      public String put(String parameters) {
        String body = null;
        log.info("parameters:{}", parameters);
        // 创建一个返回值对象
        if (httpPut != null & parameters != null && !"".equals(parameters.trim())) {
          try {
            // 建立一个NameValuePair数组,用于存储欲传送的参数
            httpPut.addHeader("Content-type", "application/json; charset=utf-8");
            httpPut.setHeader("Accept", "application/json");
            httpPut.setEntity(new StringEntity(parameters, Charset.forName("UTF-8")));
            startTime = System.currentTimeMillis();
            HttpResponse response = httpClient.execute(httpPut);
            endTime = System.currentTimeMillis();
            int statusCode = response.getStatusLine().getStatusCode();
            log.info("statusCode:" + statusCode);
            log.info("调用API:{} 花费时间(单位:毫秒):{}", httpPut.getURI(), (endTime - startTime));
            if (statusCode != HttpStatus.SC_OK) {
              log.error("httpPost failed:" + response.getStatusLine());
              status = 1;
            }
            // Read the response body
            body = EntityUtils.toString(response.getEntity());
          } catch (IOException e) {
            // 网络错误
            status = 3;
            log.error("连接失败,网络错误");
          } catch (Exception e) {
            log.info("遇到错误");
          } finally {
            log.info("调用接口状态:" + status);
          }
        }
        return body;
      }
    
      /**
       * 实现get请求
       *
       * @param baseUrl
       * @param parameters 传入参数的map;当无参数时,传入的map=null即可
       * @param headers 传入header的map, 例如cookies等,当无值时,传入null即可
       * @return
       */
      public String get(Map<String, String> parameters) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String entityString = null;
        log.info("Url:{}", apiURL);
        log.info("parameters:{}", parameters);
        try {
          URIBuilder uriBuilder = new URIBuilder(apiURL);
          if (parameters != null && parameters.size() > 0) {
            for (Map.Entry<String, String> temp : parameters.entrySet()) {
              // 循环map里面的每一对键值对,然后获取key和value即时想要的参数的 key和value
              uriBuilder.addParameter(temp.getKey(), temp.getValue());
            }
          }
          HttpGet get = new HttpGet(uriBuilder.build());
          startTime = System.currentTimeMillis();
          response = httpClient.execute(get);
          endTime = System.currentTimeMillis();
          int statusCode = response.getStatusLine().getStatusCode();
          log.info("statusCode:" + statusCode);
          log.info("调用API:{} 花费时间(单位:毫秒):{}", get.getURI(), (endTime - startTime));
          if (statusCode != HttpStatus.SC_OK) {
            log.error("httpPost failed:" + response.getStatusLine());
            status = 1;
          }
          HttpEntity entity = response.getEntity();
          entityString = EntityUtils.toString(entity, "utf-8");
        } catch (URISyntaxException e) {
          e.printStackTrace();
        } catch (IOException e) {
          // 网络错误
          status = 3;
          log.error("连接失败,网络错误");
        } finally {
          try {
            if (response != null) {
              response.close();
            }
            if (httpClient != null) {
              httpClient.close();
            }
    
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
        return entityString;
      }
    
      /**
       * 0.成功 1.执行方法失败 2.协议错误 3.网络错误
       *
       * @return the status
       */
      public int getStatus() {
        return status;
      }
    
      /** @param status the status to set */
      public void setStatus(int status) {
        this.status = status;
      }
    
      /** @return the startTime */
      public long getStartTime() {
        return startTime;
      }
    
      /** @return the endTime */
      public long getEndTime() {
        return endTime;
      }
    }
    

    项目中使用Eg:

      public void overEmpWorkTask(Map<String, Object> map) throws VehicleException {
        String str;
        try {
          str = new APIHttpClient(overEmpWorkTask).post(JSONObject.toJSONString(map));
          log.info("获得返回{}", str);
          JSONObject jsonObject = JSONObject.parseObject(str);
          if (!jsonObject.get("code").equals(ResponseObj.SUCCESS_CODE)) {
            throw new VehicleInterErrorException((String) jsonObject.get("userInfo"));
          }
        } catch (VehicleInterErrorException e) {
          throw e;
        } catch (Exception e) {
          throw new VehicleException("链接失败");
        }
      }

    如上代码,服务实现类只需要调用overEmpWorkTask方法并且穿参Map,然后捕获VehicleInterErrorException异常,抛出去,前端则会收到后端的后端抛出得异常信息;

    展开全文
  • Java http接口返回值封装实体类

    千次阅读 2019-10-31 10:31:45
    public class RequestMessage { /* 服务器成功返回用户请求数据的状态码 */ public static String SUCCESS_GETS_CODE = "200"; /* 服务器成功返回用户请求数据的提示信息 */ public static String SUCCESS_GETS_...
    public class RequestMessage {
        /* 服务器成功返回用户请求数据的状态码 */
        public static String SUCCESS_GETS_CODE = "200";
        /* 服务器成功返回用户请求数据的提示信息 */
        public static String SUCCESS_GETS_MSG = "ok";
    
        /* 新建或修改数据成功返回状态码 */
        public static String SUCCESS_POSTS_CODE = "201";
        /* 新建或修改数据成功返回提示信息 */
        public static String SUCCESS_POSTS_MSG = "ok";
    
        /* 请求进入后台排队(异步请求)成功状态码 */
        public static String SUCCESS_ACCEPTED_CODE = "202";
        /* 请求进入后台排队(异步请求)成功提示信息 */
        public static String SUCCESS_ACCEPTED_MSG = "Accepted";
    
        /* 删除数据成功返回状态码 */
        public static String SUCCESS_DELETES_CODE = "204";
        /* 删除数据成功返回提示信息 */
        public static String SUCCESS_DELETES_MSG = "ok";
    
        /* 服务器发生错误状态码 */
        public static String ERROR_CODE = "500";
        /* 服务器发生错误提示信息 */
        public static String ERROR_MSG = "error";
    
        /* 状态码 */
        private String code;
        /* 提示信息 */
        private String message;
        /* 服务器异常信息 */
        private String error;
        /* 成功返回的数据 */
        private Object data;
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
        
        public String getError() {
            return error;
        }
    
        public void setError(String error) {
            this.error = error;
        }
    
        public Object getData() {
            return data;
        }
    
        public void setData(Object data) {
            this.data = data;
        }
    }
    
    展开全文
  • C# http Get/POST请求封装

    热门讨论 2014-08-29 16:34:40
    C# http Get/POST请求封装
  • 背景:项目中有多个组件调用同一接口,为提高代码可维护性,需要封装公共方法 直接return 接口调用的结果 export function getAll() { let all = []; let opt = { method: 'get', url: 'all/teacher', success...
  • http://blog.csdn.net/zhoup324/article/details/79236489
  • HTTP请求封装

    千次阅读 2018-06-25 17:25:15
    目前JAVA实现HTTP请求的方法用的最多的有两种: 1、通过HttpURLConnection去实现,HttpURLConnection是JAVA的标准类,是JAVA比较原生的一种实现方式。 2、通过HTTPClient这种第三方的开源框架去实现。应用最广泛的...

    目前JAVA实现HTTP请求的方法用的最多的有两种:
    1、通过HttpURLConnection去实现,HttpURLConnection是JAVA的标准类,是JAVA比较原生的一种实现方式。
    2、通过HTTPClient这种第三方的开源框架去实现。应用最广泛的就是apache的HTTPClient,有两大版本,HttpClient3.1 是 org.apache.commons.httpclient下操作远程 url的工具包,虽然已不再更新,但实现工作中使用httpClient3.1的代码还是很多,HttpClient4.5.x是org.apache.http.client下操作远程 url的工具包;

    HttpURLConnection

    package com.demo;
    
    import java.io.ByteArrayOutputStream;
    import java.io.Closeable;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.Map;
    
    public class HttpURLConDemo {
        public static final String charsetName = "UTF-8";
    
        public static String doGet(String strUrl) {
            return doGet(strUrl, null);
        }
    
        public static String doGet(String strUrl, Map<String, String> headers) {
            HttpURLConnection connection = null;
            String out = null;
            InputStream inputStream = null;
            try {
                URL _url = new URL(strUrl);
                // 打开连接
                connection = (HttpURLConnection) _url.openConnection();
                // 设置请求方式:get请求
                connection.setRequestMethod("GET");
                // 设置超时时间,单位毫秒:5秒
                connection.setConnectTimeout(5000);
                // 设置读取远程服务器时间,单位毫秒:10秒
                connection.setReadTimeout(10000);
                // 设置请求头
                if (headers != null) {
                    for (String headName : headers.keySet()) {
                        String headValue = headers.get(headName);
                        connection.setRequestProperty(headName, headValue);
                    }
                }
                // 发送请求
                connection.connect();
                // 通过connection获取输入流数据
                if (connection.getResponseCode() == 200) {
                    inputStream = connection.getInputStream();
                    out = inToString(inputStream);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 关闭资源
                close(inputStream);
                // 关闭连接
                connection.disconnect();
            }
            return out;
        }
    
        public static String doPost(String strUrl, String params, Map<String, String> headers) {
            HttpURLConnection connection = null;
            String out = null;
            InputStream inputStream = null;
            OutputStream outputStream = null;
            try {
                URL _url = new URL(strUrl);
                // 打开连接
                connection = (HttpURLConnection) _url.openConnection();
                // 设置请求方式:get请求
                connection.setRequestMethod("POST");
                // 设置超时时间,单位毫秒:5秒
                connection.setConnectTimeout(5000);
                // 设置读取远程服务器时间,单位毫秒:10秒
                connection.setReadTimeout(10000);
                // 设置请求头
                if (headers != null) {
                    for (String headName : headers.keySet()) {
                        String headValue = headers.get(headName);
                        connection.setRequestProperty(headName, headValue);
                    }
                }
                // 默认值为:true,当前向远程服务读取数据时,设置为true,该参数可有可无
                connection.setDoInput(true);
                if (params != null) {
                    // 默认值为:false,当向远程服务器传送数据/写数据时,需要设置为true
                    connection.setDoOutput(true);
                    outputStream = connection.getOutputStream();
                    outputStream.write(params.getBytes(charsetName));
                }
                // 发送请求
                connection.connect();
                // 通过connection获取输入流数据
                if (connection.getResponseCode() == 200) {
                    inputStream = connection.getInputStream();
                    out = inToString(inputStream);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 关闭资源
                close(outputStream);
                close(inputStream);
                // 关闭连接
                connection.disconnect();
            }
            return out;
        }
    
        public static String doPost(String strUrl) {
            return doPost(strUrl, null, null);
        }
        //ByteArrayOutputStream无需关闭
        private static String inToString(InputStream inputStream) throws IOException {
            ByteArrayOutputStream result = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                result.write(buffer, 0, length);
            }
            String str = result.toString(charsetName);
            return str;
        }
    
        private static void close(Closeable closeable) {
            try {
                if (closeable != null) {
                    closeable.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            String result = doGet("https://blog.csdn.net/zhangsweet1991");
            System.out.println(result);
        }
    }
    

    HttpClient3.1

    package com.demo;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Map;
    
    import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
    import org.apache.commons.httpclient.HttpClient;
    import org.apache.commons.httpclient.HttpException;
    import org.apache.commons.httpclient.HttpMethod;
    import org.apache.commons.httpclient.HttpStatus;
    import org.apache.commons.httpclient.methods.GetMethod;
    import org.apache.commons.httpclient.methods.PostMethod;
    import org.apache.commons.httpclient.params.HttpMethodParams;
    
    public class HttpClientUtils {
        public static final String charsetName = "UTF-8";
    
        public static String doGet(String url) {
            /*
             * 使用 GetMethod 来访问一个 URL 对应的网页,实现步骤: 1:生成一个 HttpClinet 对象并设置相应的参数。
             * 2:生成一个 GetMethod 对象并设置响应的参数。 3:用 HttpClinet 生成的对象来执行 GetMethod 生成的Get
             * 方法。 4:处理响应状态码。 5:若响应正常,处理 HTTP 响应内容。 6:释放连接。
             */
    
            /* 1 生成 HttpClinet 对象并设置参数 */
            HttpClient httpClient = new HttpClient();
            // 设置 Http 连接超时为5秒
            httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
    
            /* 2 生成 GetMethod 对象并设置参数 */
            GetMethod getMethod = new GetMethod(url);
            // 设置 get 请求超时为 5 秒
            getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
            // 设置请求重试处理,用的是默认的重试处理:请求三次
            getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
    
            String out = null;
            /* 3 执行 HTTP GET 请求 */
            try {
                int statusCode = httpClient.executeMethod(getMethod);
                /* 4 判断访问的状态码 */
                if (statusCode == HttpStatus.SC_OK) {
                    // 读取为 InputStream,在网页内容数据量大时候推荐使用
                    out = inToString(getMethod.getResponseBodyAsStream());
                }
            } catch (HttpException e) {
                // 发生致命的异常,可能是协议不对或者返回的内容有问题
                e.printStackTrace();
            } catch (IOException e) {
                // 发生网络异常
                e.printStackTrace();
            } finally {
                /* 6 .释放连接 */
                getMethod.releaseConnection();
            }
            return out;
        }
    
        public static String doPost(String url, Map<String, String> params) {
    
            String out = null;
            HttpClient client = new HttpClient();
            HttpMethod method = new PostMethod(url);
    
            // 设置Http Post数据
            if (params != null) {
                HttpMethodParams p = new HttpMethodParams();
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    p.setParameter(entry.getKey(), entry.getValue());
                }
                method.setParams(p);
            }
            try {
                client.executeMethod(method);
                if (method.getStatusCode() == HttpStatus.SC_OK) {
                    // 读取为 InputStream,在网页内容数据量大时候推荐使用
                    out = inToString(method.getResponseBodyAsStream());
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                method.releaseConnection();
            }
            return out;
        }
    
        private static String inToString(InputStream inputStream) throws IOException {
            ByteArrayOutputStream result = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                result.write(buffer, 0, length);
            }
            String str = result.toString(charsetName);
            return str;
        }
    
        public static void main(String[] args) {
            String result = doGet("https://blog.csdn.net/zhangsweet1991");
            System.out.println(result);
        }
    }
    

    HttpClient4.5.5

    package com.youyu.util.http;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.nio.charset.Charset;
    import java.security.GeneralSecurityException;
    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.SSLContext;
    import javax.net.ssl.SSLException;
    import javax.net.ssl.SSLSession;
    import javax.net.ssl.SSLSocket;
    
    import org.apache.commons.io.IOUtils;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpStatus;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.conn.ConnectTimeoutException;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLContextBuilder;
    import org.apache.http.conn.ssl.TrustStrategy;
    import org.apache.http.conn.ssl.X509HostnameVerifier;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    
    public class HttpUtils {
        private static PoolingHttpClientConnectionManager connMgr;
        private static RequestConfig requestConfig;
        private static final int MAX_TIMEOUT = 7000;// 7秒
        private static final String UTF_8 = "UTF-8";
        public static final String JSON = "json";
        public static final String XML = "xml";
    
        static {
            // 设置连接池
            connMgr = new PoolingHttpClientConnectionManager();
            // 设置连接池大小
            connMgr.setMaxTotal(100);
            connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());
            RequestConfig.Builder configBuilder = RequestConfig.custom();
            // 设置连接超时
            configBuilder.setConnectTimeout(MAX_TIMEOUT);
            // 设置读取超时
            configBuilder.setSocketTimeout(MAX_TIMEOUT);
            // 设置从连接池获取连接实例的超时
            configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);
            // 在提交请求之前 测试连接是否可用
            configBuilder.setStaleConnectionCheckEnabled(true);
            requestConfig = configBuilder.build();
        }
    
        /**
         * 发送 GET 请求(HTTP),不带输入数据
         *
         * @param url
         * @return
         * @throws IOException
         */
        public static String doGet(String url) throws IOException {
            return doGet(url, null);
        }
    
        /**
         * 发送 GET 请求(HTTP),K-V形式
         * 
         * @param url
         * @param params
         * @return
         * @throws IOException
         */
        public static String doGet(String url, Map<String, String> params) throws IOException {
            int i = 0;
            if (params != null) {
                StringBuffer param = new StringBuffer();
                for (String key : params.keySet()) {
                    if (i == 0)
                        param.append("?");
                    else
                        param.append("&");
                    param.append(key).append("=").append(params.get(key));
                    i++;
                }
                url += param;
            }
            String result = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            CloseableHttpResponse response = null;
            HttpEntity entity = null;
            try {
                HttpGet httpGet = new HttpGet(url);
                response = httpclient.execute(httpGet);
                // int statusCode = response.getStatusLine().getStatusCode();
    
                entity = response.getEntity();
                if (entity != null) {
                    InputStream instream = entity.getContent();
                    result = IOUtils.toString(instream, UTF_8);
                }
            } finally {
                // 最后别忘了关闭应该关闭的资源,适当的释放资源
                try {
                    // 这个方法也可以把底层的流给关闭了
                    EntityUtils.consume(entity);
                    // if (null != response) {
                    // response.close();
                    // }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    
        /**
         * 发送 POST 请求(HTTP),不带输入数据
         * 
         * @param apiUrl
         * @return
         * @throws ConnectTimeoutException
         */
        public static String doPost(String apiUrl) throws IOException {
            return doPost(apiUrl, new HashMap<String, String>());
        }
    
        /**
         * 发送 POST 请求(HTTP),K-V形式
         * 
         * @param apiUrl API接口URL
         * @param params 参数map
         * @return
         * @throws ConnectTimeoutException
         */
        public static String doPost(String apiUrl, Map<String, String> params) throws IOException {
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String httpStr = null;
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
    
            try {
                httpPost.setConfig(requestConfig);
                List<NameValuePair> pairList = new ArrayList<>(params.size());
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
                    pairList.add(pair);
                }
                httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
                response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                httpStr = EntityUtils.toString(entity, "UTF-8");
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
    
        /**
         * 发送 POST 请求(HTTP),JSON形式
         * 
         * @param apiUrl
         * @param content 内容
         * @return
         * @throws IOException
         */
        public static String doPost(String apiUrl, String content, String type) throws IOException {
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String httpStr = null;
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
    
            try {
                httpPost.setConfig(requestConfig);
                StringEntity stringEntity = new StringEntity(content, "UTF-8");// 解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                if (JSON.equals(type)) {
                    stringEntity.setContentType("application/json");
                } else if (XML.equals(type)) {
                    stringEntity.setContentType("application/xml");
                } else {
                    stringEntity.setContentType("text/plain");
                }
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                // System.out.println(response.getStatusLine().getStatusCode());
                httpStr = EntityUtils.toString(entity, "UTF-8");
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
        public static String doPost(String apiUrl, String content, String type,Map<String, String> headers) throws IOException {
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String httpStr = null;
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
    
            try {
                httpPost.setConfig(requestConfig);
                if (headers != null) {
                    for (String headerName : headers.keySet()) {
                        httpPost.setHeader(headerName, headers.get(headerName));
                    }
                }
                StringEntity stringEntity = new StringEntity(content, "UTF-8");// 解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                if (JSON.equals(type)) {
                    stringEntity.setContentType("application/json");
                } else if (XML.equals(type)) {
                    stringEntity.setContentType("application/xml");
                } else {
                    stringEntity.setContentType("text/plain");
                }
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                // System.out.println(response.getStatusLine().getStatusCode());
                httpStr = EntityUtils.toString(entity, "UTF-8");
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
    
        /**
         * 发送 SSL POST 请求(HTTPS),K-V形式
         * 
         * @param apiUrl API接口URL
         * @param params 参数map
         * @return
         */
        public static String doPostSSL(String apiUrl, Map<String, Object> params) {
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr)
                    .setDefaultRequestConfig(requestConfig).build();
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
            String httpStr = null;
    
            try {
                httpPost.setConfig(requestConfig);
                List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue().toString());
                    pairList.add(pair);
                }
                httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));
                response = httpClient.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    return null;
                }
                HttpEntity entity = response.getEntity();
                if (entity == null) {
                    return null;
                }
                httpStr = EntityUtils.toString(entity, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
    
        /**
         * 发送 SSL POST 请求(HTTPS),JSON形式
         * 
         * @param apiUrl API接口URL
         * @param json JSON对象
         * @return
         */
        public static String doPostSSL(String apiUrl, Object json) {
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr)
                    .setDefaultRequestConfig(requestConfig).build();
            HttpPost httpPost = new HttpPost(apiUrl);
            CloseableHttpResponse response = null;
            String httpStr = null;
    
            try {
                httpPost.setConfig(requestConfig);
                StringEntity stringEntity = new StringEntity(json.toString(), "UTF-8");// 解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                stringEntity.setContentType("application/json");
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    return null;
                }
                HttpEntity entity = response.getEntity();
                if (entity == null) {
                    return null;
                }
                httpStr = EntityUtils.toString(entity, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                        response.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
    
        /**
         * 创建SSL安全连接
         *
         * @return
         */
        private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
            SSLConnectionSocketFactory sslsf = null;
            try {
                SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
    
                    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                        return true;
                    }
                }).build();
                sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {
    
                    @Override
                    public boolean verify(String arg0, SSLSession arg1) {
                        return true;
                    }
    
                    @Override
                    public void verify(String host, SSLSocket ssl) throws IOException {
                    }
    
                    @Override
                    public void verify(String host, X509Certificate cert) throws SSLException {
                    }
    
                    @Override
                    public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                    }
                });
            } catch (GeneralSecurityException e) {
                e.printStackTrace();
            }
            return sslsf;
        }
    
        /**
         * 发送 SSL POST 请求(HTTPS),加载证书
         * 
         * @param apiUrl API接口URL
         * @param json JSON对象
         * @return
         */
        public static String doPostSSL(String url, String content, String type, Map<String, String> headers, SSLConnectionSocketFactory sslsf) {
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr)
                    .setDefaultRequestConfig(requestConfig).build();
            HttpPost httpPost = new HttpPost(url);
            CloseableHttpResponse response = null;
            String httpStr = null;
    
            try {
                httpPost.setConfig(requestConfig);
                if (headers != null) {
                    for (String headerName : headers.keySet()) {
                        httpPost.setHeader(headerName, headers.get(headerName));
                    }
                }
                StringEntity stringEntity = new StringEntity(content, "UTF-8");// 解决中文乱码问题
                stringEntity.setContentEncoding("UTF-8");
                if (JSON.equals(type)) {
                    stringEntity.setContentType("application/json");
                } else if (XML.equals(type)) {
                    stringEntity.setContentType("application/xml");
                } else {
                    stringEntity.setContentType("text/plain");
                }
                httpPost.setEntity(stringEntity);
                response = httpClient.execute(httpPost);
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    return null;
                }
                HttpEntity entity = response.getEntity();
                if (entity == null) {
                    return null;
                }
                httpStr = EntityUtils.toString(entity, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        EntityUtils.consume(response.getEntity());
                        response.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return httpStr;
        }
    
    }
    
    展开全文
  • C#开发核心代码,用拼接XML方式,调用封装了实体类的SOAP接口
  • Springboot统一封装Http响应内容实战
  • c# http请求封装

    千次阅读 2018-07-16 10:29:31
    看到别人写的代码copy一下,作为备份。 /// /// Restful客户端 /// public class RESTClient ... HttpResponseMessage hrm = httpClient.PutAsync(strUrl, content).Result; entity.StatusCode ...
  • C++ 封装curl 的http

    2016-08-09 19:05:41
    用C++ 封装curl 的http
  • 微信小程序HTTP接口请求封装

    万次阅读 热门讨论 2018-05-16 19:56:46
    最近在学习小程序的编写,需要调用后端接口,经常要用到wx.request方法,所以就自己封装了一下,简化一下代码,如果能给大家提供帮助更好,我的项目后端是使用的Java SSM框架,wx.request的URL就是后端提供的接口。...
  • api的接口封装

    2020-10-07 18:34:55
    对vue项目中api接口封装管理 : 在src下创建network文件夹。network文件夹下创建api.js和http.js。 http.js主要用来统一管理项目http文件夹下api请求,主要用来方便管理接口。 在vue项目中,和后台交互获取数据这块...
  • 举个列子:某电商平台要测试交易过程,测试人员通过手机app测试,需要完成以下动作:用户登录、进入店铺、选择商品、提交订单、支付...,而数据工厂可以把这一系列操作封装成一个http接口,这个http接口 只需要传...
  • 从事Android开发久了不可避免的会接触对外接口封装,下面本人就以自己写过的一个例子系统讲讲怎样对应用sdk的开发。 1.封装 我们在与其他公司合作的时候,往往会有技术方面的协作,但我们又不想过多的暴露...
  • 接口请求封装

    2021-01-05 22:26:13
    接口请求封装 访问一个接口,通常有get、post、put、delete方式 封装这些方法,需要注意三大要点: 请求方法:method 请求地址:url 请求参数:params,data,json 首先,定义一个类,处理HTTP请求,在这个类中,...
  • uniApp 请求接口封装

    千次阅读 2020-06-05 17:49:47
    引入示例 async register(data) { let [err, res] = await this.$http.post('/userCt/login', { //请求账号密码登录接口 password: this.password, userName: this.mobile }); // 这里是错误的回调...
  • uniapp接口封装和使用

    千次阅读 2021-01-15 09:54:24
    const BASE_URL = 'http://192.168.110.188:8001' //后端给的url export const myRequest = (options) => { return new Promise((resolve,reject)=> { let authtoken = uni.getStorageSync('authtoken...
  • 五分钟为HTTP接口提供Java/Scala SDK

    千次阅读 2016-03-23 21:45:16
    因为不想引入Yarn的client包,所以使用了他的Http接口。那么如何调用这个HTTP接口便是一个问题了 Case描述我现在要使用yarn的两个接口,一个是application 列表,一个是根据appId获取这个app的详情。对应的接口大约...
  • SSH封装接口返回Json数据

    热门讨论 2014-03-26 15:09:17
    SSH封装接口返回Json数据 数据库是Mysql

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 463,323
精华内容 185,329
关键字:

http接口封装