Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
SDK para Java
/
Dados do modelo

Relacionamentos - SDK Java

Nesta página

  • Relacionamentos
  • Relacionamento para um
  • Relacionamento com muitos
  • Relacionamento inverso
  • Definir um campo de relacionamento
  • Muitos para um
  • Muitos-para-muitos
  • Relações inversas

Relacionamentos

O Realm permite definir relacionamentos explícitos entre os tipos de objeto em um aplicativo. Um relacionamento é uma propriedade de objeto que faz referência a outro objeto do Realm em vez de um dos tipos de dados primitivos. Você define relacionamentos definindo o tipo de propriedade de um objeto para outro tipo de objeto noesquema de propriedade .

Relacionamentos são referências diretas a outros objetos em um realm, o que significa que você não precisa de tabelas de ponte ou junções explícitas para definir um relacionamento como faria em um banco de dados relacional. Em vez disso, você pode acessar objetos relacionados lendo e gravando na propriedade que define a relação. O Realm executa operações de leitura lentamente à medida que elas entram, portanto, consultar um relacionamento é tão eficiente quanto ler uma propriedade regular.

Existem três tipos principais de relacionamentos entre objetos:

Você pode definir relacionamentos, coleções e objetos incorporados em seu esquema de objetos usando os seguintes tipos:

  • RealmObject

  • RealmList <? extends RealmObject>

Use anotações para indicar se um determinado campo representa uma relação de chave estrangeira ou uma relação de objeto incorporado. Para obter mais informações, consulte Anotações de relacionamento.

Relacionamento para um

Uma relação um-para-um significa que um objeto está relacionado de uma forma específica a não mais do que um outro objeto. Você define esse relacionamento para um tipo de objeto em seu esquema de objetos especificando uma propriedade onde o tipo é o tipo de objeto de Realm relacionado.

Definir um campo de relacionamento como nulo remove a conexão entre objetos, mas o Realm não exclui o objeto referenciado, a menos que esse objeto seja incorporado.

Relacionamento com muitos

Uma relação para muitos significa que um objeto está relacionado de uma maneira específica a vários objetos. Você pode criar uma relação entre um objeto e qualquer número de objetos usando um campo do tipo RealmList<T> em que T é um objeto de Realm em seu aplicativo:

Relacionamento inverso

Um relacionamento inverso vincula um objeto a qualquer outro objeto que se refira a ele em um relacionamento definido como um-para-um ou um-para-muitos. As definições de relacionamento são unidirecionais, então você deve definir explicitamente uma propriedade no modelo do objeto como um relacionamento inverso.

Por exemplo, o relacionamento "O usuário tem muitas tarefas" não cria automaticamente o relacionamento inverso "A tarefa pertence ao usuário". Se você não especificar o relacionamento inverso no modelo de objeto, precisará executar uma query separada para pesquisar o usuário que está atribuído a uma determinada tarefa.

Para definir um relacionamento inversa, defina uma propriedade LinkingObjects no seu modelo de objetos. A definição LinkingObjects especifica o tipo de objeto e o nome da propriedade do relacionamento que inverte.

O Realm atualiza automaticamente relacionamentos implícitos sempre que um objeto é adicionado ou removido no relacionamento especificado. Você não pode definir manualmente o valor de uma propriedade de relacionamento inversa.

Os campos anotados com @LinkingObjects devem ser:

  • marcado final

  • do tipo RealmResults<T> onde T é o tipo na extremidade oposta do relacionamento

Como os relacionamentos são muitos para um ou muitos para muitos, seguir relacionamentos inversos pode resultar em zero, um ou muitos objetos.

Como qualquer outro conjunto RealmResults, você pode consultar um relacionamento inverso.

Definir um campo de relacionamento

Dica

Veja também:

Como alternativa, você pode definir seus relacionamentos no App Services App.

Aviso

Sempre definir acessores e mutadores para campos modificáveis

Os objetos de domínio usam getters e setters para persistir valores de campo atualizados em seus realms. Sempre use getters e setters para atualizações.

Muitos para um

Para configurar um relacionamento muitos-para-um ou um-para-um, crie um campo cujo tipo seja um objeto de Realm em seu aplicativo:

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

Relacionamentos um-para-um devem ser opcionais

Quando você declara um relacionamento um-para-um no modelo de objeto, ele deve ser uma propriedade opcional. Se você tentar tornar um relacionamento um-para-um obrigatório, o Realm lançará uma exceção em tempo de execução.

Cada Frog faz referência a zero Frog instâncias ou a outra instância Frog . Nada impede que várias instâncias de Frog façam referência ao mesmo Frog como melhor amigo; a distinção entre um relacionamento muitos-para-um e um-para-um depende de sua aplicação.

Muitos-para-muitos

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 s são containers de RealmObject s, mas de outra forma se comportam como uma collection regular. Você pode usar o mesmo objeto em vários RealmList s.

Relações inversas

Por padrão, os relacionamentos do Realm são unidirecionais. Você pode seguir um link de uma classe para uma classe referenciada, mas não na direção oposta. Considere a seguinte classe definindo um Toad com uma 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() {}
}

Você pode fornecer um link na direção oposta, de Frog para Toad, com a anotação @LinkingObjects em um campo final (em Java) ou val (em Kotlin) do tipo RealmResults<T>:

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

Os campos de relacionamento inversos devem ser marcados como final.

Voltar

Definir um modelo de objeto

Próximo

Alterar um modelo de objeto

Nesta página