HttpClient

本文参考https://www.cnblogs.com/shirandedan/p/8423521.html 

https://blog.csdn.net/phineas123/article/details/80207136

另外参考的其他的不记得了，如果冒犯请联系我删除。

HttpClient 是Apache 下的项目，可以用来提供高效的支持 HTTP 协议的客户端编程工具包。如果只是需要向Web站点的某个简单页面提交请求并获取服务器响应，HttpURLConnection完全可以胜任。但在绝大部分情况下，Web站点的网页可能没这么简单，这些页面并不是通过一个简单的URL就可访问的，可能需要用户登录而且具有相应的权限才可访问该页面。在这种情况下，就需要涉及Session、Cookie的处理了，如果打算使用HttpURLConnection来处理这些细节，当然也是可能实现的，只是处理起来难度就大了。

　　为了更好地处理向Web站点请求，包括处理Session、Cookie等细节问题，Apache开源组织提供了一个HttpClient项目，看它的名称就知道，它是一个简单的HTTP客户端（并不是浏览器），可以用于发送HTTP请求，接收HTTP响应。但不会缓存服务器的响应，不能执行HTML页面中嵌入的Javascript代码；也不会对页面内容进行任何解析、处理。

　　简单来说，HttpClient就是一个增强版的HttpURLConnection，HttpURLConnection可以做的事情HttpClient全部可以做；HttpURLConnection没有提供的有些功能，HttpClient也提供了，但它只是关注于如何发送请求、接收响应，以及管理HTTP连接。

HttpClient的使用

使用HttpClient发送请求、接收响应，只要如下几步。

　　1.创建HttpClient对象（HttpClients.createDefault()）。

　　2.如果需要发送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对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

HttpClient的get请求

/**
 * @(#)httpclientGet.java, 2019/11/6.
 * <p/>
 * Copyright 2019 Netease, Inc. All rights reserved.
 * NETEASE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.lhh.controller;

/**
 * @author 吕厚厚(wb.lvhouhou @ mesg.corp.netease.com)
 */



import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * HttpClient 的Get请求   无参和有参两种
 */

/**
 * maven依赖：
 *      <dependency>
 *       <groupId>org.apache.httpcomponents</groupId>
 *       <artifactId>httpclient</artifactId>
 *       <version>4.5.2</version>
 *      </dependency>
 *
 *       <dependency>
 *       <groupId>com.alibaba</groupId>
 *       <artifactId>fastjson</artifactId>
 *       <version>1.2.58</version>
 *     </dependency>
 *
 *
 */
public class HttpclientGet1 {

    public static void main(String[] args) {

        /**
         * 1.无参的httpClient的Get请求
         */
        //①利用HttpClients创建HttpClient（CloseableHttpClient）对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String url = "http://www.baidu.com";

        //②构建HttpGet
        //②.1 通过设置请求头headers   ②.1和②.2只能选其一
        HttpGet httpGet = new HttpGet(url);

        //设置了请求header 的参数，如果不需要，可以省略
        HashMap<String, String> headers = new HashMap<>();
        headers.put("Accept", "*/*");
        headers.put("Accept-Encoding", "gzip, deflate, sdch");
        headers.put("Accept-Language", "zh-CN,zh;q=0.8");

        for (Map.Entry m : headers.entrySet()) {
            System.out.println(m.getKey() + "	" + m.getValue());
            httpGet.setHeader(m.getKey().toString(), m.getValue().toString());
        }
        //配置请求超时设置
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(5000) //设置连接超时时间
                .setConnectionRequestTimeout(5000) //  设置连接请求超时时间
                .setSocketTimeout(5000)
                .setRedirectsEnabled(true) //设置自动允许重定向
                .build();
        httpGet.setConfig(requestConfig);
        ////②.2 URIBuilder 设置url并且创建某种请求方式实例
        //        //比如：(在百度上搜索helloworld出现的路径)url：https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0
        //        // &rsv_idx=1&tn=baidu&wd=helloworld&rsv_pq=c6735cf70000fe15
        //        // &rsv_t=7e25dm7uzHpmOwrFNF33FXbom45Px0Bs0F8PP3Bcm8RMOysmKlfA%2FuqKoU4&rqlang=cn
        //        // &rsv_enter=1&rsv_sug3=9&rsv_sug1=5&rsv_sug7=101
        //        //url的构建也可以使用字符串拼接的方式
        //        try {
        //            URI url=new URIBuilder()
        //                    .setScheme("https")//设置协议
        //                    .setHost("www.baidu.com")
        //                    .setPath("/s")
        //                    .setParameter("ie","utf-8")
        //                    .setParameter("rsv_idx","1")
        //                    .setParameter("tn","baidu")
        //                    .setParameter("wd","helloworld")
        //                    .setParameter("rsv_pq","c6735cf70000fe15")
        //                    .setParameter("rsv_t","7e25dm7uzHpmOwrFNF33FXbom45Px0Bs0F8PP3Bcm8RMOysmKlfA%2FuqKoU4")
        //                    .setParameter("rqlang","cn")
        //                    .setParameter("rsv_enter","1")
        //                    .setParameter("rsv_sug3","9")
        //                    .setParameter("rsv_sug1","5")
        //                    .setParameter("rsv_sug7","101")
        //                    .build();
        //            System.out.println(url);
        //            HttpGet httpGet=new HttpGet(url);
        CloseableHttpResponse response =null;
        //③httpClient.execute()执行并获取 response内容
        try {
             response = httpClient.execute(httpGet);
            //获取响应状态码——.getStatusLine().getStatusCode()
            int statusCode = response.getStatusLine().getStatusCode();
            System.out.println(statusCode);
            //HttpStatus.SC_OK是状态码200
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                //获得响应的实体类（该对象包装了服务器的响应内容，可通过该对象获取服务器的响应内容。）
                HttpEntity httpEntity = response.getEntity();
                String strResult =null;
                if (httpEntity!=null){
                    //③.1使用EntityUtils.toString()方式转化实体类为字符串     可以在转为字符串的时候指定编码集
                     strResult = EntityUtils.toString(httpEntity,"UTF-8");
                    System.out.println("strResult:"+strResult);
                    // ④把字符串转换为json对象,JSONObject是一个Map的结构（或者称为对象），
                    // 当返回的实体类不具有Map的结构时，解析成JSONObject就会出错，如百度首页的返回是一个页面的字符串
                    //必须有httpEntity!=null 非空判断，不然为空时报SONObject语法错误
                    JSONObject jsonObject = JSONObject.parseObject(strResult);
                    //一。类型确定时可以强转
                    List<Object> O=(List<Object>)jsonObject.get("body");
                    //二。通过jsonObject的get和getString方法，有key获取value
                    JSONObject body = JSONObject.parseObject(jsonObject.getString("body"));
                    body.getString("view");
                }else {
                    //如果entity为空，那么直接消化掉即可
                   EntityUtils.consume(httpEntity);
                }


                //③.2使用InputStream方式读取实体类，  ③.1和③.2只能选其一
                /*InputStream inputStream=null;
                inputStream=httpEntity.getContent();
                //转换成字符流
                BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
                String line="";
                while ((line=bufferedReader.readLine())!=null){
                    System.out.println(line);
                }*/


                //System.out.println(jsonObject);
            } else {
                String strResult = "Error Response: " + response.getStatusLine().toString();
                System.out.println(strResult);
            }

        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭连接,需关两个，先关response,再关httpClient
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * @(#)HttpClientGet2.java, 2019/11/6.
 * <p/>
 * Copyright 2019 Netease, Inc. All rights reserved.
 * NETEASE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.lhh.controller;

/**
 * @author 吕厚厚(wb.lvhouhou @ mesg.corp.netease.com)
 */

        import com.alibaba.fastjson.JSONObject;
        import org.apache.http.HttpEntity;
        import org.apache.http.HttpStatus;
        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.impl.client.CloseableHttpClient;
        import org.apache.http.impl.client.HttpClients;
        import org.apache.http.message.BasicNameValuePair;
        import org.apache.http.util.EntityUtils;

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

/**
 * 2.带参的httpClient的Get请求
 */
public class HttpClientGet2 {

    public static void main(String[] args) {

        //①利用HttpClients创建HttpClient（CloseableHttpClient）对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String url2 = "http://www.sina.com";

        //②.1封装参数，get方法传递参数
        List<NameValuePair> param = new ArrayList<NameValuePair>();

        param.add(new BasicNameValuePair("username", "jiangcui"));
        param.add(new BasicNameValuePair("password", "pdmi1234"));
        CloseableHttpResponse response =null;
        try {
            //③设置编码方式
            UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(param, "utf-8");
            //String str = EntityUtils.toString(urlEncodedFormEntity);
            //System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try{
            //④创建httpGet请求
            HttpGet httpGet2 = new HttpGet(url2);

            ////②.2 URIBuilder 设置url并且创建某种请求方式实例  ②.1和②.2只能选其一
            //        //比如：(在百度上搜索helloworld出现的路径)url：https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0
            //        // &rsv_idx=1&tn=baidu&wd=helloworld&rsv_pq=c6735cf70000fe15
            //        // &rsv_t=7e25dm7uzHpmOwrFNF33FXbom45Px0Bs0F8PP3Bcm8RMOysmKlfA%2FuqKoU4&rqlang=cn
            //        // &rsv_enter=1&rsv_sug3=9&rsv_sug1=5&rsv_sug7=101
            //        //url的构建也可以使用字符串拼接的方式
            //        try {
            //            URI url=new URIBuilder()
            //                    .setScheme("https")//设置协议
            //                    .setHost("www.baidu.com")
            //                    .setPath("/s")
            //                    .setParameter("ie","utf-8")
            //                    .setParameter("rsv_idx","1")
            //                    .setParameter("tn","baidu")
            //                    .setParameter("wd","helloworld")
            //                    .setParameter("rsv_pq","c6735cf70000fe15")
            //                    .setParameter("rsv_t","7e25dm7uzHpmOwrFNF33FXbom45Px0Bs0F8PP3Bcm8RMOysmKlfA%2FuqKoU4")
            //                    .setParameter("rqlang","cn")
            //                    .setParameter("rsv_enter","1")
            //                    .setParameter("rsv_sug3","9")
            //                    .setParameter("rsv_sug1","5")
            //                    .setParameter("rsv_sug7","101")
            //                    .build();
            //            System.out.println(url);
            //            HttpGet httpGet=new HttpGet(url);
            //⑤执行httpGet请求
            response = httpClient.execute(httpGet2);
            //获取响应状态码——HttpStatus.SC_OK是状态码200

            //System.out.println(statusCode);
            String strResult=null;
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                //获得响应的实体类（该对象包装了服务器的响应内容，可通过该对象获取服务器的响应内容。）
                HttpEntity httpEntity = response.getEntity();
                if (httpEntity!=null){
                    //方式一：使用EntityUtils.toString()方式转化实体类为字符串     可以在转为字符串的时候指定编码集
                    strResult = EntityUtils.toString(httpEntity,"UTF-8");
                    System.out.println("strResult:"+strResult);
                    // 把字符串转换为json对象,JSONObject是一个Map的结构（或者称为对象），
                    // 当返回的实体类不具有Map的结构时，解析成JSONObject就会出错，如百度首页的返回是一个页面的字符串
                    //必须有httpEntity!=null 非空判断，不然为空时报SONObject语法错误
                    JSONObject jsonObject = JSONObject.parseObject(strResult);
                    //获取json串中的数据
                    //String str = jsonObject.get("name").toString;
                    //将json对象转化为字符串
                    //String jsonToString = jsonObject.toString();
                    //方式二：使用InputStream
                }else {
                    //如果entity为空，那么直接消化掉即可
                    EntityUtils.consume(httpEntity);
                }

            } else {
                 strResult = "Error Response: " + response.getStatusLine().toString();
                System.out.println(strResult);
            }
        }catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

HttpClient的POST请求

/**
 * @(#)HttpClientPost.java, 2019/11/6.
 * <p/>
 * Copyright 2019 Netease, Inc. All rights reserved.
 * NETEASE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.lhh.controller;

/**
 * @author 吕厚厚(wb.lvhouhou @ mesg.corp.netease.com)
 */


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
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.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * HttpClientPost（1.携带json数据）
 */
public class HttpClientPost {

    /**
     * 1.post请求,发送json数据
     *
     * @param url
     * @param json
     * @return
     */
    public static JSONObject doPost(String url, String json) {
        HttpPost post = new HttpPost(url);
        JSONObject res = null;
        try {
            StringEntity s = new StringEntity(json, "UTF-8"); // 中文乱码在此解决
            s.setContentType("application/json");
            post.setEntity(s);
            HttpResponse response = HttpClients.createDefault().execute(post);
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                String result = EntityUtils.toString(response.getEntity());// 返回json格式：
                res = JSON.parseObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;
    }
    /**
     * post请求  发送Map
     *
     * @param url
     * @param map
     * @return
     */
    public static String httpPost(String url, Map<String, Object> map) {
        try {
            HttpPost post = new HttpPost(url);
            //requestConfig post请求配置类，设置超时时间
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(50000).build();
            post.setConfig(requestConfig);
            List<NameValuePair> params = new ArrayList<NameValuePair>();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                if (entry.getValue() != null && entry.getValue() != "") {
            //用basicNameValuePair来封装数据
                    params.add(new BasicNameValuePair(entry.getKey(), entry.getValue() + ""));
                }
            }
            //在这个地方设置编码 防止请求乱码
            post.setEntity(new UrlEncodedFormEntity(params, "utf-8"));

            CloseableHttpResponse httpResponse = HttpClients.createDefault().execute(post);
            System.out.println("返回数据：" + httpResponse);
            String result = null;
            if (httpResponse.getStatusLine().getStatusCode() == 200) {
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity);// 取出应答字符串
            }
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    //3.用java自带URL发送
    public synchronized String getJSON(String url2, String param) {
        try {
            URL url = new URL(url2);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setDoOutput(true); //获取返回数据需要设置为true 默认false
            con.setDoInput(true); //发送数据需要设置为true 默认false
            con.setReadTimeout(5000);
            con.setConnectTimeout(5000);
            con.setRequestMethod("POST");
            con.connect();
            DataOutputStream out = new DataOutputStream(con.getOutputStream());
            if (param != null) {
                param = URLEncoder.encode(param,"utf-8");//url编码防止中文乱码
                out.writeBytes(param);
            }
            out.flush();
            out.close();
            BufferedReader red = new BufferedReader(new InputStreamReader(con.getInputStream(), "utf-8"));
            StringBuffer sb = new StringBuffer();
            String line;
            while ((line = red.readLine()) != null) {
                sb.append(line);
            }
            red.close();
            return JSONObject.toJSONString(sb);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

比较 GET 与 POST

下面的表格比较了两种 HTTP 方法：GET 和 POST。

	GET	POST
后退按钮/刷新	无害	数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
书签	可收藏为书签	不可收藏为书签
缓存	能被缓存	不能缓存
编码类型	application/x-www-form-urlencoded	application/x-www-form-urlencoded 或application/json或 multipart/form-data。为二进制数据使用多重编码。
历史	参数保留在浏览器历史中。	参数不会保存在浏览器历史中。
对数据长度的限制	是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。	无限制。
对数据类型的限制	只允许 ASCII 字符。	没有限制。也允许二进制数据。
安全性	与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。在发送密码或其他敏感信息时绝不要使用 GET ！	POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
可见性	数据在 URL 中对所有人都是可见的。	数据不会显示在 URL 中。

 

HTTP的组成

http消息由客户端到服务端的请求以及服务端到客户端的响应组成

HTTP请求报文的格式

请求头与请求正文中间有一行空行，是告诉服务器请求头到此结束了接下来是请求正文

请求方法：get,post,head,delete等等，告诉服务器你的具体操作是什么

URL：可以从互联网上得到资源的位置和访问方法的一种简洁标识。URL结构：协议：//域名 or IP地址：端口号/目录/文件名.文件名后缀?参数=值
协议版本：目前几乎用的都是http1.1版本，增加了一个很重要的特性它支持长连接，其他具体细微差别不做讲述。
请求头：请求头部为请求报文添加了一些附加信息，由“名/值”对组成，每行一对，名和值之间使用冒号分隔。
常用的请求头包括:

请求正文：添加请求实体即你具体要请求的内容用于POST请求，GET不用

HTTP响应报文格式

HTTP状态码

HTTP响应头

http基本请求头详解

Accept：

例：
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
表示客户端支持的数据格式，或者说客户端“希望”接受到的内容类型。
这里只是希望，但是服务器具体返回什么样的内容类型，还是由服务器自己决定，但是无论服务器返回什么样的内容类型，客户端都会接收响应报文，不可能说因为内容类型不同，接收不到服务器响应报文，这不符合http协议规范。

我们通过浏览器发起get或post请求，该字段都是浏览器自动添加的，同样在服务器端也不会解析该字段的值；
通过ajax请求或其他手段，我们可以设置该字段的值，但是通常也不进行设置。

该字段的应用场景可以是这样的，有两个终端，比如一个是纯文本阅读器，如Kinder（不能显示图片），另一个是移动终端（可以播放图片和视频），均向服务器请求有关“斑马”的信息，那么这时候服务器端就需要判断什么样的终端应该返回什么样的信息，那么它就可以根据Accept的信息来进行判断，如果解析到的Accept的值为“text/plain”，那么就表示客户端只支持文本类型；如果向上面例子中的那样，则表示客户端文本图片视频都可以。如果我们不加判断，当返回给文本阅读器一张图片时，可能它显示的就是乱码。

Accept-Encoding:
例：
Accept-Encoding:gzip, deflate, br
表示客户端所支持的解码（解压缩）格式。

网路数据的传输都是占据带宽的，而将文件数据压缩能够降低数据量，减少传输时间。所以服务器在返回数据给客户端时，常常对数据进行压缩（对用户透明，通常由服务器或代理来做），而压缩的方式有多种，到底采用哪一种则需要看客户端支持哪种解码方式，这时候就可以根据header中Accept-Encoding的值。

文件或数据的压缩，由服务器或代理来做，一般不需要程序员干预；客户端接收到数据时解压缩，通常由浏览器自动完成，对用户透明。
对于我们主动发起的ajax请求，一般数据量较少，不需要设置该字段。

Accept-Language:
例
Accept-Language:zh-CN,zh;q=0.9
表示客户端支持的语言格式（不是编码格式），如中文/英文，通常浏览器直接发起请求时，浏览器会根据被设置的语言环境（默认语言），来附加上该字段。

一般我们服务器解析报文时，是不理会该字段的。
他的使用场景可以是这样的，假如有个文件，有各种语言的版本，这样当不同请求发来时，我们可以根据Accept-Language的值来判断到底返回哪种语言版本给客户端。
（其实这种应用场景也一般不采用判断Accept-Language字段的方法，不靠谱，还不如直接在url中体现语言版本呢）

Accept-Charset：
例：
Accept-Charset:gbk,utf-8;q=0.8
表示客户端支持编码格式。服务器在返回报文时，需要将字符按照一定的编码格式转换为字节序列发送给客户端，那么该采用哪种编码格式呢？
当然作为服务器端，他可以采用任何一种编码方式，客户端都得完完整整的接收响应报文。因为目前客户端几乎都支持常见编码类型，所以服务器在返回数据时，只需要按照既定的编码方式编码，然后在响应报文中告知客户端所使用的编码方式。这样客户端在接收到报文后按照该方式进行解码，就就不会出现乱码问题。

但是，如果客户端已经定了就使用某种解码方式，那么这时候服务器端就不能那么任性了，他就需要解析Accept-Charset字段，根据这个值，来设定采用的编码方式。
如上例中，以逗号分隔，客户端支持两种编码方式，gbk和utf-8（gbk优先级高于utf8），其中utf-8后的q值，表示utf-8占的“权重”。