Dependency injection

<h2 id="roles">Roles</h2>

<p>Dependency injection involves four roles: services, clients, interfaces and injectors.
</p>
<h3>Services and clients</h3>
<p>A service is any class which contains useful functionality. In turn, a client is any class which uses services. The services that a client requires are the client's <i>dependencies</i>.
</p><p>Any object can be a service or a client; the names relate only to the role the objects play in an injection. The same object may even be both a client (it uses injected services) and a service (it is injected into other objects). Upon injection, the service is made part of the client's <a href="/facts/State_(computer_science)/4Yu8xXHS">state</a>, available for use.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a>
</p>
<h3>Interfaces</h3>
<p>Clients should not know how their dependencies are implemented, only their names and <a href="/facts/Application_programming_interface/GMlN4vUr">API</a>. A service which retrieves <a href="/facts/Email/6pD9GLtI">emails</a>, for instance, may use the <a href="/facts/Internet_Message_Access_Protocol/QMnyvUwk">IMAP</a> or <a href="/facts/Post_Office_Protocol/QCp6qJQm">POP3</a> protocols behind the scenes, but this detail is likely irrelevant to calling code that merely wants an email retrieved. By ignoring implementation details, clients do not need to change when their dependencies do.
</p>
<h3>Injectors</h3>
<p>The injector, sometimes also called an assembler, container, provider or factory, introduces services to the client.
</p><p>The role of injectors is to construct and connect complex object graphs, where objects may be both clients and services. The injector itself may be many objects working together, but must not be the client, as this would create a <a href="/facts/Circular_dependency/l6mh3qVC">circular dependency</a>.
</p><p>Because dependency injection separates how objects are constructed from how they are used, it often diminishes the importance of the new keyword found in most <a href="/facts/Object-oriented_programming/TxNMEcao">object-oriented languages</a>. Because the framework handles creating services, the programmer tends to only directly construct <a href="/facts/Value_object/dUJRl7RN">value objects</a> which represents entities in the program's domain (such as an Employee object in a business app or an Order object in a shopping app).<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a><a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a><a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a><a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a>
</p>
<h3>Analogy</h3>
<p>As an analogy, <a href="/facts/Car/I1IsH8IK">cars</a> can be thought of as services which perform the useful work of transporting people from one place to another. Car engines can require <a href="/facts/Gasoline/lcnxq5BS">gas</a>, <a href="/facts/Diesel_fuel/lm71xc19">diesel</a> or <a href="/facts/Electric_car/agINmGGQ">electricity</a>, but this detail is unimportant to the client—a driver—who only cares if it can get them to their destination.
</p><p>Cars present a uniform interface through their pedals, steering wheels and other controls. As such, which engine they were 'injected' with on the factory line ceases to matter and drivers can switch between any kind of car as needed.
</p>
<h2 id="advantages-and-disadvantages">Advantages and disadvantages</h2>
<h3>Advantages</h3>
<p>A basic benefit of dependency injection is decreased coupling between classes and their dependencies.<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a><a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a>
</p><p>By removing a client's knowledge of how its dependencies are implemented, programs become more reusable, testable and maintainable.<a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a>
</p><p>This also results in increased flexibility: a client may act on anything that supports the intrinsic interface the client expects.<a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a>
</p><p>More generally, dependency injection reduces <a href="/facts/Boilerplate_code/xbYAfVbW">boilerplate code</a>, since all dependency creation is handled by a singular component.<a class="footnote-ref" id="fnref:19" href="#fn:19"><sup>19</sup></a>
</p><p>Finally, dependency injection allows concurrent development. Two developers can independently develop <a href="/facts/Class_(computer_programming)/zvzkSAtE">classes</a> that use each other, while only needing to know the interface the classes will communicate through. <a href="/facts/Plug-in_(computing)/351Du3Wu">Plugins</a> are often developed by third-parties that never even talk to developers of the original product.<a class="footnote-ref" id="fnref:20" href="#fn:20"><sup>20</sup></a>
</p>
<h4>Testing</h4>
<p>Many of dependency injection's benefits are particularly relevant to <a href="/facts/Unit_testing/SYoGGS3T">unit-testing</a>.
</p><p>For example, dependency injection can be used to externalize a system's configuration details into configuration files, allowing the system to be reconfigured without recompilation. Separate configurations can be written for different situations that require different implementations of components.<a class="footnote-ref" id="fnref:21" href="#fn:21"><sup>21</sup></a>
</p><p>Similarly, because dependency injection does not require any change in code behavior, it can be applied to legacy code as a <a href="/facts/Code_refactoring/gkw9oVTE">refactoring</a>. This makes clients more independent and are easier to <a href="/facts/Unit_testing/SYoGGS3T">unit test</a> in isolation, using <a href="/facts/Method_stub/oG08a8Ad">stubs</a> or <a href="/facts/Mock_object/KGPLkPpV">mock objects</a>, that simulate other objects not under test.
</p><p>This ease of testing is often the first benefit noticed when using dependency injection.<a class="footnote-ref" id="fnref:22" href="#fn:22"><sup>22</sup></a>
</p>
<h3>Disadvantages</h3>
<p>Critics of dependency injection argue that it:
</p>
<ul><li>Creates clients that demand configuration details, which can be onerous when obvious defaults are available.<a class="footnote-ref" id="fnref:23" href="#fn:23"><sup>23</sup></a></li>
<li>Makes code difficult to trace because it separates behavior from construction.<a class="footnote-ref" id="fnref:24" href="#fn:24"><sup>24</sup></a></li>
<li>Is typically implemented with reflection or dynamic programming, hindering <a href="/facts/Integrated_development_environment/jbEINSQf">IDE</a> automation.<a class="footnote-ref" id="fnref:25" href="#fn:25"><sup>25</sup></a></li>
<li>Typically requires more upfront development effort.<a class="footnote-ref" id="fnref:26" href="#fn:26"><sup>26</sup></a></li>
<li>Encourages dependence on a framework.<a class="footnote-ref" id="fnref:27" href="#fn:27"><sup>27</sup></a><a class="footnote-ref" id="fnref:28" href="#fn:28"><sup>28</sup></a><a class="footnote-ref" id="fnref:29" href="#fn:29"><sup>29</sup></a></li></ul>
<h2 id="types-of-dependency-injection">Types of dependency injection</h2>
<p>There are several ways in which a client can receive injected services:<a class="footnote-ref" id="fnref:30" href="#fn:30"><sup>30</sup></a>
</p>
<ul><li>Constructor injection, where dependencies are provided through a client's class <a href="/facts/Constructor_(object-oriented_programming)/8JNHsH5H">constructor</a>.</li>
<li>Method Injection, where dependencies are provided to a method only when required for specific functionality.</li>
<li>Setter injection, where the client exposes a setter method which accepts the dependency.</li>
<li>Interface injection, where the dependency's interface provides an injector method that will inject the dependency into any client passed to it.</li></ul>
<p>In some frameworks, clients do not need to actively accept dependency injection at all. In <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, for example, reflection can make private attributes public when testing and inject services directly.<a class="footnote-ref" id="fnref:31" href="#fn:31"><sup>31</sup></a>
</p>
<h3>Without dependency injection</h3>
<p>In the following <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> example, the Client class contains a Service <a href="/facts/Member_variable/BAtCyPVd">member variable</a> initialized in the <a href="/facts/Constructor_(object-oriented_programming)/8JNHsH5H">constructor</a>. The client directly constructs and controls which service it uses, creating a hard-coded dependency.
</p>
public class Client {
    private Service service;

Client() {
        // The dependency is hard-coded.
        this.service = new ExampleService();
    }
}

<h3>Constructor injection</h3>
<p>The most common form of dependency injection is for a class to request its dependencies through its <a href="/facts/Constructor_(object-oriented_programming)/8JNHsH5H">constructor</a>. This ensures the client is always in a valid state, since it cannot be instantiated without its necessary dependencies.   
</p>
public class Client {
    private Service service;

// The dependency is injected through a constructor.
    Client(final Service service) {
        if (service == null) {
            throw new IllegalArgumentException("service must not be null");
        }
        this.service = service;
    }
}

<h3>Method Injection</h3>
<p>Dependencies are passed as arguments to a specific method, allowing them to be used only during that method's execution without maintaining a long-term reference. This approach is particularly useful for temporary dependencies or when different implementations are needed for various method calls.   
</p>
public class Client {
    public void performAction(Service service) {
        if (service == null) {
            throw new IllegalArgumentException("service must not be null");
        }
        service.execute();
    }
}

<h3>Setter injection</h3>
<p>By accepting dependencies through a <a href="/facts/Setter_method/sKfxYzFM">setter method</a>, rather than a constructor, clients can allow injectors to manipulate their dependencies at any time. This offers flexibility, but makes it difficult to ensure that all dependencies are injected and valid before the client is used.
</p>
public class Client {
    private Service service;

// The dependency is injected through a setter method.
    public void setService(final Service service) {
        if (service == null) {
            throw new IllegalArgumentException("service must not be null");
        }
        this.service = service;
    }
}

<h3>Interface injection</h3>
<p>With interface injection, dependencies are completely ignorant of their clients, yet still send and receive references to new clients.
</p><p>In this way, the dependencies become injectors. The key is that the injecting method is provided through an interface.
</p><p>An assembler is still needed to introduce the client and its dependencies. The assembler takes a reference to the client, casts it to the setter interface that sets that dependency, and passes it to that dependency object which in turn passes a reference to itself back to the client.
</p><p>For interface injection to have value, the dependency must do something in addition to simply passing back a reference to itself. This could be acting as a factory or sub-assembler to resolve other dependencies, thus abstracting some details from the main assembler. It could be reference-counting so that the dependency knows how many clients are using it. If the dependency maintains a collection of clients, it could later inject them all with a different instance of itself.
</p>
public interface ServiceSetter {
    void setService(Service service);
}

public class Client implements ServiceSetter {
    private Service service;

@Override
    public void setService(final Service service) {
        if (service == null) {
            throw new IllegalArgumentException("service must not be null");
        }
        this.service = service;
    }
}

public class ServiceInjector {
	private final Set<ServiceSetter> clients = new HashSet<>();

public void inject(final ServiceSetter client) {
		this.clients.add(client);
		client.setService(new ExampleService());
	}

public void switch() {
		for (final Client client : this.clients) {
			client.setService(new AnotherExampleService());
		}
	}
}

public class ExampleService implements Service {}

public class AnotherExampleService implements Service {}

<h2 id="assembly">Assembly</h2>
<p>The simplest way of implementing dependency injection is to manually arrange services and clients, typically done at the program's root, where execution begins.
</p>
public class Program {

public static void main(final String[] args) {
        // Build the service.
        final Service service = new ExampleService();

// Inject the service into the client.
        final Client client = new Client(service);

// Use the objects.
        System.out.println(client.greet());
    }	
}

<p>Manual construction may be more complex and involve <a href="/facts/Builder_pattern/MBW3fCog">builders</a>, <a href="/facts/Factory_(object-oriented_programming)/o3rz6Rgu">factories</a>, or other <a href="/facts/Creational_pattern/yBNWl54a">construction patterns</a>.
</p>
<h3>Frameworks</h3>

<p>Manual dependency injection is often tedious and error-prone for larger projects, promoting the use of frameworks which automate the process. Manual dependency injection becomes a dependency injection <a href="/facts/Software_framework/EWasA8sG">framework</a> once the constructing code is no longer custom to the application and is instead universal.<a class="footnote-ref" id="fnref:32" href="#fn:32"><sup>32</sup></a> While useful, these tools are not required in order to perform dependency injection.<a class="footnote-ref" id="fnref:33" href="#fn:33"><sup>33</sup></a><a class="footnote-ref" id="fnref:34" href="#fn:34"><sup>34</sup></a>
</p><p>Some frameworks, like <a href="/facts/Spring_Framework/ajIwLM73">Spring</a>, can use external configuration files to plan program composition:
</p>
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Injector {

public static void main(final String[] args) {
		// Details about which concrete service to use are stored in configuration separate from the program itself.
		final BeanFactory beanfactory = new ClassPathXmlApplicationContext("Beans.xml");
		final Client client = (Client) beanfactory.getBean("client");
		System.out.println(client.greet());
	}
}

<p>Even with a potentially long and complex object graph, the only class mentioned in code is the entry point, in this case Client.Client has not undergone any changes to work with Spring and remains a <a href="/facts/Plain_Old_Java_Object/sTUnd6MN">POJO</a>.<a class="footnote-ref" id="fnref:35" href="#fn:35"><sup>35</sup></a><a class="footnote-ref" id="fnref:36" href="#fn:36"><sup>36</sup></a><a class="footnote-ref" id="fnref:37" href="#fn:37"><sup>37</sup></a> By keeping Spring-specific annotations and calls from spreading out among many classes, the system stays only loosely dependent on Spring.<a class="footnote-ref" id="fnref:38" href="#fn:38"><sup>38</sup></a>
</p>
<h2 id="examples">Examples</h2>
<h3>AngularJS</h3>
<p>The following example shows an <a href="/facts/AngularJS/vwI5s4aJ">AngularJS</a> component receiving a greeting service through dependency injection.
</p>
function SomeClass(greeter) {
  this.greeter = greeter;
}

SomeClass.prototype.doSomething = function(name) {
  this.greeter.greet(name);
}

<p>Each AngularJS application contains a service locator responsible for the construction and look-up of dependencies.
</p>
// Provide the wiring information in a module
var myModule = angular.module('myModule', []);

// Teach the injector how to build a greeter service. 
// greeter is dependent on the $window service.
myModule.factory('greeter', function($window) {
  return {
    greet: function(text) {
      $window.alert(text);
    }
  };
});

<p>We can then create a new injector that provides components defined in the myModule module, including the greeter service.
</p>
var injector = angular.injector(['myModule', 'ng']);
var greeter = injector.get('greeter');

<p>To avoid the <a href="/facts/Service_locator_pattern/gjkmaDFg">service locator</a> antipattern, AngularJS allows declarative notation in HTML templates which delegates creating components to the injector.
</p>
<div ng-controller="MyController">
  <button ng-click="sayHello()">Hello</button>
</div>

function MyController($scope, greeter) {
  $scope.sayHello = function() {
    greeter.greet('Hello World');
  };
}

<p>The ng-controller directive triggers the injector to create an instance of the controller and its dependencies.
</p>
<h3>C#</h3>
<p>This sample provides an example of constructor injection in <a href="/facts/C/2e7jmUaG">C#</a>.
</p>
using System;

namespace DependencyInjection;

// Our client will only know about this interface, not which specific gamepad it is using.
interface IGamepadFunctionality {
    string GetGamepadName();
    void SetVibrationPower(float power);
}

// The following services provide concrete implementations of the above interface.

class XboxGamepad : IGamepadFunctionality {
    float vibrationPower = 1.0f;
    
    public string GetGamepadName() => "Xbox controller";
    
    public void SetVibrationPower(float power) => this.vibrationPower = Math.Clamp(power, 0.0f, 1.0f);
}

class PlaystationJoystick : IGamepadFunctionality {
    float vibratingPower = 100.0f;
    
    public string GetGamepadName() => "PlayStation controller";
    
    public void SetVibrationPower(float power) => this.vibratingPower = Math.Clamp(power * 100.0f, 0.0f, 100.0f);
}

class SteamController : IGamepadFunctionality {
    double vibrating = 1.0;
    
    public string GetGamepadName() => "Steam controller";
    
    public void SetVibrationPower(float power) => this.vibrating = Convert.ToDouble(Math.Clamp(power, 0.0f, 1.0f));
}

// This class is the client which receives a service.
class Gamepad {
    IGamepadFunctionality gamepadFunctionality;

// The service is injected through the constructor and stored in the above field.
    public Gamepad(IGamepadFunctionality gamepadFunctionality) => this.gamepadFunctionality = gamepadFunctionality;

public void Showcase() {
        // The injected service is used.
        var gamepadName = this.gamepadFunctionality.GetGamepadName();
        var message = $"We're using the {gamepadName} right now, do you want to change the vibrating power?";
        Console.WriteLine(message);
    }
}

class Program {
    static void Main() {
        var steamController = new SteamController();
        
        // We could have also passed in an XboxController, PlaystationJoystick, etc.
        // The gamepad doesn't know what it's using and doesn't need to.
        var gamepad = new Gamepad(steamController);
        
        gamepad.Showcase();
    }
}

<h3>Go</h3>
<p>Go does not support classes and usually dependency injection is either abstracted by a dedicated library that utilizes <a href="/facts/Reflective_programming/Nj8stFfp">reflection</a> or <a href="/facts/Generic_programming/kqtqJk7p">generics</a> (the latter being supported since Go 1.18<a class="footnote-ref" id="fnref:39" href="#fn:39"><sup>39</sup></a>).<a class="footnote-ref" id="fnref:40" href="#fn:40"><sup>40</sup></a> A simpler example without using dependency injection libraries is illustrated by the following example of an <a href="/facts/Model%E2%80%93view%E2%80%93controller/vRbMXjMm">MVC</a> web application.
</p><p>First, pass the necessary dependencies to a router and then from the router to the controllers:
</p>
package router

import (
	"database/sql"
	"net/http"

"example/controllers/users"

"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"

"github.com/redis/go-redis/v9"
	"github.com/rs/zerolog"
)

type RoutingHandler struct {
	// passing the values by pointer further down the call stack
	// means we won't create a new copy, saving memory
	log    *zerolog.Logger
	db     *sql.DB
	cache  *redis.Client
	router chi.Router
}

// connection, logger and cache initialized usually in the main function
func NewRouter(
	log *zerolog.Logger,
	db *sql.DB,
	cache *redis.Client,
) (r *RoutingHandler) {
	rtr := chi.NewRouter()

return &RoutingHandler{
		log:    log,
		db:     db,
		cache:  cache,
		router: rtr,
	}
}

func (r *RoutingHandler) SetupUsersRoutes() {
	uc := users.NewController(r.log, r.db, r.cache)

r.router.Get("/users/:name", func(w http.ResponseWriter, r *http.Request) {
		uc.Get(w, r)
	})
}

<p>Then, you can access the private fields of the <a href="/facts/Record_(computer_science)/1fvSgenB">struct</a> in any method that is its <a href="/facts/Pointer_(computer_programming)/fPoNzy9b">pointer</a> receiver, without violating encapsulation.
</p>
package users

import (
	"database/sql"
	"net/http"

"example/models"

"github.com/go-chi/chi/v5"
	"github.com/redis/go-redis/v9"
	"github.com/rs/zerolog"
)

type Controller struct {
	log     *zerolog.Logger
	storage models.UserStorage
	cache   *redis.Client
}

func NewController(log *zerolog.Logger, db *sql.DB, cache *redis.Client) *Controller {
	return &Controller{
		log:     log,
		storage: models.NewUserStorage(db),
		cache:   cache,
	}
}

func (uc *Controller) Get(w http.ResponseWriter, r *http.Request) {
	// note that we can also wrap logging in a middleware, this is for demonstration purposes
	uc.log.Info().Msg("Getting user")

userParam := chi.URLParam(r, "name")

var user *models.User
	// get the user from the cache
	err := uc.cache.Get(r.Context(), userParam).Scan(&user)
	if err != nil {
		uc.log.Error().Err(err).Msg("Error getting user from cache. Retrieving from SQL storage")
	}

user, err = uc.storage.Get(r.Context(), "johndoe")
	if err != nil {
		uc.log.Error().Err(err).Msg("Error getting user from SQL storage")
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
}

<p>Finally you can use the database connection initialized in your main function at the data access layer:
</p>
package models

import (
"database/sql"
"time"
)

type (
	UserStorage struct {
		conn *sql.DB
	}

User struct {
		Name     string 'json:"name" db:"name,primarykey"'
		JoinedAt time.Time 'json:"joined_at" db:"joined_at"'
		Email    string 'json:"email" db:"email"'
	}
)

func NewUserStorage(conn *sql.DB) *UserStorage {
	return &UserStorage{
		conn: conn,
	}
}

func (us *UserStorage) Get(name string) (user *User, err error) {
	// assuming 'name' is a unique key
	query := "SELECT * FROM users WHERE name = $1"

if err := us.conn.QueryRow(query, name).Scan(&user); err != nil {
		return nil, err
	}

return user, nil
}

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Architecture_description_language/JpElRTg7">Architecture description language</a></li>
<li><a href="/facts/Factory_pattern/o3rz6Rgu">Factory pattern</a></li>
<li><a href="/facts/Inversion_of_control/CYWDbFlM">Inversion of control</a></li>
<li><a href="/facts/Mock_trainwreck/PVklPUxK">Mock trainwreck</a></li>
<li><a href="/facts/Plug-in_(computing)/351Du3Wu">Plug-in (computing)</a></li>
<li><a href="/facts/Strategy_pattern/064GYCe2">Strategy pattern</a></li>
<li><a href="/facts/Service_locator_pattern/gjkmaDFg">Service locator pattern</a></li>
<li><a href="/facts/Parameter_(computer_programming)/LcuLbbSq">Parameter (computer programming)</a></li>
<li><a href="/facts/Quaject/M6n8lN6y">Quaject</a></li></ul>

<h2 id="external-links">External links</h2>

Wikimedia Commons has media related to Dependency injection.

<ul><li><a href="http://blog.ploeh.dk/2011/07/28/CompositionRoot/">Composition Root by Mark Seemann</a></li>
<li><a href="https://www.theserverside.com/news/1321158/A-beginners-guide-to-Dependency-Injection">A beginners guide to Dependency Injection</a></li>
<li><a href="http://www.ddj.com/185300375">Dependency Injection & Testable Objects: Designing loosely coupled and testable objects</a> - Jeremy Weiskotten; <a href="/facts/Dr._Dobb%27s_Journal/6Qov1hUK">Dr. Dobb's Journal</a>, May 2006.</li>
<li><a href="http://www.griffincaprio.com/blog/2018/04/design-patterns-dependency-injection.html">Design Patterns: Dependency Injection -- MSDN Magazine, September 2005</a></li>
<li><a href="http://martinfowler.com/articles/injection.html">Martin Fowler's original article that introduced the term Dependency Injection</a></li>
<li><a href="http://martinfowler.com/eaaCatalog/plugin.html">P of EAA: Plugin</a></li>
<li><a href="https://web.archive.org/web/20080313170630/http://www.javalobby.org/articles/di-heritage/">The Rich Engineering Heritage Behind Dependency Injection</a>[<i>usurped</i>] - Andrew McVeigh - A detailed history of dependency injection.</li>
<li><a href="http://tutorials.jenkov.com/dependency-injection/index.html">What is Dependency Injection?</a> - An alternative explanation - Jakob Jenkov</li>
<li><a href="http://www.developer.com/net/net/article.php/3636501">Writing More Testable Code with Dependency Injection -- Developer.com, October 2006</a> <a href="https://web.archive.org/web/20080311121626/http://www.developer.com/net/net/article.php/3636501">Archived</a> 2008-03-11 at the <a href="/facts/Wayback_Machine/nmQ3a6JC">Wayback Machine</a></li>
<li><a href="http://msdn.microsoft.com/en-us/library/dd460648.aspx">Managed Extensibility Framework Overview -- MSDN</a></li>
<li><a href="https://web.archive.org/web/20120425150101/http://www.midmarsh.co.uk/planetjava/tutorials/language/WatchingtheObservables.PDF">Old fashioned description of the Dependency Mechanism by Hunt 1998</a></li>
<li><a href="http://blog.thecodewhisperer.com/2011/12/07/refactor-your-way-to-a-dependency-injection-container/">Refactor Your Way to a Dependency Injection Container</a></li>
<li><a href="http://php-di.org/doc/understanding-di.html">Understanding DI in PHP</a></li>
<li><a href="https://medium.com/@wrong.about/you-dont-need-a-dependency-injection-container-10a5d4a5f878">You Don't Need a Dependency Injection Container</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Seemann, Mark. "Dependency Injection is Loose Coupling". blog.ploeh.dk. Retrieved 2015-07-28. <a href="http://blog.ploeh.dk/2010/04/07/DependencyInjectionisLooseCoupling/" target="_blank">http://blog.ploeh.dk/2010/04/07/DependencyInjectionisLooseCoupling/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>Seeman, Mark (October 2011). Dependency Injection in .NET. Manning Publications. p. 4. ISBN 9781935182504. <a href="9781935182504" target="_blank">9781935182504</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Niko Schwarz, Mircea Lungu, Oscar Nierstrasz, "Seuss: Decoupling responsibilities from static methods for fine-grained configurability", Journal of Object Technology, volume 11, no. 1 (April 2012), pp. 3:1–23. <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"HollywoodPrinciple". c2.com. Retrieved 2015-07-19. <a href="http://c2.com/cgi/wiki?HollywoodPrinciple" target="_blank">http://c2.com/cgi/wiki?HollywoodPrinciple</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"The Dependency Injection design pattern – Problem, Solution, and Applicability". w3sDesign.com. Retrieved 2017-08-12. <a href="http://w3sdesign.com/?gr=u01&ugr=proble" target="_blank">http://w3sdesign.com/?gr=u01&ugr=proble</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>Erez, Guy (2022-03-09). "Dependency Inversion vs. Dependency Injection". Medium. Retrieved 2022-12-06. <a href="https://betterprogramming.pub/straightforward-simple-dependency-inversion-vs-dependency-injection-7d8c0d0ed28e" target="_blank">https://betterprogramming.pub/straightforward-simple-dependency-inversion-vs-dependency-injection-7d8c0d0ed28e</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Mathews, Sasha (2021-03-25). "You are Simply Injecting a Dependency, Thinking that You are Following the Dependency Inversion..." Medium. Retrieved 2022-12-06. <a href="https://levelup.gitconnected.com/you-are-simply-injecting-a-dependency-thinking-that-you-are-following-the-dependency-inversion-32632954c208" target="_blank">https://levelup.gitconnected.com/you-are-simply-injecting-a-dependency-thinking-that-you-are-following-the-dependency-inversion-32632954c208</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"Spring IoC Container". Retrieved 2023-05-23. <a href="https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/beans.html" target="_blank">https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/beans.html</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>Fowler, Martin. "Inversion of Control Containers and the Dependency Injection pattern". MartinFowler.com. Retrieved 4 June 2023. <a href="https://martinfowler.com/articles/injection.html#InversionOfControl" target="_blank">https://martinfowler.com/articles/injection.html#InversionOfControl</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>I.T., Titanium. "James Shore: Dependency Injection Demystified". www.jamesshore.com. Retrieved 2015-07-18. <a href="http://www.jamesshore.com/Blog/Dependency-Injection-Demystified.html" target="_blank">http://www.jamesshore.com/Blog/Dependency-Injection-Demystified.html</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>"To "new" or not to "new"..." Archived from the original on 2020-05-13. Retrieved 2015-07-18. <a href="https://web.archive.org/web/20200513185005/http://misko.hevery.com/2008/09/30/to-new-or-not-to-new/" target="_blank">https://web.archive.org/web/20200513185005/http://misko.hevery.com/2008/09/30/to-new-or-not-to-new/</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>"How to write testable code". www.loosecouplings.com. Retrieved 2015-07-18. <a href="http://www.loosecouplings.com/2011/01/how-to-write-testable-code-overview.html" target="_blank">http://www.loosecouplings.com/2011/01/how-to-write-testable-code-overview.html</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>"Writing Clean, Testable Code". www.ethanresnick.com. Retrieved 2015-07-18. <a href="http://www.ethanresnick.com/blog/testableCode.html" target="_blank">http://www.ethanresnick.com/blog/testableCode.html</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
<li id="fn:14"><p>Sironi, Giorgio. "When to inject: the distinction between newables and injectables - Invisible to the eye". www.giorgiosironi.com. Retrieved 2015-07-18. <a href="http://www.giorgiosironi.com/2009/07/when-to-inject-distinction-between.html" target="_blank">http://www.giorgiosironi.com/2009/07/when-to-inject-distinction-between.html</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li>
<li id="fn:15"><p>"the urban canuk, eh: On Dependency Injection and Violating Encapsulation Concerns". www.bryancook.net. Retrieved 2015-07-18. <a href="http://www.bryancook.net/2011/08/on-dependency-injection-and-violating.html" target="_blank">http://www.bryancook.net/2011/08/on-dependency-injection-and-violating.html</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li>
<li id="fn:16"><p>"The Dependency Injection Design Pattern". msdn.microsoft.com. Retrieved 2015-07-18. <a href="https://msdn.microsoft.com/en-us/library/vstudio/hh323705(v=vs.100).aspx" target="_blank">https://msdn.microsoft.com/en-us/library/vstudio/hh323705(v=vs.100).aspx</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li>
<li id="fn:17"><p>"The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 330". jcp.org. Retrieved 2015-07-18. <a href="https://jcp.org/en/jsr/detail?id=330" target="_blank">https://jcp.org/en/jsr/detail?id=330</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li>
<li id="fn:18"><p>"3.1. Dependency injection — Python 3: from None to Machine Learning". Archived from the original on 2020-02-08. <a href="https://web.archive.org/web/20200208005839/http://python.astrotech.io/design-patterns/structural/dependency-injection.html" target="_blank">https://web.archive.org/web/20200208005839/http://python.astrotech.io/design-patterns/structural/dependency-injection.html</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li>
<li id="fn:19"><p>"The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 330". jcp.org. Retrieved 2015-07-18. <a href="https://jcp.org/en/jsr/detail?id=330" target="_blank">https://jcp.org/en/jsr/detail?id=330</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></p></li>
<li id="fn:20"><p>"How Dependency Injection (DI) Works in Spring Java Application Development - DZone Java". <a href="https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a" target="_blank">https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></p></li>
<li id="fn:21"><p>"Dependency injection and inversion of control in Python — Dependency Injector 4.36.2 documentation". <a href="http://python-dependency-injector.ets-labs.org/introduction/di_in_python.html" target="_blank">http://python-dependency-injector.ets-labs.org/introduction/di_in_python.html</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></p></li>
<li id="fn:22"><p>"How to Refactor for Dependency Injection, Part 3: Larger Applications". <a href="https://visualstudiomagazine.com/articles/2014/07/01/larger-applications.aspx" target="_blank">https://visualstudiomagazine.com/articles/2014/07/01/larger-applications.aspx</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></p></li>
<li id="fn:23"><p>"How Dependency Injection (DI) Works in Spring Java Application Development - DZone Java". <a href="https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a" target="_blank">https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></p></li>
<li id="fn:24"><p>"How Dependency Injection (DI) Works in Spring Java Application Development - DZone Java". <a href="https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a" target="_blank">https://dzone.com/articles/how-dependency-injection-di-works-in-spring-java-a</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></p></li>
<li id="fn:25"><p>"A quick intro to Dependency Injection: What it is, and when to use it". 18 October 2018. <a href="https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/" target="_blank">https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/</a> <a href="#fnref:25" class="footnote-back-ref">↩</a></p></li>
<li id="fn:26"><p>"Dependency Injection |Professionalqa.com". <a href="https://www.professionalqa.com/dependency-injection" target="_blank">https://www.professionalqa.com/dependency-injection</a> <a href="#fnref:26" class="footnote-back-ref">↩</a></p></li>
<li id="fn:27"><p>"What are the downsides to using Dependency Injection?". stackoverflow.com. Retrieved 2015-07-18. <a href="https://stackoverflow.com/questions/2407540/what-are-the-downsides-to-using-dependency-injection" target="_blank">https://stackoverflow.com/questions/2407540/what-are-the-downsides-to-using-dependency-injection</a> <a href="#fnref:27" class="footnote-back-ref">↩</a></p></li>
<li id="fn:28"><p>"Dependency Injection Inversion – Clean Coder". sites.google.com. Retrieved 2015-07-18. <a href="https://sites.google.com/site/unclebobconsultingllc/blogs-by-robert-martin/dependency-injection-inversion" target="_blank">https://sites.google.com/site/unclebobconsultingllc/blogs-by-robert-martin/dependency-injection-inversion</a> <a href="#fnref:28" class="footnote-back-ref">↩</a></p></li>
<li id="fn:29"><p>"Decoupling Your Application From Your Dependency Injection Framework". InfoQ. Retrieved 2015-07-18. <a href="http://www.infoq.com/news/2010/01/dependency-injection-inversion" target="_blank">http://www.infoq.com/news/2010/01/dependency-injection-inversion</a> <a href="#fnref:29" class="footnote-back-ref">↩</a></p></li>
<li id="fn:30"><p>Martin Fowler (2004-01-23). "Inversion of Control Containers and the Dependency Injection pattern – Forms of Dependency Injection". Martinfowler.com. Retrieved 2014-03-22. <a href="http://www.martinfowler.com/articles/injection.html#FormsOfDependencyInjection" target="_blank">http://www.martinfowler.com/articles/injection.html#FormsOfDependencyInjection</a> <a href="#fnref:30" class="footnote-back-ref">↩</a></p></li>
<li id="fn:31"><p>"AccessibleObject (Java Platform SE 7)". docs.oracle.com. Retrieved 2015-07-18. <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/AccessibleObject.html" target="_blank">http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/AccessibleObject.html</a> <a href="#fnref:31" class="footnote-back-ref">↩</a></p></li>
<li id="fn:32"><p>Riehle, Dirk (2000), Framework Design: A Role Modeling Approach (PDF), Swiss Federal Institute of Technology <a href="http://www.riehle.org/computer-science/research/dissertation/diss-a4.pdf" target="_blank">http://www.riehle.org/computer-science/research/dissertation/diss-a4.pdf</a> <a href="#fnref:32" class="footnote-back-ref">↩</a></p></li>
<li id="fn:33"><p>"Dependency Injection != using a DI container". www.loosecouplings.com. Retrieved 2015-07-18. <a href="http://www.loosecouplings.com/2011/01/dependency-injection-using-di-container.html" target="_blank">http://www.loosecouplings.com/2011/01/dependency-injection-using-di-container.html</a> <a href="#fnref:33" class="footnote-back-ref">↩</a></p></li>
<li id="fn:34"><p>"Black Sheep » DIY-DI » Print". blacksheep.parry.org. Archived from the original on 2015-06-27. Retrieved 2015-07-18. <a href="https://web.archive.org/web/20150627215638/http://blacksheep.parry.org/archives/diy-di/print" target="_blank">https://web.archive.org/web/20150627215638/http://blacksheep.parry.org/archives/diy-di/print</a> <a href="#fnref:34" class="footnote-back-ref">↩</a></p></li>
<li id="fn:35"><p>"Spring Tips: A POJO with annotations is not Plain". Archived from the original on 2015-07-15. Retrieved 2015-07-18. <a href="https://web.archive.org/web/20150715045353/http://springtips.blogspot.com/2007/07/pojo-with-annotations-is-not-plain.html" target="_blank">https://web.archive.org/web/20150715045353/http://springtips.blogspot.com/2007/07/pojo-with-annotations-is-not-plain.html</a> <a href="#fnref:35" class="footnote-back-ref">↩</a></p></li>
<li id="fn:36"><p>"Annotations in POJO – a boon or a curse? | Techtracer". 2007-04-07. Retrieved 2015-07-18. <a href="http://techtracer.com/2007/04/07/annotations-in-pojo-a-boon-or-a-curse/" target="_blank">http://techtracer.com/2007/04/07/annotations-in-pojo-a-boon-or-a-curse/</a> <a href="#fnref:36" class="footnote-back-ref">↩</a></p></li>
<li id="fn:37"><p>Pro Spring Dynamic Modules for OSGi Service Platforms. APress. 2009-02-17. ISBN 9781430216124. Retrieved 2015-07-06. <a href="9781430216124" target="_blank">9781430216124</a> <a href="#fnref:37" class="footnote-back-ref">↩</a></p></li>
<li id="fn:38"><p>"Dependency Injection Inversion – Clean Coder". sites.google.com. Retrieved 2015-07-18. <a href="https://sites.google.com/site/unclebobconsultingllc/blogs-by-robert-martin/dependency-injection-inversion" target="_blank">https://sites.google.com/site/unclebobconsultingllc/blogs-by-robert-martin/dependency-injection-inversion</a> <a href="#fnref:38" class="footnote-back-ref">↩</a></p></li>
<li id="fn:39"><p>"Go 1.18 Release Notes - The Go Programming Language". go.dev. Retrieved 2024-04-17. <a href="https://go.dev/doc/go1.18" target="_blank">https://go.dev/doc/go1.18</a> <a href="#fnref:39" class="footnote-back-ref">↩</a></p></li>
<li id="fn:40"><p>"Awesome Go – dependency injection". Github. April 17, 2024. Retrieved April 17, 2024. <a href="https://github.com/avelino/awesome-go?tab=readme-ov-file#dependency-injection" target="_blank">https://github.com/avelino/awesome-go?tab=readme-ov-file#dependency-injection</a> <a href="#fnref:40" class="footnote-back-ref">↩</a></p></li>
</ol>

Dependency injection open-in-new

Dependency injection