KotlinでDIを活用してマルチプラットフォームプロジェクトを構築する方法を徹底解説

KotlinでDependency Injection（DI）を活用したマルチプラットフォームプロジェクトの開発は、効率的で保守性の高いコードを構築するために非常に重要です。Kotlin Multiplatformを利用すれば、iOS、Android、Webといった複数のプラットフォーム向けに共通コードを書きつつ、各プラットフォーム固有の処理も適切に分離できます。

DIを導入することで、依存関係を明示的に管理し、コンポーネント間の結合度を下げることができます。これにより、テストが容易になり、システムの柔軟性や保守性が向上します。本記事では、Kotlin MultiplatformプロジェクトにDIを導入する方法について、具体的な手順やライブラリの選定、実装例、トラブルシューティングまで詳細に解説します。

Dependency Injection（DI）とは何か

Dependency Injection（DI）とは、ソフトウェア設計におけるパターンの一つで、コンポーネントやクラスが必要とする依存関係を外部から注入する仕組みです。依存関係を自動で管理することで、コードの再利用性、テスト容易性、保守性を向上させることができます。

DIの基本概念

DIでは、クラスが自身で依存関係を生成するのではなく、外部から依存オブジェクトを渡されます。例えば、データベースアクセスを行うクラスがある場合、そのクラスがデータベース接続を直接作成するのではなく、外部から接続オブジェクトを渡される形になります。

DIの利点

テストの容易さ
依存関係を外部から注入することで、テスト時にモックやスタブを簡単に置き換えることが可能です。
再利用性の向上
依存関係が疎結合になるため、コンポーネントを異なる場所で再利用しやすくなります。
保守性の向上
依存関係が明示的になることで、コードの変更が容易になります。

KotlinにおけるDIの活用例

Kotlinでは、KoinやDaggerといったDIライブラリが利用されます。これらのライブラリを使うことで、依存関係の定義と注入が効率的に行え、マルチプラットフォーム開発にも柔軟に対応できます。

DIを理解することで、Kotlinマルチプラットフォームプロジェクトのコード設計がよりクリーンで効率的になります。

Kotlin Multiplatformの概要

Kotlin Multiplatform（KMP）は、JetBrainsが提供する、複数のプラットフォーム（Android、iOS、Web、デスクトップなど）向けに共通のビジネスロジックを共有しつつ、プラットフォーム固有のコードを適切に分離できる仕組みです。Kotlinを使用することで、単一言語でクロスプラットフォーム開発が可能になります。

Kotlin Multiplatformの仕組み

Kotlin Multiplatformでは、以下の2種類のコードを使い分けます：

共通コード（Common Code）
ビジネスロジックやユーティリティ関数など、全プラットフォームで共通に使用するコードを記述します。
プラットフォーム固有コード（Platform-Specific Code）
Android、iOS、Webなどのプラットフォームごとに必要な固有の処理を記述します。

サポートされるプラットフォーム

Android：JVM向けのコードを利用します。
iOS：AppleのiOSネイティブコード（Objective-CやSwift）と統合できます。
Web：Kotlin/JSを利用してJavaScriptとして出力されます。
デスクトップ：Kotlin/Nativeを使用し、Windows、macOS、Linux向けのネイティブコードを生成します。

Kotlin Multiplatformのメリット

コード共有の効率化
ビジネスロジックを一度書けば、複数のプラットフォームで再利用できます。
保守性の向上
重複したコードが減るため、変更があっても一箇所の修正で済みます。
プラットフォーム固有の最適化
各プラットフォームに最適化されたUIやAPIを利用できます。

Kotlin Multiplatformを活用することで、効率的で柔軟なクロスプラットフォーム開発が実現可能になります。

DIライブラリの選定

KotlinでDependency Injection（DI）を導入する際には、適切なライブラリを選定することが重要です。Kotlin Multiplatformに対応したDIライブラリとしては、主にKoinとDaggerが人気です。それぞれの特徴と利点を理解し、プロジェクトに適したものを選びましょう。

Koin

Koinは、シンプルで学習コストが低いDIライブラリであり、Kotlin向けに設計されています。

特徴：

シンプルなDSL：宣言的に依存関係を定義できます。
リフレクション不要：リフレクションを使わず、ランタイムコストが低いです。
Kotlin Multiplatform対応：共通コードとプラットフォーム固有コードの両方で利用可能です。

サンプルコード：

val myModule = module {
    single { MyRepository() }
    factory { MyViewModel(get()) }
}

Dagger

Daggerは、Googleが提供する強力なDIライブラリで、Android開発で広く使用されています。

特徴：

コンパイル時依存解決：コンパイル時に依存関係が解決されるため、高速な実行が可能です。
コード生成：依存関係を自動でコード生成するため、リフレクションが不要です。
高度なカスタマイズ：複雑な依存関係にも対応できますが、学習コストが高めです。

サンプルコード：

@Component
interface AppComponent {
    void inject(MyActivity activity);
}

DIライブラリの比較

項目	Koin	Dagger
学習コスト	低い	高い
依存解決タイミング	ランタイム	コンパイル時
パフォーマンス	高速だがDaggerに劣る	非常に高速
Kotlin対応	Kotlinネイティブ	Java/Kotlin両方

選定ポイント

シンプルな構成や学習コストを重視する場合：Koinが適しています。
大規模プロジェクトやパフォーマンス重視の場合：Daggerが適しています。

プロジェクトの要件やチームのスキルセットに合わせて、最適なDIライブラリを選びましょう。

Koinを用いたDIの導入手順

Kotlin MultiplatformプロジェクトにKoinを導入してDependency Injection（DI）を実装する手順を解説します。KoinはシンプルなDSLで依存関係を定義でき、マルチプラットフォーム開発にも対応しています。

1. Koinの依存関係を追加

プロジェクトのbuild.gradle.ktsファイルにKoinの依存関係を追加します。

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("io.insert-koin:koin-core:3.4.0")
            }
        }
        val androidMain by getting {
            dependencies {
                implementation("io.insert-koin:koin-android:3.4.0")
            }
        }
        val iosMain by getting {
            dependencies {
                implementation("io.insert-koin:koin-core:3.4.0")
            }
        }
    }
}

2. Koinモジュールの作成

依存関係を定義するKoinモジュールを作成します。例えば、リポジトリとViewModelの依存関係を定義します。

// commonMain/src/commonMain/kotlin/di/AppModule.kt
import org.koin.dsl.module

val appModule = module {
    single { MyRepository() }
    factory { MyViewModel(get()) }
}

3. Koinの初期化

アプリケーションのエントリーポイントでKoinを初期化します。プラットフォームごとに初期化処理を行います。

Androidの場合：

// androidMain/src/main/kotlin/com/example/MainApplication.kt
import android.app.Application
import org.koin.core.context.startKoin

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            modules(appModule)
        }
    }
}

iOSの場合：

// iosMain/src/main/kotlin/IOSInitializer.kt
import org.koin.core.context.startKoin

fun initKoin() {
    startKoin {
        modules(appModule)
    }
}

4. 依存関係の注入

Koinを使って依存関係をViewModelに注入します。

// commonMain/src/commonMain/kotlin/MyViewModel.kt
class MyViewModel(private val repository: MyRepository) {
    fun getData() = repository.fetchData()
}

// commonMain/src/commonMain/kotlin/MyRepository.kt
class MyRepository {
    fun fetchData(): String = "Hello from Repository"
}

5. AndroidでのViewModelの利用

AndroidでViewModelを使用する場合の例です。

// androidMain/src/main/kotlin/com/example/MainActivity.kt
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import org.koin.android.ext.android.inject

class MainActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        println(viewModel.getData())
    }
}

6. iOSでのViewModelの利用

iOSでもViewModelを利用するためにSwiftからKotlinコードを呼び出します。

import SwiftUI
import shared

struct ContentView: View {
    let viewModel = MyViewModel(repository: MyRepository())

    var body: some View {
        Text(viewModel.getData())
    }
}

まとめ

Koinを導入することで、Kotlin Multiplatformプロジェクトにおいて依存関係をシンプルかつ効率的に管理できます。これにより、コードの保守性やテスト容易性が向上し、開発効率が大幅にアップします。

プラットフォーム別のDI設定方法

Kotlin Multiplatformプロジェクトでは、共通のビジネスロジックとプラットフォーム固有の処理を組み合わせて開発を進めます。Dependency Injection（DI）もプラットフォームごとに適切に設定する必要があります。ここでは、Android、iOS、そしてデスクトップ向けのDI設定方法を解説します。

共通コードでのDI設定

Kotlin Multiplatformプロジェクトの共通コードに依存関係を定義します。ビジネスロジックやリポジトリなど、共通で利用するクラスを含めます。

共通DIモジュールの例：

// commonMain/src/commonMain/kotlin/di/CommonModule.kt
import org.koin.dsl.module

val commonModule = module {
    single { MyRepository() }
    factory { MyViewModel(get()) }
}

Android固有のDI設定

Android固有の依存関係や、Android特有のコンポーネントをDIに追加します。

Androidモジュールの例：

// androidMain/src/main/kotlin/di/AndroidModule.kt
import org.koin.dsl.module

val androidModule = module {
    single { AndroidSpecificService() }
}

Koinの初期化：

// androidMain/src/main/kotlin/com/example/MainApplication.kt
import android.app.Application
import org.koin.core.context.startKoin

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            modules(commonModule, androidModule)
        }
    }
}

iOS固有のDI設定

iOS固有の依存関係やサービスをDIに追加します。

iOSモジュールの例：

// iosMain/src/main/kotlin/di/IOSModule.kt
import org.koin.dsl.module

val iosModule = module {
    single { IOSSpecificService() }
}

Koinの初期化：

// iosMain/src/main/kotlin/IOSInitializer.kt
import org.koin.core.context.startKoin

fun initKoin() {
    startKoin {
        modules(commonModule, iosModule)
    }
}

Swift側でKoinの初期化を呼び出します。

import shared

@main
struct iOSApp: App {
    init() {
        IOSInitializerKt.initKoin()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

デスクトップ固有のDI設定

デスクトップ向けの依存関係を設定する場合の例です。

デスクトップモジュールの例：

// jvmMain/src/main/kotlin/di/DesktopModule.kt
import org.koin.dsl.module

val desktopModule = module {
    single { DesktopSpecificService() }
}

Koinの初期化：

// jvmMain/src/main/kotlin/Main.kt
import org.koin.core.context.startKoin

fun main() {
    startKoin {
        modules(commonModule, desktopModule)
    }
}

依存関係のまとめ

プラットフォーム	初期化するモジュール
Android	`commonModule`, `androidModule`
iOS	`commonModule`, `iosModule`
デスクトップ	`commonModule`, `desktopModule`

まとめ

Kotlin Multiplatformプロジェクトでは、共通のDIモジュールに加えて、プラットフォーム固有の依存関係を適切に設定することで、効率的に依存関係を管理できます。これにより、各プラットフォームの特性を活かしつつ、重複したコードを削減し、保守性と拡張性を向上させることができます。

具体的なコード例と実装方法

Kotlin MultiplatformプロジェクトでKoinを用いてDependency Injection（DI）を実装する具体的なコード例を紹介します。ここでは、共通のビジネスロジックとプラットフォーム固有の処理を含めた形でのDIの利用方法を解説します。

1. 共通コードの作成

リポジトリクラスの作成：

// commonMain/src/commonMain/kotlin/repository/MyRepository.kt
class MyRepository {
    fun fetchData(): String = "Data fetched from MyRepository"
}

ViewModelの作成：

// commonMain/src/commonMain/kotlin/viewmodel/MyViewModel.kt
class MyViewModel(private val repository: MyRepository) {
    fun getData(): String = repository.fetchData()
}

共通DIモジュールの定義：

// commonMain/src/commonMain/kotlin/di/CommonModule.kt
import org.koin.dsl.module

val commonModule = module {
    single { MyRepository() }
    factory { MyViewModel(get()) }
}

2. Android固有の実装

Android固有のサービスクラス：

// androidMain/src/main/kotlin/service/AndroidService.kt
class AndroidService {
    fun getAndroidMessage(): String = "Hello from Android Service"
}

Android用DIモジュール：

// androidMain/src/main/kotlin/di/AndroidModule.kt
import org.koin.dsl.module

val androidModule = module {
    single { AndroidService() }
}

Koinの初期化：

// androidMain/src/main/kotlin/com/example/MainApplication.kt
import android.app.Application
import org.koin.core.context.startKoin

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            modules(commonModule, androidModule)
        }
    }
}

ActivityでのViewModel利用：

// androidMain/src/main/kotlin/com/example/MainActivity.kt
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import org.koin.android.ext.android.inject

class MainActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by inject()
    private val androidService: AndroidService by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        println(viewModel.getData())
        println(androidService.getAndroidMessage())
    }
}

3. iOS固有の実装

iOS固有のサービスクラス：

// iosMain/src/main/kotlin/service/IOSService.kt
class IOSService {
    fun getIOSMessage(): String = "Hello from iOS Service"
}

iOS用DIモジュール：

// iosMain/src/main/kotlin/di/IOSModule.kt
import org.koin.dsl.module

val iosModule = module {
    single { IOSService() }
}

Koinの初期化：

// iosMain/src/main/kotlin/IOSInitializer.kt
import org.koin.core.context.startKoin

fun initKoin() {
    startKoin {
        modules(commonModule, iosModule)
    }
}

SwiftでViewModelの利用：

import SwiftUI
import shared

struct ContentView: View {
    let viewModel = MyViewModel(repository: MyRepository())
    let iosService = IOSService()

    var body: some View {
        VStack {
            Text(viewModel.getData())
            Text(iosService.getIOSMessage())
        }
    }
}

4. デスクトップ固有の実装

デスクトップ固有のサービスクラス：

// jvmMain/src/main/kotlin/service/DesktopService.kt
class DesktopService {
    fun getDesktopMessage(): String = "Hello from Desktop Service"
}

デスクトップ用DIモジュール：

// jvmMain/src/main/kotlin/di/DesktopModule.kt
import org.koin.dsl.module

val desktopModule = module {
    single { DesktopService() }
}

Koinの初期化：

// jvmMain/src/main/kotlin/Main.kt
import org.koin.core.context.startKoin

fun main() {
    startKoin {
        modules(commonModule, desktopModule)
    }

    val viewModel: MyViewModel = get()
    val desktopService: DesktopService = get()

    println(viewModel.getData())
    println(desktopService.getDesktopMessage())
}

まとめ

このように、Kotlin Multiplatformプロジェクトでは、共通のビジネスロジックを中心にDIを設計し、各プラットフォームごとに固有の処理を追加することで効率的に依存関係を管理できます。Koinを活用することで、シンプルかつ柔軟なDIの導入が可能になり、保守性と拡張性が向上します。

テストと依存関係のモック化

Kotlin MultiplatformプロジェクトにおけるDependency Injection（DI）を活用したテスト手法と、依存関係をモック化する方法を解説します。DIを導入することで、ユニットテストがしやすくなり、テスト中に特定の依存関係を置き換える柔軟性が得られます。

1. テスト環境のセットアップ

まず、build.gradle.ktsにテストライブラリ（JUnitやMockK）を追加します。

kotlin {
    sourceSets {
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
                implementation("io.mockk:mockk-common:1.12.0")
            }
        }
    }
}

2. モックを用いた共通コードのテスト

例：MyRepositoryをモック化してMyViewModelのテストを行う。

// commonTest/src/commonTest/kotlin/MyViewModelTest.kt
import io.mockk.every
import io.mockk.mockk
import kotlin.test.Test
import kotlin.test.assertEquals

class MyViewModelTest {

    @Test
    fun `test getData returns mocked data`() {
        // モックの作成
        val mockRepository = mockk<MyRepository>()

        // モックの挙動を設定
        every { mockRepository.fetchData() } returns "Mocked Data"

        // ViewModelにモックを注入
        val viewModel = MyViewModel(mockRepository)

        // テスト実行
        val result = viewModel.getData()
        assertEquals("Mocked Data", result)
    }
}

3. プラットフォーム固有コードのテスト

プラットフォーム固有の依存関係も、モックを利用してテストします。

Android用のテスト：

// androidTest/src/androidTest/kotlin/MyAndroidServiceTest.kt
import androidx.test.ext.junit.runners.AndroidJUnit4
import io.mockk.every
import io.mockk.mockk
import org.junit.Test
import org.junit.runner.RunWith
import kotlin.test.assertEquals

@RunWith(AndroidJUnit4::class)
class MyAndroidServiceTest {

    @Test
    fun `test AndroidService returns mocked message`() {
        val mockService = mockk<AndroidService>()
        every { mockService.getAndroidMessage() } returns "Mocked Android Message"

        val result = mockService.getAndroidMessage()
        assertEquals("Mocked Android Message", result)
    }
}

4. テスト用DIモジュールの作成

テスト用のDIモジュールを作成し、依存関係をモックに置き換えます。

// commonTest/src/commonTest/kotlin/di/TestModule.kt
import org.koin.dsl.module
import io.mockk.mockk

val testModule = module {
    single { mockk<MyRepository>(relaxed = true) }
    factory { MyViewModel(get()) }
}

5. テストでKoinの初期化

Koinを初期化し、テストモジュールをロードする。

// commonTest/src/commonTest/kotlin/di/KoinTestSetup.kt
import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import kotlin.test.AfterTest
import kotlin.test.BeforeTest

open class KoinTestSetup {

    @BeforeTest
    fun setUp() {
        startKoin {
            modules(testModule)
        }
    }

    @AfterTest
    fun tearDown() {
        stopKoin()
    }
}

6. テストの実行

KoinTestSetupを継承してテストを実行します。

// commonTest/src/commonTest/kotlin/MyViewModelKoinTest.kt
import kotlin.test.Test
import kotlin.test.assertEquals

class MyViewModelKoinTest : KoinTestSetup() {

    private val viewModel: MyViewModel by inject()

    @Test
    fun `test ViewModel with injected mock repository`() {
        val result = viewModel.getData()
        assertEquals("Mocked Data", result)
    }
}

まとめ

Kotlin MultiplatformプロジェクトでDIを導入することで、テストが容易になり、依存関係を柔軟にモック化できます。KoinとMockKを組み合わせることで、共通コードおよびプラットフォーム固有コードの両方で効率的なユニットテストが実現します。これにより、品質の高いコードと保守性の向上が期待できます。

DI導入時のトラブルシューティング

Kotlin MultiplatformプロジェクトでDependency Injection（DI）を導入する際には、さまざまな問題に遭遇することがあります。ここでは、よくあるトラブルとその解決方法について解説します。

1. モジュールの依存関係が解決されない

問題：
DIで定義したモジュールの依存関係が正しく解決されず、No bean foundやMissing definitionといったエラーが発生します。

原因：

モジュールがKoinの初期化時に正しくロードされていない。
依存関係の定義に誤りがある。

解決方法：

Koinの初期化確認
Koinを初期化する際に、正しいモジュールが渡されているか確認します。

   startKoin {
       modules(commonModule, androidModule)
   }

依存関係の定義確認
モジュール内の依存関係の定義が正しいか確認します。

   val myModule = module {
       single { MyRepository() }
       factory { MyViewModel(get()) }
   }

2. ランタイム時の`ClassCastException`

問題：
ランタイム時に依存関係の型が合わず、ClassCastExceptionが発生します。

原因：

間違った型で依存関係を取得しようとしている。
依存関係の定義が異なる型になっている。

解決方法：

型の確認
依存関係を取得する際、正しい型で取得しているか確認します。

   val myRepository: MyRepository by inject()

依存定義の確認
モジュールで定義している型と、実際に取得する型が一致しているか確認します。

3. iOSでのKoin初期化エラー

問題：
iOS側でKoinの初期化時にエラーが発生する。

原因：

iOS固有モジュールが正しくロードされていない。
Kotlin/NativeでKoinの依存解決がうまく働いていない。

解決方法：

iOS初期化コードの確認

   fun initKoin() {
       startKoin {
           modules(commonModule, iosModule)
       }
   }

Swift側でKoin初期化を呼び出し

   import shared

   @main
   struct iOSApp: App {
       init() {
           IOSInitializerKt.initKoin()
       }

       var body: some Scene {
           WindowGroup {
               ContentView()
           }
       }
   }

4. プラットフォーム固有の依存関係の競合

問題：
AndroidやiOSでプラットフォーム固有の依存関係が競合し、エラーが発生する。

原因：

同じ名前の依存関係が複数のプラットフォームで定義されている。
共通コードと固有コードの依存が干渉している。

解決方法：

依存関係を明示的に分ける
プラットフォーム固有のモジュールと共通モジュールを明確に分けます。

   val androidModule = module {
       single { AndroidService() }
   }

   val iosModule = module {
       single { IOSService() }
   }

プラットフォームごとの初期化
各プラットフォームで適切なモジュールを初期化します。

5. テスト時にモックが正しく注入されない

問題：
テスト時に依存関係のモックが正しく注入されず、テストが失敗する。

原因：

テストモジュールが正しくロードされていない。
モックの設定が不完全。

解決方法：

テスト用モジュールの確認

   val testModule = module {
       single { mockk<MyRepository>(relaxed = true) }
   }

Koinの初期化と終了処理

   @BeforeTest
   fun setUp() {
       startKoin { modules(testModule) }
   }

   @AfterTest
   fun tearDown() {
       stopKoin()
   }

まとめ

Kotlin MultiplatformプロジェクトでDIを導入する際に発生する問題は、依存関係の定義やモジュールの初期化が主な原因です。正しい初期化手順や依存関係の型の確認、テスト環境の設定を行うことで、多くのトラブルを解決できます。問題が発生した場合は、ここで紹介したトラブルシューティングの手順を参考に、問題解決に役立ててください。

まとめ

本記事では、Kotlin MultiplatformプロジェクトにおけるDependency Injection（DI）の導入方法について解説しました。DIの基本概念から始まり、Koinを用いた具体的な実装手順、プラットフォーム別のDI設定、テストと依存関係のモック化、さらにトラブルシューティングまで詳しく紹介しました。

Koinを活用することで、共通コードとプラットフォーム固有コードを効率的に管理でき、保守性やテスト容易性が向上します。DIを適切に導入することで、依存関係の明確化、コードの再利用、そして開発効率の向上が期待できます。Kotlin MultiplatformとDIを組み合わせ、クロスプラットフォーム開発をより効果的に進めましょう。

KotlinでDIを活用してマルチプラットフォームプロジェクトを構築する方法を徹底解説

Dependency Injection（DI）とは何か

DIの基本概念

DIの利点

KotlinにおけるDIの活用例

Kotlin Multiplatformの概要

Kotlin Multiplatformの仕組み

サポートされるプラットフォーム

Kotlin Multiplatformのメリット

DIライブラリの選定

Koin

Dagger

DIライブラリの比較

選定ポイント

Koinを用いたDIの導入手順

1. Koinの依存関係を追加

2. Koinモジュールの作成

3. Koinの初期化

4. 依存関係の注入

5. AndroidでのViewModelの利用

6. iOSでのViewModelの利用

まとめ

プラットフォーム別のDI設定方法

共通コードでのDI設定

Android固有のDI設定

iOS固有のDI設定

デスクトップ固有のDI設定

依存関係のまとめ

まとめ

具体的なコード例と実装方法

1. 共通コードの作成

2. Android固有の実装

3. iOS固有の実装

4. デスクトップ固有の実装

まとめ

テストと依存関係のモック化

1. テスト環境のセットアップ

2. モックを用いた共通コードのテスト

3. プラットフォーム固有コードのテスト

4. テスト用DIモジュールの作成

5. テストでKoinの初期化

6. テストの実行

まとめ

DI導入時のトラブルシューティング

1. モジュールの依存関係が解決されない

2. ランタイム時の`ClassCastException`

3. iOSでのKoin初期化エラー

4. プラットフォーム固有の依存関係の競合

5. テスト時にモックが正しく注入されない

まとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル