Dagger 2 Ejemplo de Android usando Retrofit

La implementación de Android Dagger 2 es más sencilla y se basa en la arquitectura de inyección de dependencia. La Inyección de Dependencia es un patrón de diseño, que es un concepto de Programación Orientada a Objetos, donde no creamos un objeto de otra clase dentro de una clase usando la nueva palabra clave (para Java). En cambio, suministramos el objeto necesario desde el exterior. Es un marco de inyección de dependencia en tiempo de compilación completamente estático para Java y Android. Es una adaptación de una versión anterior creada por Square y ahora mantenida por Google.

La parte teórica sobre Dagger 2

• Proveedor de dependencias: Las dependencias son los objetos que necesitamos instanciar dentro de una clase. No podemos instanciar una clase dentro de una clase. La persona que nos va a proporcionar los objetos que se llaman dependencias se llama Dependency Provider. dagger2 es la clase que desea convertir en un proveedor de dependencias. Debe anotarlo con la anotación @Module .
• Consumidor de dependencia: el consumidor de dependencia es una clase en la que necesitamos instanciar los objetos. Dagger proporcionará la dependencia, y para esto, solo necesitamos anotar la declaración del objeto con @Inject.
• Componente: la conexión entre nuestro proveedor de dependencias y el consumidor de dependencias se proporciona a través de una interfaz anotándola con @Component . Y el resto del asunto lo hará Dagger.

Ejemplo

Paso 1: Crear un nuevo proyecto

Para crear un nuevo proyecto en Android Studio, consulte Cómo crear/iniciar un nuevo proyecto en Android Studio . Tenga en cuenta que seleccione Java como lenguaje de programación.

Paso 2:

Antes de ir a la sección de codificación, primero debe hacer una tarea previa. Vaya a la sección aplicación > res > valores > colores.xml y configure los colores para su aplicación.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#0F9D58</color>
    <color name="colorPrimaryDark">#0F9D58</color>
    <color name="colorAccent">#FF4081</color>
</resources>

Vaya a la sección Gradle Scripts > build.gradle (Módulo: aplicación) e importe las siguientes dependencias y haga clic en » Sincronizar ahora » en la ventana emergente anterior.

// estas dos líneas se agregan para la actualización

implementación ‘com.squareup.retrofit2:retrofit:2.7.2’

implementación ‘com.squareup.retrofit2:convertidor-gson:2.7.2’

// estas dos lineas se agregan para daga

implementación ‘com.google.dagger:dagger:2.13’

anotaciónProcesador ‘com.google.dagger:dagger-compiler:2.13’

Vaya a la sección aplicación> manifiestos> AndroidManifests.xml y permita «Permiso de Internet». A continuación se muestra el código para el archivo AndroidManifests.xml .

<!– el permiso de Internet, entonces solo se pueden recuperar las llamadas api –>

<usos-permiso android:name=”android.permission.INTERNET” />

Paso 3: Diseño de la interfaz de usuario

A continuación se muestra el código para el archivo activity_main.xml . Esto estará en la carpeta app > src > main > res > layout . Depende de las diferentes resoluciones, a veces es posible que necesitemos tenerlo en las carpetas diseño> hdpi o diseño> xhdpi, etc.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
  
    <ListView
        android:id="@+id/listViewCountries"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorPrimaryDark"/>
  
</RelativeLayout>

Paso 4: trabajar con el archivo Java

Archivo App Module.java:

En Retrofit (Retrofit es un cliente REST para Java y Android), necesitamos el objeto de contexto . Para suministrar los objetos, entonces aquí crearemos este módulo que nos dará el Contexto.

import android.app.Application;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
  
@Module
class AppModule {
    private Application mApplication;
  
    AppModule(Application mApplication) {
        this.mApplication = mApplication;
    }
  
    @Provides
    @Singleton
    Application provideApplication() {
        return mApplication;
    }
}

Con la daga, debemos anotar @Singleton cuando queremos una sola instancia.

Módulo API.java:

Para Retrofit, necesitamos un montón de cosas. Cache, Gson, OkHttpClient y el propio Retrofit. Así que definiremos los proveedores para estos objetos aquí en este módulo.

• Gson: es una biblioteca de Java que se puede usar para convertir objetos de Java en su representación JSON.
• Okhttp: funciona con Retrofit, que es una API brillante para REST.

import android.app.Application;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
import okhttp3.Cache;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
  
@Module
class ApiModule {
  
    String mBaseUrl;
  
    ApiModule(String mBaseUrl) {
        this.mBaseUrl = mBaseUrl;
    }
  
  
    @Provides
    @Singleton
    Cache provideHttpCache(Application application) {
        int cacheSize = 10 * 1024 * 1024;
        Cache cache = new Cache(application.getCacheDir(), cacheSize);
        return cache;
    }
  
    @Provides
    @Singleton
    Gson provideGson() {
        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
        return gsonBuilder.create();
    }
  
    @Provides
    @Singleton
    OkHttpClient provideOkhttpClient(Cache cache) {
        OkHttpClient.Builder client = new OkHttpClient.Builder();
        client.cache(cache);
        return client.build();
    }
  
    @Provides
    @Singleton
    Retrofit provideRetrofit(Gson gson, OkHttpClient okHttpClient) {
        return new Retrofit.Builder()
                .addConverterFactory(GsonConverterFactory.create(gson))
                .baseUrl(mBaseUrl)
                .client(okHttpClient)
                .build();
    }
}

Componente de construcción: ApiComponent.java

import javax.inject.Singleton;
import dagger.Component;
  
@Singleton
@Component(modules = {AppModule.class, ApiModule.class})
public interface ApiComponent {
    void inject(MainActivity activity);
}

Inyectaremos en MainActivity. También definimos todos los módulos usando la anotación @Component como podemos ver en el código.

Archivo MiAplicación.java:

import android.app.Application;
  
public class MyApplication extends Application {
  
    private ApiComponent mApiComponent;
  
    @Override
    public void onCreate() {
        super.onCreate();
        // https://restcountries.eu/rest/v2/all -> It will list all the country details
        mApiComponent = DaggerApiComponent.builder()
                .appModule(new AppModule(this))
                .apiModule(new ApiModule("https://restcountries.eu/rest/v2/"))
                .build();
    }
  
    public ApiComponent getNetComponent() {
        return mApiComponent;
    }
}

Archivo MainActivity.java:

import android.os.Bundle;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;
import javax.inject.Inject;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
  
public class MainActivity extends AppCompatActivity {
  
    // injecting retrofit
    @Inject Retrofit retrofit;
    ListView listView;
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
          
          // injecting here
        ((MyApplication) getApplication()).getNetComponent().inject(this);
        listView = (ListView) findViewById(R.id.listViewCountries);
        getCountries();
    }
  
    private void getCountries() {
        Api api = retrofit.create(Api.class);
          
          // Call<List<Country>> call = RetrofitClient.getInstance().getMyApi().getCountries();
        Call<List<Country>> call = api.getCountries();
        call.enqueue(new Callback<List<Country>>() {
            @Override
            public void onResponse(Call<List<Country>> call, Response<List<Country>> response) {
                List<Country> countryList = response.body();
  
                // Creating an String array for the ListView
                String[] countries = new String[countryList.size()];
  
                // looping through all the countries and inserting 
                  // the names inside the string array
                for (int i = 0; i < countryList.size(); i++) {
                    countries[i] = countryList.get(i).getName();
                }
  
                // displaying the string array into listview
                listView.setAdapter(new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, countries));
            }
  
            @Override
            public void onFailure(Call<List<Country>> call, Throwable t) {
                Toast.makeText(getApplicationContext(), t.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
    }
}

Producción:

Solicitud de ejemplo:

https://restcountries.eu/rest/v2/all proporcionará el resultado como se muestra en la imagen. Tomaremos el nombre del país de ese

Ejemplo de respuesta:

El resultado de la URL de la API REST anterior

Como solo estamos tomando nombres de países, obtendremos una lista como Afganistán, … India, etc. Al ejecutar el código anterior, podemos obtener el resultado como se muestra a continuación.

Puede encontrar el código fuente: https://github.com/raj123raj/dagger-retrofit