android cookie持久化

原博客地址：http://blog.csdn.net/shimiso/article/details/39033353

在解析网页信息的时候，需要登录后才能访问，所以使用httpclient模拟登录，然后把cookie保存下来，以供下一次访问使用，这时就需要持久化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的持久化操作：

一、请求网络获取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);

二、保存cookie

保存cookie有两种方式一种是数据库，另一种是SharedPreferences，其中http://blog.csdn.net/junjieking/article/details/7658551是使用数据库来保存的，这里我是使用SharedPreferences保存。

[java] view
plaincopy

1. package com.smthbest.smth.util;
2. import java.util.Locale;
3. import android.content.Context;
4. import android.content.SharedPreferences;
5. import android.text.TextUtils;
6. import android.util.Log;
7. import org.apache.http.client.CookieStore;
8. import org.apache.http.cookie.Cookie;
9. import java.io.ByteArrayInputStream;
10. import java.io.ByteArrayOutputStream;
11. import java.io.ObjectInputStream;
12. import java.io.ObjectOutputStream;
13. import java.util.ArrayList;
14. import java.util.Date;
15. import java.util.List;
16. import java.util.Locale;
17. import java.util.concurrent.ConcurrentHashMap;
18. ic class PersistentCookieStore implements CookieStore {
19. private static final String LOG_TAG = "PersistentCookieStore";
20. private static final String COOKIE_PREFS = "CookiePrefsFile";
21. private static final String COOKIE_NAME_STORE = "names";
22. private static final String COOKIE_NAME_PREFIX = "cookie_";
23. private boolean omitNonPersistentCookies = false;
24. private final ConcurrentHashMap<String, Cookie> cookies;
25. private final SharedPreferences cookiePrefs;
26. /**
27. * Construct a persistent cookie store.
28. *
29. * @param context Context to attach cookie store to
30. */
31. public PersistentCookieStore(Context context) {
32. cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
33. cookies = new ConcurrentHashMap<String, Cookie>();
34. // Load any previously stored cookies into the store
35. String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);
36. if (storedCookieNames != null) {
37. String[] cookieNames = TextUtils.split(storedCookieNames, ",");
38. for (String name : cookieNames) {
39. String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);
40. if (encodedCookie != null) {
41. Cookie decodedCookie = decodeCookie(encodedCookie);
42. if (decodedCookie != null) {
43. cookies.put(name, decodedCookie);
44. }
45. }
46. }
47. // Clear out expired cookies
48. clearExpired(new Date());
49. }
50. }
51. @Override
52. public void addCookie(Cookie cookie) {
53. if (omitNonPersistentCookies && !cookie.isPersistent())
54. return;
55. String name = cookie.getName() + cookie.getDomain();
56. // Save cookie into local store, or remove if expired
57. if (!cookie.isExpired(new Date())) {
58. cookies.put(name, cookie);
59. } else {
60. cookies.remove(name);
61. }
62. // Save cookie into persistent store
63. SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
64. prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));
65. prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));
66. prefsWriter.commit();
67. }
68. @Override
69. public void clear() {
70. // Clear cookies from persistent store
71. SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
72. for (String name : cookies.keySet()) {
73. prefsWriter.remove(COOKIE_NAME_PREFIX + name);
74. }
75. prefsWriter.remove(COOKIE_NAME_STORE);
76. prefsWriter.commit();
77. // Clear cookies from local store
78. cookies.clear();
79. }
80. @Override
81. public boolean clearExpired(Date date) {
82. boolean clearedAny = false;
83. SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
84. for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {
85. String name = entry.getKey();
86. Cookie cookie = entry.getValue();
87. if (cookie.isExpired(date)) {
88. // Clear cookies from local store
89. cookies.remove(name);
90. // Clear cookies from persistent store
91. prefsWriter.remove(COOKIE_NAME_PREFIX + name);
92. // We've cleared at least one
93. clearedAny = true;
94. }
95. }
96. // Update names in persistent store
97. if (clearedAny) {
98. prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));
99. }
100. prefsWriter.commit();
101. return clearedAny;
102. }
103. @Override
104. public List<Cookie> getCookies() {
105. return new ArrayList<Cookie>(cookies.values());
106. }
107. /**
108. * Will make PersistentCookieStore instance ignore Cookies, which are non-persistent by
109. * signature (`Cookie.isPersistent`)
110. *
111. * @param omitNonPersistentCookies true if non-persistent cookies should be omited
112. */
113. public void setOmitNonPersistentCookies(boolean omitNonPersistentCookies) {
114. this.omitNonPersistentCookies = omitNonPersistentCookies;
115. }
116. /**
117. * Non-standard helper method, to delete cookie
118. *
119. * @param cookie cookie to be removed
120. */
121. public void deleteCookie(Cookie cookie) {
122. String name = cookie.getName();
123. cookies.remove(name);
124. SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
125. prefsWriter.remove(COOKIE_NAME_PREFIX + name);
126. prefsWriter.commit();
127. }
128. /**
129. * Serializes Cookie object into String
130. *
131. * @param cookie cookie to be encoded, can be null
132. * @return cookie encoded as String
133. */
134. protected String encodeCookie(SerializableCookie cookie) {
135. if (cookie == null)
136. return null;
137. ByteArrayOutputStream os = new ByteArrayOutputStream();
138. try {
139. ObjectOutputStream outputStream = new ObjectOutputStream(os);
140. outputStream.writeObject(cookie);
141. } catch (Exception e) {
142. return null;
143. }
144. return byteArrayToHexString(os.toByteArray());
145. }
146. /**
147. * Returns cookie decoded from cookie string
148. *
149. * @param cookieString string of cookie as returned from http request
150. * @return decoded cookie or null if exception occured
151. */
152. protected Cookie decodeCookie(String cookieString) {
153. byte[] bytes = hexStringToByteArray(cookieString);
154. ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
155. Cookie cookie = null;
156. try {
157. ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
158. cookie = ((SerializableCookie) objectInputStream.readObject()).getCookie();
159. } catch (Exception exception) {
160. Log.d(LOG_TAG, "decodeCookie failed", exception);
161. }
162. return cookie;
163. }
164. /**
165. * Using some super basic byte array <-> hex conversions so we don't have to rely on any
166. * large Base64 libraries. Can be overridden if you like!
167. *
168. * @param bytes byte array to be converted
169. * @return string containing hex values
170. */
171. protected String byteArrayToHexString(byte[] bytes) {
172. StringBuilder sb = new StringBuilder(bytes.length * 2);
173. for (byte element : bytes) {
174. int v = element & 0xff;
175. if (v < 16) {
176. sb.append('0');
177. }
178. sb.append(Integer.toHexString(v));
179. }
180. return sb.toString().toUpperCase(Locale.US);
181. }
182. /**
183. * Converts hex values from strings to byte arra
184. *
185. * @param hexString string of hex-encoded values
186. * @return decoded byte array
187. */
188. protected byte[] hexStringToByteArray(String hexString) {
189. int len = hexString.length();
190. byte[] data = new byte[len / 2];
191. for (int i = 0; i < len; i += 2) {
192. data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));
193. }
194. return data;
195. }

使用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. }

三、cookie的使用

[java] view
plaincopy

1. PersistentCookieStore cookieStore = new PersistentCookieStore(SmthBestApp.getInstance().getApplicationContext());
2. httpClient.setCookieStore(cookieStore);
3. HttpResponse response = httpClient.execute(httpget);

这样就可以免再次登录了。