HttpURLConnection访问302，采用HttpGet获取数据

import javax.net.ssl.SSLHandshakeException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

public class HttpUtils {

    /**
     * @param httpUrl
     */
    public static String get(String httpUrl) {
        String responseText = null;
        SSLAgent.getInstance().trustAllHttpsCertificates();
        HttpGet request = new HttpGet(httpUrl);
        DefaultHttpClient httpClient = new DefaultHttpClient();
        httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 15000);
        httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 15000);
        httpClient.setHttpRequestRetryHandler(requestRetryHandler);
        try {
            responseText = httpClient.execute(request, responseHandler);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            abortConnection(request, httpClient);
        }
        return responseText;
    }

    /**
     * @param url
     * @param map
     */
    public static String post(String url, Map<String, String> map) {
        HttpPost request = new HttpPost(url);
        DefaultHttpClient client = new DefaultHttpClient();
        client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT);
        client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT);
        client.setHttpRequestRetryHandler(requestRetryHandler);
        String responseText = null;
        Set<String> keys = map.keySet();
        List<NameValuePair> params = new ArrayList<NameValuePair>(keys.size());
        for (String key : keys) {
            params.add(new BasicNameValuePair(key, map.get(key)));
        }

        try {
            HttpEntity entity = new UrlEncodedFormEntity(params, HTTP.UTF_8);
            request.setEntity(entity);
            responseText = client.execute(request, responseHandler);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            abortConnection(request, client);
        }
        return responseText;
    }

    private static void abortConnection(final HttpRequestBase httpRequestBase, final HttpClient httpclient) {
        if (httpRequestBase != null) {
            httpRequestBase.abort();
        }
        if (httpclient != null) {
            httpclient.getConnectionManager().shutdown();
        }
    }

    private static HttpRequestRetryHandler requestRetryHandler = new HttpRequestRetryHandler() {
        @Override
        public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
            if (executionCount >= 2) {
                return false;
            }
            if (exception instanceof NoHttpResponseException) {
                return true;
            }
            if (exception instanceof SSLHandshakeException) {
                return false;
            }
            HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);
            boolean idempotent = (request instanceof HttpEntityEnclosingRequest);
            if (!idempotent) {
                return true;
            }
            return false;
        }
    };

    private static ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
        @Override
        public String handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
            HttpEntity entity = response.getEntity();
            int httpstatus = response.getStatusLine().getStatusCode();
            if (entity != null && httpstatus == HttpStatus.SC_OK) {
                String charset = EntityUtils.getContentCharSet(entity) == null ? "UTF-8" : EntityUtils
                        .getContentCharSet(entity);
                return new String(EntityUtils.toByteArray(entity), charset);
            } else {
                // TODO
                return null;
            }
        }
    };


}

解决javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.的问题，出现这个问题的原因是：服务器不信任我们自己创建的证书，所以在代码中必须要忽略证书信任问题。

import android.util.Log;

import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class SSLAgent {

    private final static String TAG = "SSLAgent";
    private final static boolean DEBUG = true;

    private static SSLAgent mSSLAgent;

    public static SSLAgent getInstance(){
        if(mSSLAgent == null){
            mSSLAgent = new SSLAgent();
        }
        return mSSLAgent;
    }

    /**
     * 信任所有的https证书
     * */
    public void trustAllHttpsCertificates() {
        try{
            TrustManager[] trustAllCerts = new TrustManager[1];
            TrustManager tm = new MyTrustManager();
            trustAllCerts[0] = tm;
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, null);
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(mHostnameVerifier);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private HostnameVerifier mHostnameVerifier = new HostnameVerifier() {

        public boolean verify(String hostname, SSLSession session) {
            log("hostname:" + hostname);
            return true;
        }

    };

    private static class MyTrustManager implements TrustManager, X509TrustManager {

        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        public boolean isServerTrusted(X509Certificate[] certs) {
            return true;
        }

        public boolean isClientTrusted(X509Certificate[] certs) {
            return true;
        }

        public void checkServerTrusted(X509Certificate[] certs, String authType) {
            return;
        }

        public void checkClientTrusted(X509Certificate[] certs, String authType) {
            return;
        }

    }

    private void log(String msg){
        if(DEBUG){
            Log.i(TAG, msg);
        }
    }

}