Definir un modelo de objeto de reino - SDK de Kotlin

Objetos del reino

Losobjetos de reino son instancias con nombres únicos de clases Kotlin con las que puedes trabajar como lo harías con cualquier otra instancia de clase.

Cada clase de objeto representa un tipo de objeto. Los objetos del mismo tipo comparten un esquema de objeto, que define sus propiedades y relaciones. El SDK garantiza que todos los objetos de un dominio se ajusten al esquema de su tipo y valida los objetos al crearlos, modificarlos o eliminarlos.

Sin embargo, tenga en cuenta que los objetos Realm tienen las siguientes restricciones:

• Los objetos del reino deben heredar del RealmObject Clase o sus subclases: EmbeddedRealmObject AsymmetricRealmObjecto. El SDK de Kotlin no admite la herencia de clases base personalizadas.

• El SDK de Kotlin requiere que los objetos Realm tengan un constructor vacío. Consulte El ejemplo de solución alternativa se detalla en la siguiente sección.

• Los nombres de clase están limitados a un máximo de 57 caracteres UTF-8.

Además, el SDK de Kotlin no admite el uso de clases de datos deKotlin. Para modelar datos. Esto se debe a que las clases de datos se suelen usar para datos inmutables, lo cual contradice la forma en que el SDK de Kotlin de Realm modela los datos.

Definir un nuevo tipo de objeto

Para definir un nuevo tipo de objeto Realm, debes crear una clase Kotlin con un nombre único que implementar la interfaz RealmObject, EmbeddedRealmObject o AsymmetricRealmObject.

Luego, especifica las propiedades de tu objeto, incluyendo:

• El tipo de dato para cada propiedad. El Kotlin SDK admite los siguientes tipos de datos:

  • Tipos primitivos de Kotlin

  • un subconjunto limitado de tipos BSON

  • Tipos específicos del reino, que puede utilizar para identificadores únicos, marcas de tiempo, contadores y colecciones

• Cualquier anotación de propiedad que añada funcionalidad a las propiedades de los objetos de Realm. Puedes usar anotaciones para:

  • Designar una propiedad como clave principal

  • Marcar una propiedad como indexable

  • Ignorar una propiedad

  • Asignar un nombre de propiedad o clase a otro nombre

• Cualquier relación con otros objetos de Realm.

Una vez que haya definido su modelo de objeto Realm, puede pasar el conjunto de clases de objeto a la configuración del reino cuando abre un reino y luego trabajar con esos objetos en el reino.

class Person(var name: String, var age: Int): RealmObject {
   constructor(): this("", 0) // Empty constructor required by Realm
}

// Implements the `RealmObject` interface
class Frog : RealmObject { // Empty constructor required by Realm
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int = 0
    var species: String? = null
    var owner: String? = null
}

// Implements `EmbeddedRealmObject` interface
class EmbeddedAddress : EmbeddedRealmObject {
    // CANNOT have primary key
    var street: String? = null
    var city: String? = null
    var state: String? = null
    var postalCode: String? = null
    var propertyOwner: Contact? = null
}

// Implements the `AsymmetricRealmObject` interface
class WeatherSensor : AsymmetricRealmObject {
    @PersistedName("_id")
    @PrimaryKey
    var id: ObjectId = ObjectId()
    var deviceId: String = ""
    var temperatureInFarenheit: Float = 0.0F
    var barometricPressureInHg: Float = 0.0F
    var windSpeedInMph: Int = 0
}

Definir propiedades de colección

Una colección es un objeto que contiene cero o más instancias de un tipo de dato compatible. Las colecciones de dominio son homogéneas (todos los objetos de una colección son del mismo tipo) y están respaldadas por sus correspondientes clases integradas de Kotlin. Para obtener más información sobre los tipos de colección utilizados en el SDK de Kotlin y los tipos de datos compatibles, consulte Tipos de colección.

El SDK de Kotlin ofrece varios tipos de colecciones que puedes usar como propiedades en tu modelo de datos: RealmList, RealmSet y RealmDictionary.

Las colecciones también permiten definir relaciones de varios objetos entre objetos de Realm. Consulta Relaciones - SDK de Kotlin para obtener más información.

// RealmList<E> can be any supported primitive
// or BSON type, a RealmObject, or an EmbeddedRealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // List of RealmObject type (CANNOT be nullable)
    var favoritePonds: RealmList<Pond> = realmListOf()
    // List of EmbeddedRealmObject type (CANNOT be nullable)
    var favoriteForests: RealmList<EmbeddedForest> = realmListOf()
    // List of primitive type (can be nullable)
    var favoriteWeather: RealmList<String?> = realmListOf()
}
class Pond : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
}

// RealmSet<E> can be any supported primitive or
// BSON type or a RealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Set of RealmObject type (CANNOT be nullable)
    var favoriteSnacks: RealmSet<Snack> = realmSetOf()
    // Set of primitive type (can be nullable)
    var favoriteWeather: RealmSet<String?> = realmSetOf()
}
class Snack : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
}

// RealmDictionary<K, V> can be any supported
// primitive or BSON types, a RealmObject, or
// an EmbeddedRealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Dictionary of RealmObject type (value MUST be nullable)
    var favoriteFriendsByPond: RealmDictionary<Frog?> = realmDictionaryOf()
    // Dictionary of EmbeddedRealmObject type (value MUST be nullable)
    var favoriteTreesInForest: RealmDictionary<EmbeddedForest?> = realmDictionaryOf()
    // Dictionary of primitive type (value can be nullable)
    var favoritePondsByForest: RealmDictionary<String?> = realmDictionaryOf()
}

// Percent encode . or $ characters to use them in map keys
val mapKey = "Hundred Acre Wood.Northeast"
val encodedMapKey = "Hundred Acre Wood%2ENortheast"

Definir datos no estructurados

A partir de la versión del SDK de Kotlin,2.0.0 se pueden almacenar colecciones de datos mixtos dentro de una RealmAny propiedad. Esta función permite modelar estructuras de datos complejas, como documentos JSON o MongoDB, sin necesidad de definir un modelo de datos estricto.

Los datos no estructurados son aquellos que no se ajustan fácilmente a un esquema esperado, lo que dificulta o hace poco práctico modelarlos para clases de datos individuales. Por ejemplo, su aplicación podría tener datos muy variables o dinámicos cuya estructura se desconoce en tiempo de ejecución.

Almacenar colecciones en una propiedad mixta ofrece flexibilidad sin sacrificar la funcionalidad, incluyendo una sincronización eficiente al usar Device Sync. Además, puede trabajar con ellas de la misma manera que con una colección no mixta:

• Puedes anidar colecciones mixtas hasta 100 niveles.

• Puede consultar y reaccionar ante los cambios en colecciones mixtas.

• Puede buscar y actualizar elementos de colección mixtos individuales.

Sin embargo, almacenar datos en colecciones mixtas tiene menos rendimiento que usar un esquema estructurado o serializar blobs JSON en una única propiedad de cadena.

Para modelar datos no estructurados en tu aplicación, define las propiedades adecuadas en tu esquema como tipos RealmAny. Puedes configurar estas RealmAny propiedades como una colección RealmList o RealmDictionary de RealmAny elementos. Ten en cuenta que RealmAny no puede representar un RealmSet ni un objeto incrustado.