原文出自csdn：
http://blog.csdn.net/sk719887916/article/details/51700659；

通過對Retrofit2.0的<Retrofit 2.0 超能實踐，完美支持Https傳輸>基礎入門和案例實踐，掌握了怎麼樣使用Retrofit訪問網絡，加入自定義header，包括加入SSL證書，基本的調試基礎，但是正常的開發中會涉及cookie同步問題，可以實現一些自動或免登錄登陸問題，接下來進入cookie同步姿勢

Cookie

Cookies是一種能夠讓網站服務器把少量數據儲存到客戶端的硬盤或內存，或是從客戶端的硬盤讀取數據的一種技術。Cookies是當你瀏覽某網站時，由Web服務器置於你硬盤上的一個非常小的文本文件，它可以記錄你的用戶ID、密碼、瀏覽過的網頁、停留的時間等信息。當你再次來到該網站時，網站通過讀取Cookies，得知你的相關信息，就可以做出相應的動作，如在頁面顯示歡迎你的標語，或者讓你不用輸入ID、密碼就直接登錄等等。

從本質上講，它可以看作是你的身份證。但Cookies不能作爲代碼執行，也不會傳送病毒，且爲你所專有，並只能由提供它的服務器來讀取。保存的信息片斷以“名/值”對(name-value pairs)的形式儲存，一個“名/值”對僅僅是一條命名的數據。一個網站只能取得它放在你的電腦中的信息，它無法從其它的Cookies文件中取得信息，也無法得到你的電腦上的其它任何東西。

Cookies中的內容大多數經過了加密處理，因此一般用戶看來只是一些毫無意義的字母數字組合，只有服務器的CGI處理程序才知道它們真正的含義。

Cookie也是http的會話跟蹤技術，也包含web端的session。cookie的作用就是爲了解決HTTP協議無狀態的缺陷所作的努力.

#Cookie結構

發送規則：

瀏覽器（設備）根據下面的幾個規則決定是否發送某個Cookie信息：

請求的主機名是否與某個存儲的Cookie的Domain屬性匹配；
請求的端口號是否在該Cookie的Port屬性列表中；
請求的資源路徑是否在該Cookie的Path屬性指定的目錄及子目錄中；
該Cookie的有效期是否已過。

下面是cookie代碼示例：

     HTTP/1.1 200 OK
     Content-type: text/html
     Set-Cookie: name=value
     Set-Cookie: name2=value2; Expires=Wed, 09 Jun 2021 10:18:14 GMT
    (content of page)

Cookie請求頭字段中的每個Cookie之間用逗號或分號分隔。

在Cookie請求頭字段中除了必須有“名稱=值”的設置外，還可以有Version、Path、Domain、Port等屬性名之前，都要增加一個“$”字符作爲前綴。

Version屬性只能出現一次，且要位於Cookie請求頭字段設置值的最前面，如果需要設置鞭個Cookie信息的Path、Domain、Port等屬性，它們必須位於該Cookie信息的“名稱=值”設置之後。

Path屬性指向子目錄的Cookie排在Path屬性指向父目錄的Cookie之前。

在Servlet程序中作用Cookie

Servlet API中提供了一個javax.servlet.http.Cookie類來封閉Cookie信息，它包含有生成Cookie信息和提取Cookie信息的各個屬性的方法。

Cookie類的方法：

（構造方法：public Cookie(java.lang.String name,java.lang.String value)
getName方法
setValue與getValue方法
setMaxAge與getMaxAge方法
setPath與getPath方法
setDomian與getPath方法
setVersion與getVersion方法
setComment與getComment方法
setSecoure與getSecure方法

自定義cookie

HttpClient中大家都知道加入cookie的方式

AsyncHttpClient client = new AsyncHttpClient();
PersistentCookieStore myCookieStore = new PersistentCookieStore(MainActivity.this);
client.setCookieStore(myCookieStore);

因此Retrofit中需自我實現一個PersistentCookieStore 用來儲存OkHttpCookies。

#方案一：

-PersistentCookieStore

/**
  * Created by LIUYONGKUI on 2016-06-09.
  */
public class PersistentCookieStore {
private static final String LOG_TAG = "PersistentCookieStore";
private static final String COOKIE_PREFS = "Cookies_Prefs";

private final Map<String, ConcurrentHashMap<String, Cookie>> cookies;
private final SharedPreferences cookiePrefs;


public PersistentCookieStore(Context context) {
    cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
    cookies = new HashMap<>();

    //將持久化的cookies緩存到內存中 即map cookies
    Map<String, ?> prefsMap = cookiePrefs.getAll();
    for (Map.Entry<String, ?> entry : prefsMap.entrySet()) {
        String[] cookieNames = TextUtils.split((String) entry.getValue(), ",");
        for (String name : cookieNames) {
            String encodedCookie = cookiePrefs.getString(name, null);
            if (encodedCookie != null) {
                Cookie decodedCookie = decodeCookie(encodedCookie);
                if (decodedCookie != null) {
                    if (!cookies.containsKey(entry.getKey())) {
                        cookies.put(entry.getKey(), new ConcurrentHashMap<String, Cookie>());
                    }
                    cookies.get(entry.getKey()).put(name, decodedCookie);
                }
            }
        }
    }
}

protected String getCookieToken(Cookie cookie) {
    return cookie.name() + "@" + cookie.domain();
}

public void add(HttpUrl url, Cookie cookie) {
    String name = getCookieToken(cookie);

    //將cookies緩存到內存中 如果緩存過期 就重置此cookie
    if (!cookie.persistent()) {
        if (!cookies.containsKey(url.host())) {
            cookies.put(url.host(), new ConcurrentHashMap<String, Cookie>());
        }
        cookies.get(url.host()).put(name, cookie);
    } else {
        if (cookies.containsKey(url.host())) {
            cookies.get(url.host()).remove(name);
        }
    }

    //講cookies持久化到本地
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
    prefsWriter.putString(url.host(), TextUtils.join(",", cookies.get(url.host()).keySet()));
    prefsWriter.putString(name, encodeCookie(new OkHttpCookies(cookie)));
    prefsWriter.apply();
}

public List<Cookie> get(HttpUrl url) {
    ArrayList<Cookie> ret = new ArrayList<>();
    if (cookies.containsKey(url.host()))
        ret.addAll(cookies.get(url.host()).values());
    return ret;
}

public boolean removeAll() {
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
    prefsWriter.clear();
    prefsWriter.apply();
    cookies.clear();
    return true;
}

public boolean remove(HttpUrl url, Cookie cookie) {
    String name = getCookieToken(cookie);

    if (cookies.containsKey(url.host()) && cookies.get(url.host()).containsKey(name)) {
        cookies.get(url.host()).remove(name);

        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
        if (cookiePrefs.contains(name)) {
            prefsWriter.remove(name);
        }
        prefsWriter.putString(url.host(), TextUtils.join(",", cookies.get(url.host()).keySet()));
        prefsWriter.apply();

        return true;
    } else {
        return false;
    }
}

public List<Cookie> getCookies() {
    ArrayList<Cookie> ret = new ArrayList<>();
    for (String key : cookies.keySet())
        ret.addAll(cookies.get(key).values());

    return ret;
}

/**
 * cookies 序列化成 string
 *
 * @param cookie 要序列化的cookie
 * @return 序列化之後的string
 */
protected String encodeCookie(OkHttpCookies cookie) {
    if (cookie == null)
        return null;
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    try {
        ObjectOutputStream outputStream = new ObjectOutputStream(os);
        outputStream.writeObject(cookie);
    } catch (IOException e) {
        Log.d(LOG_TAG, "IOException in encodeCookie", e);
        return null;
    }

    return byteArrayToHexString(os.toByteArray());
}

/**
 * 將字符串反序列化成cookies
 *
 * @param cookieString cookies string
 * @return cookie object
 */
protected Cookie decodeCookie(String cookieString) {
    byte[] bytes = hexStringToByteArray(cookieString);
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
    Cookie cookie = null;
    try {
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        cookie = ((OkHttpCookies) objectInputStream.readObject()).getCookies();
    } catch (IOException e) {
        Log.d(LOG_TAG, "IOException in decodeCookie", e);
    } catch (ClassNotFoundException e) {
        Log.d(LOG_TAG, "ClassNotFoundException in decodeCookie", e);
    }

    return cookie;
}

/**
 * 二進制數組轉十六進制字符串
 *
 * @param bytes byte array to be converted
 * @return string containing hex values
 */
protected String byteArrayToHexString(byte[] bytes) {
    StringBuilder sb = new StringBuilder(bytes.length * 2);
    for (byte element : bytes) {
        int v = element & 0xff;
        if (v < 16) {
            sb.append('0');
        }
        sb.append(Integer.toHexString(v));
    }
    return sb.toString().toUpperCase(Locale.US);
}

/**
 * 十六進制字符串轉二進制數組
 *
 * @param hexString string of hex-encoded values
 * @return decoded byte array
 */
protected byte[] hexStringToByteArray(String hexString) {
    int len = hexString.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));
    }
    return data;
}

OkHttpCookies

需要實現序列化的 OkHttpCookies 用來持久OkHttpCookies

   /**
 * Created by LIUYONGKUI on 2016-05-20.
  */
public class OkHttpCookies implements Serializable {

private transient final Cookie cookies;
private transient Cookie clientCookies;

public OkHttpCookies(Cookie cookies) {
    this.cookies = cookies;
}

public Cookie getCookies() {
    Cookie bestCookies = cookies;
    if (clientCookies != null) {
        bestCookies = clientCookies;
    }
    return bestCookies;
}

private void writeObject(ObjectOutputStream out) throws IOException {
    out.writeObject(cookies.name());
    out.writeObject(cookies.value());
    out.writeLong(cookies.expiresAt());
    out.writeObject(cookies.domain());
    out.writeObject(cookies.path());
    out.writeBoolean(cookies.secure());
    out.writeBoolean(cookies.httpOnly());
    out.writeBoolean(cookies.hostOnly());
    out.writeBoolean(cookies.persistent());
}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    String name = (String) in.readObject();
    String value = (String) in.readObject();
    long expiresAt = in.readLong();
    String domain = (String) in.readObject();
    String path = (String) in.readObject();
    boolean secure = in.readBoolean();
    boolean httpOnly = in.readBoolean();
    boolean hostOnly = in.readBoolean();
    boolean persistent = in.readBoolean();
    Cookie.Builder builder = new Cookie.Builder();
    builder = builder.name(name);
    builder = builder.value(value);
    builder = builder.expiresAt(expiresAt);
    builder = hostOnly ? builder.hostOnlyDomain(domain) : builder.domain(domain);
    builder = builder.path(path);
    builder = secure ? builder.secure() : builder;
    builder = httpOnly ? builder.httpOnly() : builder;
    clientCookies =builder.build();
}

}

-自定義CookieManger

實現有一個自定義的CookieManger來管理cookies,實現以K-V結構獲取set,getCookier

public class CookieManger implements CookieJar {


private static Context mContext;

private static PersistentCookieStore cookieStore;

public CookieManger(Context context) {
    mContext = context;
    if (cookieStore == null ) {
        cookieStore = new PersistentCookieStore(mContext);
    }

}



@Override
public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
    if (cookies != null && cookies.size() > 0) {
        for (Cookie item : cookies) {
            cookieStore.add(url, item);
        }
    }
}

@Override
public List<Cookie> loadForRequest(HttpUrl url) {
    List<Cookie> cookies =cookieStore.get(url);
    return cookies;
}

}

Retrofit加入cookie

OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .addNetworkInterceptor(
                    new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.HEADERS))
            .cookieJar(new CookieManger(context))
            .addInterceptor(loginInterceptor)
            .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
            .build();

    
    Retrofit retrofit = new Retrofit.Builder()
            .client(okHttpClient)
            .build();

小結

實現加入cookies持久，實現免登陸基本步驟

1 實現可序列化的OkHttpcookies
2 實現儲存OkHttpcookies的PersistentCookieStore
3 實現cookies管理工具CookieManger
4 構建OKHttpClient
5 Retrofit加入自定義的okHttpClient
6直接調用RetrofitClient

#方案二：

方法一可能對某些網站不兼容，可以藉助retroit的攔截器實現

用來加入cookie

public class ReadCookiesInterceptor implements   Interceptor {

 @Override
  public Response intercept(Chain chain) throws IOException {
    Request.Builder builder = chain.request().newBuilder();
      HashSet<String> preferences = (HashSet) Preferences.getDefaultPreferences().getStringSet(Preferences.PREF_COOKIES, new HashSet<>());
     for (String cookie : preferences) {
        builder.addHeader("Cookie", cookie);
        Log.v("OkHttp", "Adding Header: " + cookie); // This is done so I know which headers are being added; this interceptor is used after the normal logging of OkHttp
     }

    return chain.proceed(builder.build());
 }

}

用來保存Cookies

public class SaveCookiesInterceptor implements Interceptor {
   @Override
   public Response intercept(Chain chain) throws IOException {
      Response originalResponse = chain.proceed(chain.request());

      if (!originalResponse.headers("Set-Cookie").isEmpty()) {
         HashSet<String> cookies = new HashSet<>();

         for (String header : originalResponse.headers("Set-Cookie")) {
          cookies.add(header);
         }

         Preferences.getDefaultPreferences().edit()
                .putStringSet(Preferences.PREF_COOKIES, cookies)
                .apply();
    }

      return originalResponse;
}

}

Okhttp

OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.interceptors().add(new ReadCookiesInterceptor());
okHttpClient.interceptors().add(new SaveCookiesInterceptor());

Retrofit

 Retrofit retrofit = new Retrofit.Builder()
            .client(okHttpClient)
            .build();

方案三：RxJava+ Retrofit

實現OKhttp的Interceptor器，用來將本地的cookie追加到http請求頭中；採用rxJava的操作

public class AddCookiesInterceptor implements Interceptor {
    private Context context;
    private String lang;

    public AddCookiesInterceptor(Context context, String lang) {
        super();
        this.context = context;
        this.lang = lang;

    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        if (chain == null)
            Log.d("http", "Addchain == null");
        final Request.Builder builder = chain.request().newBuilder();
        SharedPreferences sharedPreferences = context.getSharedPreferences("cookie", Context.MODE_PRIVATE);
        Observable.just(sharedPreferences.getString("cookie", ""))
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String cookie) {
                        if (cookie.contains("lang=ch")){
                            cookie = cookie.replace("lang=ch","lang="+lang);
                        }
                        if (cookie.contains("lang=en")){
                            cookie = cookie.replace("lang=en","lang="+lang);
                        }
                        //添加cookie
//                        Log.d("http", "AddCookiesInterceptor"+cookie);
                        builder.addHeader("cookie", cookie);
                    }
                });
        return chain.proceed(builder.build());
    }
}

實現Interceptor器，將Http返回的cookie存儲到本地

public class ReceivedCookiesInterceptor implements Interceptor {
    private Context context;
    SharedPreferences sharedPreferences;

    public ReceivedCookiesInterceptor(Context context) {
        super();
        this.context = context;
        sharedPreferences = context.getSharedPreferences("cookie", Context.MODE_PRIVATE);
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        if (chain == null)
            Log.d("http", "Receivedchain == null");
        Response originalResponse = chain.proceed(chain.request());
        Log.d("http", "originalResponse" + originalResponse.toString());
        if (!originalResponse.headers("set-cookie").isEmpty()) {
            final StringBuffer cookieBuffer = new StringBuffer();
            Observable.from(originalResponse.headers("set-cookie"))
                    .map(new Func1<String, String>() {
                        @Override
                        public String call(String s) {
                            String[] cookieArray = s.split(";");
                            return cookieArray[0];
                        }
                    })
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String cookie) {
                            cookieBuffer.append(cookie).append(";");
                        }
                    });
            SharedPreferences.Editor editor = sharedPreferences.edit();
            editor.putString("cookie", cookieBuffer.toString());
            Log.d("http", "ReceivedCookiesInterceptor" + cookieBuffer.toString());
            editor.commit();
        }

        return originalResponse;
    }
}

最後將攔截器加到retrofit中，參考方法二。
本方法是androidformjm提供方式感謝作者；

最後

本文詳細介紹了retrofit持久cookie的姿勢，也同樣試用與okhttp。以上三種方式至少有一種適合你

so iz 或許下一步你將會Retrofit遇到文件和圖片上傳問題，別急會乾貨即將來臨！

Retrofit系列:

項目地址：GitHub: https://github.com/NeglectedByBoss/RetrofitClient

作者：Tamic 更多原創關注開發者技術前線

Retrofit2.0 ，OkHttp3完美同步持久Cookie實現免登錄(二)

Cookie

在Servlet程序中作用Cookie

自定義cookie

-PersistentCookieStore

-自定義CookieManger

小結

Okhttp

Retrofit

方案三：RxJava+ Retrofit

最後

項目地址：GitHub: https://github.com/NeglectedByBoss/RetrofitClient

大學四年，我是如何學習編程的？

微信小程序開發(四) 後臺開發詳解, 二維碼生成，推送消息，微信支付

Flutter 的渲染邏輯及和 Native 通信（四）

Flutter 熱修復, 熱更新，動態化實現

程序員外包怎麼了？

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結