KotlinでDIを活用したAPIクライアント設計ガイド

implementation "io.insert-koin:koin-core:3.x.x"
implementation "io.insert-koin:koin-android:3.x.x" // Androidプロジェクトの場合

val appModule = module {
    single { OkHttpClient() }
    single { Retrofit.Builder().baseUrl("https://api.example.com").build() }
    single { ApiService(get()) }
}

startKoin {
    modules(appModule)
}

class ApiClient(private val apiService: ApiService) {
    fun fetchData() {
        // API通信ロジック
    }
}

kapt "com.google.dagger:dagger-compiler:2.x"
implementation "com.google.dagger:dagger:2.x"

@Module
class NetworkModule {
    @Provides
    fun provideOkHttpClient(): OkHttpClient = OkHttpClient()

    @Provides
    fun provideRetrofit(client: OkHttpClient): Retrofit =
        Retrofit.Builder().baseUrl("https://api.example.com").client(client).build()
}

@Component(modules = [NetworkModule::class])
interface AppComponent {
    fun inject(target: ApiClient)
}

class NetworkModule {
    fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder().build()

    fun provideRetrofit(baseUrl: String, client: OkHttpClient): Retrofit =
        Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
}

interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

class ApiClient(private val apiService: ApiService) {
    suspend fun fetchUsers(): List<User> {
        return apiService.getUsers()
    }
}

val appModule = module {
    single { NetworkModule().provideOkHttpClient() }
    single { NetworkModule().provideRetrofit("https://api.example.com", get()) }
    single { get<Retrofit>().create(ApiService::class.java) }
    single { ApiClient(get()) }
}

@Module
class NetworkModule {
    @Provides
    fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder().build()

    @Provides
    fun provideRetrofit(client: OkHttpClient): Retrofit =
        Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
}

@Component(modules = [NetworkModule::class])
interface AppComponent {
    fun inject(client: ApiClient)
}

class MockApiService : ApiService {
    override suspend fun getUsers(): List<User> {
        return listOf(User("John Doe"), User("Jane Smith"))
    }
}

class ApiClient(private val apiService: ApiService) {
    suspend fun fetchUsers(): Result<List<User>> {
        return try {
            val response = apiService.getUsers()
            Result.success(response)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

suspend fun fetchUsers(): Result<List<User>> {
    return try {
        val response = apiService.getUsers()
        Result.success(response)
    } catch (e: IOException) {
        Result.failure(NetworkException("ネットワークエラーが発生しました", e))
    } catch (e: HttpException) {
        Result.failure(HttpException("HTTPエラーが発生しました: ${e.code()}", e))
    } catch (e: JsonParseException) {
        Result.failure(DataParsingException("データパースエラーが発生しました", e))
    } catch (e: Exception) {
        Result.failure(e) // 一般的なエラー処理
    }
}

suspend fun <T> retryOnFailure(times: Int, block: suspend () -> T): T {
    repeat(times - 1) {
        try {
            return block()
        } catch (e: Exception) {
            // リトライ処理
        }
    }
    return block() // 最後の試行
}

class ErrorHandler {
    fun handle(e: Exception): String {
        return when (e) {
            is NetworkException -> "ネットワークエラーが発生しました"
            is HttpException -> "サーバーエラー: ${e.message}"
            else -> "不明なエラーが発生しました"
        }
    }
}

val errorHandlerModule = module {
    single { ErrorHandler() }
}

class ApiClient(
    private val apiService: ApiService,
    private val errorHandler: ErrorHandler
) {
    suspend fun fetchUsers(): String {
        return try {
            val users = apiService.getUsers()
            "成功: ${users.size}人のユーザーを取得しました"
        } catch (e: Exception) {
            errorHandler.handle(e)
        }
    }
}

val mockApiService = mockk<ApiService>()

every { mockApiService.getUsers() } returns listOf(User("Test User"))

@Test
fun `fetchUsers should return user list`() = runBlocking {
    // Arrange
    val apiClient = ApiClient(mockApiService)

    // Act
    val result = apiClient.fetchUsers()

    // Assert
    assertEquals(Result.success(listOf(User("Test User"))), result)
}

val testModule = module {
    single<ApiService> { MockApiService() }
    single { ApiClient(get()) }
}

@Test
fun `fetchUsers should return mocked data`() = runBlocking {
    startKoin {
        modules(testModule)
    }

    // Get the injected ApiClient
    val apiClient: ApiClient = get()

    val result = apiClient.fetchUsers()
    assertEquals("成功: 1人のユーザーを取得しました", result)
}

interface UserService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

interface PostService {
    @GET("posts")
    suspend fun getPosts(): List<Post>
}

class ApiClient(
    private val retrofit: Retrofit
) {
    inline fun <reified T> createService(): T {
        return retrofit.create(T::class.java)
    }
}

val apiModule = module {
    single { OkHttpClient() }
    single {
        Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .client(get())
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
    single { ApiClient(get()) }
    factory { get<ApiClient>().createService<UserService>() }
    factory { get<ApiClient>().createService<PostService>() }
}

val userService: UserService by inject()
val postService: PostService by inject()

interface CommentService {
    @GET("comments")
    suspend fun getComments(): List<Comment>
}

factory { get<ApiClient>().createService<CommentService>() }

val commentService: CommentService by inject()
val comments = commentService.getComments()

val appModule = module {
    single { OkHttpClient() }
    single { Retrofit.Builder().baseUrl("https://api.example.com").client(get()).build() }
    factory { get<Retrofit>().create(ApiService::class.java) }
}

@Module
class ApiModule {
    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

suspend fun fetchUserData(): Pair<List<User>, List<Post>> = coroutineScope {
    val usersDeferred = async { apiService.getUsers() }
    val postsDeferred = async { apiService.getPosts() }

    Pair(usersDeferred.await(), postsDeferred.await())
}

val cache = Cache(File("cache_dir"), 10L * 1024 * 1024) // 10MBキャッシュ

val okHttpClient = OkHttpClient.Builder()
    .cache(cache)
    .build()

val networkModule = module {
    single { Cache(File("cache_dir"), 10L * 1024 * 1024) }
    single { OkHttpClient.Builder().cache(get()).build() }
}

suspend fun <T> retryOnFailure(times: Int, block: suspend () -> T): T {
    repeat(times - 1) {
        try {
            return block()
        } catch (e: Exception) {
            // リトライ処理
        }
    }
    return block()
}

val loggingInterceptor = HttpLoggingInterceptor().apply {
    level = HttpLoggingInterceptor.Level.BODY
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(loggingInterceptor)
    .build()