将依赖注入作为创建型技术
学习依赖注入如何补充创建型模式，将对象构造移出使用者并集中到一个组合点中
将依赖注入作为创建型技术 是 CoddyKit 上的免费 Clean Architecture & Design Patterns in Practice 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Clean Architecture & Design Patterns in Practice 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Clean Architecture & Design Patterns in Practice 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Why Another Creational Approach?
Classic creational patterns like Factory and Builder centralize how objects are built. Dependency Injection (DI) centralizes where they are wired together.
- A class no longer creates its own collaborators.
- Instead, collaborators are supplied from outside.
This is the natural endpoint of the creational journey: removing the new keyword from business logic entirely.
The Problem DI Solves
Consider a service that builds its own dependency:
The service is now hard-wired to a concrete class. You cannot swap it for a test double or an alternative implementation without editing the service.
class ReportService {
private final MySqlDatabase db = new MySqlDatabase();
void run() { db.query("..."); }
}Constructor Injection
The most common and recommended form: dependencies arrive through the constructor.
- The class declares what it needs, not how to get it.
- Dependencies become
finaland guaranteed present.
class ReportService {
private final Database db;
ReportService(Database db) { this.db = db; }
void run() { db.query("..."); }
}Inversion of Control
DI is a concrete technique for the broader principle of Inversion of Control (IoC): the flow of object creation is inverted away from the consumer.
The consumer no longer asks I will build my tools; instead it says give me what I need. A higher layer decides the wiring.
The Composition Root
All wiring happens in one place near the program entry point, called the composition root.
This is where concrete classes are finally chosen and assembled into the object graph.
public static void main(String[] args) {
Database db = new MySqlDatabase();
ReportService service = new ReportService(db);
service.run();
}DI vs Factory
They are complementary, not competitors:
- A Factory decides which concrete object to build at runtime.
- DI passes already-built objects into consumers.
A composition root often uses factories to produce the objects it then injects.
Setter and Method Injection
Two other forms exist for optional dependencies:
- Setter injection: a dependency is set after construction.
- Method injection: a dependency is passed to a single method call.
Prefer constructor injection for required collaborators; reserve these for truly optional ones.
class Logger { void log(String m) {} }
class Job {
private Logger logger;
void setLogger(Logger l) { this.logger = l; }
}DI Containers
Frameworks like Spring or Guice provide a DI container that auto-resolves the object graph based on registered types.
The container is your composition root, automated. But the principle is identical: construction is centralized and consumers stay clean.
Testability Benefit
Because dependencies are injected, tests can pass mocks or fakes directly.
class FakeDatabase implements Database {
public void query(String s) { /* record call */ }
}
// in test
ReportService s = new ReportService(new FakeDatabase());Avoiding the Service Locator Anti-Pattern
A tempting shortcut is a global service locator that classes call to fetch dependencies.
This hides dependencies again and reintroduces coupling. Prefer explicit injection so a class signature truthfully declares everything it needs.
Guidelines for Clean Construction
- Push
newto the composition root. - Depend on abstractions, inject implementations.
- Use constructor injection by default.
- Keep constructors free of logic; only assign fields.
Quick Check
Test your understanding of dependency injection.
Recap
You learned that Dependency Injection extends the creational toolkit by removing object construction from consumers.
- Constructor injection is the default form.
- Wiring lives in the composition root.
- DI complements factories and dramatically improves testability.
You now have a complete picture of creating objects cleanly.
常见问题解答
「将依赖注入作为创建型技术」课时是免费的吗？
是的 — 「将依赖注入作为创建型技术」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Clean Architecture & Design Patterns in Practice 课程的其余内容，请升级到 CoddyKit PRO。 Clean Architecture & Design Patterns in Practice 课程共包含 4 节课。
「将依赖注入作为创建型技术」这节课中我会学到什么？
学习依赖注入如何补充创建型模式，将对象构造移出使用者并集中到一个组合点中 你通过在浏览器中直接运行的动手代码来练习 Clean Architecture & Design Patterns in Practice，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Clean Architecture & Design Patterns in Practice 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Clean Architecture & Design Patterns in Practice 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。
「将依赖注入作为创建型技术」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Clean Architecture & Design Patterns in Practice 课中编写并运行代码吗？
能。每节 Clean Architecture & Design Patterns in Practice 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。