sting

This file contains only prerequisites for all other examples. This is necessary because of the behavior of godoc. If an example has any type or function definition in it, godoc does not show a separate block for the output of the example.

package main

import (
	"fmt"
	"log"
	"net/http"
	"strconv"

	"bitbucket.org/snmed/sting"
)

type (
	PersonRepository interface {
		Find(int) *Person
		FindByName(string) *Person
	}

	PersonAccess struct {
		name string
		id   int
	}

	Config struct {
		DefaultName string
		DefaultId   int
	}

	Person struct {
		Id   int
		Name string
	}

	Log struct {
		logger log.Logger
	}
)

func (p PersonAccess) Find(id int) *Person {
	return &Person{Name: p.name, Id: id}
}

func (p PersonAccess) FindByName(name string) *Person {
	return &Person{Name: name, Id: p.id}
}

func (l *Log) Info(msg string) {
	l.logger.Println(fmt.Sprintf("Info: %v", msg))
}

func (l *Log) Error(msg string) {
	l.logger.Println(fmt.Sprintf("Error: %v", msg))
}

func createMyConfig() (*Config, error) {
	return &Config{DefaultId: 11, DefaultName: "Selene"}, nil
}

type Controller struct {
	config   *Config
	MyConfig Config           `di:"name=myconfig"`
	ignored  PersonRepository `di:"ignore"`
	repo     PersonRepository `di:"func=SetRepo"`
	Access   PersonAccess     `di:"func=SetPersonAccess,name=myconfig"`
}

func (c *Controller) SetConfig(cfg *Config) {
	c.config = cfg
}

func (c *Controller) SetRepo(r PersonRepository) {
	c.repo = r
}

func (c *Controller) SetPersonAccess(cfg Config) {
	c.Access = PersonAccess{id: cfg.DefaultId, name: cfg.DefaultName}
}

func LogMiddleware(handler http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Do some useful logging
		fmt.Printf("Calling URL %v with method %v ...\n", r.URL, r.Method)
		handler.ServeHTTP(w, r)
	})
}

func FindPerson(w http.ResponseWriter, r *http.Request, repo PersonRepository, pers Person) {
	if id, err := strconv.Atoi(r.FormValue("id")); err == nil {
		w.Write([]byte(fmt.Sprintf("%v", repo.Find(id))))
	} else {
		w.Write([]byte(fmt.Sprintf("%v", pers)))
	}
}

func ChangeCfgMiddleware(c sting.Container, handler http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// If GetService or Inject is used inside a handler func, it's
		// necessary to pass the request context to those functions.
		cfg, _, _ := c.GetService((*Config)(nil), r.Context())
		cfg.(*Config).DefaultName = "Pumuckel"
		handler.ServeHTTP(w, r)
	})
}

// This file contains only prerequisites for all other examples. This is
// necessary because of the behavior of godoc. If an example has any
// type or function definition in it, godoc does not show a separate block
// for the output of the example.
func main() {
	// This file contains only prerequisites for all other examples.
}

Output:

This example shows how to register multiple services with the same type and how to retrieve services from the di container.

container, err := sting.NewBuilder().
	// Register a pointer to struct with a  container scope
	Register(&Config{DefaultId: 42, DefaultName: "Judge Dredd"}, sting.ContainerScope()).
	// Register a creator function with a dependency and container scope
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: c.DefaultId, name: c.DefaultName}, nil
		},
		sting.RequestScope(),
	).
	// Register a named service with an already registered type
	RegisterNamed(
		"myconfig",
		func() (*Config, error) { return &Config{DefaultId: 11, DefaultName: "Selene"}, nil },
		sting.RequestScope(),
	).
	Build()

if err != nil {
	log.Fatalln(err)
}

//Get a service by passing a nil pointer to an interface
svc, _, err := container.GetService((*PersonRepository)(nil))
if err != nil {
	log.Fatalln(err)
}

// Get a service by passing a nil pointer to a struct
cfg, _, err := container.GetService((*Config)(nil))
if err != nil {
	log.Fatalln(err)
}

// Get a named service
mycfg, ctx, err := container.GetService("myconfig")
if err != nil {
	log.Fatalln(err)
}

// Change values
mycfg.(*Config).DefaultName = "Tom Bombadil"
mycfg.(*Config).DefaultId = 9999

// Get the same named service by passing the context
cfg2, _, err := container.GetService("myconfig", ctx)
if err != nil {
	log.Fatalln(err)
}

// Get the named service without a context, same as a new request.
cfg3, _, err := container.GetService("myconfig")
if err != nil {
	log.Fatalln(err)
}

fmt.Println(svc.(PersonRepository).Find(42))
fmt.Println(cfg)
fmt.Println(mycfg)
fmt.Println(cfg2)
fmt.Println(cfg3)

Output:

&{42 Judge Dredd}
&{Judge Dredd 42}
&{Tom Bombadil 9999}
&{Tom Bombadil 9999}
&{Selene 11}

This example shows how to use the di container in a web application or a microservice. Wrap any InjectionHandler inside a container.HandlerFunc. A InjectionHandler is in form of a http.Handler, but can have as many additional arguments as needed, as far as the argument types are one of the supported di types.

container, err := sting.NewBuilder().
	// Register a pointer to struct with a  container scope
	Register(&Config{DefaultId: 42, DefaultName: "Judge Dredd"}, sting.RequestScope()).
	// Register a creator function with a dependency and container scope
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: c.DefaultId, name: c.DefaultName}, nil
		},
		sting.RequestScope(),
	).
	// Register a named service with an already registered type
	Register(
		func() (*Person, error) { return &Person{Id: 11, Name: "Selene"}, nil },
		sting.RequestScope(),
	).
	Build()

if err != nil {
	log.Fatalln(err)
}

handler := ChangeCfgMiddleware(container, container.HandlerFunc(FindPerson))
handler = LogMiddleware(handler)

recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest("GET", "/api?id=55", nil))

fmt.Println(recorder.Body)

recorder = httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest("GET", "/api", nil))

fmt.Println(recorder.Body)

Output:

Calling URL /api?id=55 with method GET ...
&{55 Pumuckel}
Calling URL /api with method GET ...
{11 Selene}

This example shows how to inject dependencies into structs and functions.

container, err := sting.NewBuilder().
	// Register a pointer to struct with a  container scope
	Register(Config{DefaultId: 42, DefaultName: "Judge Dredd"}, sting.ContainerScope()).
	// Register a creator function with a dependency and container scope
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: c.DefaultId, name: c.DefaultName}, nil
		},
		sting.RequestScope(),
	).
	// Register a named service with an already registered type
	RegisterNamed(
		"myconfig",
		func() (*Config, error) { return &Config{DefaultId: 11, DefaultName: "Selene"}, nil },
		sting.RequestScope(),
	).
	Build()

controller := &Controller{}

// Inject dependencies into a struct
_, err = container.Inject(controller)
if err != nil {
	log.Fatalln(err)
}

var config *Config
var repo PersonRepository

// Inject dependencies into a function
container.Inject(func(c *Config, r PersonRepository) {
	config = c
	config.DefaultId += c.DefaultId
	config.DefaultName += " changed"
	repo = r
})

fmt.Println(controller.config)
fmt.Println(controller.MyConfig)
fmt.Println(controller.ignored)
fmt.Println(controller.repo)
fmt.Println(controller.Access)
fmt.Println(config)
fmt.Println(repo)

Output:

&{Judge Dredd 42}
{Selene 11}
<nil>
{Judge Dredd 42}
{Selene 11}
&{Judge Dredd changed 84}
{Judge Dredd 42}

This example shows how to register services and dependencies. Register requires as first argument a struct, pointer to struct or a creator function and as second argument a scope.

RegisterNamed requires as first argument a string under which the service will be registered, the other two arguments are the same as for the Register function.

container, err := sting.NewBuilder().
	// Register a struct with a transient scope
	Register(Log{}, sting.TransientScope()).
	// Register a pointer to struct with a  container scope
	Register(&Config{DefaultId: 42, DefaultName: "Judge Dredd"}, sting.ContainerScope()).
	// Register a creator function with a dependency and container scope
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: c.DefaultId, name: c.DefaultName}, nil
		},
		sting.ContainerScope(),
	).
	// Register a named service with an already registered type
	RegisterNamed(
		"myconfig",
		createMyConfig,
		sting.RequestScope(),
	).
	Build()

if err != nil {
	log.Fatalln(err)
}

// Get a service by passing a nil pointer to an interface
svc, _, err := container.GetService((*PersonRepository)(nil))
if err != nil {
	log.Fatalln(err)
}

fmt.Println(svc.(PersonRepository).Find(42))

Output:

&{42 Judge Dredd}

This example shows how to use the di container in a web application or a microservice. If request scope is used, wrap first handler of a handler chain within the UseHTTPRequestContext middleware. Afterwards wrap any InjectionHandler inside a container.HandlerFunc.

// Create the first builder and register services
builder := sting.NewBuilder().
	Register(&Config{DefaultId: 42, DefaultName: "Judge Dredd"}, sting.TransientScope()).
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: c.DefaultId, name: c.DefaultName}, nil
		},
		sting.RequestScope(),
	).
	Register(
		func() (*Person, error) { return &Person{Id: 11, Name: "Selene"}, nil },
		sting.RequestScope(),
	)

// Create a child builder and register services
childBuilder := builder.NewBuilder().
	Register(
		func(c Config) (PersonRepository, error) {
			return PersonAccess{id: 2 * c.DefaultId, name: "Child " + c.DefaultName}, nil
		},
		sting.ContainerScope(),
	)

// Important build parent builder first
container, perr := builder.Build()
subcontainer, serr := childBuilder.Build()

if perr != nil || serr != nil {
	log.Fatalln(perr, serr)
}

// Now use containers in handler chains
parentHandler := LogMiddleware(container.HandlerFunc(FindPerson))
subHandler := LogMiddleware(subcontainer.HandlerFunc(FindPerson))

precorder := httptest.NewRecorder()
parentHandler.ServeHTTP(precorder, httptest.NewRequest("GET", "/api?id=55", nil))

fmt.Println(precorder.Body)

precorder = httptest.NewRecorder()
parentHandler.ServeHTTP(precorder, httptest.NewRequest("GET", "/api", nil))

fmt.Println(precorder.Body)

srecorder := httptest.NewRecorder()
subHandler.ServeHTTP(srecorder, httptest.NewRequest("GET", "/api?id=55", nil))

fmt.Println(srecorder.Body)

srecorder = httptest.NewRecorder()
subHandler.ServeHTTP(srecorder, httptest.NewRequest("GET", "/api", nil))

fmt.Println(srecorder.Body)

Output:

Calling URL /api?id=55 with method GET ...
&{55 Judge Dredd}
Calling URL /api with method GET ...
{11 Selene}
Calling URL /api?id=55 with method GET ...
&{55 Child Judge Dredd}
Calling URL /api with method GET ...
{11 Selene}