Uso pratico di @Ignore in Realm?

Question

Ho cercato di aggiungere Realm nella mia app per Android. I loro documenti sono spiegati abbastanza bene & facili da seguire. Ma non riesce a spiegare questa particolare area. Non riesco a capire l'utilizzo pratico per l'annotazione @Ignore. So che i campi sotto questa annotazione non sono persistenti.

Qualcuno può condividere alcuni casi d'uso. Inoltre volevo conoscere la portata di tali campi. Voglio dire, se impostassi un campo @Ignore su un valore, questo sarebbe disponibile per le altre classi nella mia app per quella particolare sessione di avvio. Se sì, allora come lo accediamo? Se no (che credo sia il caso), allora perché abbiamo bisogno di un campo simile?

Ho cercato qui e sul Web ma non ho trovato le informazioni pertinenti. Se per mia ignoranza, mi sono perso alcune risorse, per favore guidami ad esso.

Grazie.

Answer 1

conseguenza alla documentazione ufficiale (vedi https://realm.io/docs/java/latest/) @Ignore è utile in due casi:

1. Quando si utilizza l'integrazione e la tua GSON JSON contiene più dati di quanti si desidera memorizzare, ma è ancora vorrebbe analizzarlo e usarlo subito dopo.

2. Non è possibile creare getter e setter personalizzati nelle classi che estendono RealmObject, poiché verranno sovrascritti. Ma nel caso in cui si desideri comunque avere una logica personalizzata, i campi ignorati possono essere usati come un trucco per farlo, perché il Realm non ha la precedenza sui propri setter getter &. Esempio:

   package io.realm.entities; 
   
   import io.realm.RealmObject; 
   import io.realm.annotations.Ignore; 
   
   public class StringOnly extends RealmObject { 
   
       private String name; 
   
       @Ignore 
       private String kingName; 
   
       // custom setter 
       public void setKingName(String kingName) { setName("King " + kingName); } 
   
       // custom getter 
       public String getKingName() { return getName(); } 
   
       // setter and getter for 'name' 
   } 
   

campi ignorati sono accessibili solo dall'oggetto sono stati impostati a (come con oggetti regolari in Java).

UPDATE: Come @ The-null-Pointer- sottolineato nei commenti, il secondo punto non è aggiornato. Il reame ora consente di avere getter e setter personalizzati nei modelli Realm.

Answer 2

Ecco un paio di casi d'uso reali:

1 - Get fullname dell'utente:

public class User extends RealmObject { 

private String first; 
private String last; 

@Ignore 
private String fullName; 

public String getFullName() { 
    return getFirst() + " " + getLast(); 
} 

Ottenere la rappresentazione JSON dell'oggetto:

public class User extends RealmObject { 

private String first; 
private String last; 

@Ignore 
private JSONObject Json; 

public JSONObject getJson() { 
    try { 
     JSONObject dict = new JSONObject(); 

     dict.put("first", getFirst()); 
     dict.put("last", getLast()); 
     return dict; 
    } catch (JSONException e) { 
     // log the exception 
    } 

    return null; 
} 

Answer 3

Si veda la official documentation su @Ignore annotazione:

L'annotazione @Ignore implica che un campo non debba essere mantenuto sul disco. I campi ignorati sono utili se il tuo input contiene più campi del tuo modello e non desideri avere molti casi speciali per gestire questi campi di dati inutilizzati.

Answer 4

Ho trovato utile definire i nomi dei campi per quando sto interrogando. Ad esempio

Utente.java

public class User extends RealmObject { 
    @Index 
    public String name; 

    @Ignore 
    public static final String NAME = "name"; 
} 

E poi in seguito posso fare qualcosa di simile:

realm.where(User.class).equalTo(User.NAME, "John").findFirst();

In questo modo se le modifiche dello schema da dire name-id che non c'è bisogno di dare la caccia a ogni occorrenza di "name".