Apakah suntikan pergantungan bahasa go?

Dalam bahasa Go, suntikan kebergantungan (DI) ialah corak reka bentuk yang memisahkan kebergantungan antara komponen apabila diperlukan, komponen yang berbeza boleh mendapatkan maklumat daripada komponen lain melalui antara muka dan keadaan bersatu. Faedah suntikan pergantungan ialah penyahgandingan dan penyahgandingan boleh membawa lebih banyak faedah: skalabiliti kod dipertingkat, kebolehselenggaraan kod dipertingkat, ujian unit yang lebih mudah, dsb.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Apakah Suntikan Ketergantungan?

Apabila saya mendengar perkataan ini buat kali pertama, saya berasa keliru tidak pernah belajar Java atau spring sebelum ini, saya sangat keliru apabila saya mula-mula bersentuhan dengan istilah ini.

Suntikan ketergantungan, nama Inggeris ialah suntikan ketergantungan, atau singkatannya DI. Perkataan kebergantungan mudah difahami Dalam reka bentuk perisian, terdapat kebergantungan besar dan kecil daripada modul seni bina kepada kaedah berfungsi.

Sebagai contoh, B baharu perlu diwujudkan sebelum A baharu. A bergantung kepada B. Pada masa ini, kita boleh katakan bahawa B ialah kebergantungan A. A mengawal B. Terdapat hubungan gandingan antara AB , dan reka bentuk kod Ideanya ialah yang terbaik untuk mencapai gandingan longgar. Jika B perlu diubah suatu hari nanti, maka A juga perlu diubah. Anda mungkin baik-baik saja dengan ini sebagai kebergantungan, tetapi jika terdapat satu siri kebergantungan antara A->B->C->D->E->F, maka ia akan menjadi sangat menyusahkan untuk berubah.

Pada masa ini, kita memerlukan sesuatu untuk memisahkan gandingan yang kuat di antara mereka. Kita hanya boleh menggunakan pihak ketiga Penyerahan kawalan kepada pihak ketiga dipanggil Penyongsangan Kawalan (Penyongsangan Kawalan IOC) , dan pihak ketiga ini dipanggil bekas IOC. Perkara yang perlu dilakukan oleh bekas IOC ialah mencipta B baharu, dan kemudian menyuntik contoh B ini ke dalam A. Kemudian A biasanya boleh menggunakan kaedah berdasarkan B. Proses ini dipanggil suntikan pergantungan, dan berdasarkan IOC Kaedah ini dipanggil suntikan pergantungan.

Ringkasnya, suntikan kebergantungan (DI) ialah corak reka bentuk yang memisahkan kebergantungan antara komponen. Apabila diperlukan, komponen berbeza boleh mendapatkan objek dan keadaan dalam komponen lain melalui antara muka bersatu. Reka bentuk antara muka bahasa Go mengelakkan banyak situasi di mana rangka kerja suntikan pergantungan pihak ketiga perlu digunakan (seperti Java, dll.). Penyelesaian suntikan kami hanya menyediakan sangat sedikit penyelesaian suntikan yang serupa dengan yang terdapat dalam Dager atau Guice, dan memfokuskan pada mengelakkan konfigurasi manual kebergantungan antara objek dan komponen.

Faedah suntikan kebergantungan

Memahami idea suntikan kebergantungan, anda juga harus memahami faedah terbesar yang dibawanya - penyahgandingan .

Dan penyahgandingan boleh membawa lebih banyak faedah: skalabiliti kod dipertingkat, kebolehselenggaraan kod dipertingkat, ujian unit yang lebih mudah, dsb.

Jadi bagaimanakah suntikan pergantungan dilaksanakan?

Terdapat kaedah berikut dalam Java:

• Suntikan kaedah penetap: laksanakan kaedah set awam sifat khusus untuk membenarkan bekas luaran memanggil objek tanggungan taip .

• Suntikan berasaskan antara muka: Laksanakan antara muka khusus untuk bekas luaran untuk menyuntik objek jenis bergantung.

• Suntikan berasaskan pembina: laksanakan pembina dengan parameter tertentu dan hantarkan objek jenis bergantung apabila mencipta objek baharu.

• Suntikan berasaskan anotasi: Tambahkan kata kunci khusus pada kod untuk mencapai suntikan.

Anotasi ialah cara yang paling biasa seperti ulasan, ia tidak dilaksanakan sebagai kod, tetapi khusus untuk dibaca oleh orang lain. Tetapi pembaca anotasi adalah manusia sepenuhnya, dan pembaca utama anotasi selain manusia ialah rangka kerja atau prapenyusun.

Go dependency injection-wire

wire ialah kaedah suntikan dependensi berasaskan anotasi. wire ialah alat suntikan kebergantungan sumber terbuka oleh Google Kami hanya perlu memberitahu go kebergantungan antara jenis dalam fail wire khas, dan ia akan menjana kod secara automatik untuk kami dan membantu kami mencipta objek daripada jenis yang ditentukan. . , dan kumpulkan kebergantungannya.

wire mempunyai dua konsep asas, Provider (pembina) dan Injector (penyuntik).

membolehkan provider mengetahui cara menjana objek bergantung ini dengan menyediakan fungsi wire. wireMenurut tandatangan fungsi injector yang kami takrifkan, fungsi injector yang lengkap dihasilkan Fungsi injector ialah fungsi terakhir yang kami perlukan, dan ia akan memanggil provider dalam susunan pergantungan. Keperluan

wire adalah sangat mudah Cipta fail wire.go baharu (nama fail boleh sewenang-wenangnya) dan cipta fungsi permulaan kami. Contohnya, jika kita ingin mencipta dan memulakan objek Mission, kita boleh melakukan ini:

//+build wireinject

package main

import "github.com/google/wire"

func InitMission(name string) Mission {
  wire.Build(NewMonster, NewPlayer, NewMission)
  return Mission{}
}

Anda boleh melihat anotasi pada baris pertama: +bina wireinject, menunjukkan bahawa ini ialah penyuntik. +buildIa sebenarnya adalah ciri bahasa Go. Sama seperti kompilasi bersyarat C/C++, beberapa pilihan boleh dihantar semasa melaksanakan go build, dan berdasarkan pilihan ini, diputuskan sama ada fail tertentu perlu disusun. Alat wire hanya akan memproses fail dengan wireinject, jadi kami perlu menambahkan ini pada fail wire.go kami.

Dalam fungsi, kami memanggil wire.Build() dan masukkan pembina jenis yang Mission bergantung padanya. Contohnya, anda perlu memanggil NewMission() untuk mencipta jenis Mission menerima dua parameter, satu daripada jenis NewMission() dan satu daripada jenis Monster. Player objek jenis perlu dibuat dengan memanggil Monster dan NewMonster() objek jenis perlu dibuat dengan memanggil Player. Jadi NewPlayer() dan NewMonster() kita juga perlu lulus ke NewPlayer(). wire

Selepas menulis fail wire.go dan melaksanakan arahan wire, fail wire_gen.go akan dijana secara automatik.

// Code generated by Wire. DO NOT EDIT.

//go:generate wire
//+build !wireinject

package main

// Injectors from wire.go:

func InitMission(name string) Mission {
  player := NewPlayer(name)
  monster := NewMonster()
  mission := NewMission(player, monster)
  return mission
}

Anda boleh melihat bahawa wayar secara automatik menjana kaedah InitMission untuk kami Dalam kaedah ini, pemain, raksasa dan misi dimulakan dalam urutan. Kemudian kita hanya perlu memanggil InitMission ini dalam fungsi utama kita.

func main() {
  mission := InitMission("dj")

  mission.Start()
}

Sebelum suntikan kebergantungan, kod kami kelihatan seperti ini:

func main() {
  monster := NewMonster()
  player := NewPlayer("dj")
  mission := NewMission(player, monster)

  mission.Start()
}

Bukankah ia lebih mudah? Terdapat hanya tiga pemulaan objek di sini Jika terdapat lebih banyak, anda mungkin tidak menyedari faedah suntikan pergantungan.

Contohnya:

wire.go文件：
// +build wireinject
// The build tag makes sure the stub is not built in the final build.

package di

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

//go:generate kratos t wire
func InitApp() (*App, func(), error) {
	panic(wire.Build(dao.Provider, service.Provider, http.New, grpc.New, NewApp))
}

实现文件：
//dao
var Provider = wire.NewSet(New, NewDB, NewRedis)
//service
var Provider = wire.NewSet(New, wire.Bind(new(pb.Server), new(*Service)))


生成的wire_gen.go 文件：
func InitApp() (*App, func(), error) {
	redis, cleanup, err := dao.NewRedis()
	if err != nil {
		return nil, nil, err
	}
	db, cleanup2, err := dao.NewDB()
	if err != nil {
		cleanup()
		return nil, nil, err
	}
	daoDao, cleanup3, err := dao.New(redis, db)
	if err != nil {
		cleanup2()
		cleanup()
		return nil, nil, err
	}
	serviceService, cleanup4, err := service.New(daoDao)
	if err != nil {
		cleanup3()
		cleanup2()
		cleanup()
		return nil, nil, err
	}
	engine, err := http.New(serviceService)
	if err != nil {
		cleanup4()
		cleanup3()
		cleanup2()
		cleanup()
		return nil, nil, err
	}
	server, err := grpc.New(serviceService)
	if err != nil {
		cleanup4()
		cleanup3()
		cleanup2()
		cleanup()
		return nil, nil, err
	}
	app, cleanup5, err := NewApp(serviceService, engine, server)
	if err != nil {
		cleanup4()
		cleanup3()
		cleanup2()
		cleanup()
		return nil, nil, err
	}
	return app, func() {
		cleanup5()
		cleanup4()
		cleanup3()
		cleanup2()
		cleanup()
	}, nil
}

Jadi, apakah sebenarnya suntikan pergantungan?

Ia hanya pengkapsulan dan penyahgandingan.

[Cadangan berkaitan:

Pergi tutorial video, Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Apakah suntikan pergantungan bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!