A thought experiment in designing a Dependency Injection pattern for GoLang, bringing out subtle nuances of the language, especially when compared to traditional object oriented languages. Brings out possibilities and challenges of the language, and enlightens you on things you shouldn’t do! Presented in GopherCon India, February 2018.

1. DUTDIP
Don’t Use This Dependency Injection Pattern
Rushabh Dadbhawala
GopherCon India 2018

2. “Only a fool learns from his own mistakes. The
wise man learns from the mistakes of others.”
- Otto von Bismarck

3. Expectations
Abstractions over Implementations
Inject or Lookup Dependencies
Lifecycle of Services and Dependencies
Loose Coupling & Unit Testing
Avoid Unutilized Dependencies

4. Abstractions over Implementations

5. Model
type Service interface {
Feature()
}
type Dependency interface {
Operation()
}
type AnotherDep interface {
AnotherOp()
}

6. New (d Dep)
func NewService(dep model.Dependency) model.Service {
return &serviceImpl{dep}
}
func (s *serviceImpl) Feature() {
s.d.Operation()
}
feature.NewService(library.NewDependency()).Feature()

7. So, what’s wrong with New()

8. So, what’s wrong with New()

9. So, what’s wrong with New()

10. New (nd NewDep)
func NewService(dep model. Dependency) model.Service {
return &serviceImpl{dep}
}
feature.NewService(library.NewDependency ).Feature()
func (s *serviceImpl) Feature() {
s.d .Operation()
}
()
New
type NewDependency func() Dependency
()

11. New(A, B, …)

12. { NewA, NewB }
type Functions struct {
Na NewAnotherDep
nd NewDependency
}
func (f *Functions) NewDependency() Dependency {
return f.nd()
}

13. { NewA, NewB }
feature.NewService(new Functions{
library.NewAnotherDep, library.NewDependency,
).Feature()
func (s *serviceImpl) Feature() {
s.f.NewDependency().Operation()
s.f.Na().AnotherOp()
}

15. func NewDependency() model.Dependency {
return &dependencyImpl{}
}
New() to New{}
type DepFactoryImpl struct{}
func (d DepFactoryImpl) NewDependency() model.Dependency {
return &dependencyImpl{}
}
type DependencyFactory interface {
NewDependency() Dependency
}

16. SuperFactory
type superFactoryImpl struct {
library.DependencyFactoryImpl
library.AnotherDepFactoryImpl
}
type SuperFactory interface {
DependencyFactory
AnotherDepFactory
}

17. Service?
func NewService(f model.SuperFactory) model.Service {
return &serviceImpl{f}
}
func (s *serviceImpl) Feature() {
s.f.NewDependency().Operation()
s.f.NewAnotherDep().AnotherOp()
}

18. { Service, Dependency }
type SuperFactory interface {
ServiceFactory
}
type superFactoryImpl struct {
feature.ServiceFactoryImpl
}
func main() {
f := &superFactoryImpl{}
f.NewService(f).Feature()
}

19. Global Reference
var SF SuperFactory
func main() {
model.SF = &superFactoryImpl{}
model.SF.NewService().Feature()
}
func (s *serviceImpl) Feature() {
model.SF.NewDependency().Operation()
model.SF.NewAnotherDep().AnotherOp()
}

20. Defer to Dispose
func (s *serviceImpl) Feature() {
dep := s.f.NewDependency()
defer dep.Release()
dep.Operation()
}

21. Unit Testing
type testSuperFactory struct {
ServiceFactoryImpl // ServiceFactory
*mock.MockDepFactory
*mock.MockDependency
}
func newTsf(ctrl *gomock.Controller) *testSuperFactory {
return & testSuperFactory{ ServiceFactoryImpl{},
mock.NewMockDepFactory(ctrl),
mock.NewMockDependency(ctrl), }
}

22. Unit Testing
func TestService(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
tsf := newTsf(ctrl)
tsf.MockDependency.EXPECT().Operation().Times(1)
tsf.MockDepFactory.EXPECT().NewDependency().
Return(tsf.MockDependency)
model.SF = tsf
model.SF.NewService().Feature()
}

23. Multiple Implementations
type SingletonDep struct {
o sync.Once
d *dependencyImpl
}
func (sd SingletonDep) NewDependency() model.Dependency {
sd.o.Do(func() {
sd.d = &dependencyImpl{}
})
return sd.d
}
type superFactoryImpl struct {
library.SingletonDependency // library.DependencyFactoryImpl
}

24. Multi-Embedding
type superFactoryImpl struct {
library.DependencyFactoryImpl
library.AnotherDepFactoryImpl
feature.ServiceFactoryImpl
}

25. Benchmarking
* Metrics are approximate, in nanoseconds, best of 3 values, calculated on a nice cloudy February Wednesday
Functions to Variables 2.69 46.10
New Functions 0.39 1.55
Singleton* New / Request*
karlkfi/inject - 6167.00
sarulabs/di 82.90 2543.00
DUTDIP 9.96 49.00

26. What’s in the name?

27. Thank You
Github:
https://github.com/rdadbhawala/dutdip
LinkedIn:
www.linkedin.com/in/rdadbhawala
Image Credits
RobertWechsler.com
Pixabay.com
Unsplash.com

28. Why DI?

29. What’s out there?

30. Service?
func NewService(f model.ServiceDeps) model.Service {
return &serviceImpl{f}
}
type ServiceDeps interface {
DependencyFactory
AnotherDepFactory
}