Android持久化保存cookie

在以前先科普一下基礎知識：

什麼是Cookies？

Cookies是一些小文件，它們被建立在客戶端的系統裏，或者被建立在客戶端瀏覽器的內存中（若是是臨時性的話）。用它能夠實現狀態管理的功能。咱們能夠存儲一些少許信息到能夠短的系統上，以便在須要的時候使用。最有趣的事情是，它是對用戶透明的。在你的web應用程序中，你能夠處處使用它，它極其得簡單。Cookies是以文本形式存儲的。若是一個web應用程序使用cookies，那麼服務器負責發送cookies，客戶端瀏覽器將存儲它。瀏覽器在下次請求頁面的時候，會返回cookies給服務器。最經常使用的例子是，使用一個cookie來存儲用戶信息，用戶的喜愛，「記住密碼」操做等。Cookies有許多優勢，固然也有許多缺點。我將在接下來說述。

Cookies是如何建立的？

當一個客戶端向服務器發出請求，服務器發送cookies給客戶端。而相同的cookies能夠被後續的請求使用。例如，若是codeproject.com將Session ID做爲cookies存儲。當一個客戶端首次向web服務器請求頁面，服務器生成Session ID，並將其做爲cookies發送往客戶端。

如今，全部來自相同客戶端的後續請求，它將使用來自cookies的Session ID，就像下面這幅圖片展現的那樣。

瀏覽器和web服務器以交換cookies信息來做爲響應。對不一樣的站點，瀏覽器會維護不一樣的cookies。若是一個頁面須要cookies中的信息，當某個URL被「點擊」，首先瀏覽器將搜索本地系統的cookies的信息，而後才轉向服務器來得到信息。

Cookies的優點

下面是使用cookies的主要優點：

(1)    實現和使用都是很是簡單的

(2)    由瀏覽器來負責維護髮送過來的數據（cookies內容）

(3)    對來自多個站點的cookies來說，瀏覽器自動管理它們

Cookies的劣勢

下面是cookies的主要劣勢：

(1)    它以簡單的文本格式來存儲數據，因此它一點也不安全

(2)    對於cookies數據，有大小限制（4kB）

(3)    Cookies最大數目也有限制。主流瀏覽器提供將cookies的個數限制在20條。若是新cookies到來，那麼老的將被刪除。有些瀏覽器能支持到300條的cookies數。

(4)    咱們須要配置瀏覽器，cookies將不能工做在瀏覽器配置的高安全級別環境下。

什麼是持久化的和非持久化的Cookies

咱們能夠將cookies分紅兩類：

(1)    持久化的cookies

(2)    非持久化的cookies

持久化的cookies：這能夠被稱爲永久性的cookies，它被存儲在客戶端的硬盤內，直到它們失效。持久化的cookies應該被設置一個失效時間。有時，它們會一直存在直到用戶刪除它們。持久化的cookies一般被用來爲某個系統收集一個用戶的標識信息。

非持久化cookies：也能夠被稱之爲臨時性的cookies。若是沒有定義失效時間，那麼cookie將會被存儲在瀏覽器的內存中。我上面展現的例子就是一個非持久的cookies。

修改一個持久化的cookies與一個非持久化的cookies並無什麼不一樣。它們惟一的區別是——持久化的cookies有一個失效時間的設置。

Cookie持久化

HttpClient能夠和任意物理表示的實現了CookieStore接口的持久化cookie存儲一塊兒使用。默認的CookieStore實現稱爲BasicClientCookie，這是憑藉java.util.ArrayList的一個簡單實現。在BasicClientCookie對象中存儲的cookie當容器對象被垃圾回收機制回收時會丟失。若是須要，用戶能夠提供更復雜的實現。

下載着重介紹在安卓中如何利用httpclient來實現對cookie的持久化操做：

1、請求網絡獲取cookie

先看一下下面的代碼：

[java] view plaincopy

1. DefaultHttpClient httpclient = new DefaultHttpClient();  

2. HttpGet httpget = new HttpGet("http://www.hlovey.com");  

3. HttpResponse response = httpclient.execute(httpget);  

4. HttpEntity entity = response.getEntity();  

5. List<Cookie> cookies = httpclient.getCookieStore().getCookies();  

Post模擬登陸

[java] view plaincopy

1. HttpPost httpPost = new HttpPost(url);  

2. List<NameValuePair> formparams = new ArrayList<NameValuePair>();  

3. formparams.add(new BasicNameValuePair("id", userid));  

4. formparams.add(new BasicNameValuePair("passwd", passwd));  

5. UrlEncodedFormEntity entity;  

6. try {  

7.     entity = new UrlEncodedFormEntity(formparams, mobileSMTHEncoding);  

8. } catch (UnsupportedEncodingException e1) {  

9.     return 3;  

10. }  

11. httpPost.setEntity(entity);  

12. httpPost.setHeader("User-Agent", userAgent);  

13. HttpResponse response = httpClient.execute(httpPost);  

2、保存cookie

保存cookie有兩種方式一種是數據庫，另外一種是SharedPreferences，其中http://blog.csdn.net/junjieking/article/details/7658551是使用數據庫來保存的，這裏我是使用SharedPreferences保存。

[java] view plaincopy

1.     package com.smthbest.smth.util;  

2.   

3.     import java.util.Locale;  

4.     import android.content.Context;  

5.     import android.content.SharedPreferences;  

6.     import android.text.TextUtils;  

7.     import android.util.Log;  

8.   

9.     import org.apache.http.client.CookieStore;  

10.     import org.apache.http.cookie.Cookie;  

11.   

12.     import java.io.ByteArrayInputStream;  

13.     import java.io.ByteArrayOutputStream;  

14.     import java.io.ObjectInputStream;  

15.     import java.io.ObjectOutputStream;  

16.     import java.util.ArrayList;  

17.     import java.util.Date;  

18.     import java.util.List;  

19.     import java.util.Locale;  

20.     import java.util.concurrent.ConcurrentHashMap;  

21.   

22. ic class PersistentCookieStore implements CookieStore {  

23. private static final String LOG_TAG = "PersistentCookieStore";  

24. private static final String COOKIE_PREFS = "CookiePrefsFile";  

25. private static final String COOKIE_NAME_STORE = "names";  

26. private static final String COOKIE_NAME_PREFIX = "cookie_";  

27. private boolean omitNonPersistentCookies = false;  

28.   

29. private final ConcurrentHashMap<String, Cookie> cookies;  

30. private final SharedPreferences cookiePrefs;  

31.   

32. /** 

33.  * Construct a persistent cookie store. 

34.  * 

35.  * @param context Context to attach cookie store to 

36.  */  

37. public PersistentCookieStore(Context context) {  

38.     cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);  

39.     cookies = new ConcurrentHashMap<String, Cookie>();  

40.   

41.     // Load any previously stored cookies into the store  

42.     String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);  

43.     if (storedCookieNames != null) {  

44.         String[] cookieNames = TextUtils.split(storedCookieNames, ",");  

45.         for (String name : cookieNames) {  

46.             String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);  

47.             if (encodedCookie != null) {  

48.                 Cookie decodedCookie = decodeCookie(encodedCookie);  

49.                 if (decodedCookie != null) {  

50.                     cookies.put(name, decodedCookie);  

51.                 }  

52.             }  

53.         }  

54.   

55.         // Clear out expired cookies  

56.         clearExpired(new Date());  

57.     }  

58. }  

59.   

60. @Override  

61. public void addCookie(Cookie cookie) {  

62.     if (omitNonPersistentCookies && !cookie.isPersistent())  

63.         return;  

64.     String name = cookie.getName() + cookie.getDomain();  

65.   

66.     // Save cookie into local store, or remove if expired  

67.     if (!cookie.isExpired(new Date())) {  

68.         cookies.put(name, cookie);  

69.     } else {  

70.         cookies.remove(name);  

71.     }  

72.   

73.     // Save cookie into persistent store  

74.     SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  

75.     prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  

76.     prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));  

77.     prefsWriter.commit();  

78. }  

79.   

80. @Override  

81. public void clear() {  

82.     // Clear cookies from persistent store  

83.     SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  

84.     for (String name : cookies.keySet()) {  

85.         prefsWriter.remove(COOKIE_NAME_PREFIX + name);  

86.     }  

87.     prefsWriter.remove(COOKIE_NAME_STORE);  

88.     prefsWriter.commit();  

89.   

90.     // Clear cookies from local store  

91.     cookies.clear();  

92. }  

93.   

94. @Override  

95. public boolean clearExpired(Date date) {  

96.     boolean clearedAny = false;  

97.     SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  

98.   

99.     for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {  

100.         String name = entry.getKey();  

101.         Cookie cookie = entry.getValue();  

102.         if (cookie.isExpired(date)) {  

103.             // Clear cookies from local store  

104.             cookies.remove(name);  

105.   

106.             // Clear cookies from persistent store  

107.             prefsWriter.remove(COOKIE_NAME_PREFIX + name);  

108.   

109.             // We've cleared at least one  

110.             clearedAny = true;  

111.         }  

112.     }  

113.   

114.     // Update names in persistent store  

115.     if (clearedAny) {  

116.         prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  

117.     }  

118.     prefsWriter.commit();  

119.   

120.     return clearedAny;  

121. }  

122.   

123. @Override  

124. public List<Cookie> getCookies() {  

125.     return new ArrayList<Cookie>(cookies.values());  

126. }  

127.   

128. /** 

129.  * Will make PersistentCookieStore instance ignore Cookies, which are non-persistent by 

130.  * signature (`Cookie.isPersistent`) 

131.  * 

132.  * @param omitNonPersistentCookies true if non-persistent cookies should be omited 

133.  */  

134. public void setOmitNonPersistentCookies(boolean omitNonPersistentCookies) {  

135.     this.omitNonPersistentCookies = omitNonPersistentCookies;  

136. }  

137.   

138. /** 

139.  * Non-standard helper method, to delete cookie 

140.  * 

141.  * @param cookie cookie to be removed 

142.  */  

143. public void deleteCookie(Cookie cookie) {  

144.     String name = cookie.getName();  

145.     cookies.remove(name);  

146.     SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  

147.     prefsWriter.remove(COOKIE_NAME_PREFIX + name);  

148.     prefsWriter.commit();  

149. }  

150.   

151. /** 

152.  * Serializes Cookie object into String 

153.  * 

154.  * @param cookie cookie to be encoded, can be null 

155.  * @return cookie encoded as String 

156.  */  

157. protected String encodeCookie(SerializableCookie cookie) {  

158.     if (cookie == null)  

159.         return null;  

160.     ByteArrayOutputStream os = new ByteArrayOutputStream();  

161.     try {  

162.         ObjectOutputStream outputStream = new ObjectOutputStream(os);  

163.         outputStream.writeObject(cookie);  

164.     } catch (Exception e) {  

165.         return null;  

166.     }  

167.   

168.     return byteArrayToHexString(os.toByteArray());  

169. }  

170.   

171. /** 

172.  * Returns cookie decoded from cookie string 

173.  * 

174.  * @param cookieString string of cookie as returned from http request 

175.  * @return decoded cookie or null if exception occured 

176.  */  

177. protected Cookie decodeCookie(String cookieString) {  

178.     byte[] bytes = hexStringToByteArray(cookieString);  

179.     ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);  

180.     Cookie cookie = null;  

181.     try {  

182.         ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);  

183.         cookie = ((SerializableCookie) objectInputStream.readObject()).getCookie();  

184.     } catch (Exception exception) {  

185.         Log.d(LOG_TAG, "decodeCookie failed", exception);  

186.     }  

187.   

188.     return cookie;  

189. }  

190.   

191. /** 

192.  * Using some super basic byte array <-> hex conversions so we don't have to rely on any 

193.  * large Base64 libraries. Can be overridden if you like! 

194.  * 

195.  * @param bytes byte array to be converted 

196.  * @return string containing hex values 

197.  */  

198. protected String byteArrayToHexString(byte[] bytes) {  

199.     StringBuilder sb = new StringBuilder(bytes.length * 2);  

200.     for (byte element : bytes) {  

201.         int v = element & 0xff;  

202.         if (v < 16) {  

203.             sb.append('0');  

204.         }  

205.         sb.append(Integer.toHexString(v));  

206.     }  

207.     return sb.toString().toUpperCase(Locale.US);  

208. }  

209.   

210. /** 

211.  * Converts hex values from strings to byte arra 

212.  * 

213.  * @param hexString string of hex-encoded values 

214.  * @return decoded byte array 

215.  */  

216. protected byte[] hexStringToByteArray(String hexString) {  

217.     int len = hexString.length();  

218.     byte[] data = new byte[len / 2];  

219.     for (int i = 0; i < len; i += 2) {  

220.         data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));  

221.     }  

222.     return data;  

223. }  

使用PersistentCookieStore來存儲cookie，首先最好把PersistentCookieStore放在Application獲取其餘的地方，取得惟一實例，保存cookie是在登陸成功後，從下面代碼獲取保存。

[java] view plaincopy

1. PersistentCookieStore myCookieStore = App.getInstance().getPersistentCookieStore();  

2. List<Cookie> cookies = httpClient.getCookieStore().getCookies();  

3. for (Cookie cookie:cookies){  

4.     myCookieStore.addCookie(cookie);  

5. }  

3、cookie的使用

[java] view plaincopy

1. PersistentCookieStore cookieStore = new PersistentCookieStore(SmthBestApp.getInstance().getApplicationContext());  

2. httpClient.setCookieStore(cookieStore);  

3. HttpResponse response = httpClient.execute(httpget);  

這樣就能夠免再次登陸了。