Retrofit in Android verwenden

Ich habe Retrofit gerade für ein paar Wochen verwendet und es fiel mir zunächst schwer, es in meiner Anwendung zu verwenden. Ich möchte Ihnen die einfachste Möglichkeit mitteilen, Retrofit in Ihrer Anwendung zu verwenden. Und wenn Sie sich später bereits gut mit Retrofit auskennen, können Sie Ihre Codes verbessern (indem Sie Ihre Benutzeroberfläche von API trennen und Callbacks verwenden). Vielleicht erhalten Sie auch einige Techniken aus dem obigen Beitrag.

In Ihrer App haben Sie Login, Aktivität für Aufgabenliste und Aktivität zum Anzeigen detaillierter Aufgaben.

Als Erstes müssen Sie Retrofit in Ihre App einfügen. Es gibt zwei Möglichkeiten, den @artemis-Beitrag oben zu befolgen.

Retrofit verwendet eine Schnittstelle als API. Erstellen Sie also eine Schnittstellenklasse.

public interface MyApi{

/*LOGIN*/
@GET("/api_reciever/login") //your login function in your api
public void login(@Query("username") String username,@Query("password") String password,Callback<String> calback); //this is for your login, and you can used String as response or you can use a POJO, retrofit is very rubust to convert JSON to POJO

/*GET LIST*/
@GET("/api_reciever/getlist") //a function in your api to get all the list
public void getTaskList(@Query("user_uuid") String user_uuid,Callback<ArrayList<Task>> callback); //this is an example of response POJO - make sure your variable name is the same with your json tagging

/*GET LIST*/
@GET("/api_reciever/getlistdetails") //a function in your api to get all the list
public void getTaskDetail(@Query("task_uuid") String task_uuid,Callback<Task> callback);   //this is an example of response POJO - make sure your variable name is the same with your json tagging

}

Erstellen Sie eine andere Schnittstellenklasse, um alle Ihre Basisadresse Ihrer API zu speichern

public interface Constants{
   public String URL = "www.yoururl.com"
}

Erstellen Sie in Ihrer Anmeldeaktivität eine Methode für die Nachrüstung

private void myLogin(String username,String password){

RestAdapter restAdapter = new RestAdapter.Builder()
    .setEndpoint(Constants.URL)  //call your base url
    .build();


MyApi mylogin = restAdapter.create(MyApi.class); //this is how retrofit create your api
mylogin.login(username,password,new Callback<String>() {
        @Override
        public void success(String s, Response response) {
            //process your response if login successfull you can call Intent and launch your main activity

        }

        @Override
        public void failure(RetrofitError retrofitError) {
            retrofitError.printStackTrace(); //to see if you have errors
        }
    });
}

In Ihrer MainActivityList

private void myList(String user_uuid){

RestAdapter restAdapter = new RestAdapter.Builder()
    .setEndpoint(Constants.URL)  //call your base url
    .build();


MyApi mytask = restAdapter.create(MyApi.class); //this is how retrofit create your api
mytask.getTaskDetail(user_uuid,new Callback<Task>>() {
        @Override
        public void success(ArrayList<Task> list, Response response) {
            //process your response if successful load the list in your listview adapter

        }

        @Override
        public void failure(RetrofitError retrofitError) {
            retrofitError.printStackTrace(); //to see if you have errors
        }
    });
}

In Ihrer detaillierten Liste

private void myDetailed(String task_uuid){

RestAdapter restAdapter = new RestAdapter.Builder()
    .setEndpoint(Constants.URL)  //call your base url
    .build();


MyApi mytask = restAdapter.create(MyApi.class); //this is how retrofit create your api
mytask.getTaskList(task_uuid,new Callback<Task>() {
        @Override
        public void success(Task task, Response response) {
            //process your response if successful do what you want in your task

        }

        @Override
        public void failure(RetrofitError retrofitError) {
            retrofitError.printStackTrace(); //to see if you have errors
        }
    });
}

Ich hoffe, dies würde Ihnen helfen, obwohl es wirklich die einfachste Möglichkeit ist, Retrofit zu verwenden. 

Sehen Sie sich dieses exzellente Blog über die Verwendung von Retrofit in Verbindung mit Otto an. Beide Bibliotheken stammen von Square.

http://www.mdswanson.com/blog/2014/04/07/durable-Android-restclients.html

Die Grundidee ist, dass Sie einen Verweis auf ein "Repository" -Objekt in Ihrer Application-Klasse halten. Dieses Objekt wird über Methoden verfügen, die "restliche" API-Ereignisanforderungen "abonnieren". Wenn eine empfangen wird, wird der entsprechende Retrofit-Anruf getätigt und dann die Antwort "gebucht", die dann von einer anderen Komponente "abonniert" werden kann (z. B. der Aktivität, die die Anforderung ausgeführt hat).

Sobald Sie alles richtig eingerichtet haben, ist der Zugriff auf Daten über Ihre Rest-API sehr einfach. Zum Beispiel würde die Anforderung von Daten ungefähr so ​​aussehen:

    mBus.post(new GetMicropostsRequest(mUserId));

und das Verbrauchen der Daten würde ungefähr so ​​aussehen:

@Subscribe
public void onGetUserProfileResponse(GetUserProfileResponse event) {
    mView.setUserIcon("http://www.gravatar.com/avatar/" + event.getGravatar_id());
    mView.setUserName(event.getName());

}

Es erfordert ein bisschen Vorarbeit, aber am Ende wird es "trivial", über Rest auf alles zuzugreifen, was Sie von unserem Backend benötigen.

Die Verwendung von RetroFit ist sehr einfach. 

• Fügen Sie dependecy in build.gradle hinzu. 

      compile 'com.squareup.retrofit:retrofit:1.9.0'
  
      compile 'com.squareup.okhttp:okhttp:2.4.0' 
  

• Erstellen Sie eine Schnittstelle für alle http-Methoden.

• Kopieren Sie Ihre Json-Ausgabe und erstellen Sie eine Pojo-Klasse, um Json von Ihrer zu erhalten
  Antwort können Sie Pojo von JsonSchema2pojo site machen.

• machen Sie einen Adapter und rufen Sie Ihre Methode auf

  für eine vollständige Demo versuchen Sie dieses Tutorial Retrofit Android Beispiel

Sie können versuchen, Verweise auf Ihre API innerhalb Ihrer Anwendungsklasse zu speichern. Dann können Sie die Instanz von jeder Aktivität oder einem Fragment erhalten und ein API von dort erhalten. Das hört sich etwas komisch an, kann aber eine einfache DI-Alternative sein. Wenn Sie nur Referenzen in Ihrer App-Klasse speichern, ist dies keine Art von Objekt

UPD: http://square.github.io/retrofit/ - Hier sind einige Dokumentationen, die möglicherweise nützlich sind

Erstens, alles in MainActivity zu setzen, wäre eine schlechte Praxis und Sie würden mit einem Gott-Objekt enden.

Die Dokumentation auf der Retrofit-Site ist fantastisch, deshalb werde ich Ihre Frage zur Strukturierung des Projekts lesen. Ich habe eine sehr kleine App zu Demonstrationszwecken geschrieben. Es lädt Katzen von der Katzen-API und sollte ziemlich einfach zu verfolgen sein, was passiert.

Es gibt ein Beispiel für die Verwendung von JSON oder XML für die Analyse von Daten aus dem Dienst. Sie finden es unter https://github.com/codepath/Android_guides/wiki/Consuming-APIs-with-Retrofit

Hoffentlich können Sie extrapolieren, warum ich es so strukturiert habe wie ich. Gerne beantworte ich Ihre Fragen in den Kommentaren und aktualisiere die Antwort.

Testen Sie diese App, die die Integration von Retrofit in die Google Tasks-API demonstriert.

https://github.com/sschendel/SyncManagerAndroid-DemoGoogleTasks

Es gibt Beispiele für Retrofit-API (TaskApi), die in Activity AsyncTask in MainActivity verwendet werden, sowie Beispiele für die Verwendung von Sync Adapter im Hintergrunddienst.

Die Strategie aus dem in @ nPn's Antwort veröffentlichten Artikel ist wahrscheinlich eine elegantere Lösung, aber Sie können sich zumindest ein anderes Arbeitsbeispiel ansehen.

Ich finde diese Tutorials AndroidHive , CodePath hilfreich

Ich werde kurz beschreiben, was ich gelernt habe.

Schritt 1: Diese drei dependencies to build.gradle hinzufügen und Internet permission zu Manifest hinzufügen

compile 'com.google.code.gson:gson:2.6.2' // for string to class conversion. Not Compulsory
compile 'com.squareup.retrofit2:retrofit:2.1.0'// compulsory
compile 'com.squareup.retrofit2:converter-gson:2.1.0' //for retrofit conversion

Fügen Sie sie in Manifest hinzu

<uses-permission Android:name="Android.permission.INTERNET" />

Schritt 2 Creae ApiClient und ApiInterface.

public class ApiClient {

    public static final String BASE_URL = "http://yourwebsite/services/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {
        if (retrofit==null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

wobei ApiInterface.class

public interface ApiInterface {

    // getting same data in three different ways.
    @GET("GetCompanyDetailByID")
    Call<CompanyResponse> getDetailOfComapanies(@Query("CompanyID") int companyID);


    @GET("GetCompanyDetailByID")
    Call<ResponseBody> getRawDetailOfCompanies(@Query("CompanyID") int companyID);

    @GET("{pathToAdd}")
    Call<CompanyResponse> getDetailOfComapaniesWithPath(@Path("pathToAdd") String pathToAppend, @Query("CompanyID") int companyID);
}

Und diesen Service gerne anrufen

ApiInterface apiService =
                ApiClient.getClient().create(ApiInterface.class);

        Call<CompanyResponse> companyResponseCall = apiService.getDetailOfComapanies(2);
        //Call<CompanyResponse> companyResponseCall = apiService.getDetailOfComapaniesWithPath("GetCompanyDetailByID",2);

        companyResponseCall.enqueue(new Callback<CompanyResponse>() {
            @Override
            public void onResponse(Call<CompanyResponse> call, Response<CompanyResponse> response) {
                CompanyResponse comapnyResponse = response.body();
                Boolean status  = comapnyResponse.getStatus();
            }

            @Override
            public void onFailure(Call<CompanyResponse> call, Throwable t) {
            }
        });

Für das Erhalten von Raw Json String 

Call<ResponseBody> call = apiService.getRawDetailOfCompanies(2);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                    String jsonStr = response.body().string();
                    if(!jsonStr.isEmpty()){
                        Gson gson = new Gson();

                        JSONObject jObject = new JSONObject(jsonStr).getJSONObject("data");

                        //1st Method
                        Data dataKiType = gson.fromJson(jObject.toString(), Data.class);
                        dataKiType.getCompanyDetail();

                        //2nd method for creaing class or List at runTime
                        Type listType = new TypeToken<Data>(){}.getType();
                        Data yourClassList = new Gson().fromJson(jObject.toString(), listType);
                        yourClassList.getCompanyDetail();
                    }  e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
            }
        });

Sie können Ihr Geschäftsobjekt mit http://www.jsonschema2pojo.org/ erstellen, indem Sie einfach json einfügen. und Auswählen des Quelltyps für JSON und Anmerkungsstil für GSon

Ein kleines, aber vollständiges und prägnantes Beispiel finden Sie unter https://github.com/square/retrofit/tree/master/samples

Anfänger finden es wenig einschüchternd, Retrofit zu lernen. Ich habe ein Tutorial vorbereitet, das die Lernkurve vereinfacht. Weitere Informationen finden Sie in Retrofit Android Tutorial .

Fügen Sie diese Zeilen zunächst der Gradle-Datei hinzu

compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    compile 'com.google.code.gson:gson:2.7'
    compile 'com.squareup:otto:1.3.8'
    compile 'com.squareup.okhttp3:logging-interceptor:3.4.1'

Erstellen Sie dann Objekte in OnCreate of Activity

HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);    
OkHttpClient client= new OkHttpClient
                .Builder()
                .connectTimeout(30, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .addInterceptor(interceptor).build();
Gson gson=new GsonBuilder()
          .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
          .create();
Retrofit retrofit= new Retrofit.Builder()
                .baseUrl("url")
                .client(client)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();

Erstellen Sie ein Iterface

public interface summaryListAPI {
//post
    @FormUrlEncoded
    @POST("index.php")
    Call<summaryList> post(
            @Field("status") String status,
            @Field("sox") String sox
    );
//get
@GET("yesbdeChatHistoryList/{userId}/")
    Call<List<ChatTabTwoResp>> getFriends(
            @Path("userId") int userId
    );
}

Klassen erstellen

public class summaryList {
    @SerializedName("bookingSummary") @Expose private List<summaryListData> status = new ArrayList<summaryListData>();
}   

public class summaryListData {
    @SerializedName("date") @Expose private String date;
}

Fügen Sie diese Methode Ihrer Aktivität hinzu

 public void apiSummaryListMain(final Retrofit retrofit) {
        retrofit.create(summaryListAPI.class).post("8547861657","100").enqueue(new Callback<summaryList>() {
            @Override
            public void onResponse(Call<summaryList> call, Response<summaryList> response) {
                if (response.isSuccessful()) {
                    progressBar.setVisibility(View.INVISIBLE);
                     List<summaryListData> summary_List= response.body().getStatus();                   
                }else{              
                }
            }
            @Override
            public void onFailure(Call<summaryList> call, Throwable t) {

            }
        });

    }

Die Entwicklung einer eigenen typsicheren HTTP-Bibliothek für die Schnittstelle mit einer REST - API kann sehr schwierig sein: Sie müssen mit vielen Aspekten umgehen, z Handhabung und mehr. Retrofit dagegen ist eine gut geplante, dokumentierte und getestete Bibliothek, die Ihnen wertvolle Zeit und Kopfschmerzen erspart.

"com.google.code.gson: gson: 2.6.2" kompilieren 

compile 'com.squareup.retrofit2: Retrofit: 2.1.0' // obligatorisch

kompilieren Sie 'com.squareup.retrofit2: converter-gson: 2.1.0' // zur Konvertierung nachträglich

Einfache Nachrüstung + okhttp-Integration mit RxJava

public WebService apiService(Context context) {
    String mBaseUrl = context.getString(BuildConfig.DEBUG ? R.string.local_url : R.string.live_url);

    int cacheSize = 5 * 1024 * 1024; // 5 MB
    Cache cache = new Cache(context.getCacheDir(), cacheSize);

    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
    loggingInterceptor.setLevel(BuildConfig.DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);

    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .readTimeout(120, TimeUnit.SECONDS)
            .writeTimeout(120, TimeUnit.SECONDS)
            .connectTimeout(120, TimeUnit.SECONDS)
            .addInterceptor(loggingInterceptor)
            //.addNetworkInterceptor(networkInterceptor)
            .cache(cache)
            .build();

    return new Retrofit.Builder().baseUrl(mBaseUrl)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build().create(WebService.class);

}

Es funktioniert

  Paket com.keshav.gmailretrofitexampleworking.network;

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class ApiClient {
    public static final String BASE_URL = "http://api.androidhive.info/json/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}
==============================================
package com.keshav.gmailretrofitexampleworking.network;

import com.keshav.gmailretrofitexampleworking.models.Message;

import Java.util.List;

import retrofit2.Call;
import retrofit2.http.GET;

public interface ApiInterface {
    @GET("inbox.json")
    Call<List<Message>> getInbox();
}

"com.google.code.gson: gson: 2.6.2" kompilieren

compile 'com.squareup.retrofit2:retrofit:2.0.2'

compile 'com.squareup.retrofit2:converter-gson:2.0.2'

================================================== ===

Rufen Sie Retrofit 2 APi in onCreate auf

private void getInbox() {
    swipeRefreshLayout.setRefreshing(true);

    ApiInterface apiService =
            ApiClient.getClient().create(ApiInterface.class);

    Call<List<Message>> call = apiService.getInbox();
    call.enqueue(new Callback<List<Message>>() {
        @Override
        public void onResponse(Call<List<Message>> call, Response<List<Message>> response) {
            // clear the inbox
            messages.clear();

            // add all the messages
            // messages.addAll(response.body());

            // TODO - avoid looping
            // the loop was performed to add colors to each message

            Log.e("keshav","response" +response.body());

            for (Message message : response.body()) {
                // generate a random color

                // TODO keshav Generate Random Color Here
                message.setColor(getRandomMaterialColor("400"));
                messages.add(message);
            }

            mAdapter.notifyDataSetChanged();
            swipeRefreshLayout.setRefreshing(false);
        }

        @Override
        public void onFailure(Call<List<Message>> call, Throwable t) {
            Toast.makeText(getApplicationContext(), "Unable to fetch json: " + t.getMessage(), Toast.LENGTH_LONG).show();
            swipeRefreshLayout.setRefreshing(false);
        }
    });
}

Quellcode https://drive.google.com/open?id=0BzBKpZ4nzNzUVFRnVVkzc0JabUU

https://drive.google.com/open?id=0BzBKpZ4nzNzUc2FBdW00WkRfWW8

Ich habe dieses Problem auf eine sehr einfache Art und Weise gebremst, Sie müssen nur ein Plugin installieren und einige Schritte ausführen, um die Nachrüstung in einer beliebigen App durchzuführen:

Bereits gepostete Antwort: Retrofit in Android?

Fügen Sie das Android Plugin (QAssist - Android Studio Plugin) in Ihrem Android Studio hinzu. ( https://github.com/sakkeerhussain/QAssist ).

Hoffe, das wird dir helfen.