Singleton Provider

[ehsannm]

Is there anyway to make a provider function as singleton ?

There are cases we have one dependency object which must be initialized only once but is used by many other objects.

How to handle those cases in uber/dig ?

[abhinav]

Hello @ehsannm.
All functions provided to Dig/Fx are treated as singletons and re-used in every other function.

For example, if you have,

func NewFoo() *Foo {
	fmt.Println("building Foo")
	return // ...
}

And you use that with two constructors NewBar(*Foo) *Bar and NewBaz(*Foo) *Bar,
both Dig and Fx will instantiate *Foo only once (calling that print statement only once)
and share it between Bar and Baz.

Sample code with Dig (run it at https://play.golang.org/p/bHol91PaDj3):

package main

import (
	"fmt"

	"go.uber.org/dig"
)

type Foo struct{}

func NewFoo() *Foo {
	fmt.Println("building Foo")
	return new(Foo)
}

type Bar struct{}

func NewBar(*Foo) *Bar {
	fmt.Println("using Foo in Bar")
	return new(Bar)
}

type Baz struct{}

func NewBaz(*Foo) *Baz {
	fmt.Println("using Foo in Baz")
	return new(Baz)
}

func main() {
	c := dig.New()

	if err := c.Provide(NewFoo); err != nil {
		panic(err)
	}

	if err := c.Provide(NewBar); err != nil {
		panic(err)
	}

	if err := c.Provide(NewBaz); err != nil {
		panic(err)
	}

	if err := c.Invoke(run); err != nil {
		panic(err)
	}
}

func run(bar *Bar, baz *Baz) {
	fmt.Println("running application")
}

Closing because answered.
If I misunderstood the question, feel free to open a new issue with more details.
Thanks!

[dalianzhu]

@abhinav hi, i have a new question, if i want to create new instance each time, could you tell me how can do that?

[abhinav]

@dalianzhu, if you need to create a new instance of a specific thing each time, one pattern you can use is to have a factory:

type FooBuilder struct {
  bar *Bar
  baz *Baz
}

func NewFooBuilder(bar *Bar, baz *Baz) *FooBuilder {
  // ...
}

func (b *FooBuilder) NewFoo() *Foo {
  return &Foo{ ... }
}

Following that, you'll inject the *FooBuilder instead of *Foo into a constructor, and request a new Foo on-demand:

type Thing struct{ .. }

func NewThing(fb *FooBuilder) *Thing {
  foo := fb.NewFoo()
  // ...
}

If you want all objects in the Dig graph to be instantiated anew for each call, Dig may not be the right tool for the job.
That's not something Dig currently supports and we don't yet have plans to support this.
We see Dig (and Fx) as something used at startup to wire up everything together once and then use all objects directly.
If we support instantiating new objects each time, that'll put Dig in the request path—it will be used in the course of processing a production request instead of just startup. That's something we want to discourage.