Tutorial Belajar Spring Framework Part II: Dependency Injection dan Spring Inversion of Control Container

Setelah pada artikel sebelumnya kita telah mengetahui gambaran spring yang begitu luas dengan 27 project yang sedang dikembangkan. Pada artikel kali ini akan membahas fokus pada core spring framework itu sendiri. Menggunakan spring framework saat ini tidaklah sulit, apalagi dengan adanya project spring boot, semakin memudahkan kita untuk menggunakan spring framework.

Sebelum spring framework versi 3.0, untuk menggunakan spring framework kita harus menuliskan konfigurasinya pada file xml. Setelah itu spring mulai memperkenalkan annotation pada versi 2.5 dan mulai mempopulerkan konfigurasi menggunakan annotation pada java class di versi 3.0. Namun, hingga kini kita tetap bisa menggunakan konfigurasi menggunakan xml. Banyak sekali perdebatan mengenai cara mana yang harus dipilih untuk mengkonfigurasi spring framework yang akan digunakan antara XML atau Annotations, yang jelas pada artikel ini saya akan menggunakan yang berbasis Annotations karena menurut saya lebih praktis. Seperti yang sudah saya jelaskan diawal, menggunakan spring framework itu tidak lah sulit tapi memahami konsep dan cara kerjanya itu yang membutuhkan sedikit imajinasi.

Dependency Injection

Dependency injection merupakan sebuah proses dimana sebuah object mendeklarasikan dependencies yang dia butuhkan lalu diinjectkan melalui constructor atau setter atau interface. Berikut contoh dalam code program

Constructor Injection

class Mobil(){
    Roda roda;

    public Mobil(Roda roda){
        this.roda=roda;
    }
}

Setter Injection


class Mobil(){
    Roda roda;

    public void setRoda(Roda roda){
        this.roda=roda;
    }
}

Interface Injection

public interface InjectRoda {
    void injectRoda(Roda roda);
}

class Mobil implements Roda{
    Roda roda;

    public void injectRoda(Roda roda){
        this.roda = roda;
    }
}

Dapat kita lihat 3 cara melakukan dependency injection, dimana Mobil membutuhkan Roda lalu kita inject. Dalam sebuah aplikasi java yang cukup besar, hal ini akan cukup merepotkan karena 1 object bisa saja membutuhkan lebih dari 1 dependency atau object yang lain dan bahkan dependency yang kita butuhkan tersebut juga membutuhkan dependency yang lain. Maka kita akan cukup kerepotan untuk menginject dependency tersebut secara manual. Sebagai contoh Mobil tidak hanya membutuhkan Roda tapi juga Mesin lalu ada Spion,dll. Lalu jika kita jabarkan lagi Roda membutuhkan Ban lalu ada juga Velg,dll. Spring framework menawarkan kemudahan untuk melakukan dependency injection, secara teknis akan kita bahas kemudian.

Spring Inversion of Control Container

Berikutnya kita akan membahas tentang container. Jika kita bayangkan container ini semacam wadah dari beans yang kita gunakan dalam aplikasi java kita yang akan menggunakan spring framework. Beans disini artinya merupakan sebuah object yang digunakan dalam aplikasi yang kita buat dan yang dimanaged oleh Spring IoC Container. Container ini tidak hanya menampung object-object tadi, tapi juga bertugas untuk menginstansiasi, mengkonfigurasi dan merangkai beans yang ada sesuai dengan konfigurasi yang kita gunakan.

spring06

Dapat kita lihat gambarannya pada diagram diatas. Untuk mendapatkan gambaran yang lebih jelas, sekarang kita akan mencoba menggunakan spring framework pada maven project yang akan kita buat. Pertama kita buat dulu maven project, bisa menggunakan ide atau melalui terminal dengan memasukkan command berikut,

mvn archetype:generate -DgroupId={project-packaging} -DartifactId={project-name} -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Setelah itu masukkan dependency spring framework pada file pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.4.RELEASE</version>
</dependency>

Setelah itu kita akan mencoba membuat main class yang akan menampilkan isi dari spring container

package com.github.blog;
import java.util.Arrays;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        System.out.println("Daftar beans");
        List<String> listContainer = Arrays.asList(applicationContext.getBeanDefinitionNames());
        for (String bean : listContainer) {
            System.out.println("Bean name: " + bean);
        }
    }
}

Dapat kita lihat interface ApplicationContext merupakan representasi dari spring container. Jika kita jalankan maka akan keluar output sebagai berikut,

spring07

Dapat kita lihat terdapat 9 bean dimana 1 bean merupakan main class yang kita buat yaitu application. Itu lah sedikit konsep dasar dari spring framework yang sudah kita bahas yaitu mengenai dependency injection dan Spring Inversion of Control Container. Untuk melihat source code lengkapnya bisa dilihat di https://github.com/leonardusdani/blog-tutorial-spring-framework/releases/tag/2.0

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s