Comment appeler un service Web RESTful D'Android?
j'ai écrit un service REST web dans Netbean IDE en utilisant Jersey Framework et Java.
pour chaque requête dont l'Utilisateur a besoin pour fournir un nom d'utilisateur et un mot de passe, je sais que cette authentification n'est pas une bonne pratique (en utilisant une commande curl comme: curl -u username:password -X PUT http://localhsot:8080/user
).
maintenant je veux appeler un service REST web d'une classe Android.
Comment faire?
j'ai une classe Android qui utilise DefaultHttpClient
et CredentialUsernameAndPassword
, mais quand je le lance dans Eclipse, j'ai parfois l'exception d'exécution ou SDK exception.
11 réponses
il s'agit d'un échantillon de la classe restclient
public class RestClient
{
public enum RequestMethod
{
GET,
POST
}
public int responseCode=0;
public String message;
public String response;
public void Execute(RequestMethod method,String url,ArrayList<NameValuePair> headers,ArrayList<NameValuePair> params) throws Exception
{
switch (method)
{
case GET:
{
// add parameters
String combinedParams = "";
if (params!=null)
{
combinedParams += "?";
for (NameValuePair p : params)
{
String paramString = p.getName() + "=" + URLEncoder.encode(p.getValue(),"UTF-8");
if (combinedParams.length() > 1)
combinedParams += "&" + paramString;
else
combinedParams += paramString;
}
}
HttpGet request = new HttpGet(url + combinedParams);
// add headers
if (headers!=null)
{
headers=addCommonHeaderField(headers);
for (NameValuePair h : headers)
request.addHeader(h.getName(), h.getValue());
}
executeRequest(request, url);
break;
}
case POST:
{
HttpPost request = new HttpPost(url);
// add headers
if (headers!=null)
{
headers=addCommonHeaderField(headers);
for (NameValuePair h : headers)
request.addHeader(h.getName(), h.getValue());
}
if (params!=null)
request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
executeRequest(request, url);
break;
}
}
}
private ArrayList<NameValuePair> addCommonHeaderField(ArrayList<NameValuePair> _header)
{
_header.add(new BasicNameValuePair("Content-Type","application/x-www-form-urlencoded"));
return _header;
}
private void executeRequest(HttpUriRequest request, String url)
{
HttpClient client = new DefaultHttpClient();
HttpResponse httpResponse;
try
{
httpResponse = client.execute(request);
responseCode = httpResponse.getStatusLine().getStatusCode();
message = httpResponse.getStatusLine().getReasonPhrase();
HttpEntity entity = httpResponse.getEntity();
if (entity != null)
{
InputStream instream = entity.getContent();
response = convertStreamToString(instream);
instream.close();
}
}
catch (Exception e)
{ }
}
private static String convertStreamToString(InputStream is)
{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line = null;
try
{
while ((line = reader.readLine()) != null)
{
sb.append(line + "\n");
}
is.close();
}
catch (IOException e)
{ }
return sb.toString();
}
}
a récemment découvert qu'une bibliothèque tierce partie - Square Retrofit peut faire le travail très bien.
Définir le point de terminaison REST
public interface GitHubService {
@GET("/users/{user}/repos")
List<Repo> listRepos(@Path("user") String user,Callback<List<User>> cb);
}
obtenir le service de béton
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://api.github.com")
.build();
GitHubService service = restAdapter.create(GitHubService.class);
Appeler le point de terminaison REST
List<Repo> repos = service.listRepos("octocat",new Callback<List<User>>() {
@Override
public void failure(final RetrofitError error) {
android.util.Log.i("example", "Error, body: " + error.getBody().toString());
}
@Override
public void success(List<User> users, Response response) {
// Do something with the List of Users object returned
// you may populate your adapter here
}
});
La bibliothèque gère le json la sérialisation et deserailization pour vous. Vous pouvez personnaliser la sérialisation et la désérialisation.
Gson gson = new GsonBuilder()
.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
.registerTypeAdapter(Date.class, new DateTypeAdapter())
.create();
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://api.github.com")
.setConverter(new GsonConverter(gson))
.build();
j'utilise ce REST Client pour mon android. Cela a l'air vraiment cool. Beau travail par Luc.
http://lukencode.com/2010/04/27/calling-web-services-in-android-using-httpclient/
arrêtez avec ce que vous faisiez ! :)
implémenter le RESTful client as a SERVICE et déléguer la substance de réseau intensif à la composante indépendante de l'activité: un SERVICE.
Regardez cette vidéo perspicace http://www.youtube.com/watch?v=xHXn3Kg2IQE où Virgil Dobjanschi explique son approche (s) à ce défi...
utilisant Spring pour Android avec RestTemplate https://spring.io/guides/gs/consuming-rest-android /
// The connection URL
String url = "https://ajax.googleapis.com/ajax/" +
"services/search/web?v=1.0&q={query}";
// Create a new RestTemplate instance
RestTemplate restTemplate = new RestTemplate();
// Add the String message converter
restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
// Make the HTTP GET request, marshaling the response to a String
String result = restTemplate.getForObject(url, String.class, "Android");
j'ai utilisé OkHttpClient
pour appeler le service web restful. C'est très simple.
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
Response response = httpClient.newCall(request).execute();
String body = response.body().string()
quelle fin? Si JAVA alors vous pouvez utiliser REST avec Java (JAX-RS) en utilisant Jersey.
côté Android, vous pouvez utiliser ce RestClient simple pour travailler avec ce service de repos.
JSON <--> mappage d'Objets sur les deux côtés (Android, Java back-end), vous pouvez utiliser GSON.
peut-être que je suis en retard ou peut-être que vous l'avez déjà utilisé avant mais il y a un autre appelé ksoap et son assez étonnant.. Il comprend également des temps morts et peut analyser n'importe quel service web à base de savon efficacement. J'ai aussi fait quelques modifications pour l'adapter à mon analyse..
suivez les étapes ci-dessous pour consommer RestFul sur android.
Etape 1
créer un projet android blank.
Step2
besoin d'une permission d'accès à internet. écrivez le code ci-dessous dans AndroidManifest.fichier xml.
<uses-permission android:name="android.permission.INTERNET">
</uses-permission>
Etape 3
ont besoin d'url RestFul qui est en cours d'exécution un autre serveur ou la même machine.
Etape 4
Faire un séjour Reposant Client qui extends AsyncTask. Voir RestFulPost.Java.
Etape 5
Faire DTO classe pour la Détente de Demande et de Réponse.
RestFulPost.java
package javaant.com.consuming_restful.restclient;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import com.google.gson.Gson;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import java.util.Map;
import javaant.com.consuming_restful.util.Util;
/**
* Created by Nirmal Dhara on 29-10-2015.
*/
public class RestFulPost extends AsyncTask<map, void,="" string=""> {
RestFulResult restFulResult = null;
ProgressDialog Asycdialog;
String msg;
String task;
public RestFulPost(RestFulResult restFulResult, Context context, String msg,String task) {
this.restFulResult = restFulResult;
this.task=task;
this.msg = msg;
Asycdialog = new ProgressDialog(context);
}
@Override
protected String doInBackground(Map... params) {
String responseStr = null;
Object dataMap = null;
HttpPost httpost = new HttpPost(params[0].get("url").toString());
try {
dataMap = (Object) params[0].get("data");
Gson gson = new Gson();
Log.d("data map", "data map------" + gson.toJson(dataMap));
httpost.setEntity(new StringEntity(gson.toJson(dataMap)));
httpost.setHeader("Accept", "application/json");
httpost.setHeader("Content-type", "application/json");
DefaultHttpClient httpclient= Util.getClient();
HttpResponse response = httpclient.execute(httpost);
int statusCode = response.getStatusLine().getStatusCode();
Log.d("resonse code", "----------------" + statusCode);
if (statusCode == 200)
responseStr = EntityUtils.toString(response.getEntity());
if (statusCode == 404) {
responseStr = "{\n" +
"\"status\":\"fail\",\n" +
" \"data\":{\n" +
"\"ValidUser\":\"Service not available\",\n" +
"\"code\":\"404\"\n" +
"}\n" +
"}";
}
} catch (Exception e) {
e.printStackTrace();
}
return responseStr;
}
@Override
protected void onPreExecute() {
Asycdialog.setMessage(msg);
//show dialog
Asycdialog.show();
super.onPreExecute();
}
@Override
protected void onPostExecute(String s) {
Asycdialog.dismiss();
restFulResult.onResfulResponse(s,task);
}
}
pour plus de détails et le code complet s'il vous plaît visitez http://javaant.com/consume-a-restful-webservice-in-android/#.VwzbipN96Hs
voici ma bibliothèque que j'ai créée pour simple appel Webservice,
vous pouvez utiliser ceci en ajoutant une dépendance de gradle d'une ligne -
compile 'com.scantity.ScHttpLibrary:ScHttpLibrary:1.0.0'
Voici la démonstration d'utilisation.
il y a des tonnes de bibliothèques disponibles pour faire cela
Retrofit remplace le AsyncTask traditionnel et il a sa propre tâche d'arrière-plan donc vous n'avez vraiment pas à vous inquiéter à ce sujet. La performance est également très bonne par rapport à AsyncTask.
Vérifier ici,
http://square.github.io/retrofit /
un exemple complet de modernisation pourrait: être trouvé ici,
https://futurestud.io/blog/retrofit-getting-started-and-android-client /
Volley est également efficace et facile à utiliser. Vous pouvez jeter un oeil ici:
https://github.com/mcxiaoke/android-volley
Il y a un tas de ressources sur le web sur la façon de l'utiliser:
http://www.androidhive.info/2014/05/android-working-with-volley-library-1
AsyncTask
ou vous devriez utiliser l'implémentation d'un AsyncTask
et ensuite surcharger la méthode doInTheBackground()
- où vous pouvez implémenter l'appel de repos.
alors vous pouvez utiliser onPostExecute()
pour laisser le thread D'UI traiter les résultats qui ont été retournés à l'étape précédente.
cette réponse fournit une bon exemple de la façon de mettre en œuvre AsyncTask
.
voir AsyncTask Android exemple
pour le commentaire de Ruffles ci-dessous, voici un exemple plus pertinent de REST call en utilisant AsyncTask: http://alvinalexander.com/android/android-asynctask-http-client-rest-example-tutorial