HttpClient介绍

2023-11-16

本文内容整理自:
https://blog.csdn.net/w372426096/article/details/82713315

HttpClient相比传统JDK自带的URLConnection,增加了易用性和灵活性,它不仅使客户端发送Http请求变得容易,而且也方便开发人员测试接口(基于Http协议的),提高了开发的效率,也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容,掌握HttpClient后,相信对于Http协议的了解会更加深入。

org.apache.commons.httpclient.HttpClient与org.apache.http.client.HttpClient的区别

Commons的HttpClient项目现在是生命的尽头,不再被开发, 已被Apache HttpComponents项目HttpClient和HttpCore 模组取代,提供更好的性能和更大的灵活性。

一、简介
HttpClient是Apache Jakarta Common下的子项目,用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包,并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中,比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。

下载地址: http://hc.apache.org/downloads.cgi

二、特性

  1. 基于标准、纯净的java语言。实现了Http1.0和Http1.1

  2. 以可扩展的面向对象的结构实现了Http全部的方法(GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE)。

  3. 支持HTTPS协议。

  4. 通过Http代理建立透明的连接。

  5. 利用CONNECT方法通过Http代理建立隧道的https连接。

  6. Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos认证方案。

  7. 插件式的自定义认证方案。

  8. 便携可靠的套接字工厂使它更容易的使用第三方解决方案。

  9. 连接管理器支持多线程应用。支持设置最大连接数,同时支持设置每个主机的最大连接数,发现并关闭过期的连接。

  10. 自动处理Set-Cookie中的Cookie。

  11. 插件式的自定义Cookie策略。

  12. Request的输出流可以避免流中内容直接缓冲到socket服务器。

  13. Response的输入流可以有效的从socket服务器直接读取相应内容。

  14. 在http1.0和http1.1中利用KeepAlive保持持久连接。

  15. 直接获取服务器发送的response code和 headers。

  16. 设置连接超时的能力。

  17. 实验性的支持http1.1 response caching。

  18. 源代码基于Apache License 可免费获取。

三、使用方法
使用HttpClient发送请求、接收响应很简单,一般需要如下几步即可。

  1. 创建HttpClient对象。

  2. 创建请求方法的实例,并指定请求URL。如果需要发送GET请求,创建HttpGet对象;如果需要发送POST请求,创建HttpPost对象。

  3. 如果需要发送请求参数,可调用HttpGet、HttpPost共同的setParams(HttpParams params)方法来添加请求参数;对于HttpPost对象而言,也可调用setEntity(HttpEntity entity)方法来设置请求参数。

  4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求,该方法返回一个HttpResponse。

  5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头;调用HttpResponse的getEntity()方法可获取HttpEntity对象,该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

  6. 释放连接。无论执行方法是否成功,都必须释放连接

相关jar包

commons-cli-1.2.jar
commons-codec-1.9.jar
commons-logging-1.2.jar
fluent-hc-4.5.1.jar
httpclient-4.5.1.jar
httpclient-cache-4.5.1.jar
httpclient-win-4.5.1.jar
httpcore-4.4.3.jar
httpcore-ab-4.4.3.jar
httpcore-nio-4.4.3.jar
httpmime-4.5.1.jar
jna-4.1.0.jar
jna-platform-4.1.0.jar
最简单post请求, 源自 http://my.oschina.net/xinxingegeya/blog/282683

import java.io.FileInputStream;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Properties;  
   
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
   
public class First {  
    public static void main(String[] args) throws Exception{  
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
        formparams.add(new BasicNameValuePair("account", ""));  
        formparams.add(new BasicNameValuePair("password", ""));  
        HttpEntity reqEntity = new UrlEncodedFormEntity(formparams, "utf-8");  
    
        RequestConfig requestConfig = RequestConfig.custom()  
        .setConnectTimeout(5000)//一、连接超时:connectionTimeout-->指的是连接一个url的连接等待时间  
                .setSocketTimeout(5000)// 二、读取数据超时:SocketTimeout-->指的是连接上一个url,获取response的返回等待时间  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpClient client = new DefaultHttpClient();  
        HttpPost post = new HttpPost("http://cnivi.com.cn/login");  
        post.setEntity(reqEntity);  
        post.setConfig(requestConfig);  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity resEntity = response.getEntity();  
            String message = EntityUtils.toString(resEntity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("请求失败");  
        }  
    }  
 }  

四、实例
主文件

import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.UnsupportedEncodingException;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.cert.CertificateException;  
import java.util.ArrayList;  
import java.util.List;  
import javax.net.ssl.SSLContext;  
import org.apache.http.HttpEntity;  
import org.apache.http.NameValuePair;  
import org.apache.http.ParseException;  
import org.apache.http.client.ClientProtocolException;  
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.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContexts;  
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;  
import org.apache.http.entity.ContentType;  
import org.apache.http.entity.mime.MultipartEntityBuilder;  
import org.apache.http.entity.mime.content.FileBody;  
import org.apache.http.entity.mime.content.StringBody;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
import org.apache.http.client.config.RequestConfig;  
import org.junit.Test;  
public class HttpClientTest {  
  //方法见下........  
}  

HttpClientUtils工具类

package com.bobo.code.web.controller.technology.httpcomponents;  
    
import org.apache.http.HttpEntity;  
import org.apache.http.HttpHost;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.methods.HttpUriRequest;  
import org.apache.http.client.methods.RequestBuilder;  
import org.apache.http.conn.routing.HttpRoute;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClientBuilder;  
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;  
    
import java.io.IOException;  
import java.util.*;  
    
public class HttpClientUtils {  
    
    private static PoolingHttpClientConnectionManager connectionManager = null;  
    private static HttpClientBuilder httpBuilder = null;  
    private static RequestConfig requestConfig = null;  
    
    private static int MAXCONNECTION = 10;  
    
    private static int DEFAULTMAXCONNECTION = 5;  
    
    private static String IP = "cnivi.com.cn";  
    private static int PORT = 80;  
    
    static {  
        //设置http的状态参数  
        requestConfig = RequestConfig.custom()  
                .setSocketTimeout(5000)  
                .setConnectTimeout(5000)  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpHost target = new HttpHost(IP, PORT);  
        connectionManager = new PoolingHttpClientConnectionManager();  
        connectionManager.setMaxTotal(MAXCONNECTION);//客户端总并行链接最大数  
        connectionManager.setDefaultMaxPerRoute(DEFAULTMAXCONNECTION);//每个主机的最大并行链接数  
        connectionManager.setMaxPerRoute(new HttpRoute(target), 20);  
        httpBuilder = HttpClients.custom();  
        httpBuilder.setConnectionManager(connectionManager);  
    }  
    
    public static CloseableHttpClient getConnection() {  
        CloseableHttpClient httpClient = httpBuilder.build();  
        return httpClient;  
    }  
    
    
    public static HttpUriRequest getRequestMethod(Map<String, String> map, String url, String method) {  
        List<NameValuePair> params = new ArrayList<NameValuePair>();  
        Set<Map.Entry<String, String>> entrySet = map.entrySet();  
        for (Map.Entry<String, String> e : entrySet) {  
            String name = e.getKey();  
            String value = e.getValue();  
            NameValuePair pair = new BasicNameValuePair(name, value);  
            params.add(pair);  
        }  
        HttpUriRequest reqMethod = null;  
        if ("post".equals(method)) {  
            reqMethod = RequestBuilder.post().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        } else if ("get".equals(method)) {  
            reqMethod = RequestBuilder.get().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        }  
        return reqMethod;  
    }  
    
    public static void main(String args[]) throws IOException {  
        Map<String, String> map = new HashMap<String, String>();  
        map.put("account", "");  
        map.put("password", "");  
    
        HttpClient client = getConnection();  
        HttpUriRequest post = getRequestMethod(map, "http://cnivi.com.cn/login", "post");  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity entity = response.getEntity();  
            String message = EntityUtils.toString(entity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("请求失败");  
        }  
    }  
}  

get方式

/** 
     * 发送 get请求 
     */   
    public void get() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            // 创建httpget.     
            HttpGet httpget = new HttpGet("http://www.baidu.com/");   
            System.out.println("executing request " + httpget.getURI());   
            // 执行get请求.     
            CloseableHttpResponse response = httpclient.execute(httpget);   
            try {   
                // 获取响应实体     
                HttpEntity entity = response.getEntity();   
                System.out.println("--------------------------------------");   
                // 打印响应状态     
                System.out.println(response.getStatusLine());   
                if (entity != null) {   
                    // 打印响应内容长度     
                    System.out.println("Response content length: " + entity.getContentLength());   
                    // 打印响应内容     
                    System.out.println("Response content: " + EntityUtils.toString(entity));   
                }   
                System.out.println("------------------------------------");   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (ParseException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 关闭连接,释放资源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    } 

post方式

/** 
     * 发送 post请求访问本地应用并根据传递参数不同返回不同结果 
     */   
    public void post() {   
        // 创建默认的httpClient实例.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 创建httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 创建参数队列     
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();   
        formparams.add(new BasicNameValuePair("type", "house"));   
        UrlEncodedFormEntity uefEntity;   
        try {   
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");   
            httppost.setEntity(uefEntity);   
            System.out.println("executing request " + httppost.getURI());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                HttpEntity entity = response.getEntity();   
                if (entity != null) {   
                    System.out.println("--------------------------------------");   
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));   
                    System.out.println("--------------------------------------");   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (UnsupportedEncodingException e1) {   
            e1.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 关闭连接,释放资源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }  

post方式乱码补充

如果有乱码,可以偿试使用 StringEntity 来替换HttpEntity:

StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName(“UTF-8”));// 第二个参数,设置后才会对,内容进行编码
content.setContentType(“application/soap+xml; charset=UTF-8”);
content.setContentEncoding(“UTF-8”);
httppost.setEntity(content);
具体SOAP协议代码如下:

 package com.isoftstone.core.service.impl;  
      
    import java.io.BufferedReader;  
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileReader;  
    import java.io.IOException;  
    import java.io.InputStreamReader;  
    import java.nio.charset.Charset;  
    import java.util.Scanner;  
      
    import org.apache.http.HttpEntity;  
    import org.apache.http.HttpResponse;  
    import org.apache.http.client.ClientProtocolException;  
    import org.apache.http.client.HttpClient;  
    import org.apache.http.client.entity.EntityBuilder;  
    import org.apache.http.client.methods.HttpPost;  
    import org.apache.http.entity.ContentType;  
    import org.apache.http.entity.StringEntity;  
    import org.apache.http.impl.client.HttpClients;  
    import org.apache.http.util.EntityUtils;  
    import org.apache.log4j.Logger;  
    import org.jdom.Document;  
    import org.jdom.Element;  
      
    import com.isoftstone.core.common.constant.RequestConstants;  
    import com.isoftstone.core.common.tools.XmlTool;  
    import com.isoftstone.core.service.intf.ServiceOfStringPara;  
    /** 
     * 
     * 
     */  
    public class DeloittePricingSingleCarImpl implements ServiceOfStringPara {  
        private  String serviceUrl = "http://10.30.0.35:7001/ZSInsUW/Auto/PricingService";  
      
        private static Logger log = Logger.getLogger(DeloittePricingSingleCarImpl.class.getName());  
      
        public String invoke(String sRequest) {  
              
            StringBuffer soapRequestData = new StringBuffer();  
            soapRequestData.append("<soapenv:Envelope");  
            soapRequestData.append("  xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" ");  
            soapRequestData.append("  xmlns:prov=\"http://provider.webservice.zsins.dtt.com/\">");  
            soapRequestData.append(" <soapenv:Header/> ");  
            soapRequestData.append("<soapenv:Body>");  
            soapRequestData.append("<prov:executePrvPricing>");  
            soapRequestData.append("<arg0>");  
            soapRequestData.append("<![CDATA[" + sRequest + "]]>");  
            soapRequestData.append("</arg0>");  
            soapRequestData.append("</prov:executePrvPricing>");  
            soapRequestData.append(" </soapenv:Body>");  
            soapRequestData.append("</soapenv:Envelope>");  
      
            HttpClient httpclient = HttpClients.createDefault();  
            HttpPost httppost = new HttpPost(serviceUrl);  
      
            StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数,设置后才会对,内容进行编码  
            content.setContentType("application/soap+xml; charset=UTF-8");  
            content.setContentEncoding("UTF-8");  
            httppost.setEntity(content);  
              
            //用下面的服务器端以UTF-8接收到的报文会乱码,原因未知  
    //        HttpEntity reqEntity = EntityBuilder.create().setContentType(  
    //                ContentType.TEXT_PLAIN) // .TEXT_PLAIN  
    //                .setText(soapRequestData.toString()).build();  
    //        httppost.setEntity(reqEntity);  
    //        httppost.addHeader("Content-Type",  
    //                "application/soap+xml; charset=utf-8");  
            HttpResponse response = null;  
            Document doc = null;  
            String returnXml = null;  
            String sentity = null;  
            try {  
                response = httpclient.execute(httppost);  
                HttpEntity resEntity = response.getEntity();  
                if (resEntity != null) {  
                    sentity = EntityUtils.toString(resEntity, "UTF-8");  
                    doc = XmlTool.getDocument(sentity, RequestConstants.ENCODE);  
                    System.out.println(doc.toString());  
                    Element eRoot = doc.getRootElement();  
                    Element body = eRoot.getChild("Body", eRoot.getNamespace());  
                    Element resp = (Element) body.getChildren().get(0);  
                    Element returnele = resp.getChild("return");  
                    returnXml = returnele.getText().toString();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                log.info("发送给系统的请求报文:\n" + soapRequestData.toString());  
                log.info("系统返回的响应报文:\n" + sentity);  
                log.info("返回给核心的的报文:\n" + returnXml);  
            }  
            return returnXml;  
        }  
          
          
        public String getServiceUrl() {  
            return serviceUrl;  
        }  
      
      
        public void setServiceUrl(String serviceUrl) {  
            this.serviceUrl = serviceUrl;  
        }  
      
      
        public static void main(String[] args) throws Exception{  
            File file = new File("D:/test.txt");  
            System.out.println(file.exists());  
              
            String temp2 = null;  
            StringBuilder sb2 = new StringBuilder();  
            InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");  
            BufferedReader br = new BufferedReader(isr);  
            temp2 = br.readLine();  
              
            while( temp2 != null ){  
                sb2.append(temp2);  
                temp2 = br.readLine();  
            }  
            String sss = sb2.toString();  
    //        System.out.println(sss.toString());  
            new DeloittePricingSingleCarImpl().invoke(sss);  
        }  
    }  

post提交表单

/** 
     * post方式提交表单(模拟用户登录请求) 
     */   
    public void postForm() {   
        // 创建默认的httpClient实例.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 创建httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 创建参数队列     
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();   
        formparams.add(new BasicNameValuePair("username", "admin"));   
        formparams.add(new BasicNameValuePair("password", "123456"));   
        UrlEncodedFormEntity uefEntity;   
        try {   
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");   
            httppost.setEntity(uefEntity);   
            System.out.println("executing request " + httppost.getURI());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                HttpEntity entity = response.getEntity();   
                if (entity != null) {   
                    System.out.println("--------------------------------------");   
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));   
                    System.out.println("--------------------------------------");   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (UnsupportedEncodingException e1) {   
            e1.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 关闭连接,释放资源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }  

文件上传

/** 
     * 上传文件 
     */   
    public void upload() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");   
     
            FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));   
            StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);   
     
            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();   
     
            httppost.setEntity(reqEntity);   
     
            System.out.println("executing request " + httppost.getRequestLine());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                System.out.println("----------------------------------------");   
                System.out.println(response.getStatusLine());   
                HttpEntity resEntity = response.getEntity();   
                if (resEntity != null) {   
                    System.out.println("Response content length: " + resEntity.getContentLength());   
                }   
                EntityUtils.consume(resEntity);   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    } 

ssl连接

/** 
     * HttpClient连接SSL 
     */   
    public void ssl() {   
        CloseableHttpClient httpclient = null;   
        try {   
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());   
            FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));   
            try {   
                // 加载keyStore d:\\tomcat.keystore     
                trustStore.load(instream, "123456".toCharArray());   
            } catch (CertificateException e) {   
                e.printStackTrace();   
            } finally {   
                try {   
                    instream.close();   
                } catch (Exception ignore) {   
                }   
            }   
            // 相信自己的CA和所有自签名的证书   
            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();   
            // 只允许使用TLSv1协议   
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,   
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);   
            httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();   
            // 创建http请求(get方式)   
            HttpGet httpget = new HttpGet("https://localhost:8443/myDemo/Ajax/serivceJ.action");   
            System.out.println("executing request" + httpget.getRequestLine());   
            CloseableHttpResponse response = httpclient.execute(httpget);   
            try {   
                HttpEntity entity = response.getEntity();   
                System.out.println("----------------------------------------");   
                System.out.println(response.getStatusLine());   
                if (entity != null) {   
                    System.out.println("Response content length: " + entity.getContentLength());   
                    System.out.println(EntityUtils.toString(entity));   
                    EntityUtils.consume(entity);   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ParseException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } catch (KeyManagementException e) {   
            e.printStackTrace();   
        } catch (NoSuchAlgorithmException e) {   
            e.printStackTrace();   
        } catch (KeyStoreException e) {   
            e.printStackTrace();   
        } finally {   
            if (httpclient != null) {   
                try {   
                    httpclient.close();   
                } catch (IOException e) {   
                    e.printStackTrace();   
                }   
            }   
        }   
    }   

关于RequestConfig的配置:
源自:

http://segmentfault.com/a/1190000000587944

http://blog.csdn.net/walkerjong/article/details/51710945

public void requestConfig(){  
//      新建一个RequestConfig:  
        RequestConfig defaultRequestConfig = RequestConfig.custom()  
            //一、连接目标服务器超时时间:ConnectionTimeout-->指的是连接一个url的连接等待时间  
            .setConnectTimeout(5000)  
            //二、读取目标服务器数据超时时间:SocketTimeout-->指的是连接上一个url,获取response的返回等待时间  
            .setSocketTimeout(5000)  
            //三、从连接池获取连接的超时时间:ConnectionRequestTimeout  
            .setConnectionRequestTimeout(5000)  
            .build();  
           
//      这个超时可以设置为客户端级别,作为所有请求的默认值:  
        CloseableHttpClient httpclient = HttpClients.custom()  
            .setDefaultRequestConfig(defaultRequestConfig)  
            .build();  
//       httpclient.execute(httppost);的时候可以让httppost直接享受到httpclient中的默认配置.  
           
//      Request不会继承客户端级别的请求配置,所以在自定义Request的时候,需要将客户端的默认配置拷贝过去:  
        HttpGet httpget = new HttpGet("http://www.apache.org/");  
        RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig)  
            .setProxy(new HttpHost("myotherproxy", 8080))  
            .build();  
        httpget.setConfig(requestConfig);  

// httpget可以单独地使用新copy的requestConfig请求配置,不会对别的request请求产生影响
}
httpGet或httpPost 的abort()和releaseConnection()差异

//httpPost.abort();//中断请求,接下来可以开始另一段请求,所以个人理应,用这个应该可以在session中虚拟登录
//httpPost.releaseConnection();//释放请求.如果释放了相当于要清空session
可知模拟登录可以如下: 源自 http://bbs.csdn.net/topics/390195343

package com.bms.core;  
     
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
     
import org.apache.http.Consts;  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
     
import com.bms.util.CommonUtil;  
     
public class Test2 {  
     
    /** 
     * @param args 
     * @throws IOException 
     * @throws ClientProtocolException 
     */  
    public static void main(String[] args) throws ClientProtocolException, IOException {  
        DefaultHttpClient httpclient = new DefaultHttpClient();  
     
         HttpGet httpGet = new HttpGet("http://www.baidu.com");  
         String body = "";  
         HttpResponse response;  
         HttpEntity entity;  
         response = httpclient.execute(httpGet);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);//这个就是页面源码了  
         httpGet.abort();//中断请求,接下来可以开始另一段请求  
         System.out.println(body);  
         //httpGet.releaseConnection();//释放请求.如果释放了相当于要清空session  
         //以下是post方法  
         HttpPost httpPost = new HttpPost("http://www.baidu.com");//一定要改成可以提交的地址,这里用百度代替  
         List <NameValuePair> nvps = new ArrayList <NameValuePair>();  
         nvps.add(new BasicNameValuePair("name", "1"));//名值对  
         nvps.add(new BasicNameValuePair("account", "xxxx"));  
         httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
         response = httpclient.execute(httpPost);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);  
         System.out.println("Login form get: " + response.getStatusLine());//这个可以打印状态  
         httpPost.abort();  
         System.out.println(body);  
         httpPost.releaseConnection();  
    }  
     
}  

源自 http://blog.csdn.net/wangpeng047/article/details/19624529#reply

其它相关资料: 非CloseableHttpClient HTTPClient模块的HttpGet和HttpPost

HttpClient 4.3教程

httpclient异常情况分析

我项目中用到的HttpClientUtil (2016/12/17)

package com.isoftstone.pcis.isc.util;  
  
import java.io.IOException;  
import java.io.InterruptedIOException;  
import java.net.UnknownHostException;  
  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLHandshakeException;  
  
import org.apache.http.HttpEntityEnclosingRequest;  
import org.apache.http.HttpRequest;  
import org.apache.http.NoHttpResponseException;  
import org.apache.http.client.HttpRequestRetryHandler;  
import org.apache.http.client.protocol.HttpClientContext;  
import org.apache.http.config.Registry;  
import org.apache.http.config.RegistryBuilder;  
import org.apache.http.conn.ConnectTimeoutException;  
import org.apache.http.conn.socket.ConnectionSocketFactory;  
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;  
import org.apache.http.conn.socket.PlainConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
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.protocol.HttpContext;  
import com.isoftstone.pcis.isc.util.ProperUtil;  
  
public class HttpClientUtil {  
      
    private static CloseableHttpClient httpclient = null;   
      
    static final int maxTotal=Integer.valueOf(ProperUtil.get("maxTotal")).intValue();//总最大连接数  
    static final int defaultMaxPerRoute=Integer.valueOf(ProperUtil.get("corePoolSize")).intValue();//每条线路最大连接数 = 本系统核心线程数 , 这样永远不会超过最大连接  
      
     public static CloseableHttpClient getHttpClient() {  
              
            if (null == httpclient) {  
                synchronized (HttpClientUtil.class) {  
                    if (null == httpclient) {  
                        httpclient = getNewHttpClient();  
                    }  
                }  
            }  
              
            return httpclient;  
        }  
       
       private static CloseableHttpClient getNewHttpClient() {  
  
            
            // 设置连接池  
            ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();  
            LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();  
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();  
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);  
            // 配置最大连接数  
            cm.setMaxTotal(maxTotal);  
            // 配置每条线路的最大连接数  
            cm.setDefaultMaxPerRoute(defaultMaxPerRoute);  
              
            // 请求重试处理  
            HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {  
                @Override  
                public boolean retryRequest(IOException exception,  
                        int executionCount, HttpContext context) {  
                    if (executionCount >= 2) {// 如果已经重试了2次,就放弃  
                        return false;  
                    }  
                    if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接,那么就重试  
                        return true;  
                    }  
                    if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常  
                        return false;  
                    }  
                    if (exception instanceof InterruptedIOException) {// 超时  
                        return false;  
                    }  
                    if (exception instanceof UnknownHostException) {// 目标服务器不可达  
                        return false;  
                    }  
                    if (exception instanceof ConnectTimeoutException) {// 连接被拒绝  
                        return false;  
                    }  
                    if (exception instanceof SSLException) {// SSL握手异常  
                        return false;  
                    }  
  
                    HttpClientContext clientContext = HttpClientContext.adapt(context);  
                    HttpRequest request = clientContext.getRequest();  
                      
                    if (!(request instanceof HttpEntityEnclosingRequest)) {  
                        return true;  
                    }  
                    return false;  
                }  
  
            };  
              
            CloseableHttpClient newHttpclient=null;  
          
                newHttpclient = HttpClients.custom()  
                                           .setConnectionManager(cm)  
//                                           .setDefaultRequestConfig(requestConfig)  
                                           .setRetryHandler(httpRequestRetryHandler)  
                                           .build();  
                  
             return newHttpclient;  
       }  
}  

我自己整理的HttpClientTool

package com.isoftstone.core.util;  
  
import java.io.IOException;  
import java.io.InterruptedIOException;  
import java.net.UnknownHostException;  
  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLHandshakeException;  
  
import org.apache.http.HttpEntityEnclosingRequest;  
import org.apache.http.HttpHost;  
import org.apache.http.HttpRequest;  
import org.apache.http.NoHttpResponseException;  
import org.apache.http.client.HttpRequestRetryHandler;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.protocol.HttpClientContext;  
import org.apache.http.config.Registry;  
import org.apache.http.config.RegistryBuilder;  
import org.apache.http.conn.ConnectTimeoutException;  
import org.apache.http.conn.routing.HttpRoute;  
import org.apache.http.conn.socket.ConnectionSocketFactory;  
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;  
import org.apache.http.conn.socket.PlainConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
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.protocol.HttpContext;  
  
/** 
 * org.apache.http.impl.client.CloseableHttpClient链接池生成工具 
 * @reference http://www.cnblogs.com/whatlonelytear/articles/4835538.html 
 * @author King 
 * @date 20170601 
 */  
public class HttpClientTool {  
  
    // org.apache.http.impl.client.CloseableHttpClient  
    private static CloseableHttpClient httpclient = null;  
  
    // 这里就直接默认固定了,因为以下三个参数在新建的method中仍然可以重新配置并被覆盖.  
    static final int connectionRequestTimeout = 5000;// ms毫秒,从池中获取链接超时时间  
    static final int connectTimeout = 5000;// ms毫秒,建立链接超时时间  
    static final int socketTimeout = 30000;// ms毫秒,读取超时时间  
  
    // 总配置,主要涉及是以下两个参数,如果要作调整没有用到properties会比较后麻烦,但鉴于一经粘贴,随处可用的特点,就不再做依赖性配置化处理了.  
    // 而且这个参数同一家公司基本不会变动.  
    static final int maxTotal = 500;// 最大总并发,很重要的参数  
    static final int maxPerRoute = 100;// 每路并发,很重要的参数  
  
    // 正常情况这里应该配成MAP或LIST  
    // 细化配置参数,用来对每路参数做精细化处理,可以管控各ip的流量,比如默认配置请求baidu:80端口最大100个并发链接,  
    static final String detailHostName = "http://www.baidu.com";// 每个细化配置之ip(不重要,在特殊场景很有用)  
    static final int detailPort = 80;// 每个细化配置之port(不重要,在特殊场景很有用)  
    static final int detailMaxPerRoute = 100;// 每个细化配置之最大并发数(不重要,在特殊场景很有用)  
  
    public static CloseableHttpClient getHttpClient() {  
        if (null == httpclient) {  
            synchronized (HttpClientTool.class) {  
                if (null == httpclient) {  
                    httpclient = init();  
                }  
            }  
        }  
        return httpclient;  
    }  
  
    /** 
     * 链接池初始化 这里最重要的一点理解就是. 让CloseableHttpClient 一直活在池的世界里, 但是HttpPost却一直用完就消掉. 
     * 这样可以让链接一直保持着. 
     *  
     * @return 
     */  
    private static CloseableHttpClient init() {  
        CloseableHttpClient newHttpclient = null;  
  
        // 设置连接池  
        ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();  
        LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();  
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();  
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);  
        // 将最大连接数增加  
        cm.setMaxTotal(maxTotal);  
        // 将每个路由基础的连接增加  
        cm.setDefaultMaxPerRoute(maxPerRoute);  
  
        // 细化配置开始,其实这里用Map或List的for循环来配置每个链接,在特殊场景很有用.  
        // 将每个路由基础的连接做特殊化配置,一般用不着  
        HttpHost httpHost = new HttpHost(detailHostName, detailPort);  
        // 将目标主机的最大连接数增加  
        cm.setMaxPerRoute(new HttpRoute(httpHost), detailMaxPerRoute);  
        // cm.setMaxPerRoute(new HttpRoute(httpHost2),  
        // detailMaxPerRoute2);//可以有细化配置2  
        // cm.setMaxPerRoute(new HttpRoute(httpHost3),  
        // detailMaxPerRoute3);//可以有细化配置3  
        // 细化配置结束  
  
        // 请求重试处理  
        HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {  
            @Override  
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {  
                if (executionCount >= 2) {// 如果已经重试了2次,就放弃  
                    return false;  
                }  
                if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接,那么就重试  
                    return true;  
                }  
                if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常  
                    return false;  
                }  
                if (exception instanceof InterruptedIOException) {// 超时  
                    return false;  
                }  
                if (exception instanceof UnknownHostException) {// 目标服务器不可达  
                    return false;  
                }  
                if (exception instanceof ConnectTimeoutException) {// 连接被拒绝  
                    return false;  
                }  
                if (exception instanceof SSLException) {// SSL握手异常  
                    return false;  
                }  
  
                HttpClientContext clientContext = HttpClientContext.adapt(context);  
                HttpRequest request = clientContext.getRequest();  
                // 如果请求是幂等的,就再次尝试  
                if (!(request instanceof HttpEntityEnclosingRequest)) {  
                    return true;  
                }  
                return false;  
            }  
        };  
  
        // 配置请求的超时设置  
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();  
        newHttpclient = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();  
        return newHttpclient;  
    }  
} 
package com.alqsoft.utils;
 
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
 
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.CookieSpecs;
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.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.cookie.Cookie;
import org.apache.http.cookie.CookieOrigin;
import org.apache.http.cookie.CookieSpec;
import org.apache.http.cookie.CookieSpecProvider;
import org.apache.http.cookie.MalformedCookieException;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.cookie.BestMatchSpecFactory;
import org.apache.http.impl.cookie.BrowserCompatSpec;
import org.apache.http.impl.cookie.BrowserCompatSpecFactory;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
 
 
public class HttpClientObject {
    private static Log logger = LogFactory.getLog(HttpClientObject.class);
    private CloseableHttpClient httpClient = null;
    private HttpResponse response;
 
    private HttpPost httpPost = null;
 
    private HttpGet httpGet = null;
 
    private String paramKey = "";
 
    private String paramValue = "";
 
    private String responseString;
 
    public void setParamKey(String paramKey) {
        this.paramKey = paramKey;
    }
 
    public void setParamValue(String paramValue) {
        this.paramValue = paramValue;
    }
 
    public String getResponseString() {
        return responseString;
    }
 
    public HttpClientObject() {
        this.getHttpClient();
    }
 
    private List<NameValuePair> getRequestBody() {
        NameValuePair pair1 = new BasicNameValuePair(paramKey, paramValue);
        List<NameValuePair> pairList = new ArrayList<NameValuePair>();
        pairList.add(pair1);
        return pairList;
    }
 
 
    public void submit() {
        try {
            if (httpPost != null) {
                response = httpClient.execute(httpPost);
                httpPost = null;
            }
            if (httpGet != null) {
                response = httpClient.execute(httpGet);
                httpGet = null;
            }
            this.response();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
 
    private void response() {
        String result = "";
        BufferedReader in = null;
        try {
            HttpEntity httpEntity = response.getEntity();
            responseString = EntityUtils.toString(httpEntity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
 
 
    }
 
 
    public void setPost(String httpUrl) {
        try {
            HttpEntity requestHttpEntity = new UrlEncodedFormEntity(this.getRequestBody());
            httpPost = new HttpPost(httpUrl);
            httpPost.addHeader("Content-Type", "”application/json;charset=UTF-8");
            httpPost.setEntity(requestHttpEntity);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
 
 
    public void setGet(String httpUrl) {
        httpGet = new HttpGet(httpUrl);
        httpGet.addHeader("Content-Type", "text/html;charset=UTF-8");
    }
 
 
    private void getHttpClient() {
        BasicCookieStore cookieStore = new BasicCookieStore();
        CookieSpecProvider easySpecProvider = new CookieSpecProvider() {
            public CookieSpec create(HttpContext context) {
 
 
                return new BrowserCompatSpec() {
                    @Override
                    public void validate(Cookie cookie, CookieOrigin origin)
                            throws MalformedCookieException {
// Oh, I am easy
                    }
                };
            }
 
 
        };
        Registry<CookieSpecProvider> r = RegistryBuilder.<CookieSpecProvider>create()
                .register(CookieSpecs.BEST_MATCH, new BestMatchSpecFactory())
                .register(CookieSpecs.BROWSER_COMPATIBILITY, new BrowserCompatSpecFactory())
                .register("easy", easySpecProvider).build();
 
 
        RequestConfig requestConfig = RequestConfig.custom().setCookieSpec("easy")
                .setSocketTimeout(20000).setConnectTimeout(20000).build();
 
 
        httpClient = HttpClients.custom().setDefaultCookieSpecRegistry(r)
                .setDefaultRequestConfig(requestConfig).setDefaultCookieStore(cookieStore).build();
    }
 
 
    /**
     * httpclient发送http get请求;
     *
     * @return
     * @throws URISyntaxException
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String sendGet(String uriPath, List<NameValuePair> ns)
            throws URISyntaxException, ClientProtocolException, IOException {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        URIBuilder uri = new URIBuilder();
        uri.setPath(uriPath);
        uri.addParameters(ns);
        URI u = uri.build();
        HttpGet httpget = new HttpGet(u);
        CloseableHttpResponse response = httpclient.execute(httpget);
        return EntityUtils.toString(response.getEntity());
    }
 
 
    /**
     * httpclient发送http post请求;
     *
     * @return
     * @throws URISyntaxException
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String sendPost(String uriPath, List<NameValuePair> ns)
            throws URISyntaxException, ClientProtocolException, IOException {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        URIBuilder uri = new URIBuilder();
        uri.setPath(uriPath);
        uri.addParameters(ns);
        URI u = uri.build();
        HttpPost httpPost = new HttpPost(u);
        CloseableHttpResponse response = httpclient.execute(httpPost);
        return EntityUtils.toString(response.getEntity());
    }
 
}
 

使用方法如下:

    String signUrl= ”路径“;

    try{
    List<NameValuePair> nameValuePairs=new ArrayList<NameValuePair>();
    nameValuePairs.add(new BasicNameValuePair("phone",phone));
    nameValuePairs.add(new BasicNameValuePair("xytId",String.valueOf(xytId)));
    nameValuePairs.add(new BasicNameValuePair("balance",balance));

    String result=HttpClientObject.sendPost(signUrl,nameValuePairs);
    logger.info("result: = "+result);
    JSONObject jsonObject=JSON.parseObject(result);

    Integer code=Integer.valueOf(jsonObject.getString("code"));
    if(code.equals(0)){
    code1=0L;
    }else if(code.equals(1)){
    code1=1L;
    }else if(code.equals(3)){
    code1=3L;
    }
    }catch(Exception e){
    e.printStackTrace();
    }
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

HttpClient介绍 的相关文章

  • 如何实现前后端交互

    大概流程 首先我们要实现前端的页面 我们要有一个页面来让我们肉眼可以看见 JS的语法我们要掌握 1因为我们要通过JS来绑定事件 比如我们点击按钮就能发送数据给服务器 或者从服务器获取资源 2我们通过ajax请求来实现向服务器发送请求 3通过
  • 网络数据包的抓包(解析数据包内容)

    使用原始套接字接收 recvfrom reav read等 时 可以接收到完整的数据包 数据组装 拆解过程 数字代表上层协议的类型 完整数据包为 传输数据包内容 链路层包头 网络层包头 传输层包头 应用层数据 Ethernet MAC 封包
  • 天线工作原理以及如何计算天线长度

    一 题记 人们的生活离不开手机 手机离不开无线通信 在家我们可以连接路由器 在外我们可以连接基站 不可否认的是我们的手机都是通过无线电波与路由器或者基站的天线相连接 见过很多天线 有室外的 有室内的 有长的 有方的 还有圆的 天线的各种形状
  • STOMP原理与应用开发详解

    本文首发微信公众号 码上观世界 STOMP概述 我们已经知道WebSocket是基于TCP协议之上的应用层协议 在 WebSocket API 中 浏览器和服务器只需要完成一次握手 两者之间就直接可以创建持久性的连接 并进行双向数据传输 W
  • Tcp/Ip四层模型---应用层、传输层、网络层和链路层以及他们的各自的主要工作

    Tcp Ip四层模型 TCP IP 协议栈是一系列网络协议的总和 是构成网络通信的核心骨架 它定义了电子设备如何连入因特网 以及数据如何在它们之间进行传输 TCP IP 协议采用4层结构 分别是应用层 传输层 网络层和链路层 每一层都呼叫它
  • UDP \TCP详详详详解,你想要的全都有(呕心沥血)

    前言 因特网为应用层提供了两种截然不同的可用运输层协议 一个是UDP 用户数据报协议 一个是TCP 传输控制协议 这两种协议无论是在开发过程中 还是面试问答中 都相当重要 先了解两个定义 多路分解 将运输层报文段中的数据交付到正确的套接字
  • python3「非阻塞socket」报错 “BlockingIOError: [Errno 11]“ 复现以及分析解决

    梦想还在 生活当继续 一 前言 linux 下 用 python 的非阻塞 socket 通信时 遇到了 BlockingIOError Errno 11 Resource temporarily unavailable 错误 翻译报错信息
  • 什么是节点光端机?总线型光端机有哪些优势?

    节点式光端机又称总线型光端机 其准确的定义是采用单 双纤链路式组网形式的图像传输系统 也被称为链路式光端机 那么 节点式光端机具体是什么呢 总线型光端机又有哪些优势呢 接下来我们就跟随飞畅科技的小编一起来详细了解下吧 什么是节点光端机 节点
  • 老猿学5G扫盲贴:R15/R16中计费架构和计费原则涉及的规范文档

    专栏 Python基础教程目录 专栏 使用PyQt开发图形界面Python应用 专栏 PyQt入门学习 老猿Python博文目录 老猿学5G博文目录 一 概述 在R16的32 240文档对应规范为3GPP TS 32 240 V16 1 0
  • 移动通信原理B-------例题解答2

    移动通信原理B例题解答2 移动通信原理B 例题解答2 一 题目 若一发射机发射载频为1850Mhz 一辆汽车以每小时72Km h的速度运动 计算在以下情况下接收机的载波频率 1 汽车沿直线朝向发射机运动 2 汽车沿直线背向发射机运动 3 汽
  • [网络通信] 什么是零拷贝?

    什么是零拷贝 文章目录 什么是零拷贝 1 Java 实现应用缓存零拷贝 2 底层零拷贝实现机制 2 1 mmap 2 2 sendfile 2 3 splice 小结 REFERENCES 我们在写一个服务端程序时 Web Server或者
  • 网络通信的整个流程

    1 网络通信流程 你的电脑打开浏览器 访问www baidu com 先将请求信息发给了交换机 然后交给了路由器 路由发给DNS服务器 通过DNS协议去找我们要访问的百度的IP地址 查到的百度服务器对应的IP地址之后 路由器通过路由协议找到
  • 43黑马QT笔记之Qt下Tcp/Udp通信过程

    43黑马QT笔记之Qt下Tcp Udp通信过程 前提 Qt下的网络通信需要加上 QT newwork 模块 1 Qt下Tcp的通信过程 1 共有三个套接字 客户端有一个QTcpServer监听套接字 服务端有两个 分别是QTcpServer
  • 如何选择一款趁手的光纤测试仪

    光纤测试仪是一种用于物理学 电子与通信技术领域的物理性能测试仪器 于1996年11月1日启用 常用光纤测试表有 光功率计 光万用表 稳定光源 光时域反射仪 OTDR 和光故障定位仪 如何选择合适的光纤测试仪 选择光纤测试仪表 一般需考虑以下
  • Python2.7网络通信socket和串口通信serial多线程同时实现

    Python2 7下多线程网络通信socket和串口通信serial同时进行 最近在写网络通信TCP IP读取数据和串口通信读取发送数据 之前写了单线程的然后这次尝试多线程实现 当然我是写的网络通信的服务端 话不多说贴上代码 coding
  • ASN.1的一些理解

    为什么要有ASN 1这个东西 我们知道 像C Java这种高级语言 对于计算机来说都要转化为二进制代码才能识别和操作 这就涉及到序列化和反序列化这两个概念 将一个对象序列化成二进制代码 就可以保存成文本或者利用网络传输到远程 与序列化相对的
  • 关于光纤收发器的一些基本常识介绍

    光纤收发器是网络数据传输中必不可缺少的一种设备 那么 什么是光纤收发器呢 光纤收发器都有什么组成的呢 光纤收发器是怎么分类的呢 光纤收发器有哪些特点呢 光纤收发器在数据传播过程中起到什么作用呢 接下来我们就跟随飞畅科技的小编一起来详细了解下
  • 【详解】静态Web服务器搭建代码实现_Python

    目录 1 浏览器网络请求流程 2 搭建python自带静态web服务器 2 1 静态web服务器开发流程 2 2 返回指定页面 2 3 多任务版服务器 2 4 面向对象服务端 3 动态端口 1 浏览器网络请求流程 浏览器首先链接DNS服务器
  • Java NIO 的前生今世 之二 NIO Channel 小结

    Java NIO Channel 通常来说 所有的 NIO 的 I O 操作都是从 Channel 开始的 一个 channel 类似于一个 stream java Stream 和 NIO Channel 对比 我们可以在同一个 Chan
  • FLUKE DSX-5000 CH线缆测试仪怎么升级到新国标

    FLUKE DSX 5000 CH线缆测试仪怎么升级新标准GB T50312 2016 下面山东朗坤小编带给您FLUKE DSX 5000 CH线缆测试仪升级带有新标准软件的整体步骤 一起来学习吧 升级到5 1之后必须使用Linkware9

随机推荐

  • WAMP环境隐藏PHP文件实际路径和后缀名

    有时候做客户端开发阶段得测试 需要一个模拟服务器的环境 我使用得最顺手得还是WAMP环境 后台给出的api接口的路径千奇百怪 在WAMP环境中如何模拟这些路径呢 如何将某个路径下的PHP文件映射到另一个URL路径下并隐藏PHP文件后缀呢 在
  • MySQL数据库安装实践 Part 1:单实例部署

    1 MySQL的安装方法介绍 当今的互联网企业中 MySQL数据库大多运行在linux系列操作系统 若应用场景不同 版本不同 MySQL数据库的安装方法也会有区别 下面把常见的几种方法介绍给朋友们 1 1 yum rpm方式安装 MySQL
  • 【zookeeper】raft 共识算法 动画演示 网站

    1 概述 地址 https cyberdak github io thesecretlivesofdatacn raft
  • 中国计算机大会CNCC技术论坛

    第十五届中国计算机大会 CNCC2018 将于 2018 年 10 月 25 27 日在杭州国际博览中心举行 本届大会以 大数据推动数字经济 Big Data Drives the Digital Economy 为主题 探讨计算技术领域最
  • Java-String类的常用方法

    Java String类的常用方法 1 常用方法1 int length 返回字符串的长度 return value length char charAt int index 返回某索引处的字符return value index bool
  • 数据库表字段命名规范

    本文是一篇包含了数据库命名 数据库表命名 数据库表字段命名及SQL语言编码的规范文档 针对研发中易产生的问题和常见错误做了一个整理和修改 为日后涉及到数据库相关的研发工作做好准备 一 数据库命名规范 采用26个英文字母 区分大小写 和0 9
  • 有关深度学习的文章

    https zybuluo com hanbingtao note 485480 https tigerneil gitbooks io neural networks and deep learning zh content chapte
  • OrCAD原理图绘制使用操作

    文章目录 工程的创建 原理图整体设置 调用元器件库 常用元器件库调用 key 一些元器件库介绍 key 常用元器件搜索名 自建元器件库 新建元器件库 新建元器件 绘制元器件管脚设置 key Homogeneous和Heterogeneous
  • 数据结构-树

    目录 树 知识框架 一 树的基本概念 1 树的定义 2 基本术语 3 树的性质 二叉树 一 二叉树的概念 1 二叉树的定义 2 特殊的二叉树 3 二叉树的一些性质 4 二叉树的存储结构 1 顺序存储 2 链式存储 二 二叉树的创建和遍历 1
  • 关于 VTK 7.1.0 + python3.X 的 pycharm 开发环境的搭建

    在此记录一下关于关于 VTK 7 1 0 python3 X 的 pycharm 开发环境的搭建中碰到的问题 一 什么是 VTK 以及支持 python 的版本 VTK visualization toolkit 是一个开源的免费软件系统
  • php7.4安装

    php7 4安装 下载安装编译工具 yum groupinstall Development Tools y 安装依赖包 yum y install libxml2 libxml2 devel openssl openssl devel b
  • Spring Security详解

    Spring Security详解 一 系统安全 二 Spring Security简介 三 案例 1 新建模块 2 导入静态资源 3 编写控制器 实现跳转 4 安全功能实现 认证和授权 权限控制和注销 记住我 一 系统安全 在Web开发中
  • ES6知识点总结二:解构赋值

    3 解构赋值 ES6 允许按照一定模式 从数组和对象中提取值 对变量进行赋值 这被称为解构 数组 const courseArr es6 es7 es8 const a courseArr 0 const b courseArr 1 con
  • 2023计算机毕业设计选题推荐——Java项目

    A170 536 springboot新冠物资管理系统 A171 537 基于SSM的社区疫情防控平台 A172 538 ssm民宿预订管理系统 A173 539 ssm网上水果生鲜超市商城 A174 540 ssm线上跳蚤市场平台 A17
  • C++万能头文件#include<bits/stdc++.h>

    include
  • 发放金币(循环)

    分享一下个人思路 如果拿1金币 可以拿1天 2金币拿两天 n金币拿n天 也就是说 我们要拿n金币 从当前的天数开始循环n次 每次拿n 每次拿完之后天数 1 include
  • 微信小程序之获取用户位置权限(拒绝后提醒)

    小编推荐 Fundebug专注于JavaScript 微信小程序 微信小游戏 Node js和Java实时BUG监控 真的是一个很好用的bug监控费服务 众多大佬公司都在使用 微信小程序获取用户当前位置有三个方式 1 wx getLocat
  • Google guava之Table简介说明

    转自 Google guava之Table简介说明 下文笔者讲述guava中Table集合的简介说明 如下所示 guava之Table集合简介 Table集合 用于存储数据表 类似于Map
  • 报错异常:java.lang.NoClassDefFoundError

    一 问题背景 由原先的jdk1 8升级至jdk20 启动项目登录后台出现报错问题 org springframework web util NestedServletException Handler dispatch failed nes
  • HttpClient介绍

    本文内容整理自 https blog csdn net w372426096 article details 82713315 HttpClient相比传统JDK自带的URLConnection 增加了易用性和灵活性 它不仅使客户端发送Ht