HttpURLConnection 中Cookie 使用

方式一:

如果想通過 HttpURLConnection 訪問網站，網站返回cookie信息，下次再通過HttpURLConnection訪問時，把網站返回 cookie信息再返回給該網站。可以使用下面代碼。

CookieManager manager = new CookieManager();
CookieHandler.setDefault(manager);

通過這兩行代碼就可以把網站返回的cookie信息存儲起來，下次訪問網站的時候，自動幫你把cookie信息帶上。

CookieManager還可以設置CookiePolicy。設置如下

CookieManager manager = new CookieManager();
//設置cookie策略，只接受與你對話服務器的cookie，而不接收Internet上其它服務器發送的cookie
manager.setCookiePolicy(CookiePolicy.ACCEPT_ORIGINAL_SERVER);

CookiePolicy 策略機制解析

public interface CookiePolicy {

    public static final CookiePolicy ACCEPT_ALL = new CookiePolicy(){
        public boolean shouldAccept(URI uri, HttpCookie cookie) {
            return true;
        }
    };

    public static final CookiePolicy ACCEPT_NONE = new CookiePolicy(){
        public boolean shouldAccept(URI uri, HttpCookie cookie) {
            return false;
        }
    };

    public static final CookiePolicy ACCEPT_ORIGINAL_SERVER  = new CookiePolicy(){
        public boolean shouldAccept(URI uri, HttpCookie cookie) {
            if (uri == null || cookie == null)
                return false;
            return HttpCookie.domainMatches(cookie.getDomain(), uri.getHost());
        }
    };

    public boolean shouldAccept(URI uri, HttpCookie cookie);
}

從源碼中可以看出CookiePolicy 默認提供了3中策略實現機制

1. CookiePolicy.ACCEPT_ALL;
   從源碼中可以發現直接return true。就是接受所有的cookie。
2. CookiePolicy.ACCEPT_NONE;
   從源碼中可以發現直接return false。就是拒絕所有的cookie。
3. CookiePolicy.ACCEPT_ORIGINAL_SERVER;
   內部調用了HttpCookie.domainMatches的方法。該方法是判斷cookie的域和URL的域是否一樣，如果一樣就return true。只接收域名相同的Cookie

Cookie實現機制

這樣每次在調用HttpURLConnection訪問網站的時候，通過CookieHandler.getDefault()方法獲取CookieManager實例（靜態的方法，全局都可用）。
從解析http的響應頭中的cookie調用CookieHandler中的put方法存放到CookieStore中。
再次訪問網站的時候調用CookieHandler中的get方法獲取該uri響應的cookie，並提交到該站點中。
這樣開發人員就不需要干預cookie信息，則每次訪問網站會自動攜帶cookie。

代碼示例

本例子中使用到了CookieHandler、CookieManager 、CookieStore、 HttpCookie。

public class CookieManagerDemo {

    //打印cookie信息
    public static void printCookie(CookieStore cookieStore){
        List<HttpCookie> listCookie = cookieStore.getCookies();
        listCookie.forEach(httpCookie -> {
            System.out.println("--------------------------------------");
            System.out.println("class      : "+httpCookie.getClass());
            System.out.println("comment    : "+httpCookie.getComment());
            System.out.println("commentURL : "+httpCookie.getCommentURL());
            System.out.println("discard    : "+httpCookie.getDiscard());
            System.out.println("domain     : "+httpCookie.getDomain());
            System.out.println("maxAge     : "+httpCookie.getMaxAge());
            System.out.println("name       : "+httpCookie.getName());
            System.out.println("path       : "+httpCookie.getPath());
            System.out.println("portlist   : "+httpCookie.getPortlist());
            System.out.println("secure     : "+httpCookie.getSecure());
            System.out.println("value      : "+httpCookie.getValue());
            System.out.println("version    : "+httpCookie.getVersion());
            System.out.println("httpCookie : "+httpCookie);
        });
    }

    public static void requestURL() throws Exception{
        URL url = new URL("http://192.168.3.249:9000/webDemo/index.jsp");
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        String basic = Base64.getEncoder().encodeToString("infcn:123456".getBytes());
        conn.setRequestProperty("Proxy-authorization", "Basic " + basic);
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line = null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
    }

    public static void main(String[] args) throws Exception {
        
        CookieManager manager = new CookieManager();
        //設置cookie策略，只接受與你對話服務器的cookie，而不接收Internet上其它服務器發送的cookie
        manager.setCookiePolicy(CookiePolicy.ACCEPT_ORIGINAL_SERVER);
        CookieHandler.setDefault(manager);
        
        printCookie(manager.getCookieStore());
        //第一次請求
        requestURL();

        printCookie(manager.getCookieStore());
        //第二次請求
        requestURL();
    }
    
}

方式一:

獲取Cookies,多個cookie是以;分隔

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.CookiePolicy;
import java.net.CookieStore;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.Proxy;
import java.net.URL;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HttpUtil {

    public static final String  KEY_HEADER_COOKIE="Set-Cookie";
    public static final String  KEY_REQUEST_COOKIE = "Cookie";
    private HttpUtil() {

    }
    public static CookieStore setCookieManager(){
        CookieManager manager = new CookieManager();
        //設置cookie策略，只接受與你對話服務器的cookie，而不接收Internet上其它服務器發送的cookie
        manager.setCookiePolicy(CookiePolicy.ACCEPT_ORIGINAL_SERVER);
        CookieHandler.setDefault(manager);
        CookieStore cookieStore = manager.getCookieStore();
        return cookieStore;
    }
    public static ResponseResult doGet(String path, Map<String, String> headers, boolean redirect,Proxy proxy) {
        HttpURLConnection connection = null;
        ResponseResult result = new ResponseResult();
        try {
            // 1. 得到訪問地址的URL
            URL url = new URL(new String(path.getBytes(), "UTF-8"));
            // 2. 得到網絡訪問對象java.net.HttpURLConnection
            if (proxy != null) {
                connection = (HttpURLConnection) url.openConnection(proxy);
            } else {
                connection = (HttpURLConnection) url.openConnection();
            }
            /* 3. 設置請求參數（過期時間，輸入、輸出流、訪問方式），以流的形式進行連接 */
            // 設置是否向HttpURLConnection輸出
            connection.setDoOutput(false);
            // 設置是否從httpUrlConnection讀入
            connection.setDoInput(true);
            // 設置請求方式
            connection.setRequestMethod("GET");
            // 設置是否使用緩存
            connection.setUseCaches(true);
            // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向
            connection.setInstanceFollowRedirects(redirect);
            // 設置超時時間
            connection.setConnectTimeout(3000);
            if (headers != null) {
                Set<Entry<String, String>> entrySet = headers.entrySet();
                for (Entry<String, String> entry : entrySet) {
                    connection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            // 連接
            connection.connect();
            int responseCode = connection.getResponseCode();
            result.setResponseCode(responseCode);
            String responseMessage = connection.getResponseMessage();
            result.setResponseMessage(responseMessage);
            List<String> cookies = connection.getHeaderFields().get(KEY_HEADER_COOKIE);
            if (cookies != null&&cookies.size()>0) {
                StringBuffer sb = new StringBuffer();
                for (String string : cookies) {
                    sb.append(string).append(";");
                }
                result.setCookies(sb.toString());
            }
            InputStream inputStream = connection.getInputStream();
            StringBuffer sb = new StringBuffer();
            // 定義 BufferedReader輸入流來讀取URL的響應
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String getLine;
            while ((getLine = in.readLine()) != null) {
               sb.append(getLine);
            }
            result.setResponseBody(sb.toString());
            inputStream.close();
            in.close();
            connection.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    public static ResponseResult doPost(String path, Map<String, String> headers, boolean redirect,Proxy proxy,String param){
        ResponseResult result = new ResponseResult();
        HttpURLConnection connection = null;
        try {
            // 1. 得到訪問地址的URL
            URL url = new URL(new String(path.getBytes(), "UTF-8"));
            // 2. 得到網絡訪問對象java.net.HttpURLConnection
            if (proxy != null) {
                connection = (HttpURLConnection) url.openConnection(proxy);
            } else {
                connection = (HttpURLConnection) url.openConnection();
            }
            /* 3. 設置請求參數等 */
            // 請求方式
            connection.setRequestMethod("POST");
            // 超時時間
            connection.setConnectTimeout(3000);
            // 設置是否輸出
            connection.setDoOutput(true);
            // 設置是否讀入
            connection.setDoInput(true);
            // 設置是否使用緩存
            connection.setUseCaches(false);
            // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向
            connection.setInstanceFollowRedirects(redirect);
            // 設置使用標准編碼格式編碼參數的名-值對
            connection.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
            if (headers != null) {
                Set<Entry<String, String>> entrySet = headers.entrySet();
                for (Entry<String, String> entry : entrySet) {
                    connection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            // 連接
            connection.connect();
            /* 4. 處理輸入輸出 */
            // 寫入參數到請求中
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
            writer.write(new String(param.getBytes(), "UTF-8"));
            writer.flush();
            writer.close();
            int responseCode = connection.getResponseCode();
            result.setResponseCode(responseCode);
            String responseMessage = connection.getResponseMessage();
            result.setResponseMessage(responseMessage);
            List<String> cookies = connection.getHeaderFields().get(KEY_HEADER_COOKIE);
            if (cookies != null&&cookies.size()>0) {
                StringBuffer sb = new StringBuffer();
                for (String string : cookies) {
                    sb.append(string).append(";");
                }
                result.setCookies(sb.toString());
            }
            InputStream inputStream = connection.getInputStream();
            StringBuffer sb = new StringBuffer();
            // 定義 BufferedReader輸入流來讀取URL的響應
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String getLine;
            while ((getLine = in.readLine()) != null) {
               sb.append(getLine);
            }
            result.setResponseBody(sb.toString());
            inputStream.close();
            in.close();
            connection.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
    public static ResponseResult doPut(String path, Map<String, String> headers, boolean redirect,Proxy proxy,String param){
        ResponseResult result = new ResponseResult();
        HttpURLConnection connection = null;
        try {
            // 1. 得到訪問地址的URL
            URL url = new URL(new String(path.getBytes(), "UTF-8"));
            // 2. 得到網絡訪問對象java.net.HttpURLConnection
            if (proxy != null) {
                connection = (HttpURLConnection) url.openConnection(proxy);
            } else {
                connection = (HttpURLConnection) url.openConnection();
            }
            /* 3. 設置請求參數等 */
            // 請求方式
            connection.setRequestMethod("PUT");
            // 超時時間
            connection.setConnectTimeout(3000);
            // 設置是否輸出
            connection.setDoOutput(true);
            // 設置是否讀入
            connection.setDoInput(true);
            // 設置是否使用緩存
            connection.setUseCaches(false);
            // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向
            connection.setInstanceFollowRedirects(redirect);
            // 設置使用標准編碼格式編碼參數的名-值對
            connection.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
            if (headers != null) {
                Set<Entry<String, String>> entrySet = headers.entrySet();
                for (Entry<String, String> entry : entrySet) {
                    connection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            // 連接
            connection.connect();
            /* 4. 處理輸入輸出 */
            // 寫入參數到請求中
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
            writer.write(new String(param.getBytes(), "UTF-8"));
            writer.flush();
            writer.close();
            int responseCode = connection.getResponseCode();
            result.setResponseCode(responseCode);
            String responseMessage = connection.getResponseMessage();
            result.setResponseMessage(responseMessage);
            List<String> cookies = connection.getHeaderFields().get(KEY_HEADER_COOKIE);
            if (cookies != null&&cookies.size()>0) {
                StringBuffer sb = new StringBuffer();
                for (String string : cookies) {
                    sb.append(string).append(";");
                }
                result.setCookies(sb.toString());
            }
            InputStream inputStream = connection.getInputStream();
            StringBuffer sb = new StringBuffer();
            // 定義 BufferedReader輸入流來讀取URL的響應
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String getLine;
            while ((getLine = in.readLine()) != null) {
               sb.append(getLine);
            }
            result.setResponseBody(sb.toString());
            inputStream.close();
            in.close();
            connection.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
    public static ResponseResult doDelete(String path, Map<String, String> headers, boolean redirect,Proxy proxy) {
        HttpURLConnection connection = null;
        ResponseResult result = new ResponseResult();
        try {
            // 1. 得到訪問地址的URL
            URL url = new URL(new String(path.getBytes(), "UTF-8"));
            // 2. 得到網絡訪問對象java.net.HttpURLConnection
            if (proxy != null) {
                connection = (HttpURLConnection) url.openConnection(proxy);
            } else {
                connection = (HttpURLConnection) url.openConnection();
            }
            /* 3. 設置請求參數（過期時間，輸入、輸出流、訪問方式），以流的形式進行連接 */
            // 設置是否向HttpURLConnection輸出
            connection.setDoOutput(false);
            // 設置是否從httpUrlConnection讀入
            connection.setDoInput(true);
            // 設置請求方式
            connection.setRequestMethod("DELETE");
            // 設置是否使用緩存
            connection.setUseCaches(true);
            // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向
            connection.setInstanceFollowRedirects(redirect);
            // 設置超時時間
            connection.setConnectTimeout(3000);
            if (headers != null) {
                Set<Entry<String, String>> entrySet = headers.entrySet();
                for (Entry<String, String> entry : entrySet) {
                    connection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            // 連接
            connection.connect();
            int responseCode = connection.getResponseCode();
            result.setResponseCode(responseCode);
            String responseMessage = connection.getResponseMessage();
            result.setResponseMessage(responseMessage);
            List<String> cookies = connection.getHeaderFields().get(KEY_HEADER_COOKIE);
            if (cookies != null&&cookies.size()>0) {
                StringBuffer sb = new StringBuffer();
                for (String string : cookies) {
                    sb.append(string).append(";");
                }
                result.setCookies(sb.toString());
            }
            InputStream inputStream = connection.getInputStream();
            StringBuffer sb = new StringBuffer();
            // 定義 BufferedReader輸入流來讀取URL的響應
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String getLine;
            while ((getLine = in.readLine()) != null) {
               sb.append(getLine);
            }
            result.setResponseBody(sb.toString());
            inputStream.close();
            in.close();
            connection.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
}

class ResponseResult{
    
    private Integer responseCode;
    
    private String responseMessage;
    
    private String responseBody;
    
    private String cookies;

    public Integer getResponseCode() {
        return responseCode;
    }

    public void setResponseCode(Integer responseCode) {
        this.responseCode = responseCode;
    }

    public String getResponseMessage() {
        return responseMessage;
    }

    public void setResponseMessage(String responseMessage) {
        this.responseMessage = responseMessage;
    }

    public String getResponseBody() {
        return responseBody;
    }

    public void setResponseBody(String responseBody) {
        this.responseBody = responseBody;
    }

    public String getCookies() {
        return cookies;
    }

    public void setCookies(String cookies) {
        this.cookies = cookies;
    }
}