Tiêm phụ thuộc

Thuộc phần Lập trình hướng đối tượng trong hành trình GO của Coddy. Bài học 45 trên 107.

Dependency Injection là kỹ thuật trong đó một struct nhận các phần phụ thuộc từ bên ngoài thay vì tự tạo chúng bên trong. Trong Go, interface giúp mẫu này trở nên tự nhiên và mạnh mẽ.

Thay vì cố định một cách triển khai cụ thể bên trong struct, bạn hãy dùng một interface. Nhờ vậy, bạn có thể thay đổi cách triển khai mà không cần sửa code của 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
}

Bây giờ, hãy tạo một struct phụ thuộc vào interface, chứ không phải kiểu cụ thể:

type OrderService struct {
    notifier Notifier  // thành phần phụ thuộc được truyền vào qua giao diện
}

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

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

OrderService không biết và cũng không quan tâm nó đang dùng email hay SMS. Bạn truyền phần phụ thuộc vào khi tạo dịch vụ:

func main() {
    emailService := NewOrderService(EmailNotifier{})
    fmt.Println(emailService.PlaceOrder("Book"))  // Email: Đã đặt hàng: Book
    
    smsService := NewOrderService(SMSNotifier{})
    fmt.Println(smsService.PlaceOrder("Phone"))   // SMS: Đã đặt hàng: Phone
}

Cách tiếp cận này giúp code của bạn linh hoạt và dễ kiểm thử hơn. Khi kiểm thử, bạn có thể đưa vào một notifier giả không thực sự gửi tin nhắn. Khi chạy trong môi trường thực tế, bạn đưa vào phần triển khai thật. Struct vẫn giữ nguyên trong cả hai trường hợp.

Thử thách

Dễ

Hãy xây dựng một hệ thống ghi nhật ký để cho thấy sức mạnh của việc tiêm phụ thuộc. Bạn sẽ tạo một dịch vụ có thể ghi nhật ký đến các đích khác nhau mà không cần biết hay quan tâm nhật ký thực sự được gửi đến đâu.

Bạn sẽ sắp xếp code trong ba tệp:

logger.go: Định nghĩa một giao diện Logger yêu cầu phương thức Log(message string) string. Sau đó, tạo hai cách triển khai trình ghi nhật ký khác nhau:
- ConsoleLogger có trường Prefix. Phương thức Log trả về [CONSOLE] [Prefix]: [message]
- FileLogger có trường Filename. Phương thức Log trả về [FILE:[Filename]] [message]
service.go: Tạo một cấu trúc AppService phụ thuộc vào giao diện Logger (không phải một kiểu cụ thể). Thêm hàm khởi tạo NewAppService nhận một Logger và trả về con trỏ đến AppService. Thêm cho AppService phương thức DoWork(task string) string, phương thức này dùng trình ghi nhật ký được tiêm vào để ghi thông báo Processing: [task] và trả về bất cứ giá trị nào mà trình ghi nhật ký trả về.
main.go: Đọc cấu hình từ đầu vào, tạo cả hai kiểu trình ghi nhật ký, tiêm từng kiểu vào một thực thể AppService riêng, rồi gọi DoWork trên mỗi dịch vụ với tác vụ được cung cấp. In kết quả từ mỗi lần gọi dịch vụ.

Đầu vào sẽ được cung cấp như sau:

Dòng 1: Tiền tố của trình ghi nhật ký console
Dòng 2: Tên tệp của trình ghi nhật ký file
Dòng 3: Tác vụ cần xử lý

Ví dụ, với INFO, app.log và user authentication, đầu ra của bạn sẽ là:

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

Hãy chú ý rằng AppService không biết nó đang ghi nhật ký ra console hay vào tệp. Nó chỉ gọi Log trên trình ghi nhật ký được tiêm vào. Sự linh hoạt này chính là cốt lõi của việc tiêm phụ thuộc: cùng một code dịch vụ có thể hoạt động với các cách triển khai ghi nhật ký hoàn toàn khác nhau.

Tự làm thử

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Đọc tiền tố của bộ ghi nhật ký console
	prefix, _ := reader.ReadString('\n')
	prefix = prefix[:len(prefix)-1]
	
	// Đọc tên tệp của bộ ghi nhật ký tệp
	filename, _ := reader.ReadString('\n')
	filename = filename[:len(filename)-1]
	
	// Đọc tác vụ cần xử lý
	task, _ := reader.ReadString('\n')
	if len(task) > 0 && task[len(task)-1] == '\n' {
		task = task[:len(task)-1]
	}
	
	// TODO: Tạo ConsoleLogger với tiền tố
	
	// TODO: Tạo FileLogger với tên tệp
	
	// TODO: Tạo AppService và truyền ConsoleLogger vào
	
	// TODO: Tạo một AppService khác và truyền FileLogger vào
	
	// TODO: Gọi DoWork trên từng dịch vụ với tác vụ rồi in ra kết quả
	fmt.Println("result1")
	fmt.Println("result2")
}