Tutorial Dasar Dagger 2 - Penggunaan Inject dan Component


Assalamu'alaikum Warahmatullahi Wabarakatuh.

Senang rasanya bisa kembali lagi ke dunia blogging, sudah beberapa bulan terakhir ini saya tidak update tutorial lagi karena ada kesibukan di kampus. Alhamdullilah pada kesempatan ini saya diberi masih diberi kesehatan untuk bisa sharing ilmu mengenai pengalaman saya di dunia android developer., Semoga ilmu yang saya share bisa bermanfaan dan dapat dengan mudah dipahami oleh kalian semua. Amiin.

Sekarang materi yang akan saya share yaitu mengenai Penggunaan Library Dagger 2 pada pemrograman Android. Di antara kalian semua pasti pernah mencoba ataupun mendengar mengnai Dagger 2, soalnya library tersebut sangat populer dan banyak digunakan oleh para android developer professional, hampir semua project yang mereka buat menggunakan Dagger 2, karena kemudahannya dalam menyelesaikan masalah pada saat menerapkan prinsip Dependency Injection.


Lalu apa itu Dependency Injection ?. Pengertian singkatnya, merupakan suatu cara untuk mengirimkan objek ke kelas yang membutuhkan. atau Dependency Inversion Principle is simply a guideline to write loosely-coupled code. Yang artinya konsep untuk mengurangi ketergantungan (interdependency) dari suatu sistem, untuk meminimalisir suatu class agar tidak terikat dengan class lain.

Materi lainnya yang direkomendasikan:

Oh iya jika kalian masih pemula dan masing bingung menggenai apa itu Dependency Injection dan apa bedanya kode yang tidak menggunakan DI dengan kode yang menggunakan DI, jika kalian belum paham, saya sarankan kalian untuk mengikuti tutorial saya sebelumnya, karena materi ini gak akan beda jauh dengan materi sebelumnya. Kalian bisa mengaksesnya pada Link di berikut ini : Tutorial Dasar Depenjency Injection Untuk Pemula di Android Studio

Didalam Library Dagger 2 banyak sekali Anotasi-anotasi ajaib yang dapat memudahkan programmer untuk menerapkan konsep ID, seperti @Inject, @Component, @Provide, @Scope, @Module, dll.

Kita akan membahasnya satu-per-satu, pertama kita akan fokus belajar mengenai penggunaan Anotasi @Inject dan @Component terlebih dahulu. OK.

Agar lebih mudah untuk dipahami, disini kita akan membuat contoh project yang sangat sederhana dengan menerapkan konsep DI, didalam project tersebut nantinya hanya akan menampilkan data pada TextView. Lalu bagaimana cara implementasinya, Ok jika kalian sudah siap, silakan simak tutorial berikut ini.

Contoh Penerapan Dependency Injection pada Project

Contoh kode yang akan saya gunakan disini hampir sama dengan kode pada tutorial sebelumnya, yaitu cerita mengenai Kelompok LightKnight dan DarkKnight, Jika pada tutorial sebelumnya menggunakan Manual Dependency Injection, disini kita menggunakan Dagger 2.

Pada tutorial sebelumnya kita telah membuat beberpaa class, seperti Senjata.java, DarkKnght.java dan LightKnight.java. Berikut ini merupakan contoh kode pada tutorial saya sebelumnya dengan menggunakan Manual Dependency (Tanpa Dagger 2).

Senjata.java
package com.wildan.belajardi;

//Class ini nantinya akan diakses oleh Class LightKnight dan DarkNight
class Senjata{

    //Deklarasi variable yang di butuhkan
    private String namaPedang;
    private String namaTombak;

    //Membuat Konstruktor untuk menentukan Nama senjata yang akan di pilih
    Senjata(String namaPedang, String namaTombak) {
        this.namaPedang = namaPedang;
        this.namaTombak = namaTombak;
    }

    //Membuat 2 Buah Fungsi yang Mengenbalikan Nilai String dengan Data Berbeda
    String tombak(){
        return namaTombak;
    }
    String pedang(){
        return namaPedang;
    }
}
DarkKnght.java
package com.wildan.belajardi;

class DarkKnight {

    //Membuat Variable dari Class Senjata
    private Senjata senjata;

    //Membuat Constructor untuk menerima objek dari class Senjata
    DarkKnight(Senjata senjata) {
        this.senjata = senjata;
    }

    //Membuat Fungsi yang Mengembalikan Nilai String
    String setEquip(){
        return "Kolempok DarkKnight Bertempur Menggunakan " + senjata.tombak();
    }
}
LightKnight.java
package com.wildan.belajardi;

class LightKnight {

    //Membuat Variable dari Class Senjata
    private Senjata senjata;

    //Membuat Constructor untuk menerima objek dari class Senjata
    LightKnight(Senjata senjata) {
        this.senjata = senjata;
    }

    //Membuat Fungsi yang mengembalikan Nilai String
    String setEquip() {
        return "Kolempok LightKnight Bertempur Menggunakan " + senjata.pedang();
    }
}
Pada class LightKnight dan DarkKnight terdapat constructor dengan parameter dari class Senjata, kedua class tersebut membuatuhkan Instance atau Objek dari Class Senjata untuk memanggil fungsi tombak() dan pedang(). Untuk implementasi objeknya kita buat didalam MainActivity, seperti berikut ini.
public class MainActivity extends AppCompatActivity {

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

        //Deklarasi dan Inisialisasi View
        final TextView reportBattle = findViewById(R.id.report);
        Button startBattle = findViewById(R.id.click_me);

        //Membuat variable untuk memberi nama pada senjata yang akan digunakan
        String namaPedang = "Pedang Api";
        String namaTombak = "Tombak Petir";

        //Membuat Objek dari Class Senjata dengan Parameter
        final Senjata senjata = new Senjata(namaPedang, namaTombak);

        //Membuat Instance atau Objec dari Class Light dan Dark Night
        final LightKnight lightKnight = new LightKnight(senjata);
        final DarkKnight darkKnight = new DarkKnight(senjata);

        //Menambahkan listener pada Button
        startBattle.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //Menampilkan Data pada TextView yang diambil dari Fungsi setEquip dari kedua Class tersebut
                String getReport = lightKnight.setEquip() + " dan " + darkKnight.setEquip();
                reportBattle.setText(getReport);
            }
        });
    }
}
Coba kalian perhatikan, untuk setiap Instance atau Objek, kita cukup membuatnya didalam MainActivity saja, karena class tersebut hanya akan di eksekusi pada MainActivity pada saat button di klik. Tapi ada satu permasalahan lagi nih, bisa saja kan se waktu-waktu Class tersebut di akses oleh class lain (selain MainActivity) masa kita harus membuat Objeknya lagi. Misalnya ada 10 Activity yang ingin mengakses class LightKnight dan DarkKnight pastinya repot. Iya kan?

Nah salah satu solusi untuk proses Injection, kita bisa menggunakan Dagger 2, sebuah library ajaib yang dapat meringankan beban programmer, tentunya dalam menggunakan konsep Dependency Injection.

Menerapkan @Inject dan @Component pada Dagger 2

Pada tutorial ini kita akan memulainnya dari dasar, yaitu penggunaan Anotasi @Inject dan @Component yang merupakan bagian terpenting dari Dagger 2. Untuk penjelasan singkatnya mengenai kedua anotasi tersebut, menurut pemahaman saya, @Inject digunakan untuk menentukan Objek atau Class mana yang ingin kita Inject (dikirim pada class yang membutuhkan) dan @Component digunakan untuk memberitahukan Class-class mana saja yang akan menima Injection.

Jika kalian masih bingung mari kita coba terapkan pada project sebelumnya. Sebelum itu kita Impelementasikan terlebih dahulu Library Dagger 2 pada project tesebut didalam file build.gradle (app module).
implementation 'com.google.dagger:dagger-android:2.15'
implementation 'com.google.dagger:dagger-android-support:2.12'
annotationProcessor 'com.google.dagger:dagger-android-processor:2.12'
Oh iya disini kita hanya akan menggunakan 2 buah class terlebih dahulu, yaitu LightKnight.java dan DarkKnight.java, jadi class Senjata.java tidak akan kita gunakan pada penggunaan dasar @Inject dan @Component.

1) Pertama kita ubah terlebih dahulu source code dari kedua class tersebut dengan menghapus variable dan Constructor nya dan mengubah data didalam method setEquip() lalu buat constructor (tampa parameter) dan tambahkan Anotasi @Inject di atasnya, sehingga menjadi seperti berikut ini.

DarkKnght.java
import javax.inject.Inject;

class DarkKnight{

    @Inject
    DarkNight(){}

    //Membuat Fungsi yang Mengembalikan Nilai String
    String setEquip(){
        return "Kolempok DarkKnight Bertempur Menggunakan Tombak" ;
    }
}
LightKnight.java
import javax.inject.Inject;

class LightKnight{

    @Inject
    LightKnight() {}

    //Membuat Fungsi yang mengembalikan Nilai String
    String setEquip() {
        return "Kolempok LightKnight Bertempur Menggunakan Pedang";
    }
}
Kenapa kita menambahkan Anotasi @Inject pada Constructor, karena dengan begitu kita tidak harus membuat Instance / Objek dari class tersebut, didalam MainActivity kita cukup membuat Variablenya saja.

2) Tapi sebelum itu selanjutnya kita perlu membuat class interface Component nya terlebih dahulu, buat class baru berinama misalnya BattleComponent. Source codenya kurang lebih seperti berikut ini.
package com.wildan.belajardi;

import dagger.Component;

@Component
interface BattleComponent {
    void inject(MainActivity context);
}
Pada class interface tersebut kita tambahkan Anotasi @Component yang didalamnya terdapat sebuah method bernama inject(), method ini digunakan untuk mengambil context dari activity yang akan menerma Inject.

3) Setelah itu kita harus membuild ulang (Rebuild) aplikasi tersebut, agar class interface BattleComponent dapat kita panggil pada MainActivity.

4) Lalu pada MainActivity, disini kita hanya perlu membuat Variable dari Class DarkKnight dan LightKnight, tanpa harus membuat Objek atau Instance nya. Lalu untuk mendapatkan Konteks dari MainActivity, kita cukup memanggil method inject()  dari class BattleComponent tadi.
import javax.inject.Inject;

public class MainActivity extends AppCompatActivity {

    //Deklarasi Variable dengan menggunakan Anotasi Inject
    @Inject DarkKnight darkKnight;
    @Inject LightKnight lightKnight;

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

        //Deklarasi dan Inisialisasi View
        final TextView reportBattle = findViewById(R.id.report);
        Button startBattle = findViewById(R.id.click_me);

        //Mendapatkan Konteks dari class yang bersangkutan
        DaggerBattleComponent.create().inject(this);

        //Menambahkan listener pada Button
        startBattle.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //Menampilkan Data pada TextView yang diambil dari Fungsi setEquip dari kedua Class tersebut
                String getReport = lightKnight.setEquip() + " dan " + darkKnight.setEquip();
                reportBattle.setText(getReport);
            }
        });
    }
}
Agar class LightKnight.java dan DarkKnight.java, dapat digunakan, kita cukup menambahkan Anotasi @Inject pada masing-masing variable tersebut, karena sebelumnya kita sudah meng-inject Constructornya, jadi cukup membuat variablenya saja.

Lalu untuk menerima konteks dari MainActivity, kita cukup memanggil fungsi inject() dari interface BattleComponent, coba kalian perhatikan, nama class interface tersebut akan berubah dengan penambahan kata Dagger di awal, secara otomatis saat kita rebuild tadi.

Seperti biasa untuk menampilkan hasilnya, cukup panggil method setEquip() dari kedua class tersebut. Maka hasilnya akan seperti berikut ini.

Demo:


Semoga tutorial yang saya buat dapat mudah dimengerti oleh kalian, seperti yang telah saya janjikan sebelumnya, kita akan terus mengupas lebih dalam lagi mengenai Dagger 2, pada materi berikutnya saya akan share mengenai penggunaan Anotasi @Madule dan @Provide. Terimakasih, mohon maaf bila ada kesalahan.

Wassalamu'alaikum Warahmatullahi Wabarakatuh.

Disqus Comments