service

Documentation

Overview

Package service - Propose une implémentation simple d'un conteneur de service afin de permettre l'injection de dépendances dans les applications web

Example (Usage)

package main

import (
	"errors"
	"fmt"
)

// On déclare le nom de notre nouveau service
const MyServiceName Name = "myService"

// On déclare le type de notre nouveau service
type MyService struct{}

// Une simple méthode exposée sur notre service
func (s *MyService) HelloWorld() {
	fmt.Println("Hello World !")
}

func main() {

	// On initialise un conteneur de services vide
	container := NewContainer()

	// On créait un "fournisseur" pour notre nouveau service.
	// Celui ci sera utilisé pour créer une nouvelle instance du service
	// à chaque fois qu'un appel à container.Service(MyServiceName)
	// sera fait
	myServiceProvider := func(container *Container) (interface{}, error) {
		// On peut potentiellement appeler d'autres services ici
		// via le conteneur afin d'initialiser notre propre service
		return &MyService{}, nil
	}

	// On expose le fournisseur de service dans notre conteneur de service
	// Cette opération est typiquement faite lors de l'initialisation de
	// l'application, avant le lancement du serveur HTTP
	container.Provide(MyServiceName, myServiceProvider)

	// Plus tard, on peut utiliser le conteneur pour récupérer une instance
	// de notre service
	service, err := container.Service(MyServiceName)
	if err != nil {
		panic(err)
	}

	// Le service est retourné en tant que interface{}, il faut utiliser
	// de l'assertion de type afin de pouvoir l'utiliser concrètement.

	// Les packages de services proposés dans goweb exposent tous les méthodes
	// From(container *service.Container) (Service, error)
	// et Must(container *service.Container) Service qui permettent de simplifier
	// ce processus.

	myService, ok := service.(*MyService)
	if !ok {
		panic(errors.New("unexpected implementation"))
	}

	// On peut maintenant utiliser le service
	myService.HelloWorld()

}

Index

• Variables
• type Container
  • func NewContainer() *Container
  • func (c *Container) Provide(name Name, provider Provider)
  • func (c *Container) Service(name Name) (interface{}, error)
• type Name
• type Provider

Examples

• Package (Usage)

Variables

var (
	// ErrNotImplemented is the error when a service is accessed
	// and no implementation was provided
	ErrNotImplemented = errors.New("service not implemented")
)

Types

type Container

type Container struct {
	// contains filtered or unexported fields
}

Container is a simple service container for dependency injection

func NewContainer

func NewContainer() *Container

NewContainer returns a new empty service container

func (*Container) Provide

func (c *Container) Provide(name Name, provider Provider)

Provide registers a provider for the survey.Service

func (*Container) Service

func (c *Container) Service(name Name) (interface{}, error)

Service retrieves a service implementation based on its name

type Name

type Name string

Name is a name of a service

type Provider

type Provider func(ctn *Container) (interface{}, error)

Provider is a provider for a service