Kotlin 将类映射到一起时处理类中null类型的最佳实践

我使用的是Kotlin 1.30。我有以下将从API填充的实体类。API中的一些属性可能为null，因此我使用安全null类型声明了它们

但是，我将把这个实体类映射到我的域模型类。想知道处理空类型的最佳方法是什么

当我映射类时，我有两个关于如何做到这一点的想法

将所有等效属性声明为安全的null类型

使用elivs运算符返回空字符串或空列表

在下面的代码片段中，我使用的是elvis运算符。只是想知道这方面的最佳实践是什么

class LoginResponseDomainMapperImp : LoginResponseDomainMapper {
    override fun map(entity: LoginResponseEntity): LoginResponse {
        return LoginResponse(
            entity.token ?: "",
            mapUsers(entity.user),
            mapEnterprises(entity.enterprises ?: emptyList()),
            mapVendors(entity.vendors ?: emptyList()))
    }

    private fun mapUsers(userEntity: UserEntity?): User {
        return User(
            userEntity?.id,
            userEntity?.email,
            userEntity?.firstName,
            userEntity?.lastName,
            userEntity?.phone,
            userEntity?.address,
            userEntity?.dob,
            userEntity?.customer,
            userEntity?.enterpriseIds ?: emptyList(),
            userEntity?.vendorIds ?: emptyList())
    }

    private fun mapEnterprises(enterprisesEntity: List<EnterprisesEntity>): List<Enterprises> {
        val enterpriseList = mutableListOf<Enterprises>()

        enterprisesEntity.forEach {
            val enterprise = Enterprises(
                it.id,
                it.enterpriseName,
                it.typeLabel,
                it.country,
                it.imageId,
                it.managers,
                it.members,
                it.stripe,
                it.locations)

            enterpriseList.add(enterprise)
        }

        return enterpriseList.toList()
    }

    private fun mapVendors(vendorsEntity: List<VendorsEntity>): List<Vendors> {
        val vendorList = mutableListOf<Vendors>()

        vendorsEntity.forEach {
            val vendor = Vendors(
                it.id,
                it.vendorName,
                it.typeLabel,
                it.userRole,
                it.latitude,
                it.longitude,
                it.partner,
                it.country,
                it.imageId,
                it.stripe)

            vendorList.add(vendor)
        }

        return vendorList.toList()
    }
}

类LoginResponseDomainMapper导入：LoginResponseDomainMapper{
覆盖趣味地图（实体：LoginResponseEntity）：LoginResponse{
返回登录应答(
entity.token？：“”，
mapUsers（entity.user），
mapEnterprises（entity.enterprises？：emptyList（）），
mapVendors（entity.vendors？：emptyList（））
}
private fun mapUsers（用户实体：用户实体？）：用户{
返回用户(
userEntity？.id，
用户实体？电子邮件，
userEntity？.firstName，
userEntity？.lastName，
用户实体？，电话，
用户实体？地址，
用户实体？.dob，
用户实体？.customer，
userEntity？.enterpriseIds？：emptyList（），
userEntity？.vendorIds？：emptyList（））
}
私营企业（企业实体：列表）：列表{
val enterpriseList=mutableListOf（）
企业实体{
val企业=企业(
it.id，
它是企业名称，
it.typeLabel，
它是一个国家，
it.imageId，
it经理，
各位议员，
它，条纹，
资讯科技(网址)
enterpriseList.add（企业）
}
return enterpriseList.toList（）
}
私人趣味地图供应商（供应商实体：列表）：列表{
val vendorList=mutableListOf（）
vendorsEntity.forEach{
val供应商=供应商(
it.id，
它叫vendorName，
it.typeLabel，
it.userRole，
它，纬度，
它，经度，
它，伙伴，
它是一个国家，
it.imageId，
它（条纹）
供应商列表。添加（供应商）
}
return vendorList.toList（）
}
}

将从API填充的实体类，因此其中任何一个都可以为null

data class LoginResponseEntity(
    @SerializedName("token") val token: String?,
    @SerializedName("user") val user: UserEntity?,
    @SerializedName("enterprises") val enterprises: List<EnterprisesEntity>?,
    @SerializedName("vendors") val vendors: List<VendorsEntity>?)

data class UserEntity(
    @SerializedName("id") val id: String?,
    @SerializedName("email") val email: String?,
    @SerializedName("first_name") val firstName: String?,
    @SerializedName("last_name") val lastName: String?,
    @SerializedName("phone") val phone: String?,
    @SerializedName("address") val address: String?,
    @SerializedName("dob") val dob: String?,
    @SerializedName("customer") val customer: String?,
    @SerializedName("enterprise_ids") val enterpriseIds: List<String>?,
    @SerializedName("vendor_ids") val vendorIds: List<String>?)

data class EnterprisesEntity(
    @SerializedName("id") val id: String?,
    @SerializedName("enterprise_name") val enterpriseName: String?,
    @SerializedName("type_label") val typeLabel: String?,
    @SerializedName("referral_code") val referralCode: String?,
    @SerializedName("country") val country: String?,
    @SerializedName("image_id") val imageId: String?,
    @SerializedName("managers") val managers: List<String>?,
    @SerializedName("members") val members: List<String>?,
    @SerializedName("stripe") val stripe: Boolean,
    @SerializedName("locations") val locations: List<String>?)

data class VendorsEntity(
    @SerializedName("id") val id: String?,
    @SerializedName("vendor_name") val vendorName: String?,
    @SerializedName("type_label") val typeLabel: String?,
    @SerializedName("user_role") val userRole: String?,
    @SerializedName("latitude") val latitude: Float,
    @SerializedName("longitude") val longitude: Float,
    @SerializedName("partner") val partner: Boolean,
    @SerializedName("country") val country: String?,
    @SerializedName("image_id") val imageId: String?,
    @SerializedName("stripe") val stripe: Boolean)

数据类登录响应实体(
@SerializedName（“标记”）val标记：字符串？，
@SerializedName（“用户”）val用户：UserEntity？，
@SerializedName（“企业”）val企业：列表？，
@序列化名称（“供应商”）val供应商：列表？）
数据类用户实体(
@SerializedName（“id”）val id:字符串？，
@SerializedName（“电子邮件”）val电子邮件：字符串？，
@SerializedName（“名字”）val firstName:字符串？，
@SerializedName（“姓氏”）val lastName:String？，
@SerializedName（“电话”）val电话：字符串？，
@SerializedName（“地址”）val地址：字符串？，
@SerializedName（“dob”）val dob:字符串？，
@SerializedName（“客户”）val客户：字符串？，
@SerializedName（“企业ID”）val EnterpriseID:列表？，
@SerializedName（“供应商标识”）val vendorIds:List？）
数据类企业实体(
@SerializedName（“id”）val id:字符串？，
@SerializedName（“企业名称”）val enterpriseName:String？，
@SerializedName（“类型标签”）val类型标签：字符串？，
@SerializedName（“参考代码”）val参考代码：字符串？，
@SerializedName（“国家”）值国家：字符串？，
@SerializedName（“image_id”）val imageId:字符串？，
@SerializedName（“管理者”）val管理者：列表？，
@SerializedName（“成员”）val成员：列表？，
@SerializedName（“stripe”）val stripe:Boolean，
@序列化名称（“位置”）val位置：列表？）
数据类实体(
@SerializedName（“id”）val id:字符串？，
@SerializedName（“供应商名称”）val vendorName:字符串？，
@SerializedName（“类型标签”）val类型标签：字符串？，
@SerializedName（“用户角色”）val userRole:字符串？，
@SerializedName（“纬度”）值纬度：浮点，
@SerializedName（“经度”）val经度：浮点，
@SerializedName（“合作伙伴”）val合作伙伴：布尔，
@SerializedName（“国家”）值国家：字符串？，
@SerializedName（“image_id”）val imageId:字符串？，
@SerializedName（“条带”）val条带：布尔值）

域中的数据模型类，最好将它们都声明为安全的空类型

data class LoginResponse(
    val token: String,
    val user: User?,
    val enterprises: List<Enterprises>,
    val vendors: List<Vendors>)

data class User(
    val id: String?,
    val email: String?,
    val firstName: String?,
    val lastName: String?,
    val phone: String?,
    val address: String?,
    val dob: String?,
    val customer: String?,
    val enterpriseIds: List<String>,
    val vendorIds: List<String>)

data class Enterprises(
    val id: String,
    val enterpriseName: String,
    val typeLabel: String,
    val country: String,
    val imageId: String,
    val managers: List<String>,
    val members: List<String>,
    val stripe: Boolean,
    val locations: List<String>)

data class Vendors(
    val id: String,
    val vendorName: String,
    val typeLabel: String?,
    val userRole: String,
    val latitude: Float,
    val longitude: Float,
    val partner: Boolean,
    val country: String?,
    val imageId: String,
    val stripe: Boolean)

数据类登录响应(
val令牌：字符串，
val用户：用户？，
val企业：名单，
val供应商：列表）
数据类用户(
val id:字符串？，
val电子邮件：字符串？，
val firstName:字符串？，
val lastName:字符串？，
val电话：字符串？，
val地址：字符串？，
val dob:字符串？，
val客户：字符串？，
val enterpriseIds：列表，
val vendorIds：列表）
数据类企业(
valid:String，
val enterpriseName:字符串，
val类型标签：字符串，
瓦尔国家：字符串，
val imageId:字符串，
val经理：列表，
val成员：名单，
val stripe:Boolean，
val位置：列表）
数据类供应商(
valid:String，
val vendorName:String，
val类型标签：字符串？，
val userRole:String，
瓦尔纬度：浮动，
经度：浮动，
val合作伙伴：布尔，
val国家/地区：字符串？，
val imageId:字符串，
val条带：布尔值）

如果将所有属性声明为

可空

，这并不比

Java

好多少，即使使用空安全操作符访问它们也是如此。如果您的JSON属性有

null

值，这意味着在您的业务逻辑中，它们并不总是有值，这是您的责任