You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
William Petit ffe95a8672 Correction mise en forme des exemples 11 months ago
cmd/di-gen Initial commit 11 months ago
example Initial commit 11 months ago
.gitignore Initial commit 11 months ago
README.md Correction mise en forme des exemples 11 months ago
modd.conf Initial commit 11 months ago

README.md

DI

Conteneur de services pour Go.

Ce projet utilise go generate pour générer automatiquement le code nécessaire à la définition/utilisation des services.

Usage

Déclarer un nouveau service

  1. Récupérer le générateur

    go get forge.cadoles.com/wpetit/di/cmd/di-gen
    
  2. Dans votre projet, créer un nouveau package, par exemple service

    mkdir service
    cd service
    
  3. Créer la définition de votre nouveau service

  // Fichier service/foo.go
  package service
  
  //go:generate di-gen -service $GOFILE

  // Un service est une interface exportée dont
  // le nom contient le suffixe "Service"
  type FooService interface {
    Hello(name string)
  }
  1. Générer le conteneur de services

    go generate
    
  2. Un fichier service/container.go devrait être créé.

  // Fichier service/container.go
  package service
  
  // Le conteneur de service est automatiquement généré
  type Container struct {
  	fooServiceProvider FooServiceProvider
  }

  // Un type "Provider" est déclaré pour votre
  // service
  type FooServiceProvider func(ctn *Container) (FooService, error)

  // Une méthode d'accès à votre service
  // est automatiquement générée
  func (c *Container) GetFooService() (FooService, error) {
  	return c.fooServiceProvider(c)
  }

  // Une méthode pour déclarer un "Provider" pour
  // votre service est générée
  func (c *Container) ProvideFooService(provider FooServiceProvider) {
  	c.fooServiceProvider = provider
  }

  // Un constructeur pour votre conteneur
  // de service est généré
  func NewContainer() *Container {
  	return &Container{}
  }

Implémenter un service et l’utiliser

package main

import "my/package/service"

// On créait une nouvelle instance
// de notre conteneur de services
var container = service.NewContainer()

func init() {
  // On déclare nos "Providers" dans
  // notre conteneur
  container.ProvideFooService(myFooServiceProvider)
}

func main() {

  foo, err := container.GetFooService()
  if err != nil {
    panic(err)
  }

  foo.Hello("bar")

}

// On créait une implémentation de notre service
// service.FooService
type fooServiceImpl struct{}

// On implémente la méthode Hello(string)
// requise par l'interface service.FooService
func (f *fooServiceImpl) Hello(name string) {
  fmt.Printf("Hello %s !", name)
}

// On créait un "Provider" pour notre implémentation de "service.FooService"
func myFooServiceProvider(c *service.Container) (FooService, error) {
  return &fooServiceImpl{}, nil
}