Volltextsuche mit Servlets

von jNotes - Team

Die Einrichtung und Unterstützung von Servlets durch den Domino-Server wurde bereits im Artikel "Löschen der Authentifizierung im Web" beschrieben. Dieser Beitrag gibt einen Einblick in die Programmierung von Servlets mit Zugriff auf Domino-Daten. Dazu wurde ein Beispiel gewählt, das zugleich den Vorteil von Servlets gegenüber Domino-Agenten oder CGI-Programmen verdeutlichen soll.

Das Servlet, das im Folgenden näher beschrieben wird, führt eine Volltextsuche über mehrere Domino-Datenbanken aus. Das Besondere daran ist, dass für jeden einzelnen Suchprozeß ein eigener Thread (selbständiger Teilprozeß) angelegt wird.

Die Programmiersprache Java bietet die Möglichkeit mehrere Threads gleichzeitig auszuführen. Dieses Konzept wird auch Multithreading genannt. Das Grundkonzept von Threads in Java soll im Folgenden kurz erläutert werden.

Zuerst muß ein Thread neu initialisiert werden, um den Zustand new zu erreichen.

MyThread t = new MyThread;

Durch den Aufruf der Methode start() wird der Thread in den Zustand runnable versetzt und erhält somit vom System Rechenzeit. Diese kann durch unterschiedliche Ereignisse unterbrochen werden. Bei einem I/O-Zugriff wird der Thread zum Beispiel automatisch für kurze Zeit in den Zustand blocked versetzt. Natürlich kann dieser Zustand auch durch entsprechende Methoden erreicht werden.

t.start(); // Thread kommt in den Zustand Runnable
t.sleep(10); // Thread wird für 10ms in den Zustand blocked versetzt
t.stop(); // Thread wird beendet

Der folgende Quellcode stellt einen speziellen Thread dar: den NotesThread. Dieser Teilprozess wird in einer eigenen Klasse verwaltet und ist für die Volltextsuche verantworlich. Der Zugriff auf Notes-Objekte ist an den entsprechenden Stellen kommentiert.

Beispiel

 class Search extends NotesThread {

String query, dbname;
PrintWriter out;

/* the constructor of class Search */
public Search(String dbname, String query, PrintWriter out) {
  super();
  this.dbname = dbname;
  this.query = query;
  this.out = out;
}

 /* start point of the NotesThread */
 public void runNotes() {
   try {
     /* initialize new Notes Session */
     Session s = NotesFactory.createSession();
     /* get the coresspondending database */
     Database db = s.getDatabase("", dbname.replace('\\', '\\'));
     /* do the full text search */
     DocumentCollection col = db.FTSearch(query);
     Document doc = col.getFirstDocument();
     while (doc != null) {
       /* do somthing with founded documents */
       String title = db.getTitle();
       out.println(title + "<br />");
       doc = col.getNextDocument();
     }
   }
   catch (NotesException ne) {
      ne.printStackTrace();
   }
 }
} 

Nun muss dieser Notes-Thread noch innerhalb eines Servlets initialisiert werden. Der folgende Quellcode zeigt wie es funktioniert.

public class SearchServlet extends HttpServlet {

String query;
String[] dbname;

public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
   res.setContentType("text/html");
   PrintWriter out = new PrintWriter(res.getWriter());
   /* get search string from web site */
   query = req.getParameter("Query");
   /* get selected databases */
   dbname = req.getParameterValues("Selection");
   try {
     /* initialize new NotesThread for this servlet
     NotesThread.sinitThread();
     out.println("<h3>Ergebnisse: </h3><br>" );
     Search[] search = new Search[dbname.length];
     for (int i=0; i       /* initialize and start all threads */
       search[i] = new Search(dbname[i], query, out);
       search[i].start();
     }
     for (int i=0; i       /* waits for this thread to die */
       search[i].join();
     }
   }
   catch (Exception e) {
     e.printStackTrace();
   }
   finally {
     /* terminate NotesThread for this servlet */
     NotesThread.stermThread();
   }

}      

Vergleich mit Agenten

Warum sollte man nun eine Volltextsuche mit Servlets programmieren, wenn es auch einfacher mit Agenten geht? Dafür kann es folgende Gründe geben:

  • Servlets werden beim ersten Aufruf oder (bei entsprechenden Einstellungen) beim Starten der Servlet-Engine einmal geladen und bleiben dann solange geladen, bis der HTTP-Server-Task beendet wird. Daraus resultiert ein deutlicher Leistungsvorteil gegenüber Agenten und CGI-Programmen, die jedesmal neu geladen werden.
  • Servlets befinden sich im Dateisystem des Webservers Gegenüber Agenten muss somit der Webuser keinen direkten Zugriff auf die Datenbank haben, auf die zugegriffen werden soll.
  • Die Servlet-API-Klassen unterstützen das Session-Handling sowie die Cookie-Verwaltung. Mit dem Session-Handling können bespielsweise durch "URL-Re-Writing" HTTP-Sitzungen ohne Unterstützung von Cookies nachgebildet werden.
  • Servlets können durch Standard-Java-Schnittstellen (z.B. JDBC) leicht auf andere Ressourcen zugreifen.

Unser Servlet, das eine Volltextsuche über mehrere Datenbanken vollzieht, ist schneller durch Mulithreading und durch das Halten des Servlets im Speicher des Webservers. Das Konzept des Multithreadings ist besonders bei komplexen I/O-Zugriffen zu empfehlen.

Download

Mit Hilfe der folgenden Dateien kann eine eigene Volltextsuche mit Servlets programmiert werden.

Hinweise zur Installation

  • Im Serverdokument nachsehen, welche Pfade für Servlets eingestellt sind.
  • Dann die *.class-Datei in den Servletpfad im Dateisystem kopieren.
  • Die Datei "servlet.properties" ins Notes-Data-Verzeichnis kopieren (hier stehen bestimmte Einstellungen, wie z.B. Namensalias).
erstellt am 06.10.2004 - nicht bewertet
Abgelegt unter: Servlet, Java, Thread, Download

Bewerten Sie diesen Artikel:


Senden Sie einen Kommentar

Name
E-Mail
Kommentar
FrageGATY-98U3UN (bitte diesen Wert in unten stehendes Feld eintragen)
Antwort