import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/**
 * This method is invoked immediately after 
 * {@link #readResponseHeaders(HttpState,HttpConnection)} and can be overridden by
 * sub-classes in order to provide custom response headers processing.

 * <p>
 * This implementation will handle the <tt>Set-Cookie</tt> and
 * <tt>Set-Cookie2</tt> headers, if any, adding the relevant cookies to
 * the given {@link HttpState}.
 * </p>
 *
 * @param state the {@link HttpState state} information associated with this method
 * @param conn the {@link HttpConnection connection} used to execute
 *        this HTTP method
 *
 * @see #readResponse
 * @see #readResponseHeaders
 */
protected void processResponseHeaders(HttpState state,
    HttpConnection conn) {
    LOG.trace("enter HttpMethodBase.processResponseHeaders(HttpState, "
        + "HttpConnection)");

    CookieSpec parser = getCookieSpec(state);

    // process set-cookie headers
    Header[] headers = getResponseHeaderGroup().getHeaders("set-cookie");
    processCookieHeaders(parser, headers, state, conn);

    // see if the cookie spec supports cookie versioning.
    if (parser instanceof CookieVersionSupport) {
        CookieVersionSupport versupport = (CookieVersionSupport) parser;
        if (versupport.getVersion() > 0) {
            // process set-cookie2 headers.
            // Cookie2 will replace equivalent Cookie instances
            headers = getResponseHeaderGroup().getHeaders("set-cookie2");
            processCookieHeaders(parser, headers, state, conn);
        }
    }
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/**
 * Returns an array of {@link Cookie cookies} in this HTTP 
 * state that match the given request parameters.
 * 
 * @param domain the request domain
 * @param port the request port
 * @param path the request path
 * @param secure <code>true</code> when using HTTPS
 * 
 * @return an array of {@link Cookie cookies}.
 * 
 * @see #getCookies()
 * 
 * @deprecated use CookieSpec#match(String, int, String, boolean, Cookie)
 */
public synchronized Cookie[] getCookies(
    String domain, 
    int port, 
    String path, 
    boolean secure
) {
    LOG.trace("enter HttpState.getCookies(String, int, String, boolean)");

    CookieSpec matcher = CookiePolicy.getDefaultSpec();
    ArrayList list = new ArrayList(cookies.size());
    for (int i = 0, m = cookies.size(); i < m; i++) {
        Cookie cookie = (Cookie) (cookies.get(i));
        if (matcher.match(domain, port, path, secure, cookie)) {
            list.add(cookie);
        }
    }
    return (Cookie[]) (list.toArray(new Cookie[list.size()]));
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/**
 * Return a textual representation of the cookie.
 * 
 * @return string.
 */
public String toExternalForm() {
    CookieSpec spec = null;
    if (getVersion() > 0) {
        spec = CookiePolicy.getDefaultSpec(); 
    } else {
        spec = CookiePolicy.getCookieSpec(CookiePolicy.NETSCAPE); 
    }
    return spec.formatCookie(this); 
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/**
 * <p>Compares two cookies to determine order for cookie header.</p>
 * <p>Most specific should be first. </p>
 * <p>This method is implemented so a cookie can be used as a comparator for
 * a SortedSet of cookies. Specifically it's used above in the 
 * createCookieHeader method.</p>
 * @param o1 The first object to be compared
 * @param o2 The second object to be compared
 * @return See {@link java.util.Comparator#compare(Object,Object)}
 */
public int compare(Object o1, Object o2) {
    LOG.trace("enter Cookie.compare(Object, Object)");

    if (!(o1 instanceof Cookie)) {
        throw new ClassCastException(o1.getClass().getName());
    }
    if (!(o2 instanceof Cookie)) {
        throw new ClassCastException(o2.getClass().getName());
    }
    Cookie c1 = (Cookie) o1;
    Cookie c2 = (Cookie) o2;
    if (c1.getPath() == null && c2.getPath() == null) {
        return 0;
    } else if (c1.getPath() == null) {
        // null is assumed to be "/"
        if (c2.getPath().equals(CookieSpec.PATH_DELIM)) {
            return 0;
        } else {
            return -1;
        }
    } else if (c2.getPath() == null) {
        // null is assumed to be "/"
        if (c1.getPath().equals(CookieSpec.PATH_DELIM)) {
            return 0;
        } else {
            return 1;
        }
    } else {
        return c1.getPath().compareTo(c2.getPath());
    }
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/** 
 * Returns the actual cookie policy
 * 
 * @param state HTTP state. TODO: to be removed in the future
 * 
 * @return cookie spec
 */
private CookieSpec getCookieSpec(final HttpState state) {
    if (this.cookiespec == null) {
        int i = state.getCookiePolicy();
        if (i == -1) {
            this.cookiespec = CookiePolicy.getCookieSpec(this.params.getCookiePolicy());
        } else {
            this.cookiespec = CookiePolicy.getSpecByPolicy(i);
        }
        this.cookiespec.setValidDateFormats(
                (Collection)this.params.getParameter(HttpMethodParams.DATE_PATTERNS));
    }
    return this.cookiespec;
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
public static List<Cookie> getResponseCookiesFromRequestResult(IContext context, RequestResult requestResult) throws MalformedURLException {
	if (requestResult == null)
		throw new IllegalArgumentException("No request result provided");
	
	List<Cookie> res = new ArrayList<Cookie>();
	JSONObject headers = new JSONObject(requestResult.get_ResponseHeaders());
	
	URL requestUrl = new URL(requestResult.getRequestUrl());
	CookieSpec spec = CookiePolicy.getDefaultSpec();
	
	if (headers.has("Set-Cookie")) {
		JSONArray cookies = headers.getJSONArray("Set-Cookie");
		for(int i = 0; i < cookies.length(); i++) {
			try {
				org.apache.commons.httpclient.Cookie[] innercookies = spec.parse(requestUrl.getHost(), requestUrl.getPort(), requestUrl.getPath(), "https".equals(requestUrl.getProtocol()), cookies.getString(i));
				for(org.apache.commons.httpclient.Cookie innercookie : innercookies) {
					Cookie cookie = new Cookie(context);
					cookie.setName(innercookie.getName());
					cookie.setValue(innercookie.getValue());
					cookie.setDomain(innercookie.getDomain());
					cookie.setPath(innercookie.getPath());
					cookie.setMaxAgeSeconds(innercookie.getExpiryDate() == null ? -1 : Math.round((innercookie.getExpiryDate().getTime() - System.currentTimeMillis()) / 1000L));
					res.add(cookie);
				}
			} catch (Exception e) {
				RestServices.LOGCONSUME.warn("Failed to parse cookie: " + e.getMessage(), e);
			}
		}
	}
	
	return res;
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
/**
 * <p>Compares two cookies to determine order for cookie header.</p>
 * <p>Most specific should be first. </p>
 * <p>This method is implemented so a cookie can be used as a comparator for
 * a SortedSet of cookies. Specifically it's used above in the 
 * createCookieHeader method.</p>
 * @param o1 The first object to be compared
 * @param o2 The second object to be compared
 * @return See {@link java.util.Comparator#compare(Object,Object)}
 */
public int compare(Object o1, Object o2) {
    LOG.trace("enter Cookie.compare(Object, Object)");

    if (!(o1 instanceof Cookie)) {
        throw new ClassCastException(o1.getClass().getName());
    }
    if (!(o2 instanceof Cookie)) {
        throw new ClassCastException(o2.getClass().getName());
    }
    Cookie c1 = (Cookie) o1;
    Cookie c2 = (Cookie) o2;
    if (c1.getPath() == null && c2.getPath() == null) {
        return 0;
    } else if (c1.getPath() == null) {
        // null is assumed to be "/"
        if (c2.getPath().equals(CookieSpec.PATH_DELIM)) {
            return 0;
        } else {
            return -1;
        }
    } else if (c2.getPath() == null) {
        // null is assumed to be "/"
        if (c1.getPath().equals(CookieSpec.PATH_DELIM)) {
            return 0;
        } else {
            return 1;
        }
    } else {
        return STRING_COLLATOR.compare(c1.getPath(), c2.getPath());
    }
}
 

import org.apache.commons.httpclient.cookie.CookieSpec; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

        HttpClient client = new HttpClient();
        client.getHostConfiguration().setHost(LOGON_SITE, LOGON_PORT, "http");
        client.getParams().setCookiePolicy(CookiePolicy.BROWSER_COMPATIBILITY);
        // 'developer.java.sun.com' has cookie compliance problems
        // Their session cookie's domain attribute is in violation of the RFC2109
        // We have to resort to using compatibility cookie policy

        GetMethod authget = new GetMethod("/servlet/SessionServlet");

        client.executeMethod(authget);
        System.out.println("Login form get: " + authget.getStatusLine().toString()); 
        // release any connection resources used by the method
        authget.releaseConnection();
        // See if we got any cookies
        CookieSpec cookiespec = CookiePolicy.getDefaultSpec();
        Cookie[] initcookies = cookiespec.match(
            LOGON_SITE, LOGON_PORT, "/", false, client.getState().getCookies());
        System.out.println("Initial set of cookies:");    
        if (initcookies.length == 0) {
            System.out.println("None");    
        } else {
            for (int i = 0; i < initcookies.length; i++) {
                System.out.println("- " + initcookies[i].toString());    
            }
        }
        
        PostMethod authpost = new PostMethod("/servlet/SessionServlet");
        // Prepare login parameters
        NameValuePair action   = new NameValuePair("action", "login");
        NameValuePair url      = new NameValuePair("url", "/index.html");
        NameValuePair userid   = new NameValuePair("UserId", "userid");
        NameValuePair password = new NameValuePair("Password", "password");
        authpost.setRequestBody( 
          new NameValuePair[] {action, url, userid, password});
        
        client.executeMethod(authpost);
        System.out.println("Login form post: " + authpost.getStatusLine().toString()); 
        // release any connection resources used by the method
        authpost.releaseConnection();
        // See if we got any cookies
        // The only way of telling whether logon succeeded is 
        // by finding a session cookie
        Cookie[] logoncookies = cookiespec.match(
            LOGON_SITE, LOGON_PORT, "/", false, client.getState().getCookies());
        System.out.println("Logon cookies:");    
        if (logoncookies.length == 0) {
            System.out.println("None");    
        } else {
            for (int i = 0; i < logoncookies.length; i++) {
                System.out.println("- " + logoncookies[i].toString());    
            }
        }
        // Usually a successful form-based login results in a redicrect to 
        // another url
        int statuscode = authpost.getStatusCode();
        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
            (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
            (statuscode == HttpStatus.SC_SEE_OTHER) ||
            (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
            Header header = authpost.getResponseHeader("location");
            if (header != null) {
                String newuri = header.getValue();
                if ((newuri == null) || (newuri.equals(""))) {
                    newuri = "/";
                }
                System.out.println("Redirect target: " + newuri); 
                GetMethod redirect = new GetMethod(newuri);

                client.executeMethod(redirect);
                System.out.println("Redirect: " + redirect.getStatusLine().toString()); 
                // release any connection resources used by the method
                redirect.releaseConnection();
            } else {
                System.out.println("Invalid redirect");
                System.exit(1);
            }
        }
    }