HttpClient介紹和簡單使用流程

HttpClient

SpringCloud中服務和服務之間的調用全部是使用HttpClient，還有前面使用SolrJ中就封裝了HttpClient，在調用SolrTemplate的saveBean方法時就調用HttpClient技術。

當前大部分項目暴漏出來的接口是Http請求，數據格式是JSON格式，但在一些老項目使用的仍然是webService。

HttpClient 提供的主要的功能

（1）實現了所有 HTTP 的方法（GET,POST,PUT,DELETE 等）

（2）支持自動轉向

（3）支持 HTTPS 協議

（4）支持代理服務器等

1、關於Http的請求類型(常見)

get、put、post、delete含義與區別

1、GET請求會向數據庫發索取數據的請求，從而來獲取信息，該請求就像數據庫的select操作一樣，只是用來查詢一下數據，不會修改、增加數據，不會影響資源的內容，即該請求不會產生副作用。無論進行多少次操作，結果都是一樣的。

2、與GET不同的是，PUT請求是向服務器端發送數據的，從而改變信息，該請求就像數據庫的update操作一樣，用來修改數據的內容，但是不會增加數據的種類等，也就是說無論進行多少次PUT操作，其結果並沒有不同。

3、POST請求同PUT請求類似，都是向服務器端發送數據的，但是該請求會改變數據的種類等資源，就像數據庫的insert操作一樣，會創建新的內容。幾乎目前所有的提交操作都是用POST請求的。

4、DELETE請求顧名思義，就是用來刪除某一個資源的，該請求就像數據庫的delete操作。

就像前面所講的一樣，既然PUT和POST操作都是向服務器端發送數據的，那么兩者有什么區別呢。。。POST主要作用在一個集合資源之上的（url），而PUT主要作用在一個具體資源之上的（url/xxx），通俗一下講就是，如URL可以在客戶端確定，那么可使用PUT，否則用POST。

數據請求格式

綜上所述，我們可理解為以下：

1、POST    /url      創建  
2、DELETE /url/xxx 刪除  
3、PUT     /url/xxx 更新
4、GET     /url/xxx 查看

2、HttpClient的請求類型

實現了所有的Http請求類型，相應的類為

HttpGet、HttpPost、HttpDelete、HttpPut

3、Http的使用流程

3.1 創建sms的war子模塊

3.2 導入坐標

<dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>
    </dependencies>

 

3.3 測試demo，原生HttpClient使用

3.3.1 新建HttpClientGetTest.java測試類，測試get請求

public static void main(String[] args) throws IOException {
        //1.打開瀏覽器
        CloseableHttpClient httpClient = HttpClients.createDefault();
        //2.聲明get請求
        HttpGet httpGet = new HttpGet("http://www.baidu.com/s?wd=java");
        //3.發送請求
        CloseableHttpResponse response = httpClient.execute(httpGet);
        //4.判斷狀態碼
        if(response.getStatusLine().getStatusCode()==200){
            HttpEntity entity = response.getEntity();
           //使用工具類EntityUtils，從響應中取出實體表示的內容並轉換成字符串
            String string = EntityUtils.toString(entity, "utf-8");
            System.out.println(string);
        }
        //5.關閉資源
        response.close();
        httpClient.close();
    }

3.3.2 新建HttpClientPostTest.java測試類，測試post請求

public static void main(String[] args) throws IOException {
        //1.打開瀏覽器
        CloseableHttpClient httpClient = HttpClients.createDefault();
        //2.聲明get請求
        HttpPost httpPost = new HttpPost("https://www.oschina.net/");
        //3.開源中國為了安全，防止惡意攻擊，在post請求中都限制了瀏覽器才能訪問
        httpPost.addHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36");
        //4.判斷狀態碼
        List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);
        parameters.add(new BasicNameValuePair("scope", "project"));
        parameters.add(new BasicNameValuePair("q", "java"));

        UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters,"UTF-8");

        httpPost.setEntity(formEntity);

        //5.發送請求
        CloseableHttpResponse response = httpClient.execute(httpPost);

        if(response.getStatusLine().getStatusCode()==200){
            HttpEntity entity = response.getEntity();
            String string = EntityUtils.toString(entity, "utf-8");
            System.out.println(string);
        }
        //6.關閉資源
        response.close();
        httpClient.close();
    }

 

3.3.3 測試獲取運營商品牌數據代碼實現

自定義工具類HttpClientUtil如果能直接訪問，簡單的訪問實現。

//設置請求地址
HttpClientUtil util=new HttpClientUtil("http://localhost:9101/brand/findAll.do");
//設置請求方式
util.get();
//獲取返回內容
String content=util.getContent();
//打印結果
System.out.println("content");

 

使用HttpClientUtil實現先登錄在訪問頁面

要點：務必保證登錄和查詢請求是連續的請求。借助的自定義工具類HttpClientUtil

public class HttpClientTest {
    public static void main(String[] args) {
        //設置用戶名和密碼
        Map<String, String> map = new HashMap<String,String>();
        map.put("username", "admin");
        map.put("password", "123456");

        //需要先通過springSecurity認證
        String s1 = HttpClientUtil.doPost("http://localhost:9101/login", map);

        Map<String, String> brand = new HashMap<String,String>();
        brand.put("name", "123456");
        brand.put("firstChar", "T");

        String jsonMap = JSON.toJSONString(brand);
        System.out.println(jsonMap);
        String s2 = HttpClientUtil.doPostJson("http://localhost:9101/brand/add.do", jsonMap);

        //String s2 = HttpClientUtil.doGet("http://localhost:9101/brand/findAll.do");
        System.out.println(s2);
    }
}

 

自定義工具類源碼HttpClientUtil。注意導入的依賴

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.text.ParseException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
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;

/**
 * http請求客戶端
 * 
 * @author Administrator
 * 
 */
public class HttpClientUtil {

    public  static HttpClientContext context = null;

    static {
        System.out.println("====================begin");
        context = HttpClientContext.create();
    }

    private String url;
    private Map<String, String> param;
    private int statusCode;
    private String content;
    private String xmlParam;
    private boolean isHttps;

    public boolean isHttps() {
        return isHttps;
    }

    public void setHttps(boolean isHttps) {
        this.isHttps = isHttps;
    }

    public String getXmlParam() {
        return xmlParam;
    }

    public void setXmlParam(String xmlParam) {
        this.xmlParam = xmlParam;
    }

    public HttpClientUtil(String url, Map<String, String> param) {
        this.url = url;
        this.param = param;
    }

    public HttpClientUtil(String url) {
        this.url = url;
    }

    public void setParameter(Map<String, String> map) {
        param = map;
    }

    public void addParameter(String key, String value) {
        if (param == null)
            param = new HashMap<String, String>();
        param.put(key, value);
    }

    public void post() throws ClientProtocolException, IOException {
        HttpPost http = new HttpPost(url);
        setEntity(http);
        execute(http);
    }

    public void put() throws ClientProtocolException, IOException {
        HttpPut http = new HttpPut(url);
        setEntity(http);
        execute(http);
    }

    public void get() throws ClientProtocolException, IOException {
        if (param != null) {
            StringBuilder url = new StringBuilder(this.url);
            boolean isFirst = true;
            for (String key : param.keySet()) {
                if (isFirst)
                    url.append("?");
                else
                    url.append("&");
                url.append(key).append("=").append(param.get(key));
            }
            this.url = url.toString();
        }
        HttpGet http = new HttpGet(url);
        execute(http);
    }

    /**
     * set http post,put param
     */
    private void setEntity(HttpEntityEnclosingRequestBase http) {
        if (param != null) {
            List<NameValuePair> nvps = new LinkedList<NameValuePair>();
            for (String key : param.keySet())
                nvps.add(new BasicNameValuePair(key, param.get(key))); // 參數
            http.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8)); // 設置參數
        }
        if (xmlParam != null) {
            http.setEntity(new StringEntity(xmlParam, Consts.UTF_8));
        }
    }

    private void execute(HttpUriRequest http) throws ClientProtocolException,
            IOException {
        CloseableHttpClient httpClient = null;
        try {
            if (isHttps) {
                SSLContext sslContext = new SSLContextBuilder()
                        .loadTrustMaterial(null, new TrustStrategy() {
                            // 信任所有
                            public boolean isTrusted(X509Certificate[] chain,
                                    String authType)
                                    throws CertificateException {
                                return true;
                            }
                        }).build();
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                        sslContext);
                httpClient = HttpClients.custom().setSSLSocketFactory(sslsf)
                        .build();
            } else {
                httpClient = HttpClients.createDefault();
            }
            CloseableHttpResponse response = httpClient.execute(http,context);
            try {
                if (response != null) {
                    if (response.getStatusLine() != null)
                        statusCode = response.getStatusLine().getStatusCode();
                    HttpEntity entity = response.getEntity();
                    // 響應內容
                    content = EntityUtils.toString(entity, Consts.UTF_8);
                }
            } finally {
                response.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            httpClient.close();
        }
    }

    public int getStatusCode() {
        return statusCode;
    }

    public String getContent() throws ParseException, IOException {
        return content;
    }
}