Qu’est-ce que l’injection de dépendance linguistique ?

Dans le langage Go, l'injection de dépendances (DI) est un modèle de conception qui découple les dépendances entre les composants ; si nécessaire, différents composants peuvent obtenir des objets et des états dans d'autres composants via une interface unifiée. L'avantage de l'injection de dépendances est le découplage ; et le découplage peut apporter davantage d'avantages : une évolutivité améliorée du code, une maintenabilité améliorée du code, des tests unitaires plus faciles, etc.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Qu'est-ce que l'injection de dépendance ?

Quand j'ai entendu ce mot pour la première fois, j'étais confus. C'était difficile à prononcer. Peut-être que de nombreux étudiants qui ont étudié le printemps pensent que c'est une connaissance très basique et facile à comprendre, mais parce que je ne l'ai jamais appris auparavant. Java et Spring, j'étais donc très confus lorsque je suis tombé sur ce mot pour la première fois.

Injection de dépendance, le nom anglais est injection de dépendance, ou DI en abrégé. Le mot dépendance est facile à comprendre. Dans la conception de logiciels, il existe des dépendances grandes et petites, des modules architecturaux aux méthodes fonctionnelles.

Par exemple, un nouveau B doit être créé avant le nouveau A, et A dépend de B. À ce stade, nous pouvons dire que B est une dépendance de A, A contrôle B et il existe une relation de couplage entre AB et l'idée de conception du code est la meilleure. Un couplage lâche peut être réalisé. Si B doit être transformé un jour, alors A devra également être transformé. Vous pourriez être d'accord avec le fait qu'il s'agisse d'une dépendance, mais s'il existe une série de dépendances entre A->B->C->D->E->F, alors il sera très difficile à transformer.

En ce moment, il faut quelque chose pour découpler le lien fort entre eux. Comment le découpler ? Nous ne pouvons utiliser que le pouvoir d'un tiers. Nous confions le contrôle de A à B à un tiers. Ce type d'idée s'appelle Inversion de contrôle (IOC Inversion Of Control), et ce tiers est appelé conteneur IOC. Ce que le conteneur IOC doit faire est de créer un nouveau B, puis d'injecter cette instance de B dans A. Ensuite, A peut normalement utiliser la méthode basée sur B. Ce processus est appelé injection de dépendances, et basé sur IOC, cette méthode est appelée injection de dépendance.

En termes simples, l'injection de dépendances (DI) est un modèle de conception qui dissocie les dépendances entre les composants. En cas de besoin, différents composants peuvent obtenir des objets et des états dans d'autres composants via une interface unifiée. La conception de l'interface du langage Go évite de nombreuses situations dans lesquelles des frameworks d'injection de dépendances tiers doivent être utilisés (tels que Java, etc.). Notre solution d'injection ne fournit que très peu de solutions d'injection similaires à celles de Dager ou Guice, et vise à éviter la configuration manuelle des dépendances entre objets et composants.

Les avantages de l'injection de dépendances

Comprenant l'idée de l'injection de dépendances, vous devez également comprendre le plus grand avantage qu'elle apporte : le découplage.

Et le découplage peut apporter plus d'avantages : une évolutivité améliorée du code, une maintenabilité améliorée du code, des tests unitaires plus faciles, etc.

Alors, comment implémenter l'injection de dépendances ?

Il existe les méthodes suivantes en Java :

• injection de méthode setter : implémente la méthode d'ensemble public de propriétés spécifiques pour permettre au conteneur externe d'appeler l'objet du type dépendant.

• Injection basée sur l'interface : implémentez une interface spécifique pour les conteneurs externes afin d'injecter des objets du type dépendant.

• Injection basée sur un constructeur : implémentez le constructeur avec des paramètres spécifiques et transmettez l'objet du type dépendant lors de la création d'un nouvel objet.

• Injection basée sur des annotations : ajoutez des mots-clés spécifiques au code pour réaliser l'injection.

Les annotations sont le moyen le plus courant, comme les commentaires, elles ne sont pas exécutées sous forme de code, mais sont spécifiquement destinées à être lues par d'autres. Mais les lecteurs d'annotations sont entièrement des humains, et les principaux lecteurs d'annotations, en plus des humains, sont des frameworks ou des précompilateurs.

Go dependency injection-wire

wire est une méthode d'injection de dépendances basée sur des annotations. wire est un outil d'injection de dépendances open source de Google. Il suffit d'indiquer à wire les dépendances entre les types dans un fichier go spécial. génère automatiquement du code pour nous, nous aide à créer des objets de types spécifiés et à assembler ses dépendances. wire是 Google 开源的一个依赖注入工具，我们只需要在一个特殊的go文件中告诉wire类型之间的依赖关系，它会自动帮我们生成代码，帮助我们创建指定类型的对象，并组装它的依赖。

wire有两个基础概念，Provider（构造器）和Injector（注入器）。

通过提供provider函数，让wire知道如何产生这些依赖对象。wire根据我们定义的injector函数签名，生成完整的injector函数，injector函数是最终我们需要的函数，它将按依赖顺序调用provider。

wire的要求很简单，新建一个wire.go文件（文件名可以随意），创建我们的初始化函数。比如，我们要创建并初始化一个Mission

wire a deux concepts de base, Provider (constructeur) et Injector (injecteur). 🎜🎜En fournissant la fonction provider, faites savoir à wire comment générer ces objets dépendants. wire génère une fonction injector complète basée sur la signature de la fonction injector que nous avons définie. La fonction injector est ce que nous avons finalement utilisé. besoin. Fonction, qui appellera provider dans l'ordre des dépendances. 🎜🎜Les exigences de wire sont très simples. Créez un nouveau fichier wire.go (le nom du fichier peut être arbitraire) et créez notre fonction d'initialisation. Par exemple, si nous voulons créer et initialiser un objet Mission, nous pouvons faire ceci : 🎜

//+build wireinject

package main

import "github.com/google/wire"

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

Vous pouvez voir l'annotation sur la première ligne : +build wireinject, indiquant qu'il s'agit d'un injecteur. +build est en fait une fonctionnalité du langage Go. Semblable à la compilation conditionnelle de C/C++, certaines options peuvent être transmises lors de l'exécution de go build, et sur la base de ces options, il est décidé si certains fichiers sont compilés. L'outil wire ne traitera que les fichiers avec wireinject, donc notre fichier wire.go doit l'ajouter. +build其实是 Go 语言的一个特性。类似 C/C++ 的条件编译，在执行go build时可传入一些选项，根据这个选项决定某些文件是否编译。wire工具只会处理有wireinject的文件，所以我们的wire.go文件要加上这个。

在函数中，我们调用wire.Build()将创建Mission所依赖的类型的构造器传进去。例如，需要调用NewMission()创建Mission类型，NewMission()接受两个参数一个Monster类型，一个Player类型。Monster类型对象需要调用NewMonster()创建，Player类型对象需要调用NewPlayer()创建。所以NewMonster()和NewPlayer()我们也需要传给wire

Dans la fonction, nous appelons wire.Build() pour transmettre le constructeur du type dont dépend Mission. Par exemple, vous devez appeler NewMission() pour créer un type Mission NewMission() accepte deux paramètres et un Monster<. type> Un type <code>Joueur. Les objets de type Monster doivent être créés en appelant NewMonster(), et les objets de type Player doivent être créés en appelant NewPlayer() . Nous devons donc également passer NewMonster() et NewPlayer() à wire.

Après avoir écrit le fichier wire.go et exécuté la commande wire, un fichier wire_gen.go sera automatiquement généré.

// 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
}

Vous pouvez voir que wire génère automatiquement la méthode InitMission pour nous. Dans cette méthode, le joueur, le monstre et la mission sont initialisés en séquence. Ensuite, il nous suffit d'appeler cette InitMission dans notre fonction principale.

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

  mission.Start()
}

Avant l'injection de dépendances, notre code ressemblait à ceci :

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

  mission.Start()
}

N'est-ce pas beaucoup plus simple ? Il n'y a que trois initialisations d'objets ici. S'il y en avait plus, vous ne réaliseriez peut-être pas les avantages de l'injection de dépendances.

Par exemple :

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
}

Alors, qu'est-ce que l'injection de dépendance exactement ?

C’est juste de l’encapsulation et du découplage.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation

】🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!