xutils 2.x（2.6）中的session获得和cookieStore使用

来源：互联网发布：mac word选项编辑：程序博客网时间：2024/06/10 15:55

xutils框架是如今使用比较广泛的android开源框架，我对其也情有独钟，对于框架模块，我想大家都很熟悉了，就不多说了。我今天主要主要说下xutils2.6中如何为http请求设置cookie和session，当时这个问题纠结了很久，试了多次，问了不少人，上网搜索，结果越来越模糊，最终通过认真阅读源代码，终于清楚如何使用了，现在和大家分享一下自己的心得，也希望大家对开源框架的学习要认真阅读源代码。

不多说了，大家看示例。

程序设计到三个类，

1.MyApplication（扩展应用）定义保存的Cookie和会话的全局变量

2.LoginActivity演示获得的cookie和session

3.GetDataActivity演示设置的cookie和session

[java] view plain copy
import com.lidroid.xutils.util.PreferencesCookieStore;  
import android.app.Application;  
public class MyApplication extends Application{  
      
    /** 
     * 用PreferencesCookieStore 持久化cookie到本地  
     *   类的定义：public class PreferencesCookieStore implements CookieStore 
     *   其内部用SharedPreferences保存，操作内部已封装 
     * 位置：com.lidroid.xutils.util.PreferencesCookieStore; 
     *  
     * 特别注意：PreferencesCookieStore 这个类在xutils 2.6中才出现，以前的版本没有 
     *          xutils 3.x 版本中也没有这个类 
     *          在xutils 2.6 以前版本要么自己参照PreferencesCookieStore源码，保存cookie到本地 
     *          或者自己用SharedPreferences保存sessionid 到本地,sessionid就是一个字符串，用 
     *          SharedPreferences保存很简单，就不介绍了 
     *           
     * 注：sessionid  实际是保存在cookie中 
     *       向服务器可以提交cookie 或 sessionid 
     *       提交cookie :调用方法 public HttpUtils configCookieStore(CookieStore cookieStore);  
     *       提交sessionid ： RequestParams public void addHeader(String name, String value); 
     *                       或setHeader(String name, String value); 
     */  
    public static PreferencesCookieStore presCookieStore;  
    public static String jsessionid = ""; //保存sessionid  
  
    public void onCreate() {          
        /* 
         * 程序启动，调用这个构造函数 
         * 在构造函数中 PreferencesCookieStore内部从本地 
         * 取出cookie,保存在PreferencesCookieStore 中的队列中 
         * 如果本地没有，PreferencesCookieStore  public List<Cookie> getCookies(); 
         * 返回的 List<Cookie> 长度为0 
         *  
         */  
        presCookieStore = new PreferencesCookieStore(getApplicationContext());  
  
    }  
  
}  

[java] view plain copy
import java.util.List;  
import org.apache.http.client.CookieStore;  
import org.apache.http.cookie.Cookie;  
import org.apache.http.impl.client.DefaultHttpClient;  
import com.lidroid.xutils.HttpUtils;  
import com.lidroid.xutils.exception.HttpException;  
import com.lidroid.xutils.http.RequestParams;  
import com.lidroid.xutils.http.ResponseInfo;  
import com.lidroid.xutils.http.callback.RequestCallBack;  
import com.lidroid.xutils.http.client.HttpRequest.HttpMethod;  
  
public class LoginActivity {      
    /** 
     * 登陆 后获得cookie sessionid 
     * 这儿只是演示如何获得cookie和seesionid 
     * 因此 url,RequestParams 直接用null,大家注意 
     * 
     */  
    public void login(){          
        final HttpUtils http = new HttpUtils();  
        String url = null;  
        RequestParams params = null;          
        http.send(HttpMethod.POST, url,params, new RequestCallBack<String>() {  
              
            @Override  
            public void onFailure(HttpException arg0, String arg1) {  
            }  
  
            @Override  
            public void onSuccess(ResponseInfo<String> arg0) {                  
                /* 
                 * 得到cookie seesionid 并持久化到本地的核心代码 
                 */  
                DefaultHttpClient defaultHttpClient = (DefaultHttpClient) http.getHttpClient();  
                CookieStore cookieStore = defaultHttpClient.getCookieStore();  
                List<Cookie> cookies = cookieStore.getCookies();  
                for (Cookie cookie : cookies) {  
                    if ("JSESSIONID".equals(cookie.getName())) {  
                        MyApplication.jsessionid = cookie.getValue(); //得到sessionid  
                    }  
                    MyApplication.presCookieStore.addCookie(cookie); //将cookie保存在本地  
                }                 
            }         
        });  
          
    }  
  
}  

[java] view plain copy
import com.lidroid.xutils.HttpUtils;  
import com.lidroid.xutils.exception.HttpException;  
import com.lidroid.xutils.http.RequestParams;  
import com.lidroid.xutils.http.ResponseInfo;  
import com.lidroid.xutils.http.callback.RequestCallBack;  
import com.lidroid.xutils.http.client.HttpRequest.HttpMethod;  
  
/** 
 * 从服务器获取数据前 添加cookie 
 * 或sessionid 
 *  
 * @author Administrator 
 * 
 */  
public class GetDataActivity {  
      
    public void getData() {  
        final HttpUtils http = new HttpUtils();  
        String url = null;    
        /* 
         * get无参请求添加cookie 
         * get 含参请求可以添加cookie或session 
         * post请求可以添加cookie或session 
         */  
        http.configCookieStore(MyApplication.presCookieStore);   
        http.send(HttpMethod.GET, url,  new RequestCallBack<String>() {  
            @Override  
            public void onFailure(HttpException arg0, String arg1) {}  
            @Override  
            public void onSuccess(ResponseInfo<String> arg0) {}  
  
        });  
          
        /* 
         * seesionid字段在不同服务器开发语言中不同 
         * java中“JSESSIONID”，php中“PSESSIONID” 其他请自己查阅资料 
         * 这儿用java示例 
         *  
         * setHeader 和addHeader的区别： 
         *   setHeader 未设置时，添加；已设置，重新赋值 
         *   addHeader 未设置时，添加；已设置，仍保持以前的值不变 
         */  
        RequestParams params = new RequestParams();  
        params.setHeader("Cookie", "JSESSIONID="+MyApplication.jsessionid); //设置头信息  
        http.send(HttpMethod.GET, url,  new RequestCallBack<String>() {  
            @Override  
            public void onFailure(HttpException arg0, String arg1) {}  
            @Override  
            public void onSuccess(ResponseInfo<String> arg0) {}  
  
        });       
    }  
}  

如果存在不足，请大家多多指教，共同进步！

参考Xutils2.6源代码

1.HttpUtils

[java] view plain copy
package com.lidroid.xutils;  
  
import android.text.TextUtils;  
import com.lidroid.xutils.exception.HttpException;  
import com.lidroid.xutils.http.*;  
import com.lidroid.xutils.http.callback.HttpRedirectHandler;  
import com.lidroid.xutils.http.callback.RequestCallBack;  
import com.lidroid.xutils.http.client.DefaultSSLSocketFactory;  
import com.lidroid.xutils.http.client.HttpRequest;  
import com.lidroid.xutils.http.client.RetryHandler;  
import com.lidroid.xutils.http.client.entity.GZipDecompressingEntity;  
import com.lidroid.xutils.task.PriorityExecutor;  
import com.lidroid.xutils.util.OtherUtils;  
import org.apache.http.*;  
import org.apache.http.client.CookieStore;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.protocol.ClientContext;  
import org.apache.http.conn.params.ConnManagerParams;  
import org.apache.http.conn.params.ConnPerRouteBean;  
import org.apache.http.conn.scheme.PlainSocketFactory;  
import org.apache.http.conn.scheme.Scheme;  
import org.apache.http.conn.scheme.SchemeRegistry;  
import org.apache.http.conn.ssl.SSLSocketFactory;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;  
import org.apache.http.params.BasicHttpParams;  
import org.apache.http.params.HttpConnectionParams;  
import org.apache.http.params.HttpParams;  
import org.apache.http.params.HttpProtocolParams;  
import org.apache.http.protocol.BasicHttpContext;  
import org.apache.http.protocol.HTTP;  
import org.apache.http.protocol.HttpContext;  
  
import java.io.File;  
import java.io.IOException;  
  
public class HttpUtils {  
  
    public final static HttpCache sHttpCache = new HttpCache();  
  
    private final DefaultHttpClient httpClient;  
    private final HttpContext httpContext = new BasicHttpContext();  
  
    private HttpRedirectHandler httpRedirectHandler;  
  
    public HttpUtils() {  
        this(HttpUtils.DEFAULT_CONN_TIMEOUT, null);  
    }  
  
    public HttpUtils(int connTimeout) {  
        this(connTimeout, null);  
    }  
  
    public HttpUtils(String userAgent) {  
        this(HttpUtils.DEFAULT_CONN_TIMEOUT, userAgent);  
    }  
  
    public HttpUtils(int connTimeout, String userAgent) {  
        HttpParams params = new BasicHttpParams();  
  
        ConnManagerParams.setTimeout(params, connTimeout);  
        HttpConnectionParams.setSoTimeout(params, connTimeout);  
        HttpConnectionParams.setConnectionTimeout(params, connTimeout);  
  
        if (TextUtils.isEmpty(userAgent)) {  
            userAgent = OtherUtils.getUserAgent(null);  
        }  
        HttpProtocolParams.setUserAgent(params, userAgent);  
  
        ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10));  
        ConnManagerParams.setMaxTotalConnections(params, 10);  
  
        HttpConnectionParams.setTcpNoDelay(params, true);  
        HttpConnectionParams.setSocketBufferSize(params, 1024 * 8);  
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);  
  
        SchemeRegistry schemeRegistry = new SchemeRegistry();  
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));  
        schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443));  
  
        httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);  
  
        httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));  
  
        httpClient.addRequestInterceptor(new HttpRequestInterceptor() {  
            @Override  
            public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.HttpException, IOException {  
                if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) {  
                    httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);  
                }  
            }  
        });  
  
        httpClient.addResponseInterceptor(new HttpResponseInterceptor() {  
            @Override  
            public void process(HttpResponse response, HttpContext httpContext) throws org.apache.http.HttpException, IOException {  
                final HttpEntity entity = response.getEntity();  
                if (entity == null) {  
                    return;  
                }  
                final Header encoding = entity.getContentEncoding();  
                if (encoding != null) {  
                    for (HeaderElement element : encoding.getElements()) {  
                        if (element.getName().equalsIgnoreCase("gzip")) {  
                            response.setEntity(new GZipDecompressingEntity(response.getEntity()));  
                            return;  
                        }  
                    }  
                }  
            }  
        });  
    }  
  
    // ************************************    default settings & fields ****************************  
  
    private String responseTextCharset = HTTP.UTF_8;  
  
    private long currentRequestExpiry = HttpCache.getDefaultExpiryTime();  
  
    private final static int DEFAULT_CONN_TIMEOUT = 1000 * 15; // 15s  
  
    private final static int DEFAULT_RETRY_TIMES = 3;  
  
    private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";  
    private static final String ENCODING_GZIP = "gzip";  
  
    private final static int DEFAULT_POOL_SIZE = 3;  
    private final static PriorityExecutor EXECUTOR = new PriorityExecutor(DEFAULT_POOL_SIZE);  
  
    public HttpClient getHttpClient() {  
        return this.httpClient;  
    }  
  
    // ***************************************** config *******************************************  
  
    public HttpUtils configResponseTextCharset(String charSet) {  
        if (!TextUtils.isEmpty(charSet)) {  
            this.responseTextCharset = charSet;  
        }  
        return this;  
    }  
  
    public HttpUtils configHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) {  
        this.httpRedirectHandler = httpRedirectHandler;  
        return this;  
    }  
  
    public HttpUtils configHttpCacheSize(int httpCacheSize) {  
        sHttpCache.setCacheSize(httpCacheSize);  
        return this;  
    }  
  
    public HttpUtils configDefaultHttpCacheExpiry(long defaultExpiry) {  
        HttpCache.setDefaultExpiryTime(defaultExpiry);  
        currentRequestExpiry = HttpCache.getDefaultExpiryTime();  
        return this;  
    }  
  
    public HttpUtils configCurrentHttpCacheExpiry(long currRequestExpiry) {  
        this.currentRequestExpiry = currRequestExpiry;  
        return this;  
    }  
  
    public HttpUtils configCookieStore(CookieStore cookieStore) {  
        httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);  
        return this;  
    }  
  
    public HttpUtils configUserAgent(String userAgent) {  
        HttpProtocolParams.setUserAgent(this.httpClient.getParams(), userAgent);  
        return this;  
    }  
  
    public HttpUtils configTimeout(int timeout) {  
        final HttpParams httpParams = this.httpClient.getParams();  
        ConnManagerParams.setTimeout(httpParams, timeout);  
        HttpConnectionParams.setConnectionTimeout(httpParams, timeout);  
        return this;  
    }  
  
    public HttpUtils configSoTimeout(int timeout) {  
        final HttpParams httpParams = this.httpClient.getParams();  
        HttpConnectionParams.setSoTimeout(httpParams, timeout);  
        return this;  
    }  
  
    public HttpUtils configRegisterScheme(Scheme scheme) {  
        this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);  
        return this;  
    }  
  
    public HttpUtils configSSLSocketFactory(SSLSocketFactory sslSocketFactory) {  
        Scheme scheme = new Scheme("https", sslSocketFactory, 443);  
        this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);  
        return this;  
    }  
  
    public HttpUtils configRequestRetryCount(int count) {  
        this.httpClient.setHttpRequestRetryHandler(new RetryHandler(count));  
        return this;  
    }  
  
    public HttpUtils configRequestThreadPoolSize(int threadPoolSize) {  
        HttpUtils.EXECUTOR.setPoolSize(threadPoolSize);  
        return this;  
    }  
  
    // ***************************************** send request *******************************************  
  
    public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url,  
                                   RequestCallBack<T> callBack) {  
        return send(method, url, null, callBack);  
    }  
  
    public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url, RequestParams params,  
                                   RequestCallBack<T> callBack) {  
        if (url == null) throw new IllegalArgumentException("url may not be null");  
  
        HttpRequest request = new HttpRequest(method, url);  
        return sendRequest(request, params, callBack);  
    }  
  
    public ResponseStream sendSync(HttpRequest.HttpMethod method, String url) throws HttpException {  
        return sendSync(method, url, null);  
    }  
  
    public ResponseStream sendSync(HttpRequest.HttpMethod method, String url, RequestParams params) throws HttpException {  
        if (url == null) throw new IllegalArgumentException("url may not be null");  
  
        HttpRequest request = new HttpRequest(method, url);  
        return sendSyncRequest(request, params);  
    }  
  
    // ***************************************** download *******************************************  
  
    public HttpHandler<File> download(String url, String target,  
                                      RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, null, false, false, callback);  
    }  
  
    public HttpHandler<File> download(String url, String target,  
                                      boolean autoResume, RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, false, callback);  
    }  
  
    public HttpHandler<File> download(String url, String target,  
                                      boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, autoRename, callback);  
    }  
  
    public HttpHandler<File> download(String url, String target,  
                                      RequestParams params, RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, params, false, false, callback);  
    }  
  
    public HttpHandler<File> download(String url, String target,  
                                      RequestParams params, boolean autoResume, RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, false, callback);  
    }  
  
    public HttpHandler<File> download(String url, String target,  
                                      RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {  
        return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, autoRename, callback);  
    }  
  
    public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
                                      RequestParams params, RequestCallBack<File> callback) {  
        return download(method, url, target, params, false, false, callback);  
    }  
  
    public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
                                      RequestParams params, boolean autoResume, RequestCallBack<File> callback) {  
        return download(method, url, target, params, autoResume, false, callback);  
    }  
  
    public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
                                      RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {  
  
        if (url == null) throw new IllegalArgumentException("url may not be null");  
        if (target == null) throw new IllegalArgumentException("target may not be null");  
  
        HttpRequest request = new HttpRequest(method, url);  
  
        HttpHandler<File> handler = new HttpHandler<File>(httpClient, httpContext, responseTextCharset, callback);  
  
        handler.setExpiry(currentRequestExpiry);  
        handler.setHttpRedirectHandler(httpRedirectHandler);  
  
        if (params != null) {  
            request.setRequestParams(params, handler);  
            handler.setPriority(params.getPriority());  
        }  
        handler.executeOnExecutor(EXECUTOR, request, target, autoResume, autoRename);  
        return handler;  
    }  
  
    ////////////////////////////////////////////////////////////////////////////////////////////////  
    private <T> HttpHandler<T> sendRequest(HttpRequest request, RequestParams params, RequestCallBack<T> callBack) {  
  
        HttpHandler<T> handler = new HttpHandler<T>(httpClient, httpContext, responseTextCharset, callBack);  
  
        handler.setExpiry(currentRequestExpiry);  
        handler.setHttpRedirectHandler(httpRedirectHandler);  
        request.setRequestParams(params, handler);  
  
        if (params != null) {  
            handler.setPriority(params.getPriority());  
        }  
        handler.executeOnExecutor(EXECUTOR, request);  
        return handler;  
    }  
  
    private ResponseStream sendSyncRequest(HttpRequest request, RequestParams params) throws HttpException {  
  
        SyncHttpHandler handler = new SyncHttpHandler(httpClient, httpContext, responseTextCharset);  
  
        handler.setExpiry(currentRequestExpiry);  
        handler.setHttpRedirectHandler(httpRedirectHandler);  
        request.setRequestParams(params);  
  
        return handler.sendRequest(request);  
    }  
}  

2.PreferencesCookieStore

[java] view plain copy
package com.lidroid.xutils.util;  
  
import android.content.Context;  
import android.content.SharedPreferences;  
import android.text.TextUtils;  
import org.apache.http.client.CookieStore;  
import org.apache.http.cookie.Cookie;  
import org.apache.http.impl.cookie.BasicClientCookie;  
  
import java.io.*;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
import java.util.concurrent.ConcurrentHashMap;  
  
/** 
 * A CookieStore impl, it's save cookie to SharedPreferences. 
 * 
 * @author michael yang 
 */  
public class PreferencesCookieStore implements CookieStore {  
  
    private static final String COOKIE_PREFS = "CookiePrefsFile";  
    private static final String COOKIE_NAME_STORE = "names";  
    private static final String COOKIE_NAME_PREFIX = "cookie_";  
  
    private final ConcurrentHashMap<String, Cookie> cookies;  
    private final SharedPreferences cookiePrefs;  
  
    /** 
     * Construct a persistent cookie store. 
     */  
    public PreferencesCookieStore(Context context) {  
        cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, Context.MODE_PRIVATE);  
        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) {  
        String name = cookie.getName();  
  
        // 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 editor = cookiePrefs.edit();  
        editor.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  
        editor.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));  
        editor.commit();  
    }  
  
    @Override  
    public void clear() {  
        // Clear cookies from persistent store  
        SharedPreferences.Editor editor = cookiePrefs.edit();  
        for (String name : cookies.keySet()) {  
            editor.remove(COOKIE_NAME_PREFIX + name);  
        }  
        editor.remove(COOKIE_NAME_STORE);  
        editor.commit();  
  
        // Clear cookies from local store  
        cookies.clear();  
    }  
  
    @Override  
    public boolean clearExpired(Date date) {  
        boolean clearedAny = false;  
        SharedPreferences.Editor editor = cookiePrefs.edit();  
  
        for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {  
            String name = entry.getKey();  
            Cookie cookie = entry.getValue();  
            if (cookie.getExpiryDate() == null || cookie.isExpired(date)) {  
                // Remove the cookie by name  
                cookies.remove(name);  
  
                // Clear cookies from persistent store  
                editor.remove(COOKIE_NAME_PREFIX + name);  
  
                // We've cleared at least one  
                clearedAny = true;  
            }  
        }  
  
        // Update names in persistent store  
        if (clearedAny) {  
            editor.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  
        }  
        editor.commit();  
  
        return clearedAny;  
    }  
  
    @Override  
    public List<Cookie> getCookies() {  
        return new ArrayList<Cookie>(cookies.values());  
    }  
  
    public Cookie getCookie(String name) {  
        return cookies.get(name);  
    }  
  
  
    protected String encodeCookie(SerializableCookie cookie) {  
        ByteArrayOutputStream os = new ByteArrayOutputStream();  
        try {  
            ObjectOutputStream outputStream = new ObjectOutputStream(os);  
            outputStream.writeObject(cookie);  
        } catch (Throwable e) {  
            return null;  
        }  
  
        return byteArrayToHexString(os.toByteArray());  
    }  
  
    protected Cookie decodeCookie(String cookieStr) {  
        byte[] bytes = hexStringToByteArray(cookieStr);  
        ByteArrayInputStream is = new ByteArrayInputStream(bytes);  
        Cookie cookie = null;  
        try {  
            ObjectInputStream ois = new ObjectInputStream(is);  
            cookie = ((SerializableCookie) ois.readObject()).getCookie();  
        } catch (Throwable e) {  
            LogUtils.e(e.getMessage(), e);  
        }  
  
        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!  
    protected String byteArrayToHexString(byte[] b) {  
        StringBuffer sb = new StringBuffer(b.length * 2);  
        for (byte element : b) {  
            int v = element & 0xff;  
            if (v < 16) {  
                sb.append('0');  
            }  
            sb.append(Integer.toHexString(v));  
        }  
        return sb.toString().toUpperCase();  
    }  
  
    protected byte[] hexStringToByteArray(String s) {  
        int len = s.length();  
        byte[] data = new byte[len / 2];  
        for (int i = 0; i < len; i += 2) {  
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));  
        }  
        return data;  
    }  
  
  
    public class SerializableCookie implements Serializable {  
        private static final long serialVersionUID = 6374381828722046732L;  
  
        private transient final Cookie cookie;  
        private transient BasicClientCookie clientCookie;  
  
        public SerializableCookie(Cookie cookie) {  
            this.cookie = cookie;  
        }  
  
        public Cookie getCookie() {  
            Cookie bestCookie = cookie;  
            if (clientCookie != null) {  
                bestCookie = clientCookie;  
            }  
            return bestCookie;  
        }  
  
        private void writeObject(ObjectOutputStream out) throws IOException {  
            out.writeObject(cookie.getName());  
            out.writeObject(cookie.getValue());  
            out.writeObject(cookie.getComment());  
            out.writeObject(cookie.getDomain());  
            out.writeObject(cookie.getExpiryDate());  
            out.writeObject(cookie.getPath());  
            out.writeInt(cookie.getVersion());  
            out.writeBoolean(cookie.isSecure());  
        }  
  
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
            String name = (String) in.readObject();  
            String value = (String) in.readObject();  
            clientCookie = new BasicClientCookie(name, value);  
            clientCookie.setComment((String) in.readObject());  
            clientCookie.setDomain((String) in.readObject());  
            clientCookie.setExpiryDate((Date) in.readObject());  
            clientCookie.setPath((String) in.readObject());  
            clientCookie.setVersion(in.readInt());  
            clientCookie.setSecure(in.readBoolean());  
        }  
    }  
}  

3.RequestParams

[java] view plain copy
package com.lidroid.xutils.http;  
  
import android.text.TextUtils;  
import com.lidroid.xutils.http.client.entity.BodyParamsEntity;  
import com.lidroid.xutils.http.client.multipart.HttpMultipartMode;  
import com.lidroid.xutils.http.client.multipart.MultipartEntity;  
import com.lidroid.xutils.http.client.multipart.content.ContentBody;  
import com.lidroid.xutils.http.client.multipart.content.FileBody;  
import com.lidroid.xutils.http.client.multipart.content.InputStreamBody;  
import com.lidroid.xutils.http.client.multipart.content.StringBody;  
import com.lidroid.xutils.util.LogUtils;  
import com.lidroid.xutils.task.Priority;  
import org.apache.http.Header;  
import org.apache.http.HttpEntity;  
import org.apache.http.NameValuePair;  
import org.apache.http.message.BasicHeader;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.protocol.HTTP;  
  
import java.io.File;  
import java.io.InputStream;  
import java.io.UnsupportedEncodingException;  
import java.nio.charset.Charset;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.concurrent.ConcurrentHashMap;  
  
  
public class RequestParams {  
  
    private String charset = HTTP.UTF_8;  
  
    private List<HeaderItem> headers;  
    private List<NameValuePair> queryStringParams;  
    private HttpEntity bodyEntity;  
    private List<NameValuePair> bodyParams;  
    private HashMap<String, ContentBody> fileParams;  
  
    private Priority priority;  
  
    public RequestParams() {  
    }  
  
    public RequestParams(String charset) {  
        if (!TextUtils.isEmpty(charset)) {  
            this.charset = charset;  
        }  
    }  
  
    public Priority getPriority() {  
        return priority;  
    }  
  
    public void setPriority(Priority priority) {  
        this.priority = priority;  
    }  
  
    public String getCharset() {  
        return charset;  
    }  
  
    public void setContentType(String contentType) {  
        this.setHeader("Content-Type", contentType);  
    }  
  
    /** 
     * Adds a header to this message. The header will be appended to the end of the list. 
     * 
     * @param header 
     */  
    public void addHeader(Header header) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        this.headers.add(new HeaderItem(header));  
    }  
  
    /** 
     * Adds a header to this message. The header will be appended to the end of the list. 
     * 
     * @param name 
     * @param value 
     */  
    public void addHeader(String name, String value) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        this.headers.add(new HeaderItem(name, value));  
    }  
  
    /** 
     * Adds all the headers to this message. 
     * 
     * @param headers 
     */  
    public void addHeaders(List<Header> headers) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        for (Header header : headers) {  
            this.headers.add(new HeaderItem(header));  
        }  
    }  
  
    /** 
     * Overwrites the first header with the same name. 
     * The new header will be appended to the end of the list, if no header with the given name can be found. 
     * 
     * @param header 
     */  
    public void setHeader(Header header) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        this.headers.add(new HeaderItem(header, true));  
    }  
  
    /** 
     * Overwrites the first header with the same name. 
     * The new header will be appended to the end of the list, if no header with the given name can be found. 
     * 
     * @param name 
     * @param value 
     */  
    public void setHeader(String name, String value) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        this.headers.add(new HeaderItem(name, value, true));  
    }  
  
    /** 
     * Overwrites all the headers in the message. 
     * 
     * @param headers 
     */  
    public void setHeaders(List<Header> headers) {  
        if (this.headers == null) {  
            this.headers = new ArrayList<HeaderItem>();  
        }  
        for (Header header : headers) {  
            this.headers.add(new HeaderItem(header, true));  
        }  
    }  
  
    public void addQueryStringParameter(String name, String value) {  
        if (queryStringParams == null) {  
            queryStringParams = new ArrayList<NameValuePair>();  
        }  
        queryStringParams.add(new BasicNameValuePair(name, value));  
    }  
  
    public void addQueryStringParameter(NameValuePair nameValuePair) {  
        if (queryStringParams == null) {  
            queryStringParams = new ArrayList<NameValuePair>();  
        }  
        queryStringParams.add(nameValuePair);  
    }  
  
    public void addQueryStringParameter(List<NameValuePair> nameValuePairs) {  
        if (queryStringParams == null) {  
            queryStringParams = new ArrayList<NameValuePair>();  
        }  
        if (nameValuePairs != null && nameValuePairs.size() > 0) {  
            for (NameValuePair pair : nameValuePairs) {  
                queryStringParams.add(pair);  
            }  
        }  
    }  
  
    public void addBodyParameter(String name, String value) {  
        if (bodyParams == null) {  
            bodyParams = new ArrayList<NameValuePair>();  
        }  
        bodyParams.add(new BasicNameValuePair(name, value));  
    }  
  
    public void addBodyParameter(NameValuePair nameValuePair) {  
        if (bodyParams == null) {  
            bodyParams = new ArrayList<NameValuePair>();  
        }  
        bodyParams.add(nameValuePair);  
    }  
  
    public void addBodyParameter(List<NameValuePair> nameValuePairs) {  
        if (bodyParams == null) {  
            bodyParams = new ArrayList<NameValuePair>();  
        }  
        if (nameValuePairs != null && nameValuePairs.size() > 0) {  
            for (NameValuePair pair : nameValuePairs) {  
                bodyParams.add(pair);  
            }  
        }  
    }  
  
    public void addBodyParameter(String key, File file) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new FileBody(file));  
    }  
  
    public void addBodyParameter(String key, File file, String mimeType) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new FileBody(file, mimeType));  
    }  
  
    public void addBodyParameter(String key, File file, String mimeType, String charset) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new FileBody(file, mimeType, charset));  
    }  
  
    public void addBodyParameter(String key, File file, String fileName, String mimeType, String charset) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new FileBody(file, fileName, mimeType, charset));  
    }  
  
    public void addBodyParameter(String key, InputStream stream, long length) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new InputStreamBody(stream, length));  
    }  
  
    public void addBodyParameter(String key, InputStream stream, long length, String fileName) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new InputStreamBody(stream, length, fileName));  
    }  
  
    public void addBodyParameter(String key, InputStream stream, long length, String fileName, String mimeType) {  
        if (fileParams == null) {  
            fileParams = new HashMap<String, ContentBody>();  
        }  
        fileParams.put(key, new InputStreamBody(stream, length, fileName, mimeType));  
    }  
  
    public void setBodyEntity(HttpEntity bodyEntity) {  
        this.bodyEntity = bodyEntity;  
        if (bodyParams != null) {  
            bodyParams.clear();  
            bodyParams = null;  
        }  
        if (fileParams != null) {  
            fileParams.clear();  
            fileParams = null;  
        }  
    }  
  
    /** 
     * Returns an HttpEntity containing all request parameters 
     */  
    public HttpEntity getEntity() {  
  
        if (bodyEntity != null) {  
            return bodyEntity;  
        }  
  
        HttpEntity result = null;  
  
        if (fileParams != null && !fileParams.isEmpty()) {  
  
            MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.STRICT, null, Charset.forName(charset));  
  
            if (bodyParams != null && !bodyParams.isEmpty()) {  
                for (NameValuePair param : bodyParams) {  
                    try {  
                        multipartEntity.addPart(param.getName(), new StringBody(param.getValue()));  
                    } catch (UnsupportedEncodingException e) {  
                        LogUtils.e(e.getMessage(), e);  
                    }  
                }  
            }  
  
            for (ConcurrentHashMap.Entry<String, ContentBody> entry : fileParams.entrySet()) {  
                multipartEntity.addPart(entry.getKey(), entry.getValue());  
            }  
  
            result = multipartEntity;  
        } else if (bodyParams != null && !bodyParams.isEmpty()) {  
            result = new BodyParamsEntity(bodyParams, charset);  
        }  
  
        return result;  
    }  
  
    public List<NameValuePair> getQueryStringParams() {  
        return queryStringParams;  
    }  
  
    public List<HeaderItem> getHeaders() {  
        return headers;  
    }  
  
    public class HeaderItem {  
        public final boolean overwrite;  
        public final Header header;  
  
        public HeaderItem(Header header) {  
            this.overwrite = false;  
            this.header = header;  
        }  
  
        public HeaderItem(Header header, boolean overwrite) {  
            this.overwrite = overwrite;  
            this.header = header;  
        }  
  
        public HeaderItem(String name, String value) {  
            this.overwrite = false;  
            this.header = new BasicHeader(name, value);  
        }  
  
        public HeaderItem(String name, String value, boolean overwrite) {  
            this.overwrite = overwrite;  
            this.header = new BasicHeader(name, value);  
        }  
    }  

0 0