即使这个帖子已经接受了答案，请随时提出其他想法，您确实使用或喜欢

我见过这些文章:

• Restful API service
• Java REST client API for Android

这让我看到了这个关于 REST 客户端应用程序的 Google I/O 2010 视频

• http://www.youtube.com/watch?v=xHXn3Kg2IQE&feature=player_embedded

从现在开始，我一直在我的应用程序 Controller 类中创建 REST 组件作为静态组件。

从现在开始，我想，我应该改变模式。 Somebody 指出 Google IOSched 应用程序是如何在 Android 上编写 REST 客户端的绝佳示例。 Somebody else 表示这种方式过于复杂。

那么，谁能告诉我们什么是最佳实践？简而言之。
IOSched 应用程序对于示例用例来说过于复杂。

最佳答案

编辑 2(2017 年 10 月):

现在是 2017 年。只需使用 Retrofit。几乎没有理由使用其他任何东西。

编辑:

在本次编辑时，原始答案已有一年半的历史。尽管原始答案中提出的概念仍然有效，但正如其他答案所指出的那样，现在有一些库可以让您更轻松地完成这项任务。更重要的是，其中一些库会为您处理设备配置更改。

下面保留原始答案以供引用。但也请花时间检查一些适用于 Android 的 Rest 客户端库，看看它们是否适合您的用例。以下是我评估过的一些库的列表。这绝不是一份详尽的 list 。

• Volley (来自 Google)
• RESTDroid
• RoboSpice
• Retrofit

原答案:

介绍我在 Android 上使用 REST 客户端的方法。我并不声称它是最好的 :) 另外，请注意，这是我根据我的要求提出的。如果您的用例需要，您可能需要更多层/增加更多复杂性。例如，我根本没有本地存储；因为我的应用可以容忍丢失一些 REST 响应。

我的方法在幕后只使用了 AsyncTask。就我而言，我从我的 Activity 实例“调用”这些任务；但要充分考虑屏幕旋转等情况，您可能会选择从 Service 等调用它们。

我有意识地选择了我的 REST 客户端本身作为 API。这意味着，使用我的 REST 客户端的应用程序甚至不需要知道实际的 REST URL 和使用的数据格式。

客户端将有 2 层:

1. 顶层:这一层的目的是提供反射(reflect) REST API 功能的方法。例如，您可以为 REST API 中的每个 URL 设置一个 Java 方法(甚至可以有两个 - 一个用于 GET，一个用于 POST)。
   这是 REST 客户端 API 的入口点。这是应用程序正常使用的层。可以是单例，但不一定。
   REST调用的响应被这一层解析成POJO并返回给app。

2. 这是较低级别的 AsyncTask 层，它使用 HTTP 客户端方法实际执行 REST 调用。

此外，我选择使用回调机制将 AsyncTask 的结果传回应用程序。

足够的文字。现在让我们看一些代码。让我们假设一个 REST API URL - http://myhypotheticalapi.com/user/profile

顶层可能如下所示:

   /**
 * 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();

}

请注意，该应用不使用 REST API 直接返回的 JSON 或 XML(或任何其他格式)。相反，应用程序只看到 bean Profile。

那么，下层(AsyncTask 层)可能是这样的:

/**
 * 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);
    }

以下是应用使用 API 的方式(在 Activity 或 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
            }
        });

我希望评论足以解释设计；但我很乐意提供更多信息。

关于java - Android REST 客户端，示例？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8267928/