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

二、特性

基于标准、纯净的java语言。实现了Http1.0和Http1.1
以可扩展的面向对象的结构实现了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）。
支持HTTPS协议。
通过Http代理建立透明的连接。
利用CONNECT方法通过Http代理建立隧道的https连接。
Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos认证方案。
插件式的自定义认证方案。
便携可靠的套接字工厂使它更容易的使用第三方解决方案。
连接管理器支持多线程应用。支持设置最大连接数，同时支持设置每个主机的最大连接数，发现并关闭过期的连接。
自动处理Set-Cookie中的Cookie。
插件式的自定义Cookie策略。
Request的输出流可以避免流中内容直接缓冲到socket服务器。
Response的输入流可以有效的从socket服务器直接读取相应内容。
在http1.0和http1.1中利用KeepAlive保持持久连接。
直接获取服务器发送的response code和 headers。
设置连接超时的能力。
实验性的支持http1.1 response caching。
源代码基于Apache License 可免费获取。

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

创建HttpClient对象。
创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HttpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。
调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。
调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
释放连接。无论执行方法是否成功，都必须释放连接

相关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介绍的相关文章

Linux下的TCP&UDP通信作业

题目描述一对于TCP传输实现客户端发送某特定信息字符时结束信息传输断开连接二编写程序验证在同一台机器上TCP和UDP能不能同时占用同一个端口进行通信开始编程使用vim创建并编辑几个源文件 vim TCPserver c v
关于搭建简易广域网私人通信程序（python）一步到位！

原料 python3 腾讯云服务器用到的库 socket sys threading time pyinstaller 除pyinstaller外均不需单独安装首先默认已经买好云服务器且安装好了python3 此处使用腾讯云服务器
OSI 五层网络模型详解

OSI网络模型是指开放式系统互联通信参考模型英语 Open System Interconnection Reference Model 缩写为 OSI 简称为OSI模型 OSI model 一种概念模型由ISO 国际标准化组织提
Connectify Hotspot，让你的电脑变成WIFI热点！！

http www ttrar com html Connectify Hotspot Professional html down 我使用的是破解版
Cisco Packet Tracer 实验：生成树配置

实验目的 1 理解广播风暴的成因 2 掌握STP和RSTP原理及配置方法实验内容实验描述学校为了开展计算机教学和网络办公建立的一个计算机教室和一个校办公区这两处的计算机网络通过两台交换机互联组成内部校园网为了提高网络的可靠性作
Linux学习笔记-----网络编程套接字

目录一概念一端口号概念二套接字概念三套接字 socket 编程接口四 sockaddr结构五网络字节序二基于UDP的相关理解一 UDP协议二编写简单的UDP服务端和客户端三小结三基于TCP的相关理解
C#常用代码

最近学习用C 写了几个程序记录一下常用的几个操作方便以后Copy 文件操作 FileStream fs null try byte buf FileStream fs new FileStream strSampleFileName F
中兴网络设备交换机路由器检查调试信息是否关闭命令方法

描述中兴网络设备交换机路由器检查调试信息是否关闭命令方法命令 show debug
面试了这么多场，“ 进程间的通信 ” 真是从不缺席，小伙伴们赶快重视起来！！

进程间通信 1 管道 2 消息队列 3 共享内存 4 信号量 5 信号 6 Socket 套接字每个进程的用户地址空间都是独立的一般而言是不能互相访问的但内核空间是每个进程都共享的所以进程之间要通信必须通过内核在内核中开辟一块缓冲
什么是节点光端机？总线型光端机有哪些优势？

节点式光端机又称总线型光端机其准确的定义是采用单双纤链路式组网形式的图像传输系统也被称为链路式光端机那么节点式光端机具体是什么呢总线型光端机又有哪些优势呢接下来我们就跟随飞畅科技的小编一起来详细了解下吧什么是节点光端机节点
socket通讯相互发送读取xml实例

首先了解下socket通讯传输数据的特点数据在网络传输时使用的都是字节流或字符流 Socket也不例外所以我们发送数据的时候需要转换为字节发送读取的时候也是以字节为单位读取那么问题就在于socket通讯时接收方并不知道此次数据有多
Ubuntu 16.04.1 LTS下安装FreeRADIUS2.2.8并开启MySQL认证

更新系统 sudo apt update sudo apt upgrade 安装MariaDB sudo apt get install software properties common sudo apt key adv recv ke
嵌入式编写TCP连接过程

先来一个三次握手和四次挥手嵌入式连接过程 1 af 为地址族 Address Family 也就是 IP 地址类型常用的有 AF INET 和 AF INET6 AF 是 Address Family 的简写 INET是 Inetnet
王道考研计算机网络第二章--物理层

目录 2 1通信基础 2 1 1物理层基本概念 1物理层基本概念 2 1 2数据通信基础知识 1典型的数据通信模型 2数据通信相关术语 3三种通信方式 4两种数据传输方式 2 1 3码元波特速率带宽 1码元 2速率波特带宽 2 1
关于非同一局域网下两台设备之间的网络通信（服务器的作用）

看过很多关于局域网下的两台设备之间的通信方式最多的就是通过socket进行tcp ip通信建立一个服务端再建立一个客户端客户端向服务端发起请求连接然后再进行两端的通信但发现其实这却存在着很多的问题与不足如果是不在同一局域网下的
Wireshark抓包解释说明

Wireshark与对应的OSI七层模型 TCP三次握手 TCP三次握手的理论知识 wireshark三次握手对应的报文情况图中可以看到wireshark截获到了三次握手的三个数据包第四个包才是HTTP的这说明HTTP的确是使用TCP
The remote endpoint was in state [TEXT_FULL_WRITING]

使用websocket出现的坑 The remote endpoint was in state TEXT FULL WRITING which is an invalid state for called method websocket
TSN协议之冗余协议——IEEE 802.1 CB

在车载通信领域我们时常面临一个困惑要是通信线路异常断开了怎么办这里的异常断开不仅指物理上的断开也可能是受电磁干扰等导致线路通信功能的异常等解决此类问题一个显而易见的解决方案就是增加冗余路径即把数据传输2 N份以进行备份这样就
【详解】静态Web服务器搭建代码实现_Python

目录 1 浏览器网络请求流程 2 搭建python自带静态web服务器 2 1 静态web服务器开发流程 2 2 返回指定页面 2 3 多任务版服务器 2 4 面向对象服务端 3 动态端口 1 浏览器网络请求流程浏览器首先链接DNS服务器
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

HttpClient介绍

HttpClient介绍 的相关文章

随机推荐

热门标签

HttpClient介绍的相关文章