org.apache.httpcomponents.httpclient

apache org doc :http://hc.apache.org/httpcomponents-client-ga/tutorial/html/fundamentals.html#d5e49

依赖：

<!--  https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.5</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.4.1</version>
</dependency>

<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.3</version>
</dependency>

<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.1</version>
</dependency>

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;

import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.log4j.Logger;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;
import org.apache.http.HttpStatus;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpDemo {
    private static Logger LOGGER = Logger.getLogger(HttpDemo.class);
    private static CloseableHttpResponse response;
    private static HttpEntity entity;

    /**
     * this is ssl ignore https CloseableClient
     */
    static CloseableHttpClient sslIgnoreClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        CloseableHttpClient client = null;
        SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {

            public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                return true;
            }
        }).build();
        client = HttpClients.custom().setSSLContext(sslContext).setSSLHostnameVerifier(new NoopHostnameVerifier()).build();

        return client;
    }

    /**
     * http get method
     */
    static String doGet(String url, Map<Object, Object> header) throws KeyStoreException, IOException,
            KeyManagementException, NoSuchAlgorithmException {
        String result = null;  // initialize result
        CloseableHttpClient request = sslIgnoreClient();
        HttpGet msg = new HttpGet(url);
        if (header != null) {
            header.forEach((key, value) -> {
                msg.addHeader(key.toString(), value.toString());
            });

        }
        response = request.execute(msg);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            entity = response.getEntity();
            result = EntityUtils.toString(entity, "UTF-8");
        }
        return result;
    }

    /**
     * String body is json type
     */
    static String doPost(String url, String body, Map<Object, Object> header) throws KeyStoreException, IOException,
            KeyManagementException, NoSuchAlgorithmException {
        String result = null;
        CloseableHttpClient request = sslIgnoreClient();
        HttpPost msg = new HttpPost(url);
        if (header != null) {
            header.forEach((key, value) -> {
                msg.addHeader(key.toString(), value.toString());
            });
        }
        msg.setEntity(new StringEntity(body));
        response = request.execute(msg);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            entity = response.getEntity();
            result = EntityUtils.toString(entity, "UTF-8");
        }
        return result;
    }

    /**
     * do post form-data
     */
    static String doPostParam(String url, Map<Object, Object> header, Map<Object, Object> params) throws KeyStoreException, IOException,
            KeyManagementException, NoSuchAlgorithmException {
        String result = null;
        CloseableHttpClient request = sslIgnoreClient();
        HttpPost msg = new HttpPost();
        if (header != null) {
            header.forEach((key, value) -> {
                msg.addHeader(key.toString(), value.toString());
            });
        }
        List<BasicNameValuePair> paramList = new ArrayList<>();
        params.forEach((key, value) -> {
            paramList.add(new BasicNameValuePair(key.toString(), value.toString()));
        });
        HttpEntity formEntity = new UrlEncodedFormEntity(paramList, "utf-8");
        msg.setEntity(formEntity);
        response = request.execute(msg);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            entity = response.getEntity();
            result = EntityUtils.toString(entity, "UTF-8");
        }
        return result;
    }

    /**
     * do  upload and download operation
     */
    static String postFileImage(String url, Map<Object, Object> textBody, List<String> fileList, Map<Object, Object> header, int ttl) throws KeyStoreException, IOException,
            KeyManagementException, NoSuchAlgorithmException {
        String result = null;
        CloseableHttpClient request = sslIgnoreClient();
        HttpPost msg = new HttpPost();
        //msg.setHeader(key,value);
        if (header != null) {
            header.forEach((key, value) -> {
                msg.addHeader(key.toString(), value.toString());
            });
        }
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(ttl).setSocketTimeout(ttl).build();
        msg.setConfig(requestConfig);
        MultipartEntityBuilder builder = MultipartEntityBuilder.create();

        fileList.forEach(item -> {
            File f = new File(item);
            try {
                builder.addBinaryBody(
                        "file",
                        new FileInputStream(f),
                        ContentType.APPLICATION_OCTET_STREAM,
                        f.getName()
                );
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        });

        textBody.forEach((key, value) -> {
            builder.addTextBody(String.valueOf(key), String.valueOf(value), ContentType.TEXT_PLAIN);
        });

        msg.setEntity(builder.build());
        response = request.execute(msg);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            entity = response.getEntity();
            long length = entity.getContentLength();
            byte[] res = null;
            res = EntityUtils.toByteArray(entity);
            result = new String(res, StandardCharsets.UTF_8);
        }

        return result;

    }

}