Android持久化保存cookie的方法

DefaultHttpClient httpclient = new DefaultHttpClient(); 
HttpGet httpget = new HttpGet("http://www.hlovey.com"); 
HttpResponse response = httpclient.execute(httpget); 
HttpEntity entity = response.getEntity(); 
List<Cookie  cookies = httpclient.getCookieStore().getCookies(); 

HttpPost httpPost = new HttpPost(url); 
List<NameValuePair  formparams = new ArrayList<NameValuePair (); 
formparams.add(new BasicNameValuePair("id", userid)); 
formparams.add(new BasicNameValuePair("passwd", passwd)); 
UrlEncodedFormEntity entity; 
try { 
 entity = new UrlEncodedFormEntity(formparams, mobileSMTHEncoding); 
} catch (UnsupportedEncodingException e1) { 
 return 3; 
} 
httpPost.setEntity(entity); 
httpPost.setHeader("User-Agent", userAgent); 
HttpResponse response = httpClient.execute(httpPost); 

package com.smthbest.smth.util; 
import java.util.Locale; 
import android.content.Context; 
import android.content.SharedPreferences; 
import android.text.TextUtils; 
import android.util.Log; 
import org.apache.http.client.CookieStore; 
import org.apache.http.cookie.Cookie; 
import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.util.ArrayList; 
import java.util.Date; 
import java.util.List; 
import java.util.Locale; 
import java.util.concurrent.ConcurrentHashMap; 
ic class PersistentCookieStore implements CookieStore { 
private static final String LOG_TAG = "PersistentCookieStore"; 
private static final String COOKIE_PREFS = "CookiePrefsFile"; 
private static final String COOKIE_NAME_STORE = "names"; 
private static final String COOKIE_NAME_PREFIX = "cookie_"; 
private boolean omitNonPersistentCookies = false; 
private final ConcurrentHashMap<String, Cookie  cookies; 
private final SharedPreferences cookiePrefs; 
/** 
* Construct a persistent cookie store. 
* 
* @param context Context to attach cookie store to 
*/ 
public PersistentCookieStore(Context context) { 
cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0); 
cookies = new ConcurrentHashMap<String, Cookie (); 
// Load any previously stored cookies into the store 
String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null); 
if (storedCookieNames != null) { 
String[] cookieNames = TextUtils.split(storedCookieNames, ","); 
for (String name : cookieNames) { 
String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null); 
if (encodedCookie != null) { 
Cookie decodedCookie = decodeCookie(encodedCookie); 
if (decodedCookie != null) { 
cookies.put(name, decodedCookie); 
} 
} 
} 
// Clear out expired cookies 
clearExpired(new Date()); 
} 
} 
@Override 
public void addCookie(Cookie cookie) { 
if (omitNonPersistentCookies && !cookie.isPersistent()) 
return; 
String name = cookie.getName() + cookie.getDomain(); 
// Save cookie into local store, or remove if expired 
if (!cookie.isExpired(new Date())) { 
cookies.put(name, cookie); 
} else { 
cookies.remove(name); 
} 
// Save cookie into persistent store 
SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); 
prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet())); 
prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie))); 
prefsWriter.commit(); 
} 
@Override 
public void clear() { 
// Clear cookies from persistent store 
SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); 
for (String name : cookies.keySet()) { 
prefsWriter.remove(COOKIE_NAME_PREFIX + name); 
} 
prefsWriter.remove(COOKIE_NAME_STORE); 
prefsWriter.commit(); 
// Clear cookies from local store 
cookies.clear(); 
} 
@Override 
public boolean clearExpired(Date date) { 
boolean clearedAny = false; 
SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); 
for (ConcurrentHashMap.Entry<String, Cookie  entry : cookies.entrySet()) { 
String name = entry.getKey(); 
Cookie cookie = entry.getValue(); 
if (cookie.isExpired(date)) { 
// Clear cookies from local store 
cookies.remove(name); 
// Clear cookies from persistent store 
prefsWriter.remove(COOKIE_NAME_PREFIX + name); 
// We've cleared at least one 
clearedAny = true; 
} 
} 
// Update names in persistent store 
if (clearedAny) { 
prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet())); 
} 
prefsWriter.commit(); 
return clearedAny; 
} 
@Override 
public List<Cookie  getCookies() { 
return new ArrayList<Cookie (cookies.values()); 
} 
/** 
* Will make PersistentCookieStore instance ignore Cookies, which are non-persistent by 
* signature (`Cookie.isPersistent`) 
* 
* @param omitNonPersistentCookies true if non-persistent cookies should be omited 
*/ 
public void setOmitNonPersistentCookies(boolean omitNonPersistentCookies) { 
this.omitNonPersistentCookies = omitNonPersistentCookies; 
} 
/** 
* Non-standard helper method, to delete cookie 
* 
* @param cookie cookie to be removed 
*/ 
public void deleteCookie(Cookie cookie) { 
String name = cookie.getName(); 
cookies.remove(name); 
SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); 
prefsWriter.remove(COOKIE_NAME_PREFIX + name); 
prefsWriter.commit(); 
} 
/** 
* Serializes Cookie object into String 
* 
* @param cookie cookie to be encoded, can be null 
* @return cookie encoded as String 
*/ 
protected String encodeCookie(SerializableCookie cookie) { 
if (cookie == null) 
return null; 
ByteArrayOutputStream os = new ByteArrayOutputStream(); 
try { 
ObjectOutputStream outputStream = new ObjectOutputStream(os); 
outputStream.writeObject(cookie); 
} catch (Exception e) { 
return null; 
} 
return byteArrayToHexString(os.toByteArray()); 
} 
/** 
* Returns cookie decoded from cookie string 
* 
* @param cookieString string of cookie as returned from http request 
* @return decoded cookie or null if exception occured 
*/ 
protected Cookie decodeCookie(String cookieString) { 
byte[] bytes = hexStringToByteArray(cookieString); 
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes); 
Cookie cookie = null; 
try { 
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream); 
cookie = ((SerializableCookie) objectInputStream.readObject()).getCookie(); 
} catch (Exception exception) { 
Log.d(LOG_TAG, "decodeCookie failed", exception); 
} 
return cookie; 
} 
/** 
* Using some super basic byte array <-  hex conversions so we don't have to rely on any 
* large Base64 libraries. Can be overridden if you like! 
* 
* @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); 
} 
/** 
* Converts hex values from strings to byte arra 
* 
* @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; 
} 

PersistentCookieStore myCookieStore = App.getInstance().getPersistentCookieStore(); 
List<Cookie  cookies = httpClient.getCookieStore().getCookies(); 
for (Cookie cookie:cookies){ 
myCookieStore.addCookie(cookie); 
} 

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