HttpClient实例的一些基本方法使用

import org.apache.http.*;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
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.protocol.HttpClientContext;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by zhanghaibin on 2018/6/11.
 */
public class HttpClientTest {

    public static void test1() {
        try {
            HttpClient httpclient = new DefaultHttpClient();
            HttpGet httpget = new HttpGet("http://localhost/");
            HttpResponse response = null;
            response = httpclient.execute(httpget);
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instream = entity.getContent();
                int l;
                byte[] tmp = new byte[2048];
                while ((l = instream.read(tmp)) != -1) {
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // HTTP 请求（Request）
    public static void request() {
        URI uri = null;
        try {
            uri = new URIBuilder()
                    .setScheme("http")
                    .setHost("www.google.com")
                    .setPath("/search")
                    .setParameter("q", "httpclient")
                    .setParameter("btnG", "Google Search")
                    .setParameter("aq", "f")
                    .setParameter("oq", "")
                    .build();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        HttpGet httpget = new HttpGet(uri);
        System.out.println(httpget.getURI());
    }

    // HTTP 响应（Response）
    public static void response() {
        HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1
                , HttpStatus.SC_OK, "OK");
        System.out.println(response.getProtocolVersion());
        System.out.println(response.getStatusLine().getStatusCode());
        System.out.println(response.getStatusLine().getReasonPhrase());
        System.out.println(response.getStatusLine().toString());
    }

    //  处理报文首部（Headers）
    public static void headers() {
        HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK");
        response.addHeader("Set-Cookie", "c1=a; path=/; domain=localhost");
        response.addHeader("Set-Cookie", "c2=b; path=\"/\", c3=c; domain=\"localhost\"");
        Header h1 = response.getFirstHeader("Set-Cookie");
        System.out.println(h1);
        Header h2 = response.getLastHeader("Set-Cookie");
        System.out.println(h2);
        Header[] hs = response.getHeaders("Set-Cookie");
        System.out.println(hs.length);


        // ==============获得所有指定类型首部最有效的方式是使用HeaderIterator接口====================================
        response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK");
        response.addHeader("Set-Cookie", "c1=a; path=/; domain=localhost");
        response.addHeader("Set-Cookie", "c2=b; path=\"/\", c3=c; domain=\"localhost\"");
        HeaderIterator it = response.headerIterator("Set-Cookie");
        while (it.hasNext()) {
            System.out.println(it.next());
        }


        // =============================HttpClient也提供了其他便利的方法吧HTTP报文转化为单个的HTTP元素。=====================================
        response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK");
        response.addHeader("Set-Cookie", "c1=a; path=/; domain=localhost");
        response.addHeader("Set-Cookie", "c2=b; path=\"/\", c3=c; domain=\"localhost\"");
        HeaderElementIterator hei = new BasicHeaderElementIterator(
                response.headerIterator("Set-Cookie"));
        while (hei.hasNext()) {
            HeaderElement elem = hei.nextElement();
            System.out.println(elem.getName() + " = " + elem.getValue());
            NameValuePair[] params = elem.getParameters();
            for (int i = 0; i < params.length; i++) {
                System.out.println(" " + params[i]);
            }
        }
    }

    // HTTP实体（HTTP Entity）
    public static void createEntity() {

        try {
            StringEntity myEntity = new StringEntity("important message",
                    ContentType.create("text/plain", "UTF-8"));
            System.out.println(myEntity.getContentType());
            System.out.println(myEntity.getContentLength());
            System.out.println(EntityUtils.toString(myEntity));
            System.out.println(EntityUtils.toByteArray(myEntity).length);


            // 某些情况，整个响应内容的仅仅一小部分需要被取出，会使消费其他剩余内容的性能代价和连接可重用性代价太高，
            // 这时可以通过关闭响应来终止内容流
            // （例子中可以看出，实体输入流仅仅读取了两个字节，就关闭了响应，也就是按需读取，而不是读取全部响应）
            CloseableHttpClient httpclient = HttpClients.createDefault();
            HttpGet httpget = new HttpGet("http://localhost/");
            CloseableHttpResponse response = httpclient.execute(httpget);
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    InputStream instream = entity.getContent();
                    int byteOne = instream.read();
                    int byteTwo = instream.read();
                    // Do not need the rest
                }
            } finally {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // HTML表单
    public static void createNameValuePair() {
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();
        formparams.add(new BasicNameValuePair("param1", "value1"));
        formparams.add(new BasicNameValuePair("param2", "value2"));
        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams,
                Consts.UTF_8);
        HttpPost httppost = new HttpPost("http://localhost/handler.do");
        httppost.setEntity(entity);
    }

    // 使用内容分块
    public static void useChunked() {
        StringEntity entity = new StringEntity("important message",
                ContentType.create("plain/text", Consts.UTF_8));
        entity.setChunked(true);
        HttpPost httppost = new HttpPost("http://localhost/acrtion.do");
        httppost.setEntity(entity);
    }

    // 响应处理
    public static void handlerResponse() {
        try {
            HttpClient httpclient = new DefaultHttpClient();
            HttpGet httpget = new HttpGet("https://blog.csdn.net/u011179993/article/details/47251909");
            ResponseHandler<byte[]> handler = new ResponseHandler<byte[]>() {
                public byte[] handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
                    HttpEntity entity = response.getEntity();
                    if (entity != null) {
                        ByteArrayOutputStream result = new ByteArrayOutputStream();
                        byte[] buffer = new byte[1024];
                        int length;
                        while ((length = entity.getContent().read(buffer)) != -1) {
                            result.write(buffer, 0, length);
                        }
                        System.out.println(result.toString());
                        return EntityUtils.toByteArray(entity);
                    } else {
                        return null;
                    }
                }
            };

            byte[] response = httpclient.execute(httpget, handler);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //HTTP执行环境
    public static void zhixinghuanjing() {
        try {
            DefaultHttpClient httpclient = new DefaultHttpClient();
            HttpContext localContext = new BasicHttpContext();
            HttpGet httpget = new HttpGet("https://blog.csdn.net/u011179993/article/details/47251909");
            HttpResponse response = httpclient.execute(httpget, localContext);
            HttpHost target = (HttpHost) localContext.getAttribute(
                    ExecutionContext.HTTP_TARGET_HOST);
            System.out.println("Final target: " + target);
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                entity.consumeContent();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 上下文
    public static void context() {
        HttpContext context = new BasicHttpContext();
        context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, new HttpHost("127.0.0.1:8bhb"));

        HttpClientContext clientContext = HttpClientContext.adapt(context);

        HttpHost target = clientContext.getTargetHost();
        HttpRequest request = clientContext.getRequest();
        HttpResponse response = clientContext.getResponse();
        RequestConfig config = clientContext.getRequestConfig();

        System.out.println(target);
        System.out.println(target.getHostName());
        System.out.println(request);
        System.out.println(response);
        System.out.println(config);
    }

    public static void main(String[] args) {
        //test1();
        /*request();
        response();
        headers();
        createEntity();
        createNameValuePair();*/
        //handlerResponse();
        //zhixinghuanjing();
        context();
    }
}