精华内容
下载资源
问答
  • http请求封装

    2019-05-08 09:04:39
    封装了一下java 的http请求工具类要求jdk版本在1.8及以上
  • 微信小程序 http请求封装 示例代码 wx.request({ url: 'test.php', //仅为示例,并非真实的接口地址 data: { x: '' , y: '' }, method:'POST', header: { 'content-type': 'application/json' }, ...
  • 主要介绍了php实现的http请求封装,结合实例形式分析了php基于curl的http请求操作功能实现技巧与使用方法,需要的朋友可以参考下
  • c#Http请求封装类库.rar

    2021-01-14 22:18:43
    http的get,post请求,都已封装好,并且,无视https证书,非常好用
  • 主要介绍了nodejs实现的http、https 请求封装操作,结合实例形式分析了node.js针对http、https 请求的封装与使用相关操作技巧,需要的朋友可以参考下
  • 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;
        }
    
    }
    
    展开全文
  • 主要介绍了微信小程序HTTP接口请求封装的实现,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 接口调用传入两个参数:post(url, map)简化接口调用代码
  • php中http请求封装HttpClient精华中的经典代码。从国外官网直接下的,看看人家怎么封装的,受益匪浅啊,堪称经典。里边有说明和实例
  • 主要介绍了Java http请求封装工具类代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 【cocos creator】Http 请求封装

    千次阅读 2020-05-14 18:26:06
    * Http 请求封装 */ const HttpHelper = cc.Class({ extends: cc.Component, statics: { }, properties: { }, /** * get请求 * @param {string} url * @param {function} callback .

    https://www.jianshu.com/p/37640cdc3717

    /**
     * Http 请求封装
     */
    const HttpHelper = cc.Class({
        extends: cc.Component,
    
        statics: {
        },
    
        properties: {
    
        },
    
        /**
         * get请求
         * @param {string} url 
         * @param {function} callback 
         */
        httpGet(url, callback) {
            cc.myGame.gameUi.onShowLockScreen();
            let xhr = cc.loader.getXMLHttpRequest();
            xhr.onreadystatechange = function () {
                // cc.log("Get: readyState:" + xhr.readyState + " status:" + xhr.status);
                if (xhr.readyState === 4 && xhr.status == 200) {
                    let respone = xhr.responseText;
                    let rsp = JSON.parse(respone);
                    cc.myGame.gameUi.onHideLockScreen();
                    callback(rsp);
                } else if (xhr.readyState === 4 && xhr.status == 401) {
                    cc.myGame.gameUi.onHideLockScreen();
                    callback({status:401});
                } else {
                    //callback(-1);
                }
    
    
            };
            xhr.withCredentials = true;
            xhr.open('GET', url, true);
    
            // if (cc.sys.isNative) {
            xhr.setRequestHeader('Access-Control-Allow-Origin', '*');
            xhr.setRequestHeader('Access-Control-Allow-Methods', 'GET, POST');
            xhr.setRequestHeader('Access-Control-Allow-Headers', 'x-requested-with,content-type,authorization');
            xhr.setRequestHeader("Content-Type", "application/json");
            xhr.setRequestHeader('Authorization', 'Bearer ' + cc.myGame.gameManager.getToken());
            // xhr.setRequestHeader('Authorization', 'Bearer ' + "");
            // }
    
            // note: In Internet Explorer, the timeout property may be set only after calling the open()
            // method and before calling the send() method.
            xhr.timeout = 8000;// 8 seconds for timeout
    
            xhr.send();
        },
    
        /**
         * post请求
         * @param {string} url 
         * @param {object} params 
         * @param {function} callback 
         */
        httpPost(url, params, callback) {
            cc.myGame.gameUi.onShowLockScreen();
            let xhr = cc.loader.getXMLHttpRequest();
            xhr.onreadystatechange = function () {
                // cc.log('xhr.readyState=' + xhr.readyState + '  xhr.status=' + xhr.status);
                if (xhr.readyState === 4 && xhr.status == 200) {
                    let respone = xhr.responseText;
                    let rsp = JSON.parse(respone);
                    cc.myGame.gameUi.onHideLockScreen();
                    callback(rsp);
                } else {
                    callback(-1);
                }
            };
            xhr.open('POST', url, true);
            // if (cc.sys.isNative) {
            xhr.setRequestHeader('Access-Control-Allow-Origin', '*');
            xhr.setRequestHeader('Access-Control-Allow-Methods', 'GET, POST');
            xhr.setRequestHeader('Access-Control-Allow-Headers', 'x-requested-with,content-type');
            xhr.setRequestHeader("Content-Type", "application/json");
            xhr.setRequestHeader('Authorization', 'Bearer ' + cc.myGame.gameManager.getToken());
            // }
    
            // note: In Internet Explorer, the timeout property may be set only after calling the open()
            // method and before calling the send() method.
            xhr.timeout = 8000;// 8 seconds for timeout
    
            xhr.send(JSON.stringify(params));
        },
    
        /**
         * 登录专用
         * @param {string} url 
         * @param {object} params 
         * @param {function} callback 
         * @param {string} account 
         * @param {string} password 
         */
        httpPostLogin(url, params, callback, account, password) {
            cc.myGame.gameUi.onShowLockScreen();
            let xhr = cc.loader.getXMLHttpRequest();
            xhr.onreadystatechange = function () {
                // cc.log('xhr.readyState=' + xhr.readyState + '  xhr.status=' + xhr.status);
                if (xhr.readyState === 4 && xhr.status == 200) {
                    let respone = xhr.responseText;
                    let rsp = JSON.parse(respone);
                    cc.myGame.gameUi.onHideLockScreen();
                    callback(rsp);
                } else {
                    callback(-1);
                }
            };
            xhr.open('POST', url, true);
            xhr.setRequestHeader('Access-Control-Allow-Origin', '*');
            xhr.setRequestHeader('Access-Control-Allow-Methods', 'GET, POST');
            xhr.setRequestHeader('Access-Control-Allow-Headers', 'x-requested-with,content-type');
            xhr.setRequestHeader("Content-Type", "application/json");
            let str = account + "@" + password;
            xhr.setRequestHeader('Authorization', 'Basic' + ' ' + window.btoa(str));
    
            xhr.timeout = 8000;// 8 seconds for timeout
    
            xhr.send(JSON.stringify(params));
    
        }
    });
    
    window.HttpHelper = new HttpHelper();
    
    展开全文
  • 封装了一些采用HttpClient发送HTTP请求的方法;httpPOST2方法HttpUtil.post(url, params)需引入jar <dependency> <groupId>...
  • golang http请求封装

    千次阅读 2018-08-09 16:49:30
    http.go package utils import ( "crypto/tls" "encoding/json" "errors" "fmt" "io/ioutil" "net/http" "net/url" "...

    在GOPATH 中创建 utils 文件夹 放置这两个文件

    http.go

    package utils
    
    import (
        "crypto/tls"
        "encoding/json"
        "errors"
        "fmt"
        "io/ioutil"
        "net/http"
        "net/url"
        "strings"
        "sync"
    )
    
    var (
        GET_METHOD    = "GET"
        POST_METHOD   = "POST"
        SENDTYPE_FROM = "from"
        SENDTYPE_JSON = "json"
    )
    
    type HttpSend struct {
        Link     string
        SendType string
        Header   map[string]string
        Body     map[string]string
        sync.RWMutex
    }
    
    func NewHttpSend(link string) *HttpSend {
        return &HttpSend{
            Link:     link,
            SendType: SENDTYPE_FROM,
        }
    }
    
    func (h *HttpSend) SetBody(body map[string]string) {
        h.Lock()
        defer h.Unlock()
        h.Body = body
    }
    
    func (h *HttpSend) SetHeader(header map[string]string) {
        h.Lock()
        defer h.Unlock()
        h.Header = header
    }
    
    func (h *HttpSend) SetSendType(send_type string) {
        h.Lock()
        defer h.Unlock()
        h.SendType = send_type
    }
    
    func (h *HttpSend) Get() ([]byte, error) {
        return h.send(GET_METHOD)
    }
    
    func (h *HttpSend) Post() ([]byte, error) {
        return h.send(POST_METHOD)
    }
    
    func GetUrlBuild(link string, data map[string]string) string {
        u, _ := url.Parse(link)
        q := u.Query()
        for k, v := range data {
            q.Set(k, v)
        }
        u.RawQuery = q.Encode()
        return u.String()
    }
    
    func (h *HttpSend) send(method string) ([]byte, error) {
        var (
            req       *http.Request
            resp      *http.Response
            client    http.Client
            send_data string
            err       error
        )
    
        if len(h.Body) > 0 {
            if strings.ToLower(h.SendType) == SENDTYPE_JSON {
                send_body, json_err := json.Marshal(h.Body)
                if json_err != nil {
                    return nil, json_err
                }
                send_data = string(send_body)
            } else {
                send_body := http.Request{}
                send_body.ParseForm()
                for k, v := range h.Body {
                    send_body.Form.Add(k, v)
                }
                send_data = send_body.Form.Encode()
            }
        }
    
        //忽略https的证书
        client.Transport = &http.Transport{
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        }
    
        req, err = http.NewRequest(method, h.Link, strings.NewReader(send_data))
        if err != nil {
            return nil, err
        }
        defer req.Body.Close()
    
        //设置默认header
        if len(h.Header) == 0 {
            //json
            if strings.ToLower(h.SendType) == SENDTYPE_JSON {
                h.Header = map[string]string{
                    "Content-Type": "application/json; charset=utf-8",
                }
            } else { //form
                h.Header = map[string]string{
                    "Content-Type": "application/x-www-form-urlencoded",
                }
            }
        }
    
        for k, v := range h.Header {
            if strings.ToLower(k) == "host" {
                req.Host = v
            } else {
                req.Header.Add(k, v)
            }
        }
    
        resp, err = client.Do(req)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()
    
        if resp.StatusCode != http.StatusOK {
            return nil, errors.New(fmt.Sprintf("error http code :%d", resp.StatusCode))
        }
    
        return ioutil.ReadAll(resp.Body)
    }
    

     http_test.go

    package utils
    
    import (
    	"testing"
    )
    
    func Test_Get(t *testing.T) {
    	h := NewHttpSend(GetUrlBuild("http://127.0.0.1/test.php", map[string]string{"name": "xiaochuan"}))
    	_, err := h.Get()
    	if err != nil {
    		t.Error("请求错误:", err)
    	} else {
    		t.Log("正常返回")
    	}
    }
    
    func Test_Post(t *testing.T) {
    	h := NewHttpSend("http://127.0.0.1/test.php")
    	h.SetBody(map[string]string{"name": "xiaochuan"})
    	_, err := h.Post()
    	if err != nil {
    		t.Error("请求错误:", err)
    	} else {
    		t.Log("正常返回")
    	}
    }
    
    func Test_Json(t *testing.T) {
    	h := NewHttpSend("http://127.0.0.1/test.php")
    	h.SetSendType("JSON")
    	h.SetBody(map[string]string{"name": "xiaochuan"})
    	_, err := h.Post()
    	if err != nil {
    		t.Error("请求错误:", err)
    	} else {
    		t.Log("正常返回")
    	}
    }
    
    func Benchmark_GET(b *testing.B) {
    	for i := 0; i < b.N; i++ {
    		h := NewHttpSend(GetUrlBuild("http://127.0.0.1/test.php", map[string]string{"name": "xiaochuan"}))
    		_, err := h.Get()
    		if err != nil {
    			b.Error("请求错误:", err)
    		} else {
    			b.Log("正常返回")
    		}
    	}
    }
    

     

    展开全文
  • c# http请求封装

    千次阅读 2018-07-16 10:29:31
    /// 请求GET方法 /// /// <param name="url"></param> /// <returns></returns> public RESTResponseEntity RequestGet(string url) { RESTResponseEntity entity = new RESTResponseEntity(); try { ...

    看到别人写的代码copy一下,作为备份。

    /// <summary>
        /// Restful客户端
        /// </summary>
        public class RESTClient
        {
    
            // 常量
            private const string HEAD_KEY = "Authorization";
            private const string TOKEN_KEY_PREFIX = "SmartTracking";
    
            // Restful访问基地址
            private string baseUrl = string.Empty;
    
            /// <summary>
            /// Restful访问基地址
            /// </summary>
            public string BaseUrl
            {
                get { return baseUrl; }
                set { baseUrl = value; }
            }
    
            // 令牌钥匙
            private string tokenKey = string.Empty;
    
            /// <summary>
            /// 令牌钥匙
            /// </summary>
            public string TokenKey
            {
                set { tokenKey = value; }
            }
    
            // 访问超时时间
            private long timeout;
    
            /// <summary>
            /// 访问超时时间
            /// </summary>
            public long Timeout
            {
                get { return timeout; }
                set { timeout = value; }
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            public RESTClient()
            {
    
            }
    
            /// <summary>
            /// 请求GET方法
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public RESTResponseEntity RequestGet(string url)
            {
                RESTResponseEntity entity = new RESTResponseEntity();
                try
                {
                    HttpClient httpClient = new HttpClient();
                    if(timeout > 0){
                        httpClient.Timeout = TimeSpan.FromMilliseconds(timeout);
                    }
                    httpClient.DefaultRequestHeaders.Add(HEAD_KEY, TOKEN_KEY_PREFIX + " " + tokenKey);
                    string strUrl = baseUrl + url;
                    HttpResponseMessage hrm = httpClient.GetAsync(strUrl).Result;
                    entity.StatusCode = Convert.ToInt32(hrm.StatusCode);
                    entity.Buffer = hrm.Content.ReadAsByteArrayAsync().Result;
                }
                catch (Exception ex)
                {
                    Log.WriteLogFile(ex, "RESTClient RequestGet() Error");
                }
                return entity;
            }
    
            /// <summary>
            /// 请求POST方法
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public RESTResponseEntity RequestPOST(string url,List<KeyValuePair<string, string>> paras)
            {
                RESTResponseEntity entity = new RESTResponseEntity();
                HttpClient httpClient = null;
                FormUrlEncodedContent content = null;
                HttpResponseMessage hrm = null;
                try
                {
                    httpClient = new HttpClient();
                    if (timeout > 0)
                    {
                        httpClient.Timeout = TimeSpan.FromMilliseconds(timeout);
                    }
                    httpClient.DefaultRequestHeaders.Add(HEAD_KEY, TOKEN_KEY_PREFIX + " "+ tokenKey);
                    content = new FormUrlEncodedContent(paras);
                    string strUrl = baseUrl + url;
                    hrm = httpClient.PostAsync(strUrl, content).Result;
                    entity.StatusCode = Convert.ToInt32(hrm.StatusCode);
                    entity.Buffer = hrm.Content.ReadAsByteArrayAsync().Result;
                    httpClient.Dispose();
                }
                catch (Exception ex)
                {
                    Log.WriteLogFile(ex, "RESTClient RequestPOST() Error");
                    //Console.WriteLine("RESTClient RequestPOST():" + ex.Message);
                }
                if (httpClient != null)
                {
                    httpClient.Dispose();
                    httpClient = null;
                }
                if (content != null)
                {
                    content.Dispose();
                    content = null;
                }
                if (hrm != null)
                {
                    hrm.Dispose();
                    hrm = null;
                }
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                return entity;
            }
            /// <summary>
            /// 请求POST方法
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public RESTResponseEntity RequestMulPOST(string url, List<KeyValuePair<string, string>> paras)
            {
                RESTResponseEntity entity = new RESTResponseEntity();
                HttpClient httpClient = null;
                FormUrlEncodedContent content = null;
                MultipartFormDataContent mulcontnt = null;
                HttpResponseMessage hrm = null;
                try
                {
                    httpClient = new HttpClient();
                    if (timeout > 0)
                    {
                        httpClient.Timeout = TimeSpan.FromMilliseconds(timeout);
                    }
                    httpClient.DefaultRequestHeaders.Add(HEAD_KEY, TOKEN_KEY_PREFIX + " " + tokenKey);
                    content = new FormUrlEncodedContent(paras);
                    mulcontnt = new MultipartFormDataContent();
                    string strUrl = baseUrl + url;
                    hrm = httpClient.PostAsync(strUrl, content).Result;
                    entity.StatusCode = Convert.ToInt32(hrm.StatusCode);
                    entity.Buffer = hrm.Content.ReadAsByteArrayAsync().Result;
                    httpClient.Dispose();
                }
                catch (Exception ex)
                {
                    Log.WriteLogFile(ex, "RESTClient RequestPOST() Error");
                    //Console.WriteLine("RESTClient RequestPOST():" + ex.Message);
                }
                if (httpClient != null)
                {
                    httpClient.Dispose();
                    httpClient = null;
                }
                if (content != null)
                {
                    content.Dispose();
                    content = null;
                }
                if (hrm != null)
                {
                    hrm.Dispose();
                    hrm = null;
                }
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                return entity;
            }
    
            /// <summary>
            /// 请求PUT方法
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public RESTResponseEntity RequestPUT(string url, List<KeyValuePair<string, string>> paras)
            {
                RESTResponseEntity entity = new RESTResponseEntity();
                try
                {
                    HttpClient httpClient = new HttpClient();
                    if (timeout > 0)
                    {
                        httpClient.Timeout = TimeSpan.FromMilliseconds(timeout);
                    }
                    httpClient.DefaultRequestHeaders.Add(HEAD_KEY, TOKEN_KEY_PREFIX + " " + tokenKey);
                    FormUrlEncodedContent content = new FormUrlEncodedContent(paras);
                    string strUrl = baseUrl + url;
                    HttpResponseMessage hrm = httpClient.PutAsync(strUrl, content).Result;
                    entity.StatusCode = Convert.ToInt32(hrm.StatusCode);
                    entity.Buffer = hrm.Content.ReadAsByteArrayAsync().Result;
                }
                catch (Exception ex)
                {
                    Log.WriteLogFile(ex, "RESTClient RequestPUT() Error");
                }
                return entity;
            }
    
            /// <summary>
            /// 请求DELETE方法
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public RESTResponseEntity RequestDELETE(string url)
            {
                RESTResponseEntity entity = new RESTResponseEntity();
                try
                {
                    HttpClient httpClient = new HttpClient();
                    if (timeout > 0)
                    {
                        httpClient.Timeout = TimeSpan.FromMilliseconds(timeout);
                    }
                    httpClient.DefaultRequestHeaders.Add(HEAD_KEY, TOKEN_KEY_PREFIX + " " + tokenKey);
                    string strUrl = baseUrl + url;
                    HttpResponseMessage hrm = httpClient.DeleteAsync(strUrl).Result;
                    entity.StatusCode = Convert.ToInt32(hrm.StatusCode);
                    entity.Buffer = hrm.Content.ReadAsByteArrayAsync().Result;
                }
                catch (Exception ex)
                {
                    Log.WriteLogFile(ex, "RESTClient RequestDELETE() Error");
                }
                return entity;
            }
        }

    展开全文
  • Unity http请求封装(www)

    千次阅读 2017-09-06 19:10:32
    项目中需要经常访问后台,以任何需求都只写一遍代码的想法决定对www进行一下封装,目的即是让程序在每个访问后台的入口保持唯一,同时可以自己定制回调函数,处理每一个访问http请求: 首先看了其他网友的文章,...
  • 3.HTTP请求工具类 package com.yarm.common.http; import com.alibaba.fastjson.JSONObject; import com.yarm.common.pojo.HttpClientResult; import org.apache.http.HttpStatus; import org.apache....
  • vue cli3的http请求封装

    千次阅读 2019-04-23 15:55:47
    import Cookies from 'js-cookie' const TokenKey ...'请重新请求!' , duration : 5000 } ) ; return Promise . reject ( error ) } ) export default request
  • 需求:在一个页面有三个及多个请求,请求的数据很多都是重复的,让整个页面看起来很臃肿,那个这个时候我们可以对其相似的代码进行抽离;
  • * 封装了post请求的方法: * 1.使用了异步AsyncTask + Handler的处理模式; * 2.适用于仅仅一条数据的请求,最大的优势在于:能够同时适用于多条数据的请求,并保证数据不出现紊乱; * 3.这里面也同时使用了 * ...
  • Qt--Http请求封装(Get Post)

    万次阅读 2016-09-19 20:18:59
    qt为我们继承了一些网络操作的类,因此不...今天就跟大家分享一下qt中对http请求封装。其中用到了: QNetworkRequest The QNetworkRequest class holds a request to be sent with QNetworkAccessManager. http://
  • Springboot统一封装Http响应内容实战
  • C# http Get/POST请求封装

    热门讨论 2014-08-29 16:34:40
    C# http Get/POST请求封装
  • Java模拟Http请求封装工具类

    万次阅读 2020-06-29 16:54:27
    封装一个简单的Http请求工具类,主要方便设置代理请求,无需额外框架 1、需要引入的jar包 <!-- 简化代码getter setter --> <dependency> <groupId>org.projectlombok</groupId> <...
  • 建立http.js文件 在/src/utils/目录下建立一个htttp.js 1.首先导入axios和router。 import axios from 'axios'; import router from '../router'; 2.接着设置axios请求参数。 axios.defaults.timeout = 5000; //...
  • Cocos Creator Http请求封装

    千次阅读 2019-07-01 16:35:54
    /** * Http 请求封装 */ const HttpHelper = cc.Class({ extends: cc.Component, statics: { }, properties: { }, /** * get请求 * @param {string} url * @param {functi...
  • guzzlehttp请求封装

    千次阅读 2018-10-18 20:21:47
    guzzlehttp请求封装 /** * 发送请求 * https://guzzle-cn.readthedocs.io/zh_CN/latest/quickstart.html * * @param string $url * @param array $params * @param string $method * @pa...
  • 最近抽空学习了一下Angular6,之前主要使用的是vue,所以免不了的也想对Angular6提供的工具进行一些封装,今天主要就跟大家讲一下这个http模块。 之前使用的ajax库是axios,可以设置baseurl,公共头部;集中捕捉错误...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 438,494
精华内容 175,397
关键字:

http请求封装