Akademi Manajemen Informatika

Dependency Injection di Go-Lang Menggunakan Wire

Dependency injection (DI) adalah konsep Krusial dalam pengembangan perangkat lunak yang membantu dalam mengatur dependensi antara komponen-komponen dalam sebuah aplikasi. Di bahasa pemrograman Go, terdapat paket (package) yang disebut “Wire” yang memudahkan implementasi DI secara Mekanis. Pada tulisan ini, kita akan mencoba menggunakan paket “wire” Kepada melakukan DI dalam aplikasi Go.

Apa itu Wire?

Wire adalah paket yang dikembangkan oleh Google Kepada mempermudah pengaturan dependensi dalam proyek Go. Dengan menggunakan Wire, kita dapat mendefinisikan dependensi antara komponen-komponen dalam sebuah konfigurasi, dan Wire akan menghasilkan kode penghubung (wiring code) yang diperlukan secara Mekanis.

Manfaat Menggunakan Wire

Penggunaan paket Wire Kepada melakukan DI dalam aplikasi Go Mempunyai beberapa manfaat, antara lain adalah sebagai berikut:

  1. Kode Lebih Rapi: Dengan menggunakan Wire, kita dapat memisahkan logika penghubungan dependensi dari kode bisnis Penting. Ini Membikin kode lebih Rapi, lebih mudah dibaca, dan lebih mudah dipelihara.
  2. Pengurangan Kesalahan: Wire menggunakan analisis Stagnan Kepada memastikan kesalahan penghubungan dependensi terdeteksi sebelum aplikasi dijalankan. Ini membantu mencegah beberapa kesalahan Lumrah yang terkait dengan pengaturan dependensi manual.
  3. Skalabilitas: Dengan menggunakan Wire, kita dapat dengan mudah menambah atau mengubah dependensi dalam proyek Go. Wire akan menghasilkan kode penghubung yang diperbarui secara Mekanis, sehingga mempermudah pengembangan aplikasi yang skalabel.

Install Wire

Kepada menginstal paket “Wire” di Go, Kita dapat mengikuti langkah-langkah berikut:

Pastikan Kita Mempunyai Go yang terinstal di sistem Kita. Kita dapat mengunduh dan menginstal Go dari situs Formal Go: https://golang.org/

READ  Pengertian, Jenis, Komponen, dan Fungsinya

Buka terminal atau command prompt dan ketik perintah berikut Kepada menginstal paket “Wire”:

go get github.com/google/wire

Perintah ini akan mendownload dan menginstal paket “Wire” beserta dependensinya ke dalam direktori Go Kita.

Setelah selesai, Kita dapat menggunakan paket “Wire” dalam proyek Go Kita dengan mengimpornya menggunakan import “github.com/google/wire” di file Go yang relevan.

Pastikan sistem Kita terhubung dengan internet Demi menjalankan perintah go get Kepada mengunduh dan menginstal paket “Wire” serta dependensinya dari repositori GitHub. Apabila Eksis masalah atau kesalahan, pastikan Kita telah mengatur konfigurasi lingkungan Go dengan Betul.

Setelah menginstal Wire, Kita dapat mulai menggunakan Wire Kepada mengelola dependensi dalam proyek Go Kita.

Misalnya Sederhana Penggunaan Wire

Berikut ini adalah Misalnya kode sederhana Kepada mengilustrasikan penggunaan paket “Wire” dalam Go:

Mendefinisikan Provider

Mekanisme Penting dalam Wire adalah provider: fungsi yang dapat menghasilkan nilai. Fungsi-fungsi ini adalah kode Go Normal.

package foobarbaz

type Foo struct {
    X int
}

// ProvideFoo mengembalikan sebuah Foo.
func ProvideFoo() Foo {
    return Foo{X: 42}
}

Fungsi provider harus diekspor agar Bisa digunakan dari package lain, seperti halnya fungsi Normal.

Provider dapat menentukan dependensi dengan menggunakan parameter:

package foobarbaz

// ...

type Bar struct {
    X int
}

// ProvideBar mengembalikan sebuah Bar: sebuah Foo dengan nilai negatif.
func ProvideBar(foo Foo) Bar {
    return Bar{X: -foo.X}
}

Provider juga dapat mengembalikan error:

package foobarbaz

import (
    "context"
    "errors"
)

// ...

type Baz struct {
    X int
}

// ProvideBaz mengembalikan sebuah nilai Apabila Bar Kagak Nihil.
func ProvideBaz(ctx context.Context, bar Bar) (Baz, error) {
    if bar.X == 0 {
        return Baz{}, errors.New("Kagak dapat menyediakan baz ketika bar bernilai Nihil")
    }
    return Baz{X: bar.X}, nil
}

Provider dapat dikelompokkan menjadi set provider. Hal ini Bermanfaat Apabila beberapa provider akan sering digunakan Serempak. Kepada menambahkan provider-provider ini ke dalam set baru yang disebut “SuperSet”, gunakan fungsi wire.NewSet:

package foobarbaz

import (
    // ...
    "github.com/google/wire"
)

// ...

var SuperSet = wire.NewSet(ProvideFoo, ProvideBar, ProvideBaz)

Kita juga dapat menambahkan set provider lain ke dalam set provider.

package foobarbaz

import (
    // ...
    "example.com/some/other/pkg"
)

// ...

var MegaSet = wire.NewSet(SuperSet, pkg.OtherSet)

Injector

Sebuah aplikasi menghubungkan provider-provider ini dengan injector: sebuah fungsi yang memanggil provider-provider sesuai dengan urutan dependensi. Dengan Wire, Kita menuliskan tanda tangan injector, kemudian Wire menghasilkan isi fungsi tersebut.

READ  #20: Function - Belajar Golang Dari Dasar

Sebuah injector dideklarasikan dengan menuliskan deklarasi fungsi yang bodinya adalah pemanggilan wire.Build. Nilai kembalian Kagak Krusial selama mereka Mempunyai tipe yang Betul. Nilai-nilai itu sendiri akan diabaikan dalam kode yang dihasilkan. Misalkan provider-provider di atas didefinisikan dalam package dengan nama example.com/foobarbaz. Berikut adalah Misalnya mendeklarasikan injector Kepada mendapatkan sebuah Baz:

// +build wireinject
// Tag build memastikan stub ini Kagak dibangun dalam build akhir.

package main

import (
    "context"

    "github.com/google/wire"
    "example.com/foobarbaz"
)

func initializeBaz(ctx context.Context) (foobarbaz.Baz, error) {
    wire.Build(foobarbaz.MegaSet)
    return foobarbaz.Baz{}, nil
}

Seperti provider, injector dapat diberikan parameter masukan (yang kemudian dikirimkan ke provider) dan dapat mengembalikan error. Argumen-argumen Kepada wire.Build adalah sama dengan wire.NewSet: mereka membentuk satu set provider. Inilah set provider yang digunakan Demi Pendapatan kode Kepada injector tersebut.

READ  Definisi, Gaji, Tugas, Skill, & Kualifikasi

Setiap deklarasi non-injector yang ditemukan dalam file yang Mempunyai injector akan disalin ke file yang dihasilkan.

Kita dapat menghasilkan injector dengan menjalankan Wire di direktori package:

Wire akan menghasilkan implementasi injector dalam sebuah file bernama wire_gen.go yang terlihat mirip dengan ini:

// Code generated by Wire. DO NOT EDIT.

//go:generate go run -mod=mod github.com/google/wire/cmd/wire
//+build !wireinject

package main

import (
    "example.com/foobarbaz"
)

func initializeBaz(ctx context.Context) (foobarbaz.Baz, error) {
    foo := foobarbaz.ProvideFoo()
    bar := foobarbaz.ProvideBar(foo)
    baz, err := foobarbaz.ProvideBaz(ctx, bar)
    if err != nil {
        return foobarbaz.Baz{}, err
    }
    return baz, nil
}

Seperti yang dapat Kita lihat, outputnya sangat mirip dengan apa yang akan ditulis oleh pengembang secara manual. Selain itu, Kagak Eksis ketergantungan pada Wire Demi runtime: Segala kode yang ditulis adalah kode Go normal dan dapat digunakan tanpa Wire.

Setelah wire_gen.go dibuat, Kita dapat menghasilkannya kembali dengan menjalankan perintah go generate.

Sumber: https://github.com/google/wire/blob/main/docs/guide.md