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

三、cookie的使用

[java] view
plaincopy

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

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

时间： 2024-10-24 19:05:31

android cookie持久化的相关文章

Android数据持久化之ContentProvider机制详解

本文实例讲述了Android数据持久化之ContentProvider机制.分享给大家供大家参考,具体如下: 一般而言,android操作系统的应用程序所建立的数据只允许自己使用,应用程序彼此间无法借助公用存储器来共享数据,android系统提供了一个机制,即内容提供器(ContentProvider),来公开自己私有的数据到数据内容器,通过该机制,可以供其他应用程序来读取自己内部的数据,当然也可以访问其他应用程序的数据.通常,内容提供器背后都有SQLite数据库的支持,用以存储内容提供内部数据

Android数据持久化之读写SD卡中内容的方法详解

本文实例讲述了Android数据持久化之读写SD卡中内容的方法.分享给大家供大家参考,具体如下: 前面文章里讲的那三个方法:openFileOutput .openFileInput 虽然都能通过流对象OutputStream和InputStream可以处理任意文件中的数据,但与 SharedPreferences 一样,只能在手机内存的指定目录下建立文件,因此,在实际的开发使用中有很大的局限性,那么在这一节中,我们来看一个比较高级的方法来实现数据的持久化--读写SD卡上的内容. --读取ass

Android数据持久化之I/O操作详解

本文实例讲述了Android数据持久化之I/O操作.分享给大家供大家参考,具体如下: 前面文章里我们简单的介绍了File的操作,这一节来说说使用android平台自带对象实现文件的基本操作 主要的两个类:openFileOutput(写)和openFileInput(读) 向文件中写如数据代码如下: //向文件写入内容 try { OutputStream os = openFileOutput("file-io.txt", Context.MODE_PRIVATE); String

Android数据持久化之File机制分析

本文实例讲述了Android数据持久化之File机制.分享给大家供大家参考,具体如下: 在使用Java SE平台开发C/S结构的软件中,File 的IO输入输出流的使用率是非常高的,通过使用IO输入输出流可以对存储介质上的文件进行读写操作,下面的代码就是实现一个在Android平台上使用File对象操作文件的功能: package com.example.data_file; import java.io.File; import java.io.FileInputStream; import

Android数据持久化之Preferences机制详解

本文实例讲述了Android数据持久化之Preferences机制.分享给大家供大家参考,具体如下: 在Android中,实现数据持久化有五种方式:Preferences,文件File,I/O操作.SQLite数据库,ContentProvider组件. 下面逐个做一简单的介绍: 一.Preferences的介绍: Preferences是一种轻量级的数据存储机制,他将一些简单的数据类型的数据,包括boolean类型,int类型,float类型,long类型以及String类型的数据,以键值对的

JavaWeb开发使用Cookie创建-获取-持久化、自动登录、购物记录、作用路径_java

1.cookie是啥?随手百度了网友的说说 简单的说,Cookie就是服务器暂存放在你计算机上的一笔资料,好让服务器用来辨认你的计算机.当你在浏览网站的时候,Web服务器会先送一小小资料放在你的计算机上,当下次你再光临同一个网站,Web服务器会先看看有没有它上次留下的Cookie资料,有的话,就会依据Cookie里的内容来判断使用者,送出特定的网页内容给你. 2.cookie在哪里? 3.cookie可以删除吗? 4.cookie实现原理 第一次请求浏览器,在浏览器的cookie存储区,没有co

Android中的cookie管理简介

Cookie管理是大家在做安卓app中难以避免的问题.我在此发表一些拙见. 先看看cookie可能存放的位置 1.Httpclient会存储当次请求的cookie内容,存储位置在 httpClient.getCookieStore 但是apache建议自定义cookie存储方式,因为cookiestore把cookie放在arraylist里很容易被系统回收[1]. 2.WebView会存储cookie在CookieManager,具体使用方式,后续的文章会讲这里不是重点. 正常HttpClie

Android如何使用读写cookie的方法

http://www.cnblogs.com/cosiray/archive/2012/06/25/2562117.html 可以使用SharedPreferences或者SQLite来保存用户信息 private static HashMap<String,String>  CookieContiner=new HashMap<String,String>() ;     /** * 保存Cookie * @param resp */     public void SaveCo

前端开发中Cookie那些事儿：cookie属性详解

前段时间做了项目,在前端实现中频繁的操作cookie,记录几点供大家参考! cookie操作在前端开发过程中经常遇到,当然如果只是用来存储一些简单用户数据,还是比较简单的,我们要做的可能只是设置cookie名,值,过期时间等,读取也只要根据cookie的名读取相应的cookie值就可以了.在复杂的应用中,光这些肯定就不够了. cookie的属性 除了name(名)和value(值),cookie还有以下一些可选属性,用来控制cookie的有效期,作用域,安全性等: expires属性   指定了