Suggest an edit

Improve this article

Refine the answer for “Why is Abstract Factory often used together with Dependency Injection?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

**Abstract Factory** and **Dependency Injection (DI)** are often used together because they solve **the same architectural problem**: **isolating object creation from object use**, thereby achieving **loose coupling** and **flexible application configuration**.

---

### 1. **A shared goal: dependency inversion**

Both approaches follow the *Dependency Inversion* principle:

> high-level modules should not depend on low-level ones - both should depend on abstractions.

- Abstract Factory provides an **interface for creating families of objects** without exposing the concrete classes.
- DI lets you **inject a concrete implementation** of that factory (or product) from outside, instead of creating it by hand inside the code.

---

### 2. **What this looks like in practice**

For example:

```java
class Application {
    private final GUIFactory factory;

// The factory is injected through the constructor (DI)
    public Application(GUIFactory factory) {
        this.factory = factory;
    }

public void createUI() {
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();
    }
}
```

Now `Application` does not know which exact factory is used: `WinFactory` or `MacFactory`.
That decision is made when the application is configured (for example, through a DI container).

---

### 3. **Advantages of this combination**

- **Maximum loose coupling** - the object does not create its own dependencies, DI supplies them.
- **Flexible configuration** - you can change the factory (and so the product family) without changing the code.
- **Testability** - it is easy to substitute a mock factory in tests.
- **Extensibility** - new factory implementations are plugged in through the DI container without rewriting business logic.

---

### 4. **Conclusion**

Abstract Factory defines *what to create*,
Dependency Injection decides *when and how to inject* the needed factory or object.

Together they provide a **clean architecture**, where the code stays independent of concrete implementations and easily adapts to different environments.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts294 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.