Android的REST客户端，来样？ [英] Android REST client, Sample?
问题描述
即使这个线程已经接受的答案，请随时提出其他的想法，你就使用或喜欢
我见过这些文章：
- Restful API service
- Java REST client API for Android
这使我这个关于REST客户端应用程序的谷歌I / O 2010的视频
And that lead me to this Google I/O 2010 video about REST client applications
- <一个href="http://www.youtube.com/watch?v=xHXn3Kg2IQE&feature=player_embedded">http://www.youtube.com/watch?v=xHXn3Kg2IQE&feature=player_embedded
由于现在，我已经创建REST组件为静态零件在我的应用控制器类。
Since now, I've been creating REST component as static component in my Application controller class.
从现在开始，我想，我应该改变的格局。 <一href="http://stackoverflow.com/questions/3197335/android-restful-api-service#answer-3197456">Somebody指出，谷歌IOSched 应用程序是如何在Android编写REST客户极大的样本。 某些别有用心的人告诉我，这方法太过于复杂。
From now, I think, I should change the pattern. Somebody pointed out that Google IOSched application is great sample of how to write REST clients on Android. Somebody else told that this ways is too overcomplicated.
所以，任何人都可以请告诉我们什么是最好的做法是什么？在短期和简单的方式。
该IOSched应用是样品用例太复杂了。
So, can anybody please show us what is the best practice? In short and simple way.
The IOSched application is too complex for sample use-case.
推荐答案
原来答案是超过一年半的时间老在这个编辑的时间。虽然psented在原来的答案的概念$ P $仍然坚持，因为其他的答案指出，现在有库，在那里，使这项任务更容易。更重要的是，一些库处理设备配置更改为你。
The original answer is more than a year and a half old at the time of this edit. Although the concepts presented in original answer still hold, as other answers point out, there are now libraries out there that make this task easier for you. More importantly, some of these libraries handle device configuration changes for you.
原答案保留如下，以供参考。但也请花时间去研究一些其他地区的客户端库，为Android，看是否符合您的使用案例。以下是一些我已经评估的库的列表。它绝不是旨在是详尽的列表
The original answer is retained below for reference. But please also take the time to examine some of the Rest client libraries for Android to see if they fit your use cases. The following is a list of some of the libraries I've evaluated. It is by no means intended to be an exhaustive list.
- Volley (this is from Google)
- RESTDroid
- RoboSpice
- Retrofit
presenting我的做法具有REST客户端在Android上。我不要求它是最好的，虽然:)另外，注意，这就是我想出了回应我的要求。您可能需要有更多层/添加更多的复杂性，如果你的用例需要它。例如，我没有在所有本地存储;因为我的应用程序可以容忍的几个REST响应的损失。
Presenting my approach to having REST clients on Android. I do not claim it is the best though :) Also, note that this is what I came up with in response to my requirement. You might need to have more layers/add more complexity if your use case demands it. For example, I do not have local storage at all; because my app can tolerate loss of a few REST responses.
我的方法只使用的AsyncTask S以封面。就我而言，我呼从我的活动实例，这些任务;但要充分考虑像屏幕旋转的情况下，您可以选择从服务或打电话给他们这样的。
My approach uses just AsyncTasks under the covers. In my case, I "call" these Tasks from my Activity instance; but to fully account for cases like screen rotation, you might choose to call them from a Service or such.
我有意识地选择了我的REST客户端本身是一个API。这意味着，它使用我的REST客户端应用程序甚至不需要知道实际的REST的URL以及所使用的数据格式。
I consciously chose my REST client itself to be an API. This means, that the app which uses my REST client need not even be aware of the actual REST URL's and the data format used.
客户端将有2层：
-
顶层：此层的目的是提供一种镜像REST API的功能的方法。例如，你可以有一个Java方法在你的REST API相当于每个URL（甚至两个 - 一个是GET和一个用于员额）。
这是进入点REST客户端API。这是应用程序通常使用的图层。这可能是一个单身，但不一定。
REST的呼叫的响应由该层解析成一个POJO和返回到该应用
Top layer: The purpose of this layer is to provide methods which mirror the functionality of the REST API. For example, you could have one Java method corresponding to every URL in your REST API (or even two - one for GETs and one for POSTs).
This is the entry point into the REST client API. This is the layer the app would use normally. It could be a singleton, but not necessarily.
The response of the REST call is parsed by this layer into a POJO and returned to the app.
这是下级的AsyncTask 层，它使用HTTP客户端的方法来真正走出去，把那REST调用。
This is the lower level AsyncTask layer, which uses HTTP client methods to actually go out and make that REST call.
另外，我选择使用回拨机制，沟通的结果的AsyncTask 发回给应用程序。
In addition, I chose to use a Callback mechanism to communicate the result of the AsyncTasks back to the app.
文本足够。让我们来看看一些code现在。让我们来假设REST API网址 - http://myhypotheticalapi.com/user/profile
Enough of text. Let's see some code now. Lets take a hypothetical 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（或任何其他格式）。相反，应用程序只看到豆简介。
Note that the app doesn't use the JSON or XML (or whatever other format) returned by the REST API directly. Instead, the app only sees the bean Profile.
然后，下层（AsyncTask的层）可能是这样的：
Then, the lower layer (AsyncTask layer) might look like this:
/**
* 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（在活动或服务）：
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
}
});
我希望评论是不足以解释的设计;但我很乐意提供更多的信息。
I hope the comments are sufficient to explain the design; but I'd be glad to provide more info.
这篇关于Android的REST客户端，来样？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
