Wenn Sie den ersten Artikel nicht gelesen haben, lesen Sie diesen zuerst und fahren Sie mit diesem Artikel fort.

Gründungsartikel (Teil 1)

Warten Sie nicht auf Rest-APIs in der Android-App-Entwicklung

Wie im ersten Teil dieses Artikels erläutert, werden wir drei Modelle für jede Schicht verwenden

1. Data Transfer Object (DTO)-Modell – um mit den Antworten der API umzugehen
2. Entitätsmodell – um mit der lokalen Datenbank umzugehen
3. Domänenmodell – um mit der Geschäftsschicht umzugehen.

Lassen Sie uns das Benutzer-DTO-Datenmodell definieren.

data class UserDto(
    @SerializedName("id") val id: String,
    @SerializedName("firstName") val firstName: String?,
    @SerializedName("lastName") val lastName: String?,
    @SerializedName("phone") val phone: String?,
    @SerializedName("email") val email: String?
)

class UserDto

data class User(
    val id: String,
    val fullName: String,
    val phone: String,
    val email: String
)

abstract class Mapper<Domain, Dto, Entity> {

    // dto-domain mappings, mandatory to implement
    abstract fun dtoToDomain(dto: Dto): Domain
    abstract fun domainToDto(domain: Domain): Dto
    
    // dto-domain list mapping support
    fun dtoToDomain(dtoList: List<Dto>?): List<Domain> = (dtoList ?: emptyList()).map(::dtoToDomain)
    fun domainToDto(domainList: List<Domain>?): List<Dto> = (domainList?: emptyList()).map(::domainToDto)

    // entity-domain mappings, mandatory to implement
    open fun entityToDomain(entity: Entity): Domain =
        throw NotImplementedError("override and implement this method")
    open fun domainToEntity(domain: Domain): Entity =
        throw NotImplementedError("override and implement this method")

    // entity-domain list mapping support
    fun entityToDomain(domainList: List<Entity>): List<Domain> = domainList.map(::entityToDomain)
    fun domainToEntity(domainList: List<Domain>): List<Entity> = domainList.map(::domainToEntity)

    // entity-dto mappings, mandatory to implement
    open fun entityToDto(entity: Entity): Dto =
        throw NotImplementedError("override and implement this method")
    open fun dtoToEntity(dto: Dto): Entity =
        throw NotImplementedError("override and implement this method")

    // entity-dto list mapping support
    fun entityToDto(dtoList: List<Entity>): List<Dto> = dtoList.map(::entityToDto)
    fun dtoToEntity(dtoList: List<Dto>): List<Entity> = dtoList.map(::dtoToEntity)

}

class UserMapper: Mapper<User, UserDto, Unit>() {
    override fun dtoToDomain(dto: UserDto): User {
        TODO("Not yet implemented")
    }

    override fun domainToDto(domain: User): UserDto {
        TODO("Not yet implemented")
    }
}

1. Domäne – Der erste Domänenmodellparameter ist der Benutzer
2. DTO – Der zweite DTO-Modellparameter ist UserDto
3. DTO – Third Entity-Modellparameter ist die Einheit. Wenn Sie Daten in der lokalen Datenbank speichern möchten, können Sie den dritten Parameter als Entität betrachten

override fun dtoToDomain(dto: UserDto) = with(dto) {
    User(
        id = id,
        fullName =  "$firstName + $lastName",
        phone = phone ?: "",
        email = email ?: ""
    )
}

Ich weiß nichts über die API-Antwort, verspotte sie einfach im Mapping

override fun dtoToDomain(dto: UserDto) =
    User(
        id = "1",
        fullName = "Gautam Singh",
        phone = "xxxxxxxxxx",
        email = "[email protected]"
    )

Außerdem können Sie hier Dinge tun wie –

1. Formatieren Sie Ihre API-Daten in ein Domänenmodell um, da ich in meinem Geschäft nur den vollständigen Namen der Benutzer benötige, also verketten Sie firstName und secondName , um einen vollständigen Namen zu erstellen

fullName =  "$firstName + $lastName",

phone = phone ?: "",

Lassen Sie uns versuchen, diesen Mapper mit einem Anwendungsfall zu verwenden

Remote-Datenquelle für Benutzer

interface UserRemoteDataSource {
    suspend fun getUsers(): List<UserDto>
}

class GetAllUserUseCase(
    private val userMapper: UserMapper,
    private val remote: UserRemoteDataSource
) {

    suspend fun invoke(): List<User> = remote.getUsers().map(userMapper::dtoToDomain)

}

class UserListViewModel(getAllUserUseCase: GetAllUserUseCase) {
    
    fun users() {
        viewModelScope.launch {
            val users = getAllUserUseCase()
        }
    }

}

Kommentar für weitere Fragen, ich helfe Ihnen gerne weiter.