/ /

/ /

SDK de dispositivos Atlas

SDK de Java

Datos del modelo

Relaciones - SDK de Java

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Relaciones

Realm permite definir relaciones explícitas entre los tipos de objetos de una aplicación. Una relación es una propiedad de objeto que hace referencia a otro objeto de Realm, en lugar de a uno de los tipos de datos primitivos. Las relaciones se definen estableciendo el tipo de una propiedad de objeto a otro tipo de objeto en el... esquema de propiedad.

Las relaciones son referencias directas a otros objetos de un dominio, lo que significa que no se necesitan tablas puente ni uniones explícitas para definir una relación como en una base de datos relacional. En su lugar, se puede acceder a los objetos relacionados leyendo y escribiendo en la propiedad que define la relación. Realm ejecuta las operaciones de lectura de forma diferida a medida que llegan, por lo que consultar una relación es tan eficiente como leer una propiedad normal.

Hay tres tipos principales de relaciones entre objetos:

Relación uno a uno
Relación de uno a muchos
Relación inversa

Puede definir relaciones, colecciones y objetos incrustados en su esquema de objetos utilizando los siguientes tipos:

RealmObject
RealmList <? extends RealmObject>

Utilice anotaciones para indicar si un campo determinado representa una relación de clave externa o de objeto incrustado. Para obtener más información, consulte Anotaciones de relación.

Relación de uno a uno

Una relación de uno a uno significa que un objeto está relacionado de una manera específica con solo otro objeto. Se define una relación de uno a uno para un tipo de objeto en su esquema de objeto especificando una propiedad donde el tipo es el tipo de objeto de dominio relacionado.

Establecer un campo de relación como nulo elimina la conexión entre los objetos, pero Realm no elimina el objeto referenciado a menos que ese objeto esté incrustado.

Relación de muchos

Una relación de varios objetos significa que un objeto está relacionado de una manera específica con varios objetos. Puede crear una relación entre un objeto y cualquier número de objetos utilizando un campo de tipo,RealmList<T> donde T es un objeto Realm en su aplicación:

Relación inversa

Una relación inversa vincula un objeto con cualquier otro objeto que haga referencia a él en una relación definida de uno a muchos. Las definiciones de relación son unidireccionales, por lo que debe definir explícitamente una propiedad en el modelo del objeto como una relación inversa.

Por ejemplo, la relación "El usuario tiene muchas tareas" no crea automáticamente la relación inversa "La tarea pertenece al usuario". Si no se especifica la relación inversa en el modelo de objetos, se deberá ejecutar una consulta independiente para buscar al usuario asignado a una tarea determinada.

Para definir una relación inversa, defina una propiedad LinkingObjects en su modelo de objetos. La definición LinkingObjects especifica el tipo de objeto y el nombre de la propiedad de la relación que invierte.

Realm actualiza automáticamente las relaciones implícitas al añadir o eliminar un objeto en la relación especificada. No se puede establecer manualmente el valor de una propiedad de relación inversa.

Los campos anotados con @LinkingObjects deben ser:

marcado final
de tipo RealmResults<T> donde T es el tipo en el extremo opuesto de la relación

Dado que las relaciones son de muchos a uno o de muchos a muchos, las siguientes relaciones inversas pueden dar como resultado cero, uno o muchos objetos.

Como cualquier otro RealmResults conjunto, puedes consultar una relación inversa.

Definir un campo de relación

Tip

Alternativamente, puede definir sus relaciones en su aplicación App Services.

Advertencia

Defina siempre accesores y mutadores para campos modificables

Los objetos Realm utilizan getters y setters para persistir los valores de campo actualizados en sus realms. Utilice siempre getters y setters para las actualizaciones.

Muchos a uno

Para configurar una relación muchos a uno o uno a uno, crea un campo cuyo tipo sea un objeto Realm en tu aplicación:

import io.realm.RealmObject;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    private Frog bestFriend;
    public Frog(String name, int age, String species, String owner, Frog bestFriend) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
        this.bestFriend = bestFriend;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
    public Frog getBestFriend() { return bestFriend; }
    public void setBestFriend(Frog bestFriend) { this.bestFriend = bestFriend; }
}

import io.realm.RealmObject
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    var bestFriend: Frog? = null
    constructor(
        name: String?,
        age: Int,
        species: String?,
        owner: String?,
        bestFriend: Frog?
    ) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
        this.bestFriend = bestFriend
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Importante

Las relaciones de uno a uno deben ser opcionales

Al declarar una relación "a-uno" en el modelo de objetos, esta debe ser una propiedad opcional. Si se intenta que la relación "a-uno" sea obligatoria, Realm genera una excepción en tiempo de ejecución.

Cada Frog hace referencia a cero Frog instancias o a una instancia Frog diferente. Nada impide que múltiples instancias Frog hagan referencia al mismo Frog como mejor amigo; la distinción entre una relación muchos-a-uno y uno-a-uno depende de su aplicación.

Muchos a muchos

import io.realm.RealmList;
import io.realm.RealmObject;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    private RealmList<Frog> bestFriends;
    public Frog(String name, int age, String species, String owner, RealmList<Frog> bestFriends) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
        this.bestFriends = bestFriends;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
    public RealmList<Frog> getBestFriends() { return bestFriends; }
    public void setBestFriends(RealmList<Frog> bestFriends) { this.bestFriends = bestFriends; }
}

import io.realm.RealmList
import io.realm.RealmObject
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    var bestFriends: RealmList<Frog>? = null
    constructor(
        name: String?,
        age: Int,
        species: String?,
        owner: String?,
        bestFriends: RealmList<Frog>?
    ) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
        this.bestFriends = bestFriends
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

RealmList Los objetos son contenedores de RealmObject objetos, pero por lo demás se comportan como una colección normal. Se puede usar el mismo objeto en varios objetos RealmList.

Relaciones inversas

Por defecto, las relaciones de dominio son unidireccionales. Se puede seguir un enlace de una clase a otra referenciada, pero no en la dirección opuesta. Considere la siguiente clase que define un Toad con una lista de frogFriends:

import io.realm.RealmList;
import io.realm.RealmObject;
public class Toad extends RealmObject {
    private RealmList<Frog> frogFriends;
    public Toad(RealmList<Frog> frogFriends) {
        this.frogFriends = frogFriends;
    }
    public Toad() {}
    public RealmList<Frog> getFrogFriends() { return frogFriends; }
    public void setFrogFriends(RealmList<Frog> frogFriends) { this.frogFriends = frogFriends; }
}

import io.realm.RealmList
import io.realm.RealmObject
open class Toad : RealmObject {
    var frogFriends: RealmList<Frog>? = null
    constructor(frogFriends: RealmList<Frog>?) {
        this.frogFriends = frogFriends
    }
    constructor() {}
}

Puede proporcionar un enlace en la dirección opuesta,Frog de Toad a, con la anotación @LinkingObjects en un final campo (en Java) o val (en Kotlin) de RealmResults<T> tipo:

import io.realm.RealmObject;
import io.realm.RealmResults;
import io.realm.annotations.LinkingObjects;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    @LinkingObjects("frogFriends")
    private final RealmResults<Toad> toadFriends = null;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.RealmResults
import io.realm.annotations.LinkingObjects
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    @LinkingObjects("frogFriends")
    private val toadFriends: RealmResults<Toad>? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Importante

Los campos de relación inversa deben estar marcados con final.

Volver

Define un modelo de objeto

Cambiar un modelo de objeto