2016-06-03 16 views
2

Es tut mir leid, dies ist keine "Coding" -Frage, aber nach einiger Zeit auf dem Lernpfad mit XPages und Java habe ich immer noch mit endgültigen Informationen über den richtigen Weg zu finden führe die Grundlagen aus.Beste Methode zum Abrufen von Daten in XPages und Java

Bei der Entwicklung einer XPages-Anwendung mit Java, die die beste oder effizienteste Methode für den Zugriff auf Daten ist?

1) Einrichten und Verwalten einer Ansicht mit einer Spalte für jedes Feld im Dokument und Abrufen von Daten mit ViewEntry.getColumnValues ​​(). Get (int); d. h. nicht auf das Dokument zugreifen und die Daten aus der Ansicht abrufen. Was ich gemacht habe, aber meine View-Spalten nehmen immer weiter zu, ebenso wie die Pflege von Spaltensequenzen. Mein Verständnis ist dies eine schnellere Methode.

oder

2) Legen Sie einfach alles in einem Dokument eine Ansicht mit nur wenn notwendig, aber in der Haupt mit Database.getDocumentByUNID(). GetItemValueAsString („Feld“) und keine Sorgen über viele Spalten hinzufügen, viel einfacher zu pflegen, aber greift auf das Dokument zu verlangsamen?

Antwort

2

Weder 1) oder 2).

Gehen Sie auf diese Weise Dokumentdaten in einer Java-Klasse zu verwalten:

  • Dokument lesen Stücke auf einmal in Ihrer Java-Klasse in Klassenfelder
  • erinnert UNID in einem Klassenfeld zu
  • Recycling-Dokument nach dem lesen Artikel
  • get Dokument erneut mit Hilfe von UNID für danach alle Lese-/Schreib und recyceln

Database.getDocumentByUNID() ist ziemlich schnell, aber rufen Sie es nur einmal für ein Dokument und nicht für jedes Element auf.

aktualisiert

Wie Sie in einem Kommentar erwähnt, haben Sie eine Datenbank mit 50.000 Dokumenten verschiedenen Typen.

Ich würde versuchen, nur die Dokumente zu lesen, die Sie wirklich brauchen. Wenn Sie z.B. Für alle Support-Ticket-Dokumente eines Kunden würden Sie eine Ansicht verwenden, die Support-Tickets nach Kunden sortiert (ohne zusätzliche Spalten) enthält. Sie würden die Dokumente mit getAllDocumentsByKey(customer, true) erhalten und die Java-Objekte (jeweils basierend auf einem Dokument) in eine Map einfügen.

Sie können zusätzlich einen Cache pflegen. Erstellen Sie eine Map von Modellen (Modell = Java-Objekt für einen Dokumenttyp) und verwenden Sie UNID als Schlüssel. Auf diese Weise können Sie vermeiden, dass Dokumente doppelt gelesen/gespeichert werden.

+0

Sorry ich verstehe Ihren ersten Aufzählungspunkt Knut nicht. Meine Frage ist - ist es besser, die Daten nach dem Abrufen des Dokuments aus Ansichtsspalten oder einzelnen Dokumentenelementen in jedes Klassenfeld zu übertragen. –

+0

Mein Vorschlag ist, aus einzelnen Dokumenten aber alle Elemente gleichzeitig zu lesen. Deine 2) würde das Dokument für jeden Artikel nochmal lesen ... –

+0

Ja, sorry, ich würde das Dokument nur einmal bekommen, es war schlecht geschrieben. Ich werde getDocumentByUNID() im Allgemeinen verwenden, anstatt Zeit mit vielen View-Spalten zu verschwenden. Danke vielmals. –

0

Es geht um Balance. alles hat seinen Preis. Große Ansichten (Fall 1) verlangsamen die Indizierung. Das Öffnen von Dokumenten jedes Mal (Fall 2) verlangsamt Ihren Code.

Finden Sie etwas dazwischen.

2

Das ist eine wirklich gute Frage. Ich würde zuerst sagen, dass ich zu 100% mit Knut übereinstimme, und so kodiere ich meine Objekte, die Dokumente darstellen.

Unten habe ich ein Codebeispiel von dem eingefügt, was ich normalerweise tue.Beachten Sie, dass dieser Code die OpenNTF Domino API verwendet, die unter anderem das Recycling für mich übernimmt. Sie werden also keine Recycle-Anrufe sehen.

Aber wie Knut sagt - schnappen Sie sich das Dokument. Holen Sie, was Sie dafür brauchen, dann kann es wieder verworfen werden. Wenn Sie etwas speichern möchten, rufen Sie das Dokument erneut ab. Zu diesem Zeitpunkt könnten Sie sogar lastModified überprüfen oder etwas von einem anderen Speichervorgang sehen, der seit dem Zeitpunkt des Ladens stattgefunden hat.

Manchmal Einfachheit halber überlasten ich die Methode load() und fügen Sie eine NotesViewEntry: public boolean load (Viewentry-Eintrag) {}

Dann dort konnte ich nur das Dokument erhalten, in, wenn es sich um eine spezifische Situation Gebrauch ist Spalten anzeigen.

Jetzt funktioniert das großartig, wenn Sie mit einem einzelnen Dokument zu einer Zeit beschäftigen. Es funktioniert wirklich gut, wenn ich viele Dokumente für eine Sammlung durchlaufen möchte. Aber wenn Sie zu viele bekommen, werden Sie vielleicht mitbekommen, dass einige der belauschten beginnen, die Dinge zu verlangsamen. Eine App, die ich habe, wenn ich 30.000 Dokumente so in eine Sammlung "inje", kann es ein bisschen langsam werden.

Ich habe noch keine gute Antwort dafür. Ich habe die große Ansicht mit vielen Spalten versucht, so als ob es sich anhört. Ich habe versucht, eine niedrigere Version der Basisversion des Objekts mit nur benötigten Feldern zu erstellen, und das wurde mehr entwickelt, um auf ViewEntry und ihre Spalten zu arbeiten. Ich habe dafür noch keine gute Antwort. Stellen Sie sicher, dass Sie faul laden, was Sie können, ist ziemlich wichtig, denke ich.

Wie auch immer, hier ist ein Codebeispiel, das zeigt, wie ich die meisten meiner dokumentgesteuerten Objekte erstelle.

package com.notesIn9.video; 

import java.io.Serializable; 
import java.util.Date; 

import org.openntf.domino.Database; 
import org.openntf.domino.Document; 
import org.openntf.domino.Session; 
import org.openntf.domino.View; 
import org.openntf.domino.utils.Factory; 

public class Episode implements Serializable { 

    /** 
    * 
    */ 
    private static final long serialVersionUID = 1L; 
    private String title; 
    private Double number; 
    private String authorId; 
    private String contributorId; 
    private String summary; 
    private String subTitle; 
    private String youTube; 
    private String libsyn; 
    private Date publishedDate; 
    private Double minutes; 
    private Double seconds; 

    private String blogLink; 

    private boolean valid; 
    private String unid; 
    private String unique; 
    private String creator; 

    public Episode() { 
     this.unid = ""; 

    } 

    public void create() { 

     Session session = Factory.getSession(); // this will be slightly 
               // different if not using the 
               // OpenNTF Domino API 
     this.setUnique(session.getUnique()); 
     this.setCreator(session.getEffectiveUserName()); 
     this.valid = true; 

    } 

    public Episode load(Document doc) { 

     this.loadValues(doc); 
     return this; 

    } 

    public boolean load(String key) { 

     // this key is the unique key of the document. UNID would be 
     // faster/easier.. I just kinda hate using them and seeing them in URLS 
     Session session = Factory.getSession(); 
     Database currentDb = session.getCurrentDatabase(); 
     Database db = session.getDatabase(currentDb.getServer(), "episodes.nsf"); 
     View view = db.getView("lkup_episodes"); 
     Document doc = view.getDocumentByKey(key); // This is deprecated because 
                // the API prefers to use 
                // getFirstDocumentByKey 

     if (null == doc) { 
      // document not found. DANGER 
      this.valid = false; 
     } else { 

      this.loadValues(doc); 

     } 

     return this.valid; 

    } 

    private void loadValues(Document doc) { 

     this.title = doc.getItemValueString("title"); 
     this.number = doc.getItemValueDouble("number"); 
     this.authorId = doc.getItemValueString("authorId"); 
     this.contributorId = doc.getItemValueString("contributorId"); 
     this.summary = doc.getItemValueString("summary"); 
     this.subTitle = doc.getItemValueString("subtitle"); 
     this.youTube = doc.getItemValueString("youTube"); 
     this.libsyn = doc.getItemValueString("libsyn"); 
     this.publishedDate = doc.getItemValue("publishedDate", Date.class); 
     this.minutes = doc.getItemValueDouble("minutes"); 
     this.seconds = doc.getItemValueDouble("seconds"); 
     this.blogLink = doc.getItemValueString("blogLink"); 

     this.unique = doc.getItemValueString("unique"); 
     this.creator = doc.getItemValueString("creator"); 

     this.unid = doc.getUniversalID(); 
     this.valid = true; 

    } 

    public boolean save() { 

     Session session = Factory.getSession(); 
     Database currentDb = session.getCurrentDatabase(); 
     Database db = session.getDatabase(currentDb.getServer(), "episodes.nsf"); 
     Document doc = null; 

     if (this.unid.isEmpty()) { 
      doc = db.createDocument(); 
      doc.replaceItemValue("form", "episode"); 
      this.unid = doc.getUniversalID(); 
     } else { 
      doc = db.getDocumentByUNID(this.unid); 
     } 

     this.saveValues(doc); 
     return doc.save(); 

    } 

    private void saveValues(Document doc) { 

     doc.replaceItemValue("title", this.title); 
     doc.replaceItemValue("number", this.number); 
     doc.replaceItemValue("authorId", this.authorId); 
     doc.replaceItemValue("contributorId", this.contributorId); 
     doc.replaceItemValue("summary", this.summary); 
     doc.replaceItemValue("subtitle", this.subTitle); 
     doc.replaceItemValue("youTube", this.youTube); 
     doc.replaceItemValue("libsyn", this.libsyn); 
     doc.replaceItemValue("publishedData", this.publishedDate); 
     doc.replaceItemValue("minutes", this.minutes); 
     doc.replaceItemValue("seconds", this.seconds); 
     doc.replaceItemValue("blogLink", this.blogLink); 

     doc.replaceItemValue("unique", this.unique); 
     doc.replaceItemValue("creator", this.creator); 

    } 

    // getters and setters removed to condense code. 


    public boolean remove() { 

     Session session = Factory.getSession(); 
     Database currentDb = session.getCurrentDatabase(); 
     Database db = session.getDatabase(currentDb.getServer(), "episodes.nsf"); 

     if (this.unid.isEmpty()) { 
      // this is a new Doc 
      return false; 

     } else { 

      Document doc = db.getDocumentByUNID(this.getUnid()); 
      return doc.remove(true); 

     } 

    } 

} 
+0

Hallo David, das ist genau das Szenario, das ich versuche, richtig zu machen. Eine Datenbank mit vielen Ansichten, die Ansichten können nur ein paar hundert Dokumente enthalten, aber die gesamte Anwendung hat 50.000 Dokumente verschiedener Typen. Ich durchlaufe dann eine Ansicht, um eine ArrayList oder eine Karte von Objekten zu erstellen - beispielsweise Objekte aller Supporttickets pro Kunde. Also versuche ich im Allgemeinen zu verstehen, ob es besser ist, die 50.000 Gesamtdokumente mit einer looping getDocumentByUNID() zu erreichen und die Daten aus dem Dokument abzurufen oder die Map aus View Entries and Columns aus einer bestimmten View zu erstellen. Vielen Dank für deine Hilfe. –

+0

Sie müssen ein wenig experimentieren .. Wenn Sie wirklich eine Sammlung von allen 50.000 haben müssen, dann würde ich versuchen, für die ViewEntry/Spalte Werte Sache gehen, aber Sie müssen damit spielen .. Vielleicht müssen Sie nicht jedes Feld vorab laden und einige laden. Sie sind auf dem richtigen Weg, denke ich ... aber es dauert eine Weile, 50.000 Dokumente in Objekte zu konvertieren. Du willst also auch ein "Bitte warten" Ding machen ... Ich habe vor nicht allzu langer Zeit ein NotesIn9 gemacht, denke ich –

Verwandte Themen