web-dev-qa-db-fra.com

REST Bibliothèque de clients API pour Android

Nous construisons une application de messagerie géolocalisée utilisant Parse.com comme back-end (Parse.com est similaire à Urban Airship/PubNub, etc.) et nous souhaitons maintenant passer à notre propre back-end pour un meilleur contrôle. Pour cela, nous avons construit un back-end basé sur node.js avec une fonctionnalité exposée sur l'API REST.

Pour utiliser cette API, nous souhaitons créer une bibliothèque Android (similaire à le SDK de Android de Parse.com ) qui résume toutes les requêtes/réponses HTTP. ou REST API appelle et fournit des fonctions directes pour diverses opérations telles que getUsers (), sendMessage (), etc.

Méthodes d'implémentation de REST client API dans Android:

Maintenant, étant donné que nous voulons construire une bibliothèque Android et qu'il pourrait y avoir des appels d'API REST simultanés pendant que l'utilisateur interagit avec l'application, quelle approche serait la meilleure pour aller de l'avant ? Je suis également ouvert à d’autres suggestions/recommandations.

[~ # ~] update [~ # ~] : Nous avons d'abord construit notre propre bibliothèque en utilisant IntentService + ResultReceiver, ce qui a bien fonctionné. Mais nous sommes tombés plus tard sur Android Async Http . Utilise le. C'est génial!

androidrestasynchronousandroid-libraryintentservice
45
Madhur

La meilleure implémentation que j'ai vue sur Google IO Pro Tips 2010 est la bibliothèque RoboSpice, qui est REST et fonctionne très intelligemment avec le cycle de vie de l'activité pour ne pas fuite de mémoire.

Rapide infographie la bibliothèque est ici

  • Les chargeurs sont conçus pour la base de données, pas REST, ils sont réinitialisés à la réinitialisation de l'activité, ce qui signifie que vous perdez vos données.
  • Tâche async, juste non.
  • Le service Intent Service + Result est essentiellement le fonctionnement de RoboSpice. Si vous construisez votre propre bibliothèque, je choisirais cette approche!
  • Le service est également bon, similaire à la méthode IntentService, mais IntentService fonctionne un peu mieux dans ce cas.

La méthode Service est peut-être meilleure, regardez le service robospice ils utilisent un ExecutorService qui termine le Service quand il est à court de Requests à traverser, c’est plus Java simultanéité que Android spécifique. Le principal élément à noter que le service s'exécute pendant le traitement des demandes, puis se termine lui-même si il n'y en a plus.

L'avantage d'utiliser ExecutorService ou tout type de pool de threads est que vous pouvez définir le nombre de demandes que vous pouvez exécuter simultanément. Sauf si vous avez une connexion très rapide, 2-4 est le maximum que je puisse suggérer.

43
Chris.Jenkins

Peut être cette classe peut aider: -

/*Copyright 2014 Bhavit Singh Sengar
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.Apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.*/

package com.infotech.zeus.util;

import Java.io.IOException;
import Java.io.UnsupportedEncodingException;
import org.Apache.http.HttpEntity;
import org.Apache.http.HttpResponse;
import org.Apache.http.client.ClientProtocolException;
import org.Apache.http.client.HttpClient;
import org.Apache.http.client.ResponseHandler;
import org.Apache.http.client.methods.HttpGet;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.StringEntity;
import org.Apache.http.impl.client.BasicResponseHandler;
import org.Apache.http.impl.client.DefaultHttpClient;
import org.Apache.http.protocol.HTTP;
import org.Apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
import Android.widget.Toast;

public class RestClient {


        JSONObject data = new JSONObject();
        String url;
        String headerName;
        String headerValue;

        public RestClient(String s){

            url = s;
        }


        public void addHeader(String name, String value){

            headerName = name;
            headerValue = value;

        }

        public void addParam(String key, String value){

            try {
                data.put(key, value);
            } catch (JSONException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }


        }

        public String executePost(){  // If you want to use post method to hit server

            HttpClient httpClient = new DefaultHttpClient();
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader(headerName, headerValue);
            HttpResponse response = null;
            String result = null;
            try {
                StringEntity entity = new StringEntity(data.toString(), HTTP.UTF_8);
                httpPost.setEntity(entity);
                response = httpClient.execute(httpPost);
                HttpEntity entity1 = response.getEntity();
                result = EntityUtils.toString(entity1);
                return result;
                //Toast.makeText(MainPage.this, result, Toast.LENGTH_LONG).show();
            } catch (UnsupportedEncodingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ClientProtocolException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return result;



        }

        public String executeGet(){ //If you want to use get method to hit server

            HttpClient httpClient = new DefaultHttpClient();
            HttpGet httpget = new HttpGet(url);
            String result = null;
            ResponseHandler<String> responseHandler = new BasicResponseHandler();
            try {
                result = httpClient.execute(httpget, responseHandler);
            } catch (ClientProtocolException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            return result;
        }
}

N EXEMPLE SIMPLE D'UTILISER CETTE CLASSE:

RestClient client = new RestClient("http://www.example.com/demo.php");  //Write your url here
        client.addParam("Name", "Bhavit"); //Here I am adding key-value parameters
        client.addParam("Age", "23");

        client.addHeader("content-type", "application/json"); // Here I am specifying that the key-value pairs are sent in the JSON format

        try {
            String response = client.executePost(); // In case your server sends any response back, it will be saved in this response string.

        } catch (Exception e) {
            e.printStackTrace();
        }
8
Bhavit S. Sengar

J'ai utilisé Retrofit et c'est vraiment une bonne bibliothèque qui fournit une structure simple pour gérer les points finaux et analyser les données/collections/objets.

La documentation est suffisamment complète pour écrire facilement votre code.

CQFD> allez-y

7
Hugo Gresse

Vous pouvez également utiliser RESTDroid . C'est assez similaire à RoboSpice mais plus simple à utiliser (bien que moins puissant).

Si vous créez un module Parse.com pour RESTDroid, n'hésitez pas à l'ajouter sur GitHub!

4
Pierre Criulanscy

Si je peux ajouter quelque chose, j’ai récemment commencé à écrire une bibliothèque Nice pour implémenter des moteurs (utilisés par MKNetworkKit dans iOS) et des commandes permettant de communiquer avec REST pour Android. Peut être utile pour tout le monde. essayer d'atteindre REST. https://github.com/m2d2/MDBaseAndroidLibraries

1
dineth

Vous pouvez également essayer Annotations Android avec le plugin rest-spring pour effectuer ces tâches automatiquement.

Ils utilisent un wrapper sur framework printanier pour Android et fournissent un très bon moyen de gérer reste apis.

Exemples:

Remplacer AsyncTask -> doInBackground () par @Background annotation:

@Background
protected void backgroundWork(){
    // do something in background
}

Remplacez runOnUiThread, onPostExecute () par @UiThread

@UiThread
protected void uiWork(){
    // do something on UI Thread
}

Pour les API Rest]

créer un client de repos:

@Rest(rootUrl = "http://company.com/ajax/services",
      converters = { MappingJackson2HttpMessageConverter.class })
public interface MyRestClient {

    @Get("/events")
    EventList getEvents();
}

utilise le client de repos:

@RestClient
MyRestClient myRestClient;

public void showAllEvents(){
    EventList list = myRestClient.getEvents();
    // do something with this list

}
1
user5934402