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);
}
}
}
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. –
Mein Vorschlag ist, aus einzelnen Dokumenten aber alle Elemente gleichzeitig zu lesen. Deine 2) würde das Dokument für jeden Artikel nochmal lesen ... –
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. –