Erstellen Sie eine API mit Retrofit2, Okhttp3 und Gson (Java).

Ein Memorandum beim Erstellen der API. Damit konnte ich vorerst ohne ausführliche Erklärung kommunizieren.

• Retrofit2
• Okhttp3
• Gson

Verfahren

• Setzen Sie die Manifestdatei, um die Kommunikation zu ermöglichen
• Definieren Sie eine Klasse für den Empfang von Anfragen und Antworten --Erstellen Sie den Endpunkt
• Erstellen Sie einen HTTP-Client --Ausführen

Stellen Sie manifestFile ein, um die Kommunikation zu ermöglichen

AndroidManifest.Schreiben Sie Folgendes in XML

#### **`AndroidManifest.xml`**
```java

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

Definieren Sie eine Klasse für den Empfang von Anforderungen und Antworten

Anforderungsklasse für die Anmeldung, der Hauptteil der Anforderung wird in diesem Format gesendet

LoginRequest.java

package com.example.bookmanager_android.models.requests;

public class LoginRequest {
    private String email;
    private String password;

    public LoginRequest(String email, String passWord){
        this.email = email;
        this.password = passWord;
    }
}

• Antwortklasse

Antwortklasse für die Anmeldung, Antwort wird in diesem Formular empfangen

LoginResponse.java

package com.example.bookmanager_android.models.requests.response;

public class LoginResponse {
    public int status;
    public Result result;

    public static class Result {
        public int id;
        public String email;
        public String token;
    }
}

Erstellen Sie einen Endpunkt

Schnittstelle erstellen

RequestApiService

public interface RequestApiService {
    @POST("/login") //API-Endpunkt
    Call<LoginResponse> logIn(@Body LoginRequest requestBody); 
    //Wenn die Anmeldemethode aufgerufen wird,Das Body-Format ist die Form der oben erstellten LoginRequest-Klasse.
}

Erstellen eines HTTP-Clients

HttpClient.java

public class HttpClient {
    public static RequestApiService apiService;

    private static final String URL = "http://baseurl"; //Geben Sie BaseUrl an

    // Okhttp
    private static final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();
    // GSON
    private static final Gson gson = new GsonBuilder()
            .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
            .create();

    //Erstellen Sie einen HTTP-Client, indem Sie Retrofit mit GSON und Okhttp kombinieren
    public static RequestApiService getRequestApiService() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(URL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .client(client)
                .build();
        apiService = retrofit.create(RequestApiService.class);
        return apiService;
    }

Lauf

SignInFragment.java

private boolean starLogin(String emailStr, String passwordStr) {
        //Einen Körper schaffen
        LoginRequest requestBody = new LoginRequest(emailStr, passwordStr);
        //HTTP-Client-Aufruf
        RequestApiService apiService = HttpClient.getRequestApiService();

        //Kommunikationsstart: Der in der Schnittstelle definierte Prozess wird aufgerufen
        apiService.logIn(requestBody).enqueue(new Callback<LoginResponse>() {
            @Override
            public void onResponse(Call<LoginResponse> call, Response<LoginResponse> response) {
                if (response.isSuccessful()) {
                   //Beschreibt die Verarbeitung bei erfolgreicher Kommunikationsverarbeitung
                } else {
                    Log.e("SignInFragment", "Something wrong On Response: " + response.toString());   
                }
            }

            @Override
            public void onFailure(Call<LoginResponse> call, Throwable t) {
                //Beschreibt die Verarbeitung, wenn die Kommunikationsverarbeitung fehlschlägt
            }
        });
        return true;
    }

Impressionen

Es gibt immer noch Dinge wie das Halten von Token und die Verarbeitung, wenn Erfolg oder Misserfolg auftreten, aber vorerst war Kommunikation möglich.