(Tutorial Android) Dependency Injection in Android with Dagger 2

Dependency Injection atau biasa disingkat DI adalah sebuah konsep dalam software design pattern yang berfokus untuk menjadikan aplikasi lebih loosely coupled, extensible, dan maintainable. Artinya, dalam pembuatan aplikasi menjadi lebih rapi, mudah dipahami dan dikelola. Dengan konsep DI ini bertujuan agar suatu kelas tidak terikat dengan kelas lain dan bagian-bagian code menjadi longgar (loosely coupled). Fungsi dari DI sendiri yaitu menginjeksi bagian-bagian tertentu dalam aplikasi sehingga dapat mempermudah mengatur flow sebuah program. Konsep ini sering juga disebut Inversion of Control.

Jadi intinya, dengan dependency injection kita dapat menginjeksi kelas-kelas tertentu ke kelas yang membutuhkan dependency.

Dagger 2 merupakan library dependency injection untuk Android dan Java. Dagger 2 berbasis Java Specification Request (JSR) 330 yang merupakan standar Java Annotations. Dagger 2 benar-benar hasil dari code generation dan bukan merupakan refleksi seperti library lainnya sehingga penggunaan menjadi lebih efisien.

Dagger 2 terdapat beberapa annotation diantaranya :
- @Module : mendefinisikan kelas yang menyediakan dependencies
- @Provides : mendefinisikan method-method yang ada di kelas @Module
- @Inject : mendefinisikan sebuah request dependency, bisa berupa konstruktor, method, maupun field
- @Component : mendefinisikan sebuah jembatan penghubung antara module dan injection.

Pada postingan kali ini saya ingin mencoba menjelaskan implementasi Dependency Injection di Android dengan menggunakan library Dagger 2.

Mengenai Dagger 2 selengkapnya bisa dilihat di http://google.github.io/dagger/ 

Terlebih dahulu kita harus menambahkan library dagger di Gradle.

Top-Level

dependencies {
    classpath 'com.android.tools.build:gradle:2.0.0'
    classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files
}

Module-Level

apply plugin: 'com.neenbedankt.android-apt'
…

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'

    compile 'com.android.support:appcompat-v7:23.3.0'
    compile 'com.google.dagger:dagger:2.5'
    apt 'com.google.dagger:dagger-compiler:2.5'
    provided 'javax.annotation:jsr250-api:1.0'
}

Step 1 : Membuat kelas Object Dependent

Buat kelas dengan nama User.java

package example.wim.androiddagger2;
import javax.inject.Inject;

/**
 * Created by Wim on 8/12/16.
 */
public class User {

    private String id;
    private String firstName;
    private String lastName;

    public User() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "[id = " +id+ ", firstName = " + firstName + ", lastName = " + lastName + "]";
    }

}

Selanjutnya buat kelas UserService.java. Kelas ini yang akan menyediakan dependencies.

package example.wim.androiddagger2;

/**
 * Created by Wim on 8/12/16.
 */
public class UserService {

    private User user;

    public UserService(User user) {
        this.user = user;
    }

    public void addNewUser(String id, String firstname, String lastname) {
        user.setId(id);
        user.setFirstName(firstname);
        user.setLastName(lastname);
    }

    public User getUser() {
        return user;
    }

}

Step 2 : Membuat kelas Module

Selanjutnya kita akan membuat kelas-kelas module yaitu AppModule dan UserModule.

package example.wim.androiddagger2;

import android.app.Application;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;

/**
 * Created by Wim on 8/12/16.
 */
@Module
public class AppModule {

    private Application application;

    public AppModule(Application application) {
        this.application = application;
    }

    @Provides
    @Singleton
    Context provideApplicationContext() {
        return application.getApplicationContext();
    }

    @Provides
    @Singleton
    SharedPreferences provideSharedPref() {
        return PreferenceManager.getDefaultSharedPreferences(application);
    }
}

package example.wim.androiddagger2;

import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;

/**
 * Created by Wim on 8/12/16.
 */
@Module
public class UserModule {

    @Provides
    @Singleton
    public UserService provideUserService() {
        return new UserService(new User());
    }

}

Step 3 : Membuat kelas Component sebagai penghubungkan antara Module dengan Injection

Buat kelas Dagger Component.

package example.wim.androiddagger2;

import javax.inject.Singleton;
import dagger.Component;

/**
 * Created by Wim on 8/7/16.
 */
@Singleton
@Component(modules = {AppModule.class, UserModule.class})
public interface DiComponent {

    void inject(MainActivity activity);

}

Sampai disini, rebuild project terlebih dahulu agar otomatis ter-generate kelas DaggerDiComponent.

Buat kelas Application dan instance kelas DiComponent yang memberikan dependency injection, kemudian kita dapat mengaksesnya melalui method getComponent.

package example.wim.androiddagger2;
import android.app.Application;

/**
 * Created by Wim on 8/7/16.
 */
public class MainApp extends Application {

    DiComponent component;

    @Override
    public void onCreate() {
        super.onCreate();
        component = DaggerDiComponent.builder()
                .appModule(new AppModule(this))
                .build();
    }

    public DiComponent getComponent() {
        return component;
    }

}

Sekarang kita telah memiliki setiap koneksi kelasnya. Di kelas MainActivity, gunakan annotation @Inject untuk mengambil dependencies.

package example.wim.androiddagger2;

import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import javax.inject.Inject;

public class MainActivity extends AppCompatActivity {

    @Inject
    UserService userService;

    @Inject
    SharedPreferences sharedPref;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView message = (TextView) findViewById(R.id.message);

        ((MainApp) getApplication()).getComponent().inject(this);

        userService.addNewUser("1", "Wim", "Sonevel");

        sharedPref.edit()
                .putString(userService.getUser().getId(), userService.getUser().toString())
                .apply();

        message.setText("New User Inserted : " + sharedPref.getString(userService.getUser().getId()
, ""));

    }
}

Sekarang build dan jalankan, maka hasilnya sebagai berikut :

Source code lengkap dapat dilihat di https://github.com/wimsonevel/Android-Dagger2

Sekian tutorial kali ini, semoga bermanfaat.
Terima kasih.

Happy Coding. ^^

Share this :