PricingLoginStart free
Clean Architecture & Design Patterns in Practice · Pelajaran

Injeksi Dependensi sebagai Teknik Pembuatan

Pelajari cara injeksi dependensi melengkapi pattern pembuatan dengan memindahkan konstruksi objek dari pengguna ke titik komposisi terpusat.

Pelajaran 4 dari 413 langkah

Injeksi Dependensi sebagai Teknik Pembuatan adalah pelajaran Clean Architecture & Design Patterns in Practice gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Clean Architecture & Design Patterns in Practice, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Clean Architecture & Design Patterns in Practice mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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 final and 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 new to 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.

Jawab di pelajaran interaktif

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.

Gratis untuk memulai

Belajar Clean Architecture & Design Patterns in Practice dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
12
Pelajaran
48
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Injeksi Dependensi sebagai Teknik Pembuatan” gratis?

Ya — teks lengkap “Injeksi Dependensi sebagai Teknik Pembuatan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Clean Architecture & Design Patterns in Practice, upgrade ke CoddyKit PRO. Kursus Clean Architecture & Design Patterns in Practice mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Injeksi Dependensi sebagai Teknik Pembuatan”?

Pelajari cara injeksi dependensi melengkapi pattern pembuatan dengan memindahkan konstruksi objek dari pengguna ke titik komposisi terpusat. Kamu berlatih Clean Architecture & Design Patterns in Practice dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Clean Architecture & Design Patterns in Practice?

Tidak diperlukan pengalaman sebelumnya. Clean Architecture & Design Patterns in Practice di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Injeksi Dependensi sebagai Teknik Pembuatan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Clean Architecture & Design Patterns in Practice ini?

Ya. Setiap pelajaran Clean Architecture & Design Patterns in Practice menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Singleton dan Metode Pabrik
  2. Pabrik Abstrak dan Pembuat
  3. Prototipe dan Kumpulan Objek
  4. Injeksi Dependensi sebagai Teknik Pembuatan
← Kembali ke Clean Architecture & Design Patterns in Practice