Android RESTE client, l'Échantillon?

EDIT 2 (octobre 2017):

C'est 2017. Juste l'utilisation de Rénovation. Il n'y a presque pas de raison d'utiliser autre chose.

EDIT:

L'original de la réponse est plus d'un an et demi d'existence au moment de cette édition. Bien que les concepts présentés dans la réponse originale à cette question encore de les tenir, comme d'autres réponses point, il y a maintenant bibliothèques que de rendre cette tâche plus facile pour vous. Plus important encore, certains de ces bibliothèques supporter les changements de configuration pour vous.

L'original de la réplique est maintenu en dessous pour référence. Mais s'il vous plaît prendre le temps d'examiner le Reste des bibliothèques clientes pour Android pour voir si elles correspondent à votre cas d'utilisation. Ce qui suit est une liste de certains des bibliothèques, j'ai évalué. Il n'est pas destiné à être une liste exhaustive.

• Volley (ce qui est de Google)
• RESTDroid
• RoboSpice
• Rénovation

---

Réponse Originale À Cette Question:

Présenter mon approche de REPOS clients sur Android. Je ne prétendons pas que c'est le meilleur bien 🙂 notez Également que c'est ce que j'ai trouvé de réponse à ma demande. Vous pourriez avoir besoin d'avoir plusieurs calques/ajouter plus de complexité si votre cas l'exige. Par exemple, je n'ai pas de local de stockage à tous; parce que mon application peut tolérer la perte d'un peu de REPOS réponses.

Mon approche utilise juste AsyncTasks sous les couvertures. Dans mon cas, j'ai "appel" de ces Tâches à partir de mon Activity instance; mais pleinement compte pour les cas comme la rotation de l'écran, vous pouvez choisir de les appeler à partir d'un Service ou telle.

J'ai consciemment choisi mon REPOS client lui-même à une API. Cela signifie, que l'application qui utilise mon REPOS client n'a même pas besoin d'être conscient de la réelle RESTE de l'URL et le format de données utilisé.

Le client aura de 2 couches:

1. Couche supérieure: Le but de cette couche est de fournir des méthodes qui reflètent la fonctionnalité de l'API REST. Par exemple, vous pourriez avoir une méthode Java correspondant à chaque URL dans votre API REST (ou même les deux en un " pour les Obtient et un pour les Poteaux).
   
   C'est le point d'entrée dans le RESTE de l'API client. C'est la couche de l'application serait de l'utiliser normalement. Il pourrait être un singleton, mais pas nécessairement.
   
   La réponse de l'appel RESTE est analysé par cette couche dans un POJO et est retourné à l'application.

2. Ce qui est le plus bas niveau AsyncTask couche, qui utilise le client HTTP méthodes de sortir et de faire appel RESTE.

En outre, j'ai choisi d'utiliser un mécanisme de Rappel à communiquer les résultats de l' AsyncTaskde revenir à l'application.

Assez de texte. Nous allons voir le code maintenant. Permet de prendre un hypothétique RESTE URL API - http://myhypotheticalapi.com/user/profile

La couche supérieure pourrait ressembler à ceci:

   /**
 * Entry point into the API.
 */
public class HypotheticalApi{   
    public static HypotheticalApi getInstance(){
        //Choose an appropriate creation strategy.
    }

    /**
     * Request a User Profile from the REST server.
     * @param userName The user name for which the profile is to be requested.
     * @param callback Callback to execute when the profile is available.
     */
    public void getUserProfile(String userName, final GetResponseCallback callback){
        String restUrl = Utils.constructRestUrlForProfile(userName);
        new GetTask(restUrl, new RestTaskCallback (){
            @Override
            public void onTaskComplete(String response){
                Profile profile = Utils.parseResponseAsProfile(response);
                callback.onDataReceived(profile);
            }
        }).execute();
    }

    /**
     * Submit a user profile to the server.
     * @param profile The profile to submit
     * @param callback The callback to execute when submission status is available.
     */
    public void postUserProfile(Profile profile, final PostCallback callback){
        String restUrl = Utils.constructRestUrlForProfile(profile);
        String requestBody = Utils.serializeProfileAsString(profile);
        new PostTask(restUrl, requestBody, new RestTaskCallback(){
            public void onTaskComplete(String response){
                callback.onPostSuccess();
            }
        }).execute();
    }
}


/**
 * Class definition for a callback to be invoked when the response data for the
 * GET call is available.
 */
public abstract class GetResponseCallback{

    /**
     * Called when the response data for the REST call is ready. <br/>
     * This method is guaranteed to execute on the UI thread.
     * 
     * @param profile The {@code Profile} that was received from the server.
     */
    abstract void onDataReceived(Profile profile);

    /*
     * Additional methods like onPreGet() or onFailure() can be added with default implementations.
     * This is why this has been made and abstract class rather than Interface.
     */
}

/**
 * 
 * Class definition for a callback to be invoked when the response for the data 
 * submission is available.
 * 
 */
public abstract class PostCallback{
    /**
     * Called when a POST success response is received. <br/>
     * This method is guaranteed to execute on the UI thread.
     */
    public abstract void onPostSuccess();

}

Noter que l'application ne permet pas d'utiliser le JSON ou XML (ou tout autre format) retourné par l'API REST directement. Au lieu de cela, l'application ne voit que le haricot Profile.

Ensuite, la couche inférieure (AsyncTask couche) pourrait ressembler à ceci:

/**
* An AsyncTask implementation for performing GETs on the Hypothetical REST APIs.
*/
public class GetTask extends AsyncTask<String, String, String>{
private String mRestUrl;
private RestTaskCallback mCallback;
/**
* Creates a new instance of GetTask with the specified URL and callback.
* 
* @param restUrl The URL for the REST API.
* @param callback The callback to be invoked when the HTTP request
*            completes.
* 
*/
public GetTask(String restUrl, RestTaskCallback callback){
this.mRestUrl = restUrl;
this.mCallback = callback;
}
@Override
protected String doInBackground(String... params) {
String response = null;
//Use HTTP Client APIs to make the call.
//Return the HTTP Response body here.
return response;
}
@Override
protected void onPostExecute(String result) {
mCallback.onTaskComplete(result);
super.onPostExecute(result);
}
}
/**
* An AsyncTask implementation for performing POSTs on the Hypothetical REST APIs.
*/
public class PostTask extends AsyncTask<String, String, String>{
private String mRestUrl;
private RestTaskCallback mCallback;
private String mRequestBody;
/**
* Creates a new instance of PostTask with the specified URL, callback, and
* request body.
* 
* @param restUrl The URL for the REST API.
* @param callback The callback to be invoked when the HTTP request
*            completes.
* @param requestBody The body of the POST request.
* 
*/
public PostTask(String restUrl, String requestBody, RestTaskCallback callback){
this.mRestUrl = restUrl;
this.mRequestBody = requestBody;
this.mCallback = callback;
}
@Override
protected String doInBackground(String... arg0) {
//Use HTTP client API's to do the POST
//Return response.
}
@Override
protected void onPostExecute(String result) {
mCallback.onTaskComplete(result);
super.onPostExecute(result);
}
}
/**
* Class definition for a callback to be invoked when the HTTP request
* representing the REST API Call completes.
*/
public abstract class RestTaskCallback{
/**
* Called when the HTTP request completes.
* 
* @param result The result of the HTTP request.
*/
public abstract void onTaskComplete(String result);
}

Voici comment une application peut utiliser l'API (dans un Activity ou Service):

HypotheticalApi myApi = HypotheticalApi.getInstance();
myApi.getUserProfile("techie.curious", new GetResponseCallback() {
@Override
void onDataReceived(Profile profile) {
//Use the profile to display it on screen, etc.
}
});
Profile newProfile = new Profile();
myApi.postUserProfile(newProfile, new PostCallback() {
@Override
public void onPostSuccess() {
//Display Success
}
});

J'espère que les commentaires sont suffisantes pour expliquer la conception de; mais je serais heureux de vous fournir plus d'informations.

Ne jamais utiliser AsynTask pour effectuer la demande de réseau ou n'importe quoi qui doivent être conservés. Async Task sont fortement liés à votre activité et si l'utilisateur de changer l'orientation de l'écran étant donné que l'App est de nouveau créé l'AsyncTask sera arrêté.

Je vous suggérons d'utiliser le Service de motif avec l'Intention de Services et ResultReceiver. Jetez un oeil à RESTDroid. C'est une bibliothèque qui vous permet d'effectuer tout type de REPOS demande de manière asynchrone et informez-en votre INTERFACE utilisateur avec Demande Auditeurs de la mise en œuvre de l'Virgile Dobjanschi de service du modèle.

Il y a beaucoup de bibliothèques et j'utilise celui-ci: https://github.com/nerde/rest-resource. Il a été créé par moi, et, comme vous pouvez le voir dans la documentation, c'est beaucoup plus propre et plus simple que les autres. Il n'est pas porté sur Android, mais je suis en utilisant en elle, et ça fonctionne assez bien.

Il prend en charge HTTP Basic Auth. Il fait le sale boulot de la sérialisation et la désérialisation des objets JSON. Vous l'aimez, spécialement si votre API Rails comme.