Dependency injection

As explained in Go by Example

Dependency injection is a software design technique in which required dependencies are supplied to a component from outside rather than created internally.

Dependency injection supplies a component’s dependencies from outside instead of creating them internally. In Go, this decouples program logic from external inputs and outputs, making behavior easier to test without changing the program’s external behavior. section 5.0 section 5.2.1

A practical refactoring for a command-line tool follows these steps:

• Extract main’s core logic into a testable run function. section 5.3
• Group dependencies such as global inputs and outputs in an env struct. section 5.2.1
• Pass real dependencies from main and controlled fakes, such as in-memory buffers, from tests. section 5.2.1
• Update parsers and integrations to use the injected dependencies, then verify behavior manually and automatically. section 5.3 section 5.0

Injecting a logger into middleware

Middleware can accept a specific logger and return a handler-wrapping function instead of using a global logger. The logger is supplied when middleware is configured, which simplifies testing and preserves the func(Handler) Handler signature needed for composition. section 9.1.2 section 9.9

Figure 5.2 Moving main's code into a run function that accepts an *env struct. The env struct has fields for us to inject the global variables, such as the os.Stdout. This approach allows main to inject real globals to run, and tests can inject controlled fakes that we can observe from tests later.

The diagram shows main passing real globals through an env struct to run while tests pass controlled fakes that can be observed. section 5.2.1

How Go by Example covers it

How deep it goes

Explains refactoring steps, injected structs, interfaces, fakes, and explicit logger configuration, stopping short of framework-based techniques.

Examples

Uses a CLI env struct with in-memory buffers and middleware configured with an explicitly injected logger.

What it assumes

Assumes basic knowledge of Go interfaces while teaching dependency isolation through concrete CLI refactoring.

What you can do after

Build testable CLI and middleware components by passing real or fake dependencies through explicit parameters.

How it connects

Connects dependency injection with testability, interfaces, middleware, handlers, function signatures, and composition.

liveBookmanning.com

Read Go by Example on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  ASP.NET Core in Action, 3eDependency injection is a design pattern in which an object receives its dependencies from an external provider rather than creating them itself.
• 

  liveBookmanning.com
  Infrastructure as Code, Patterns and Practices: With examples in Python and TerraformDependency injection is a design pattern in which high-level modules obtain low-level dependencies through an abstraction rather than constructing or directly binding to them.
• 

  liveBookmanning.com
  .NET MAUI in ActionDependency injection is a technique in which an object receives its required dependencies from an external provider rather than constructing them itself.
• 

  liveBookmanning.com
  Modern AngularDependency injection is a software design technique in which a framework supplies an object's required dependencies rather than the object constructing them itself.
• 

  liveBookmanning.com
  Shipping Go: Develop, deliver, discuss, design, and go againDependency injection is a software design technique in which a component receives the services or objects it depends on from outside rather than constructing them itself.
• 

  liveBookmanning.com
  Functional Design and Architecture: Examples in HaskellDependency injection is a technique for supplying a component's external functionality through an abstraction rather than constructing or selecting its concrete implementation internally.
• 

  liveBookmanning.com
  Kafka Streams in Action, Second EditionDependency injection is a design technique in which an object's required dependencies are supplied by external configuration or a framework rather than created by the object itself.
• 

  liveBookmanning.com
  Pro Angular 16Dependency injection is a technique in which a framework supplies an object's required dependencies rather than the object constructing them directly.
• 

  liveBookmanning.com
  Pro ASP.NET Core 7, Tenth EditionDependency injection is a software design technique in which a component receives its dependencies from external configuration or composition rather than creating them itself.
• 

  liveBookmanning.com
  The Art of Unit Testing 3eA technique in which a component receives a value or behavior from outside rather than creating it internally.
• 

  liveBookmanning.com
  Learn Go with Pocket-Sized ProjectsDependency injection is a technique in which an object or component receives its required dependencies from outside rather than constructing them internally.
• 

  liveBookmanning.com
  Build Python Web Apps with StreamlitDependency injection is a software design pattern in which an object receives the components it depends on from outside rather than constructing them internally.
• 

  liveBookmanning.com
  gRPC Microservices in GoDependency injection is a design technique in which a component receives its required collaborators from outside rather than constructing them internally.
• 

  liveBookmanning.com
  Building Web APIs with ASP.NET CoreDependency injection is a software design pattern in which a component receives its required dependencies from an external provider rather than constructing them itself.
• 

  liveBookmanning.com
  .NET in Action, Second EditionDependency injection is a pattern in which an object receives its dependencies from an external composition mechanism rather than creating them itself.
• 

  liveBookmanning.com
  Simple Object-Oriented Design: Create clean, maintainable applicationsA dependency injection framework is a software framework that constructs objects and supplies their declared dependencies according to configuration or conventions.
• 

  liveBookmanning.com
  Rust Servers, Services, and AppsDependency injection is a technique in which a component receives the resources or services it needs from an external provider.
• 

  liveBookmanning.com
  Spring in Action, Sixth EditionA framework that supplies an object's dependencies from outside the object rather than requiring the object to construct them.
• 

  liveBookmanning.com
  Go in Action, Second EditionDependency injection is a design technique in which a component receives its required collaborators from outside rather than constructing them internally.
• 

  liveBookmanning.com
  100 Go Mistakes and How to Avoid ThemDependency injection is a technique in which a component receives required dependencies from its caller rather than constructing or retrieving them internally.

Compare how 21 books explain dependency injection →

Related concepts

• ASP.NET Coreused by · ASP.NET Core is Microsoft’s cross-platform, open-source framework for building web applications and services on the .NET platform.
• inversion of controlequivalent to · Inversion of control is a design principle that delegates application flow, object creation, or dependency selection from application components to an external mechanism or caller.
• view componentused by · A view component is a reusable presentation component that encapsulates application logic and renders a portion of a user interface or response.
• design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
• dependency inversionuses · Dependency inversion is a design principle in which high-level policy and low-level implementation depend on abstractions rather than directly on each other.
• testabilityproduces · Testability is the degree to which a system’s behavior can be exercised and evaluated effectively, efficiently, and reliably through testing.

This explainer was generated by Manning's knowledge graph from the text of Go by Example. The section links point to the parts of the book it draws on.