This document discusses different approaches for dependency injection in Go including: 1. Using package-level new functions to create dependencies and services. 2. Creating a "Super Factory" structure that embeds multiple dependency factories and can be used to initialize services and their dependencies with a uniform invocation mechanism. 3. Initializing a "Test Super Factory" for unit testing that can mock dependencies. It analyzes the tradeoffs of different approaches and references additional resources on the topic.

2. Opinions and emotions
DUTDIP
Interesting Go nuances & My Mistakes

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

4. Code against interfaces
Contracts & Data Model in a “model” package
Ben Johnson’s “Root” package
No cyclical dependencies
References:
https://medium.com/@benbjohnson/standard-package-layout-7cdbc8391fc1
https://appliedgo.net/di/
https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.html
Credit:
Robert Wechsler (www.robertwechsler.com) for permission to use image of “Circular
Bike”.

5. Contracts to be implemented
Service has a Dependency
Sometimes, it also has Another-Dependency

6. Package-Level-New-Function (PLNF) for Service
Consume Dependency from the instance member
Typical Service initialization and invocation

7. Pass problem of implementations to Upper Layer
Tight coupling, Upper Layer needs to “know”

8. Pass from top (main) package to that
specific layer

9. Dependencies before Services
Validation & Persistence example
Why incur cost and allocate resources for unused dependencies?

10. Pass New Function
Func type in Model Package
Function not Instance
New Instance then Invoke
https://martinfowler.com/articles/injection.html#UsingAServiceLocator

11. Projects evolve, Requirements change
Signature of “New” function can change
Context class

12. Cant embed Functions in a Structure
(Language feature request)
Wrapper Method to a private member

13. Instantiate a Service, Invoke Operations
Code is a bit tedious

14. Func types -> Package Level New Functions
Orchestration, Package Level Variables
Encapsulate to Structures
Structure changes are backward compatible
Hide behind Interfaces
Flexibility and Extensibility
Reference:
● https://dave.cheney.net/2017/06/11/go-without-package-scoped-variables

15. Dependency New Function -> Dependency Factory Structure
Interface

16. Embed multiple Factories -> Super Factory
No wrapper code
Interface

17. Service expects Super Factory
Invoke

18. Add Service to Super Factory
Uniform invocation mechanism
SuperFactory is parameter
Pass SF to all Layers

19. Global Reference to SuperFactory in Model package
Initialize Service
Initialize Dependency

20. No Injection, Only Lookup
Defer language syntax

21. Unit Testing using GoMock
Create a Test Super Factory
Can also embed other relevant data structures
Initialize a Test-SF

23. Change my Factory implementation
Create a Singleton
Replace Embedding

24. Embed multiple structures
Almost like Multiple Inheritance
Can’t do it in Java or C#
No wrapper Code

28. Many services & dependencies, centralization
Changes in dependencies
Extreme loose coupling, Unit Testing

29. • Package level New Functions
• Pass Dependencies, Simple
• Assign functions to Package Variables
• Overwrite variables with Mock
• Same benefits and limitations
• Graph / Container
• Definitions, Resolve
• Reflection, Casting, Tighty coupling to variable
• Duck Typing
• Violation of Dependency Inversion principle
References:
● Package New Function
○ https://appliedgo.net/di/
○ https://medium.com/@zach_4342/dependency-injection-in-golang-
e587c69478a8
○ http://www.florinpatan.ro/2016/09/using-dependency-injection-pattern-

30. in-go.html
● Graphs & Containers
○ github.com/facebookgo/inject
○ github.com/karlkfi/inject
○ github.com/sarulabs/di
○ github.com/uber-go/dig
● Duck Typing
○ http://txt.fliglio.com/2015/04/di-duck-typing-and-clean-code-in-go/
● New Functions Assigned to Variables:
○ http://openmymind.net/Dependency-Injection-In-Go/
○ https://dave.cheney.net/2017/06/11/go-without-package-scoped-
variables

31. Super Factory contains many items
Restrict access to only the relevant factories
Create a custom factory interface,
Inherently compatible with SuperFactory