Injeksi Dependensi

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan GO di Coddy. Pelajaran 45 dari 107.

Dependency Injection adalah teknik ketika sebuah struct menerima dependensinya dari luar, bukan membuatnya sendiri. Di Go, interface membuat pola ini terasa alami dan ampuh.

Alih-alih menulis implementasi tertentu secara langsung di dalam struct, kamu menerima interface. Ini memungkinkan kamu mengganti implementasi tanpa mengubah kode struct:

type Notifier interface {
    Send(message string) string
}

type EmailNotifier struct{}
func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

type SMSNotifier struct{}
func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

Sekarang buat struct yang bergantung pada interface, bukan tipe konkret:

type OrderService struct {
    notifier Notifier  // dependensi disuntikkan melalui interface
}

func NewOrderService(n Notifier) *OrderService {
    return &OrderService{notifier: n}
}

func (o *OrderService) PlaceOrder(item string) string {
    return o.notifier.Send("Order placed: " + item)
}

OrderService tidak tahu atau peduli apakah layanan itu menggunakan email atau SMS. Kamu menyuntikkan dependensi saat membuat layanan:

func main() {
    emailService := NewOrderService(EmailNotifier{})
    fmt.Println(emailService.PlaceOrder("Book"))  // Email: Pesanan dibuat: Book
    
    smsService := NewOrderService(SMSNotifier{})
    fmt.Println(smsService.PlaceOrder("Phone"))   // SMS: Pesanan dibuat: Phone
}

Pendekatan ini membuat kodemu lebih fleksibel dan mudah diuji. Saat pengujian, kamu bisa memasukkan notifier tiruan yang tidak benar-benar mengirim pesan. Dalam lingkungan produksi, kamu memasukkan implementasi yang sebenarnya. Struct tetap sama dalam kedua skenario.

Tantangan

Mudah

Mari buat sistem pencatatan log yang menunjukkan keunggulan injeksi dependensi. Kamu akan membuat service yang dapat menulis log ke berbagai tujuan, tanpa service tersebut mengetahui atau peduli ke mana log itu sebenarnya dikirim.

Kamu akan menyusun kodemu dalam tiga file:

logger.go: Definisikan interface Logger yang mewajibkan method Log(message string) string. Lalu buat dua implementasi logger yang berbeda:
- ConsoleLogger dengan field Prefix. Method Log-nya mengembalikan [CONSOLE] [Prefix]: [message]
- FileLogger dengan field Filename. Method Log-nya mengembalikan [FILE:[Filename]] [message]
service.go: Buat struct AppService yang bergantung pada interface Logger, bukan tipe konkret. Sertakan fungsi konstruktor NewAppService yang menerima Logger dan mengembalikan pointer ke AppService. Tambahkan method bernama DoWork(task string) string ke AppService yang menggunakan logger yang diinjeksi untuk mencatat pesan Processing: [task] dan mengembalikan apa pun yang dikembalikan logger.
main.go: Baca konfigurasi dari input, buat kedua tipe logger, injeksikan masing-masing ke instance AppService yang terpisah, lalu panggil DoWork pada setiap service dengan task yang diberikan. Cetak hasil dari setiap pemanggilan service.

Input berikut akan diberikan:

Baris 1: Prefix logger konsol
Baris 2: Nama file logger file
Baris 3: Task yang akan diproses

Contohnya, jika diberikan INFO, app.log, dan user authentication, outputmu seharusnya:

[CONSOLE] INFO: Processing: user authentication
[FILE:app.log] Processing: user authentication

Perhatikan bahwa AppService tidak tahu apakah log dicatat ke konsol atau file. Service itu hanya memanggil Log pada logger mana pun yang diinjeksi. Fleksibilitas ini adalah inti dari injeksi dependensi: kode service yang sama dapat digunakan dengan implementasi pencatatan log yang sepenuhnya berbeda.

Coba sendiri

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Baca prefiks logger konsol
	prefix, _ := reader.ReadString('\n')
	prefix = prefix[:len(prefix)-1]
	
	// Baca nama file untuk logger file
	filename, _ := reader.ReadString('\n')
	filename = filename[:len(filename)-1]
	
	// Baca tugas yang akan diproses
	task, _ := reader.ReadString('\n')
	if len(task) > 0 && task[len(task)-1] == '\n' {
		task = task[:len(task)-1]
	}
	
	// TODO: Buat ConsoleLogger dengan prefiks tersebut
	
	// TODO: Buat FileLogger dengan nama file tersebut
	
	// TODO: Buat AppService dengan ConsoleLogger yang disuntikkan
	
	// TODO: Buat AppService lain dengan FileLogger yang disuntikkan
	
	// TODO: Panggil DoWork pada setiap layanan dengan tugas tersebut, lalu cetak hasilnya
	fmt.Println("result1")
	fmt.Println("result2")
}