web-dev-qa-db-fra.com

Android - Envoi d'une requête HTTPS Get

Je voudrais envoyer une requête HTTPS Get à l'API Google Shopping, mais rien ne fonctionne vraiment pour moi, par exemple, voici ce que j'essaie en ce moment:

try {        
        HttpClient client = new DefaultHttpClient();
        HttpGet request = new HttpGet();
        request.setURI(new URI("https://www.googleapis.com/shopping/search/v1/public/products/?key={my_key}&country=&q=t-shirts&alt=json&rankByrelevancy="));
        HttpResponse response = client.execute(request);
    } catch (URISyntaxException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }   
    return response;
}

Si quelqu'un a des suggestions pour améliorer cela ou le remplacer, faites-le moi savoir, merci à l'avance.

androidhttphttpsgethttpclient
16
Sam Jackson

Vous devriez obtenir une erreur de compilation.

Ceci est la bonne version:

HttpResponse response = null;
try {        
        HttpClient client = new DefaultHttpClient();
        HttpGet request = new HttpGet();
        request.setURI(new URI("https://www.googleapis.com/shopping/search/v1/public/products/?key={my_key}&country=&q=t-shirts&alt=json&rankByrelevancy="));
        response = client.execute(request);
    } catch (URISyntaxException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }   
    return response;
}

Par conséquent, maintenant, si vous avez une erreur, votre réponse sera retournée comme nulle.

Une fois que vous avez la réponse et que vous l'avez vérifiée pour null, vous voudrez obtenir le contenu (c'est-à-dire votre JSON).

http://developer.Android.com/reference/org/Apache/http/HttpResponse.htmlhttp://developer.Android.com/reference/org/Apache/http/ HttpEntity.htmlhttp://developer.Android.com/reference/Java/io/InputStream.html

response.getEntity().getContent();

Cela vous donne un InputStream avec lequel travailler. Si vous voulez convertir cela en une chaîne, vous feriez ce qui suit ou équivalent:

http://www.mkyong.com/Java/how-to-convert-inputstream-to-string-in-Java/

public static String convertStreamToString(InputStream inputStream) throws IOException {
        if (inputStream != null) {
            Writer writer = new StringWriter();

            char[] buffer = new char[1024];
            try {
                Reader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"),1024);
                int n;
                while ((n = reader.read(buffer)) != -1) {
                    writer.write(buffer, 0, n);
                }
            } finally {
                inputStream.close();
            }
            return writer.toString();
        } else {
            return "";
        }
    }

Lorsque vous avez cette chaîne, vous devez en créer un JSONObject:

http://developer.Android.com/reference/org/json/JSONObject.html

JSONObject json = new JSONObject(inputStreamAsString);

Terminé!

40
Blundell

L'avez-vous ajouté à votre manifeste

<uses-permission Android:name="Android.permission.INTERNET" />
6
Helal Ismail

Vous pouvez l'essayer de cette façon en utilisant peut-être la classe URLConnection

String error = ""; // string field
private String getDataFromUrl(String demoIdUrl) {

    String result = null;
    int resCode;
    InputStream in;
    try {
        URL url = new URL(demoIdUrl);
        URLConnection urlConn = url.openConnection();

        HttpsURLConnection httpsConn = (HttpsURLConnection) urlConn;
        httpsConn.setAllowUserInteraction(false);
        httpsConn.setInstanceFollowRedirects(true);
        httpsConn.setRequestMethod("GET");
        httpsConn.connect();
        resCode = httpsConn.getResponseCode();

        if (resCode == HttpURLConnection.HTTP_OK) {
            in = httpsConn.getInputStream();

            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    in, "iso-8859-1"), 8);
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
            in.close();
            result = sb.toString();
        } else {
            error += resCode;
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}
4
SMagic

J'écris deux méthodes ici.Copiez les deux.Dans votre première méthode uri = votre URL que vous souhaitez envoyer la demande:

Première méthode:

public  static String Getdata (String uri ){

        BufferedReader reader = null;

        try {

            URL url = new URL(uri);
            HttpURLConnection con = null;

            URL testUrlHttps = new URL(uri);
            if (testUrlHttps.getProtocol().toLowerCase().equals("https"))
            {
                trustAllHosts();
                HttpsURLConnection https = (HttpsURLConnection) url.openConnection();
                https.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                con = https;
            } else
            {
                con = (HttpURLConnection) url.openConnection();
            }


            con.setReadTimeout(15000);
            con.setConnectTimeout(15000);
            StringBuilder sb = new StringBuilder();
            reader = new BufferedReader(new InputStreamReader(con.getInputStream()));

            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }

            return sb.toString();

        } catch (Exception e) {
            e.printStackTrace();
            return "";
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    return "";
                }
            }
        }
    }

et une autre méthode qui fait entièrement confiance à toutes les certifications pour la première méthode.

Deuxième méthode:

private static void trustAllHosts()
    {
        // Create a trust manager that does not validate certificate chains
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager()
        {
            public Java.security.cert.X509Certificate[] getAcceptedIssuers()
            {
                return new Java.security.cert.X509Certificate[] {};
            }

            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException
            {
            }

            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException
            {
            }
        } };

        // Install the all-trusting trust manager
        try
        {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new Java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }
2
nima barati

Merci à Faire une requête HTTPS/HTTP dans Android

Ajoutez une classe Java classe CustomSSLSocketFactory.Java 

 import Java.io.IOException;
 import Java.net.Socket;
 import Java.net.UnknownHostException;
 import Java.security.KeyManagementException;
 import Java.security.KeyStore;
 import Java.security.KeyStoreException;
 import Java.security.NoSuchAlgorithmException;
 import Java.security.UnrecoverableKeyException;
 import Java.security.cert.CertificateException;
 import Java.security.cert.X509Certificate;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 import org.Apache.http.conn.ssl.SSLSocketFactory;

 public class CustomSSLSocketFactory extends SSLSocketFactory{
SSLContext sslContext = SSLContext.getInstance("TLS");
/**
 * Generate Certificate for ssl connection
 * @param truststore
 * @throws NoSuchAlgorithmException
 * @throws KeyManagementException
 * @throws KeyStoreException
 * @throws UnrecoverableKeyException
 */
public CustomSSLSocketFactory(KeyStore truststore)
        throws NoSuchAlgorithmException, KeyManagementException,
        KeyStoreException, UnrecoverableKeyException {
    super(truststore);
    TrustManager tm = new X509TrustManager(){
        @Override
        public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {
        }
        @Override
        public void checkServerTrusted(X509Certificate[] chain,
                                       String authType) throws CertificateException {
        }
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    };
    sslContext.init(null, new TrustManager[] {tm}, null);
}

@Override
public Socket createSocket(Socket socket, String Host, int port,
                           boolean autoClose) throws IOException, UnknownHostException {
    return sslContext.getSocketFactory().createSocket(socket, Host, port,
            autoClose);
}

@Override
public Socket createSocket() throws IOException {
    return sslContext.getSocketFactory().createSocket();
}
 }

dans votre code

    String cloud_url="https://www.google.com";
    HttpClient client = new DefaultHttpClient();
        if(cloud_url.toLowerCase().contains("https://")){
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);
            SSLSocketFactory sf = new CustomSSLSocketFactory(trustStore);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            HttpParams params = new BasicHttpParams();
            SchemeRegistry registry = new SchemeRegistry();
            registry.register(new Scheme("https", sf, 443));

            ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);
            client= new DefaultHttpClient(ccm, params);
        }


        HttpGet request= new HttpGet( );
        request.setURI(new URI( cloud_url));
        HttpResponse response = client.execute(request);

fonctionne également dans HttpPost.

1
Joshy Francis

Il est difficile de dire avec certitude si vous ne nous dites pas quelle est l'erreur.

Mais si vous exécutez cela sur le thread d'interface utilisateur et que le serveur Web met plus de quelques secondes à répondre, vous obtiendrez un avertissement Application ne répondant pas du système. Assurez-vous que vous effectuez tous les transferts réseau sur un thread séparé.

0
Theasis