Android
Nachrüstung2

Einführung

Bemerkungen

dependencies {
    ...
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'    
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    ...
}

<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>retrofit</artifactId>
  <version>2.3.0</version>
</dependency>

Eine einfache GET-Anfrage

Wir zeigen Ihnen, wie Sie eine GET Anfrage an eine API richten, die mit einem JSON Objekt oder einem JSON Array antwortet. Als Erstes müssen wir die Abhängigkeiten von Retrofit und GSON Converter zur Gradle-Datei unseres Moduls hinzufügen.

Fügen Sie die Abhängigkeiten für die Retrofit-Bibliothek hinzu, wie im Abschnitt Anmerkungen beschrieben.

Beispiel eines erwarteten JSON-Objekts:

{
    "deviceId": "56V56C14SF5B4SF",
    "name": "Steven",
    "eventCount": 0
}

Beispiel eines JSON-Arrays:

[
    {
        "deviceId": "56V56C14SF5B4SF",
        "name": "Steven",
        "eventCount": 0
    },
    {
        "deviceId": "35A80SF3QDV7M9F",
        "name": "John",
        "eventCount": 2
    }
]

Beispiel für eine entsprechende Modellklasse:

public class Device
{
    @SerializedName("deviceId")
    public String id;

    @SerializedName("name")
    public String name;

    @SerializedName("eventCount")
    public int eventCount;
}

Die @SerializedName Annotationen hier stammen aus der GSON Bibliothek und ermöglichen es uns, diese Klasse in JSON zu serialize und deserialize , wobei der serialisierte Name als Schlüssel verwendet wird. Jetzt können wir die Schnittstelle für die API erstellen, die die Daten tatsächlich vom Server abruft.

public interface DeviceAPI
{
    @GET("device/{deviceId}")
    Call<Device> getDevice (@Path("deviceId") String deviceID);

    @GET("devices")
    Call<List<Device>> getDevices();
}

Hier ist viel los in einer ziemlich kompakten Umgebung, also lassen Sie uns das aufteilen:

• Die @GET Annotation stammt aus Retrofit und teilt der Bibliothek mit, dass wir eine GET-Anforderung definieren.
• Der Pfad in den Klammern ist der Endpunkt, den unsere GET-Anfrage treffen soll (wir setzen die Basis-URL etwas später).
• Die geschweiften Klammern ermöglichen es uns, Teile des Pfads zur Laufzeit zu ersetzen, damit wir Argumente übergeben können.
• Die Funktion, die wir definieren, heißt getDevice und nimmt die getDevice Geräte-ID als Argument an.
• Die @PATH Annotation teilt Retrofit mit, dass dieses Argument den Platzhalter "deviceId" im Pfad ersetzen soll.
• Die Funktion gibt ein Call Objekt vom Typ Device .

Erstellen einer Wrapper-Klasse:

Jetzt werden wir eine kleine Wrapper-Klasse für unsere API erstellen, um den Retrofit-Initialisierungscode gut verpackt zu halten.

public class DeviceAPIHelper
{
    public final DeviceAPI api;

    private DeviceAPIHelper ()
    {

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        api = retrofit.create(DeviceAPI.class);
    }
}

Diese Klasse erstellt eine GSON-Instanz, um die JSON-Antwort analysieren zu können, erstellt eine Retrofit-Instanz mit unserer Basis-URL und einem GSONConverter und erstellt dann eine Instanz unserer API.

Aufruf der API:

// Getting a JSON object
Call<Device> callObject = api.getDevice(deviceID);
callObject.enqueue(new Callback<Response<Device>>()
{
    @Override
    public void onResponse (Call<Device> call, Response<Device> response)
    {
        if (response.isSuccessful()) 
        {
           Device device = response.body();
        }
    }

    @Override
    public void onFailure (Call<Device> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

// Getting a JSON array
Call<List<Device>> callArray = api.getDevices();
callArray.enqueue(new Callback<Response<List<Device>>()
{
    @Override
    public void onResponse (Call<List<Device>> call, Response<List<Device>> response)
    {
        if (response.isSuccessful()) 
        {
           List<Device> devices = response.body();
        }
    }

    @Override
    public void onFailure (Call<List<Device>> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

Diese verwendet unsere API-Schnittstelle, um ein Call<Device> -Objekt bzw. ein Call<List<Device>> Call<Device> zu erstellen. Beim Aufruf von enqueue wird Retrofit enqueue , diesen Aufruf in einem Hintergrundthread enqueue und das Ergebnis an den hier erstellten Rückruf zurückzugeben.

Anmerkung: Das Parsing eines JSON-Arrays aus primitiven Objekten (wie String, Integer, Boolean und Double ) ähnelt dem Parsing eines JSON-Arrays. Sie benötigen jedoch keine eigene Modellklasse. Sie können das Array von Strings beispielsweise abrufen, indem Call<List<String>> den Rückgabetyp des Anrufs als Call<List<String>> .

Protokollierung zu Retrofit2 hinzufügen

Nachrüstaufträge können mit einem Interceptor protokolliert werden. Es stehen verschiedene Detailebenen zur Verfügung: KEINE, BASIC, HEADERS, BODY. Siehe das Github-Projekt hier .

1. Fügen Sie Abhängigkeit zu build.gradle hinzu:

compile 'com.squareup.okhttp3:logging-interceptor:3.8.1'

2. Fügen Sie beim Erstellen von Retrofit Protokollierungs-Interceptor hinzu:

  HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
  loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
  OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
          .addInterceptor(loggingInterceptor)
          .build();
  Retrofit retrofit = new Retrofit.Builder()
          .baseUrl("http://example.com/")
          .client(okHttpClient)
          .addConverterFactory(GsonConverterFactory.create(gson))
          .build();

Das Freigeben der Protokolle im Terminal (Android Monitor) sollte in der Release-Version vermieden werden, da dies zu unerwünschtem Freigeben wichtiger Informationen wie Auth-Token usw. führen kann

Überprüfen Sie die folgende Bedingung, um zu vermeiden, dass die Protokolle zur Laufzeit angezeigt werden

if(BuildConfig.DEBUG){
     //your interfector code here   
    }

Zum Beispiel:

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
if(BuildConfig.DEBUG){
     //print the logs in this case   
    loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
}else{
    loggingInterceptor.setLevel(LoggingInterceptor.Level.NONE);
}

OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
      .addInterceptor(loggingInterceptor)
      .build();

Retrofit retrofit = new Retrofit.Builder()
      .baseUrl("http://example.com/")
      .client(okHttpClient)
      .addConverterFactory(GsonConverterFactory.create(gson))
      .build();

Hochladen einer Datei über Multipart

Deklarieren Sie Ihre Schnittstelle mit Retrofit2-Anmerkungen:

public interface BackendApiClient {
    @Multipart
    @POST("/uploadFile")
    Call<RestApiDefaultResponse> uploadPhoto(@Part("file\"; filename=\"photo.jpg\" ") RequestBody photo);
}

Dabei ist RestApiDefaultResponse eine benutzerdefinierte Klasse, die die Antwort enthält.

Aufbau der Implementierung Ihrer API und Aufnahme des Aufrufs:

Retrofit retrofit = new Retrofit.Builder()
                                .addConverterFactory(GsonConverterFactory.create())
                                .baseUrl("http://<yourhost>/")
                                .client(okHttpClient)
                                .build();

BackendApiClient apiClient = retrofit.create(BackendApiClient.class);
RequestBody reqBody = RequestBody.create(MediaType.parse("image/jpeg"), photoFile);
Call<RestApiDefaultResponse> call = apiClient.uploadPhoto(reqBody);
call.enqueue(<your callback function>);

Nachrüstung mit OkHttp-Interceptor

Dieses Beispiel zeigt, wie ein Anforderungsinterceptor mit OkHttp verwendet wird. Dies hat zahlreiche Anwendungsfälle wie:

• Universellen header zur Anfrage hinzufügen. ZB eine Anfrage authentifizieren
• Debuggen von vernetzten Anwendungen
• Rohe response abrufen
• Protokollierung der Netzwerktransaktion usw.
• Legen Sie einen benutzerdefinierten Benutzeragenten fest

Retrofit.Builder builder = new Retrofit.Builder()
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .baseUrl("https://api.github.com/");

if (!TextUtils.isEmpty(githubToken)) {
    // `githubToken`: Access token for GitHub
    OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
        @Override public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request newReq = request.newBuilder()
                    .addHeader("Authorization", format("token %s", githubToken))
                    .build();
            return chain.proceed(newReq);
        }
    }).build();

    builder.client(client);
}

return builder.build().create(GithubApi.class);

Weitere Informationen finden Sie im OkHttp-Thema .

Header und Body: ein Authentifizierungsbeispiel

Die Annotationen @Header und @Body können in die Methodensignaturen @Body werden, und Retrofit erstellt diese automatisch basierend auf Ihren Modellen.

public interface MyService {
     @POST("authentication/user")
     Call<AuthenticationResponse> authenticateUser(@Body AuthenticationRequest request, @Header("Authorization") String basicToken);
}

AuthenticaionRequest ist unser Modell, ein POJO, das die Informationen enthält, die der Server benötigt. Für dieses Beispiel möchte unser Server den Clientschlüssel und das Geheimnis.

public class AuthenticationRequest {
     String clientKey;
     String clientSecret;
}

Beachten Sie, dass wir in @Header("Authorization") dass der Authorization-Header @Header("Authorization") . Die anderen Header werden automatisch aufgefüllt, da Retrofit auf die Art der Objekte schließen kann, die wir als Gegenleistung senden und erwarten.

Wir schaffen irgendwo unseren Retrofit-Service. Wir stellen sicher, dass Sie HTTPS verwenden.

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https:// some example site")
            .client(client)
            .build();
MyService myService = retrofit.create(MyService.class)

Dann können wir unseren Service nutzen.

AuthenticationRequest request = new AuthenticationRequest();
request.setClientKey(getClientKey());
request.setClientSecret(getClientSecret());
String basicToken = "Basic " + token;
myService.authenticateUser(request, basicToken);

Laden Sie mehrere Dateien mit Retrofit als Multipart hoch

Nachdem Sie die Retrofit-Umgebung in Ihrem Projekt eingerichtet haben, können Sie das folgende Beispiel verwenden, das das Hochladen mehrerer Dateien mit Retrofit veranschaulicht:

private void mulipleFileUploadFile(Uri[] fileUri) {
    OkHttpClient okHttpClient = new OkHttpClient();
    OkHttpClient clientWith30sTimeout = okHttpClient.newBuilder()
            .readTimeout(30, TimeUnit.SECONDS)
            .build();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(API_URL_BASE)
            .addConverterFactory(new MultiPartConverter())
            .client(clientWith30sTimeout)
            .build();

    WebAPIService service = retrofit.create(WebAPIService.class); //here is the interface which you have created for the call service
    Map<String, okhttp3.RequestBody> maps = new HashMap<>();

    if (fileUri!=null && fileUri.length>0) {
        for (int i = 0; i < fileUri.length; i++) {
            String filePath = getRealPathFromUri(fileUri[i]);
            File file1 = new File(filePath);

            if (filePath != null && filePath.length() > 0) {
                if (file1.exists()) {
                    okhttp3.RequestBody requestFile = okhttp3.RequestBody.create(okhttp3.MediaType.parse("multipart/form-data"), file1);
                    String filename = "imagePath" + i; //key for upload file like : imagePath0
                    maps.put(filename + "\"; filename=\"" + file1.getName(), requestFile);
                }
            }
        }
    }

    String descriptionString = " string request";//
    //hear is the your json request
    Call<String> call = service.postFile(maps, descriptionString);
    call.enqueue(new Callback<String>() {
        @Override
        public void onResponse(Call<String> call,
                               Response<String> response) {
            Log.i(LOG_TAG, "success");
            Log.d("body==>", response.body().toString() + "");
            Log.d("isSuccessful==>", response.isSuccessful() + "");
            Log.d("message==>", response.message() + "");
            Log.d("raw==>", response.raw().toString() + "");
            Log.d("raw().networkResponse()", response.raw().networkResponse().toString() + "");
        }

        @Override
        public void onFailure(Call<String> call, Throwable t) {
            Log.e(LOG_TAG, t.getMessage());
        }
    });
}
    
public String getRealPathFromUri(final Uri uri) { // function for file path from uri,
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(mContext, uri)) {
        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/" + split[1];
            }
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(
                    Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));

            return getDataColumn(mContext, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[]{
                    split[1]
            };

            return getDataColumn(mContext, contentUri, selection, selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {

        // Return the remote address
        if (isGooglePhotosUri(uri))
            return uri.getLastPathSegment();

        return getDataColumn(mContext, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

Folgendes ist die Schnittstelle

public interface WebAPIService {
    @Multipart
    @POST("main.php")
    Call<String> postFile(@PartMap Map<String,RequestBody> Files, @Part("json") String description);
}

Laden Sie eine Datei mit Retrofit2 vom Server herunter

Schnittstellendeklaration zum Herunterladen einer Datei

public interface ApiInterface {
    @GET("movie/now_playing")
    Call<MovieResponse> getNowPlayingMovies(@Query("api_key") String apiKey, @Query("page") int page);

    // option 1: a resource relative to your base URL
    @GET("resource/example.zip")
    Call<ResponseBody> downloadFileWithFixedUrl();

    // option 2: using a dynamic URL
    @GET
    Call<ResponseBody> downloadFileWithDynamicUrl(@Url String fileUrl);
}

Die Option 1 wird zum Herunterladen einer Datei vom Server mit fester URL verwendet. Option 2 wird verwendet, um einen dynamischen Wert als vollständige URL an den Anforderungsaufruf zu übergeben. Dies kann beim Herunterladen von Dateien hilfreich sein, die von Parametern wie Benutzer oder Zeit abhängen.

Setup-Nachrüstung für das Aufrufen von APIs

public class ServiceGenerator {

    public static final String API_BASE_URL = "http://your.api-base.url/";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder =
            new Retrofit.Builder()
            .baseUrl(API_BASE_URL)
            .addConverterFactory(GsonConverterFactory.create());

    public static <S> S createService(Class<S> serviceClass){
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }

}

Nehmen Sie nun die Implementierung von API zum Herunterladen der Datei vom Server vor

private void downloadFile(){
        ApiInterface apiInterface = ServiceGenerator.createService(ApiInterface.class);

        Call<ResponseBody> call = apiInterface.downloadFileWithFixedUrl();

        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.isSuccessful()){
                    boolean writtenToDisk = writeResponseBodyToDisk(response.body());

                    Log.d("File download was a success? ", String.valueOf(writtenToDisk));
                }
            }

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

            }
        });
    }

Nachdem Sie im Rückruf eine Antwort erhalten haben, codieren Sie einige Standard-E / A, um die Datei auf der Festplatte zu speichern. Hier ist der Code:

private boolean writeResponseBodyToDisk(ResponseBody body) {
        try {
            // todo change the file location/name according to your needs
            File futureStudioIconFile = new File(getExternalFilesDir(null) + File.separator + "Future Studio Icon.png");

            InputStream inputStream = null;
            OutputStream outputStream = null;

            try {
                byte[] fileReader = new byte[4096];

                long fileSize = body.contentLength();
                long fileSizeDownloaded = 0;

                inputStream = body.byteStream();
                outputStream = new FileOutputStream(futureStudioIconFile);

                while (true) {
                    int read = inputStream.read(fileReader);

                    if (read == -1) {
                        break;
                    }

                    outputStream.write(fileReader, 0, read);

                    fileSizeDownloaded += read;

                    Log.d("File Download: " , fileSizeDownloaded + " of " + fileSize);
                }

                outputStream.flush();

                return true;
            } catch (IOException e) {
                return false;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }

                if (outputStream != null) {
                    outputStream.close();
                }
            }
        } catch (IOException e) {
            return false;
        }
    }

Hinweis: Wir haben ResponseBody als Rückgabetyp angegeben. Andernfalls versucht Retrofit, den Code zu analysieren und zu konvertieren.

Wenn Sie mehr über Retrofit erfahren möchten, besuchen Sie diesen Link, da er sehr nützlich ist. [1]: https://futurestud.io/blog/retrofit-getting-started-and-android-client

Debuggen mit Stetho

Fügen Sie Ihrer Anwendung die folgenden Abhängigkeiten hinzu.

compile 'com.facebook.stetho:stetho:1.5.0' 
compile 'com.facebook.stetho:stetho-okhttp3:1.5.0' 

Rufen Sie in der onCreate Methode Ihrer Application-Klasse Folgendes auf.

Stetho.initializeWithDefaults(this);

Erstellen Sie beim Erstellen Ihrer Retrofit Instanz eine benutzerdefinierte OkHttp-Instanz.

OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
clientBuilder.addNetworkInterceptor(new StethoInterceptor());

Legen Sie dann diese benutzerdefinierte OkHttp-Instanz in der Retrofit-Instanz fest.

Retrofit retrofit = new Retrofit.Builder()
    // ...
    .client(clientBuilder.build())
    .build();

Verbinden Sie jetzt Ihr Telefon mit Ihrem Computer, starten Sie die App und geben Sie chrome://inspect in Ihren Chrome-Browser ein. Nachgerüstete Netzwerkanrufe sollten jetzt angezeigt werden.

Retrofit 2 Custom Xml Converter

Hinzufügen von Abhängigkeiten zur build.gradle-Datei.

dependencies {
    ....
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile ('com.thoughtworks.xstream:xstream:1.4.7') {
        exclude group: 'xmlpull', module: 'xmlpull'
    }
    ....
}

Dann erstellen Sie Converter Factory

public class XStreamXmlConverterFactory extends Converter.Factory {

    /** Create an instance using a default {@link com.thoughtworks.xstream.XStream} instance for conversion. */
    public static XStreamXmlConverterFactory create() {
        return create(new XStream());
    }

    /** Create an instance using {@code xStream} for conversion. */
    public static XStreamXmlConverterFactory create(XStream xStream) {
        return new XStreamXmlConverterFactory(xStream);
    }

    private final XStream xStream;

    private XStreamXmlConverterFactory(XStream xStream) {
        if (xStream == null) throw new NullPointerException("xStream == null");
        this.xStream = xStream;
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        Class<?> cls = (Class<?>) type;

        return new XStreamXmlResponseBodyConverter<>(cls, xStream);
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
          Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        return new XStreamXmlRequestBodyConverter<>(xStream);
    }
}

Erstellen Sie eine Klasse, um die Anfrage zu bearbeiten.

final class XStreamXmlResponseBodyConverter <T> implements Converter<ResponseBody, T> {

    private final Class<T> cls;
    private final XStream xStream;

    XStreamXmlResponseBodyConverter(Class<T> cls, XStream xStream) {
        this.cls = cls;
        this.xStream = xStream;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {

        try {

            this.xStream.processAnnotations(cls);
            Object object =  this.xStream.fromXML(value.byteStream());
            return (T) object;

        }finally {
            value.close();
        }
    }
}

Erstellen Sie eine Klasse, um mit der Antwort des Körpers umzugehen.

final class XStreamXmlRequestBodyConverter<T> implements Converter<T, RequestBody> {

    private static final MediaType MEDIA_TYPE = MediaType.parse("application/xml; charset=UTF-8");
    private static final String CHARSET = "UTF-8";

    private final XStream xStream;

    XStreamXmlRequestBodyConverter(XStream xStream) {
        this.xStream = xStream;
    }

    @Override
    public RequestBody convert(T value) throws IOException {

        Buffer buffer = new Buffer();

        try {
            OutputStreamWriter osw = new OutputStreamWriter(buffer.outputStream(), CHARSET);
            xStream.toXML(value, osw);
            osw.flush();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
    }
}

An diesem Punkt können wir jedes XML senden und empfangen. Wir müssen lediglich XStream-Anmerkungen für die Entitäten erstellen.

Dann erstellen Sie eine Retrofit-Instanz:

XStream xs = new XStream(new DomDriver());
xs.autodetectAnnotations(true);

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://example.com/")
    .addConverterFactory(XStreamXmlConverterFactory.create(xs))
    .client(client)
    .build();

Eine einfache POST-Anfrage mit GSON

Beispiel JSON:

{ 
    "id": "12345",
    "type": "android"
}

Definieren Sie Ihre Anfrage:

public class GetDeviceRequest {

    @SerializedName("deviceId")
    private String mDeviceId;

    public GetDeviceRequest(String deviceId) {
        this.mDeviceId = deviceId;
    }

    public String getDeviceId() {
        return mDeviceId;
    }

}

Definieren Sie Ihren Service (Endpunkte für Treffer):

public interface Service {

    @POST("device")
    Call<Device> getDevice(@Body GetDeviceRequest getDeviceRequest);

}

Definieren Sie Ihre Singleton-Instanz des Netzwerkclients:

public class RestClient {

    private static Service REST_CLIENT;

    static {
        setupRestClient();
    }

    private static void setupRestClient() {
        
        // Define gson 
        Gson gson = new Gson();

        // Define our client 
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();

        REST_CLIENT = retrofit.create(Service.class);
    }

    public static Retrofit getRestClient() {
        return REST_CLIENT;
    }

} 

Definieren Sie ein einfaches Modellobjekt für das Gerät:

public class Device {

    @SerializedName("id")
    private String mId;

    @SerializedName("type")
    private String mType;

    public String getId() {
        return mId;
    }

    public String getType() {
        return mType;
    }

}

Definieren Sie einen Controller, um die Anforderungen für das Gerät zu bearbeiten

public class DeviceController {

    // Other initialization code here...

    public void getDeviceFromAPI() {

        // Define our request and enqueue 
        Call<Device> call = RestClient.getRestClient().getDevice(new GetDeviceRequest("12345"));

        // Go ahead and enqueue the request 
        call.enqueue(new Callback<Device>() {
            @Override
            public void onSuccess(Response<Device> deviceResponse) {
                // Take care of your device here 
                if (deviceResponse.isSuccess()) {
                    // Handle success
                    //delegate.passDeviceObject();
                }
            }

            @Override
            public void onFailure(Throwable t) {
                // Go ahead and handle the error here 
            } 

        });

XML-Formular-URL mit Retrofit 2 lesen

Wir werden retrofit 2 und SimpleXmlConverter verwenden, um XML-Daten von der URL abzurufen und in die Java-Klasse zu analysieren.

Fügen Sie dem Gradle-Skript eine Abhängigkeit hinzu:

compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-simplexml:2.1.0'

Schnittstelle erstellen

Erstellen Sie in unserer Fall-Rss-Klasse auch einen XML-Klassen-Wrapper

    public interface ApiDataInterface{
    
        // path to xml link on web site
    
        @GET (data/read.xml)
    
        Call<Rss> getData();

}

XML-Lesefunktion

private void readXmlFeed() {
        try {

            // base url - url of web site
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(http://www.google.com/)
                    .client(new OkHttpClient())
                    .addConverterFactory(SimpleXmlConverterFactory.create())
                    .build();

            ApiDataInterface apiService = retrofit.create(ApiDataInterface.class);

            Call<Rss> call = apiService.getData();
            call.enqueue(new Callback<Rss>() {

                @Override
                public void onResponse(Call<Rss> call, Response<Rss> response) {

                    Log.e("Response success", response.message());
                    
                }

                @Override
                public void onFailure(Call<Rss> call, Throwable t) {
                    Log.e("Response fail", t.getMessage());
                }
            });

        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }


    }

Dies ist ein Beispiel für eine Java-Klasse mit SimpleXML-Anmerkungen

Weitere Informationen zu Anmerkungen SimpleXmlDocumentation

@Root (name = "rss")

public class Rss
{


    public Rss() {

    }



    public Rss(String title, String description, String link, List<Item> item, String language) {

        this.title = title;
        this.description = description;
        this.link = link;
        this.item = item;
        this.language = language;

    }

    @Element (name = "title")
    private String title;

    @Element(name = "description")
    private String description;

    @Element(name = "link")
    private String link;

    @ElementList (entry="item", inline=true)
    private List<Item> item;

    @Element(name = "language")
    private String language;