KotlinでのRetrofitとKotlinx.serializationを使った効率的なデータ処理の解説

dependencies {
    // Retrofitライブラリ
    implementation("com.squareup.retrofit2:retrofit:2.9.0")

    // Kotlin Coroutines用のアダプタ
    implementation("com.squareup.retrofit2:converter-kotlinx-serialization:0.8.0")

    // Kotlinx.serializationライブラリ
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
}

plugins {
    kotlin("plugin.serialization") version "1.9.0"
}

import retrofit2.Retrofit
import retrofit2.converter.kotlinx.serialization.asConverterFactory
import kotlinx.serialization.json.Json
import okhttp3.MediaType.Companion.toMediaType

// Retrofitインスタンスの作成
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/") // APIのベースURL
    .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
    .build()

import retrofit2.http.GET
import retrofit2.http.Path

interface ApiService {
    @GET("users/{id}")
    suspend fun getUserById(@Path("id") userId: String): User
}

import kotlinx.serialization.Serializable

@Serializable
data class User(
    val id: String,
    val name: String,
    val email: String
)

val apiService = retrofit.create(ApiService::class.java)

import kotlinx.coroutines.runBlocking

fun fetchUserDetails(userId: String) {
    runBlocking {
        try {
            val user = apiService.getUserById(userId)
            println("User Name: ${user.name}, Email: ${user.email}")
        } catch (e: Exception) {
            println("Error fetching user details: ${e.message}")
        }
    }
}

import kotlinx.serialization.json.Json

val jsonString = """
    {
        "id": "123",
        "name": "John Doe",
        "email": "john.doe@example.com"
    }
"""

val user: User = Json.decodeFromString(jsonString)
println("Name: ${user.name}, Email: ${user.email}")

val user = User(id = "123", name = "John Doe", email = "john.doe@example.com")
val jsonString = Json.encodeToString(user)
println(jsonString)

{"id":"123","name":"John Doe","email":"john.doe@example.com"}

val customJson = Json {
    ignoreUnknownKeys = true // 不明なキーを無視する
    prettyPrint = true       // JSONを整形して出力する
}

val user = customJson.decodeFromString<User>(jsonString)
println(user)

{
    "id": "123",
    "name": "John Doe",
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

@Serializable
data class Address(
    val city: String,
    val zip: String
)

@Serializable
data class UserWithAddress(
    val id: String,
    val name: String,
    val address: Address
)

suspend fun fetchUser(userId: String): User {
    return apiService.getUserById(userId)
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        val user = fetchUser("123")
        println("User Name: ${user.name}")
    } catch (e: Exception) {
        println("Error: ${e.message}")
    }
}

try {
    val user = apiService.getUserById("123")
    println("User: $user")
} catch (e: HttpException) {
    println("HTTP Error: ${e.code()}")
} catch (e: IOException) {
    println("Network Error: ${e.message}")
} catch (e: Exception) {
    println("Unexpected Error: ${e.message}")
}

val response = apiService.getUserByIdResponse("123")
if (response.isSuccessful) {
    val user = response.body()
    println("User: $user")
} else {
    println("API Error: ${response.errorBody()?.string()}")
}

import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit

val okHttpClient = OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .writeTimeout(10, TimeUnit.SECONDS)
    .build()

{
    "id": "123",
    "name": "John Doe",
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "zip": "10001"
    },
    "hobbies": ["Reading", "Cycling", "Gaming"]
}

@Serializable
data class Address(
    val street: String,
    val city: String,
    val zip: String
)

@Serializable
data class User(
    val id: String,
    val name: String,
    val address: Address,
    val hobbies: List<String>
)

@GET("users/{id}")
suspend fun getUserById(@Path("id") userId: String): User

suspend fun fetchAndPrintUserDetails(userId: String) {
    val user = apiService.getUserById(userId)
    println("Name: ${user.name}, City: ${user.address.city}")
    println("Hobbies: ${user.hobbies.joinToString()}")
}

[
    {
        "id": "1",
        "name": "Alice"
    },
    {
        "id": "2",
        "name": "Bob"
    }
]

@Serializable
data class SimpleUser(
    val id: String,
    val name: String
)

@GET("users")
suspend fun getUsers(): List<SimpleUser>

suspend fun fetchAndPrintUsers() {
    val users = apiService.getUsers()
    users.forEach { user ->
        println("ID: ${user.id}, Name: ${user.name}")
    }
}

@Serializable
data class UserResponse(
    val data: List<User>,
    val status: String
)

val jsonString = """
    {
        "data": [
            {"id": "1", "name": "Alice", "address": {"street": "123 St", "city": "NY", "zip": "10001"}, "hobbies": ["Music"]},
            {"id": "2", "name": "Bob", "address": {"street": "456 Rd", "city": "LA", "zip": "90001"}, "hobbies": ["Art"]}
        ],
        "status": "success"
    }
"""

val userResponse: UserResponse = Json.decodeFromString(jsonString)
println("Status: ${userResponse.status}")
userResponse.data.forEach { println(it) }

val okHttpClient = OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .writeTimeout(10, TimeUnit.SECONDS)
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(okHttpClient) // 同じOkHttpClientを使用
    .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
    .build()

val cacheSize = 10 * 1024 * 1024 // 10MB
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize)

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

val okHttpClient = OkHttpClient.Builder()
    .connectionPool(ConnectionPool(5, 5, TimeUnit.MINUTES))
    .build()

@Serializable
data class User(
    val id: String,
    val name: String
)

val optimizedJson = Json {
    ignoreUnknownKeys = true  // 不明なキーを無視
    isLenient = true          // 柔軟な解析を許可
    prettyPrint = false       // 整形出力を無効化
}

suspend fun fetchUserData(userId: String): User = withContext(Dispatchers.IO) {
    apiService.getUserById(userId)
}

suspend fun fetchUsersData(userIds: List<String>): List<User> = coroutineScope {
    userIds.map { userId ->
        async { apiService.getUserById(userId) }
    }.awaitAll()
}

import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer

val mockWebServer = MockWebServer()

fun setupMockServer() {
    mockWebServer.enqueue(
        MockResponse()
            .setBody("""{"id": "123", "name": "John Doe", "email": "john.doe@example.com"}""")
            .setResponseCode(200)
    )
    mockWebServer.start()
}

@Test
fun testGetUserById() = runBlocking {
    setupMockServer()
    val apiService = retrofit.create(ApiService::class.java)
    val user = apiService.getUserById("123")

    assertEquals("John Doe", user.name)
    assertEquals("john.doe@example.com", user.email)
    mockWebServer.shutdown()
}

import okhttp3.logging.HttpLoggingInterceptor

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

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

try {
    val user = Json.decodeFromString<User>("""{"id": "123", "name": "John Doe"}""")
} catch (e: Exception) {
    println("Serialization Error: ${e.message}")
}

mockWebServer.enqueue(
    MockResponse()
        .setResponseCode(404)
        .setBody("""{"error": "User not found"}""")
)