0Pricing
Swift Academy · Pelajaran

Inversi Dependensi dengan Abstraksi Protokol

Bergantung pada abstraksi, bukan perwujudan konkret, dengan protokol Swift sebagai batas.

Inversi Dependensi dengan Abstraksi Protokol adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 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 Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Prinsip Pembalikan Dependensi

Modul tingkat tinggi tidak boleh bergantung pada modul tingkat rendah. Keduanya harus bergantung pada abstraksi (protokol).

// WITHOUT DIP:
class OrderService { let db = SQLiteDatabase() }  // depends on concrete
// WITH DIP:
class OrderService { let db: Database }  // depends on abstraction

Mendefinisikan Abstraksi

Ekstrak sebuah protokol yang memuat kontrak yang dibutuhkan modul tingkat tinggi Anda.

protocol Database {
  func save<T: Encodable>(_ value: T, key: String) throws
  func load<T: Decodable>(key: String) throws -> T
}

Implementasi Konkret

Sediakan beberapa implementasi konkret di balik protokol tersebut: untuk produksi, pengujian, dan alternatif di masa mendatang.

class SQLiteDatabase: Database { ... }
class InMemoryDatabase: Database { ... }
class KeychainDatabase: Database { ... }

Injeksi Konstruktor

Teruskan abstraksi melalui penginisialisasi—gaya injeksi yang paling eksplisit dan mudah diuji.

class ProfileService {
  private let db: Database
  init(db: Database) { self.db = db }
}

Mengapa Tidak Menggunakan Singleton untuk Semua Hal?

Singleton global menyembunyikan dependensi, sehingga kode sulit diuji dan dianalisis.

// Hard to test:
class Service { func run() { MySingleton.shared.doWork() } }
// Easy to test:
class Service { let dep: MyProtocol; func run() { dep.doWork() } }

Abstraksi Protokol di Swift

Protokol Swift dapat memuat tipe terkait, implementasi bawaan, dan komposisi—ideal untuk abstraksi yang kaya.

protocol Cacheable {
  associatedtype Key: Hashable
  associatedtype Value
  func get(_ key: Key) -> Value?
  func set(_ key: Key, value: Value)
}

Granularitas Abstraksi

Pemisahan Antarmuka: utamakan protokol yang sempit daripada protokol yang gemuk, sehingga implementasi hanya menyediakan hal yang dibutuhkan pemanggil.

// Fat (avoid):
protocol DataStore {
  func save(...); func load(...); func delete(...); func query(...); func migrate()
}
// Narrow (prefer):
protocol Readable { func load<T>(...) throws -> T }
protocol Writable { func save<T>(...) throws }

DIP dengan Combine

Kembalikan AnyPublisher dari metode protokol agar tipe penerbit yang mendasarinya tetap tersembunyi.

protocol UserStream {
  func userUpdates() -> AnyPublisher<User, Never>
}

DIP dengan async/await

Metode protokol yang ditandai async throws sepenuhnya kompatibel dengan konkurensi terstruktur Swift.

protocol Analytics {
  func track(event: String) async
}
struct FirebaseAnalytics: Analytics {
  func track(event: String) async { /* Firebase call */ }
}

DIP di Tingkat Aplikasi

Hubungkan implementasi konkret di titik masuk aplikasi (Akar Komposisi), sehingga semua pengikatan tetap berada di satu tempat.

@main
struct MyApp: App {
  let db: Database = SQLiteDatabase()
  let repo: UserRepository = RemoteUserRepository(db: db)
  let useCase = FetchUserUseCase(repo: repo)
  var body: some Scene {
    WindowGroup { ContentView(useCase: useCase) }
  }
}

Pengujian dengan DIP

Dalam pengujian, ganti implementasi nyata dengan objek tiruan/pengganti di titik injeksi.

let mockDB = InMemoryDatabase()
let service = ProfileService(db: mockDB)
// Exercise service
XCTAssertEqual(try mockDB.load(key: "profile"), expectedProfile)

Pemeriksaan Singkat

Apa yang dinyatakan oleh Prinsip Pembalikan Dependensi tentang modul tingkat tinggi?

Ringkasan Pelajaran

DIP: modul tingkat tinggi bergantung pada abstraksi protokol; tipe konkret mengimplementasikannya. Ekstrak protokol yang sempit, lakukan injeksi melalui konstruktor, dan hubungkan semuanya di Akar Komposisi. Hal ini memungkinkan penggantian implementasi untuk pengujian, penggunaan tanda fitur, dan kebutuhan di masa mendatang.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Inversi Dependensi dengan Abstraksi Protokol” gratis?

Ya — teks lengkap “Inversi Dependensi dengan Abstraksi Protokol” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Inversi Dependensi dengan Abstraksi Protokol”?

Bergantung pada abstraksi, bukan perwujudan konkret, dengan protokol Swift sebagai batas. Kamu berlatih Swift Academy 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 Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy 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 3 dari 4.

Berapa lama pelajaran “Inversi Dependensi dengan Abstraksi Protokol” 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 Swift Academy ini?

Ya. Setiap pelajaran Swift Academy 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. Lapisan: Domain, Data, dan Presentasi
  2. Pola Use Case dan Repositori
  3. Inversi Dependensi dengan Abstraksi Protokol
  4. Menghubungkan Lapisan tanpa Framework DI
← Kembali ke Swift Academy