(Tutorial Android) Dependency Injection In Android With Dagger 2

Dependency Injection atau biasa disingkat DI yaitu sebuah konsep dalam software design pattern yang berfokus untuk mengakibatkan aplikasi lebih loosely coupled, extensible, dan maintainable. Artinya, dalam pembuatan aplikasi menjadi lebih rapi, gampang dipahami dan dikelola. Dengan konsep DI ini bertujuan semoga 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 sanggup mempermudah mengatur flow sebuah program. Konsep ini sering juga disebut Inversion of Control.

Kaprikornus intinya, dengan dependency injection kita sanggup 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 menyerupai 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, sanggup berupa konstruktor, method, maupun field
- @Component : mendefinisikan sebuah jembatan penghubung antara module dan injection.

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

Mengenai Dagger 2 selengkapnya sanggup 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 menciptakan 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 semoga otomatis ter-generate kelas DaggerDiComponent.

Buat kelas Application dan instance kelas DiComponent yang menunjukkan dependency injection, kemudian kita sanggup 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 mempunyai 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 akhirnya sebagai berikut :

Source code lengkap sanggup dilihat di https://github.com/andronut/Android-Dagger2

Sekian tutorial kali ini, semoga bermanfaat.
Terima kasih.

Happy Coding. ^^