Dependency injection
BenMcDonald (Talk | contribs) (New page: Dependency injection separates behaviour from dependency resolution. It is an alternative to the Factory pattern and hard coded dependencies. === Three examples of managing dependencies =...) |
m (Reverted edits by Ebybymic (Talk); changed back to last version by Joey Scarr) |
||
| (8 intermediate revisions by 6 users not shown) | |||
| Line 1: | Line 1: | ||
| − | Dependency | + | In the Dependency Injection pattern, an object's dependencies are provided externally. This separates behaviour from dependency resolution. It is the general concept behind the Factory patterns, which aim to reduce coupling and unwanted dependencies. |
| − | === Three examples of managing dependencies | + | It can also be viewed as an example of the [[Dependency inversion principle]], because it removes dependencies from low-level concepts in favour of the higher-level abstractions. |
| + | |||
| + | == Participants == | ||
| + | This design pattern can arise in a few different forms, but there are generally three participants. | ||
| + | |||
| + | * '''Dependent:''' An object that is expected to perform some task | ||
| + | * '''Dependencies:''' The object(s) that the dependent relies on to perform some task | ||
| + | * '''Injector:''' Composes the dependent with its dependencies so it is ready to use | ||
| + | |||
| + | The injector (also known as a provider or container) handles all issues associated with composing these objects and managing them throughout their life cycle. This includes when and how they are instantiated and disposed of. The injector can be implemented as a abstract factory or service locator. | ||
| + | |||
| + | == Three examples of managing dependencies == | ||
A dependency hard coded into an object: | A dependency hard coded into an object: | ||
| − | class SimpleCar implements Car | + | class SimpleCar implements Car { |
| − | + | private Engine engine = new SimpleEngine(); // Note the dependency on the SimpleEngine implementation | |
| − | public accelerate() | + | public accelerate() { |
| − | engine.setFuelValveIntake(gasPedalPressure) | + | engine.setFuelValveIntake(gasPedalPressure); |
| + | } | ||
| + | } | ||
| − | Dependency | + | Dependency injection through the constructor: |
| − | class SimpleCar implements Car | + | class SimpleCar implements Car { |
| − | + | private Engine engine; | |
| − | + | ||
| − | + | ||
| − | + | public SimpleCar(Engine engineImpl) { | |
| − | + | engine = engineImpl; | |
| − | + | } | |
| − | + | ||
| − | public | + | public void accelerate() { |
| − | + | engine.setFuelValveIntake(gasPedalPressure); | |
| − | + | } | |
| − | public accelerate() | + | } |
| − | engine.setFuelValveIntake(gasPedalPressure) | + | |
| + | Martin Fowler described three types of dependency injection: ''interface'', ''setter'' and ''constructor'' injection. Each method provides a slightly different way of "injecting" the dependency into a class without using hard-coded references. | ||
| + | |||
| + | There are also frameworks in most major languages for dependency injection. These frameworks let dependencies be defined with additional language syntax so that the framework can manage the dependencies - for example, an XML configuration file may be used to define what implementations should be used for each abstraction. | ||
| + | |||
| + | |||
| + | == See also == | ||
| + | |||
| + | * [[Dependency inversion principle]] | ||
| + | * [[Factory Method]] | ||
| + | * [[Abstract Factory]] | ||
| + | |||
| + | == References == | ||
| − | + | * [http://www.martinfowler.com/articles/injection.html#FormsOfDependencyInjection Martin Fowler on dependency injection] | |
Latest revision as of 03:23, 25 November 2010
In the Dependency Injection pattern, an object's dependencies are provided externally. This separates behaviour from dependency resolution. It is the general concept behind the Factory patterns, which aim to reduce coupling and unwanted dependencies.
It can also be viewed as an example of the Dependency inversion principle, because it removes dependencies from low-level concepts in favour of the higher-level abstractions.
Contents |
Participants
This design pattern can arise in a few different forms, but there are generally three participants.
- Dependent: An object that is expected to perform some task
- Dependencies: The object(s) that the dependent relies on to perform some task
- Injector: Composes the dependent with its dependencies so it is ready to use
The injector (also known as a provider or container) handles all issues associated with composing these objects and managing them throughout their life cycle. This includes when and how they are instantiated and disposed of. The injector can be implemented as a abstract factory or service locator.
Three examples of managing dependencies
A dependency hard coded into an object:
class SimpleCar implements Car {
private Engine engine = new SimpleEngine(); // Note the dependency on the SimpleEngine implementation
public accelerate() {
engine.setFuelValveIntake(gasPedalPressure);
}
}
Dependency injection through the constructor:
class SimpleCar implements Car {
private Engine engine;
public SimpleCar(Engine engineImpl) {
engine = engineImpl;
}
public void accelerate() {
engine.setFuelValveIntake(gasPedalPressure);
}
}
Martin Fowler described three types of dependency injection: interface, setter and constructor injection. Each method provides a slightly different way of "injecting" the dependency into a class without using hard-coded references.
There are also frameworks in most major languages for dependency injection. These frameworks let dependencies be defined with additional language syntax so that the framework can manage the dependencies - for example, an XML configuration file may be used to define what implementations should be used for each abstraction.
