Spring Data Solr Tutorial:Dynamische Abfragen

Solr wird oft als Suchserver bezeichnet, den wir verwenden können, wenn wir Volltextsuchfunktionen implementieren. Es ist jedoch oft ratsam, die Leistung von Solr zu nutzen, wenn wir eine Suchfunktion implementieren, die ihre Eingabe aus einem Suchformular bezieht.

In diesem Szenario hängt die ausgeführte Suchanfrage von der empfangenen Eingabe ab. Das bedeutet, dass die Anzahl der Abfrageparameter von der Eingabe in das Suchformular abhängt. Mit anderen Worten, die ausgeführte Suchanfrage ist dynamisch.

Im vorherigen Teil meines Spring Data Solr-Tutorials haben wir gelernt, wie wir benutzerdefinierte Methoden zu einem einzelnen Repository hinzufügen können. Es ist an der Zeit, diese Informationen zu nutzen und herauszufinden, wie wir mit Spring Data Solr dynamische Abfragen erstellen können.

Fangen wir an.

Dynamische Abfragen erstellen

Dieser Abschnitt beschreibt, wie wir mit Spring Data Solr dynamische Abfragen erstellen können. Es gliedert sich in zwei Unterabschnitte, die im Folgenden beschrieben werden:

• Der erste Unterabschnitt beschreibt die Grundlagen, die wir wissen müssen, bevor wir mit der Arbeit an der eigentlichen Suchfunktion beginnen können.
• Der zweite Unterabschnitt beschreibt, wie wir die Suchfunktion unserer Beispielanwendung implementieren können, indem wir unserem Spring Data Solr-Repository eine benutzerdefinierte Methode hinzufügen.

Die Grundlagen lernen

Bevor wir mit der Implementierung der Suchfunktion unserer Beispielanwendung beginnen können, müssen wir wissen, wie wir mithilfe von Spring Data Solr Abfragen "manuell" erstellen können. Wir können eine Abfrage "manuell" erstellen, indem wir diesen Schritten folgen:

1. Suchkriterien erstellen.
2. Erstellen Sie die Abfrage, die die verwendeten Suchkriterien enthält.
3. Führen Sie die erstellte Abfrage aus.

Diese Schritte werden im Folgenden ausführlicher beschrieben.

Suchkriterien erstellen

Zuerst müssen wir die Suchkriterien für unsere Abfrage erstellen. Wir können dies tun, indem wir die im Folgenden beschriebenen Kriterienklassen verwenden:

• Die org.springframework.data.solr.core.query.SimpleStringCriteria Die Klasse ist eine grundlegende Kriterienklasse, die verwendet wird, um die ausgeführte Abfrage durch Verwendung einer bereits formatierten Abfragezeichenfolge zu spezifizieren. Die in dieser Klasse angegebene Abfragezeichenfolge wird unverändert ausgeführt. Daher kann diese Klasse nicht zum Erstellen dynamischer Abfragen verwendet werden.
• Die org.springframework.data.solr.core.query.Criteria ist eine Kriterienklasse, die zum Erstellen dynamischer Abfragen verwendet wird. Es hat eine fließende API, die die Verkettung mehrerer Kriterien unterstützt Objekte.

Ausgeführte Abfrage erstellen

Zweitens müssen wir die ausgeführte Abfrage erstellen. Die Abfrageklassen von Spring Data Solr werden im Folgenden beschrieben:

• Die org.springframework.data.solr.core.query.SimpleQuery class ist eine Abfrageklasse, die sowohl Paginierung als auch Gruppierung unterstützt.
• Die org.springframework.data.solr.core.query.SimpleFacetQuery Klasse ist eine Abfrageklasse, die facettierte Suche unterstützt.
• Die org.springframework.data.solr.core.query.SimpleFilterQuery Klasse ist eine Abfrageklasse, die Filterabfragen unterstützt.

Ausführen der erstellten Abfrage

Drittens müssen wir die erstellte Abfrage ausführen. Das SolrTemplate Die Klasse implementiert mehrere Methoden, die wir für diesen Zweck verwenden können. Diese Methoden werden im Folgenden beschrieben:

• Die lange Zählung (letzte SolrDataQuery-Abfrage) Die Methode gibt die Anzahl der Dokumente zurück, die mit der als Methodenparameter angegebenen Abfrage gefunden wurden.
• Die UpdateResponse delete(SolrDataQuery query) -Methode löscht die Dokumente, die mit der als Methodenparameter angegebenen Abfrage übereinstimmen, und gibt eine UpdateResponse zurück Objekt.
• Die T queryForObject(Query query, Class clazz) Die Methode gibt ein einzelnes Dokument zurück, das mit der als Methodenparameter angegebenen Abfrage übereinstimmt.
• Die FacetPage queryForFacetPage(FacetQuery query, Class clazz) -Methode führt eine Facettenabfrage gegen den Solr-Index aus und gibt die Abfrageergebnisse als FacetPage zurück Objekt.
• Die Page queryForPage(Query query, Class clazz) -Methode führt die Abfrage anhand des Solr-Index aus und gibt die Abfrageergebnisse als Implementierung der Page-Schnittstelle zurück.

Lassen Sie uns weitermachen und diese Theorie in die Praxis umsetzen.

Implementieren der Suchfunktion

Die Anforderungen an unsere Suchfunktion lauten wie folgt:

• Die Suchfunktion muss alle Aufgabeneinträge zurückgeben, deren Name oder Beschreibung ein Wort des angegebenen Suchbegriffs enthält. Mit anderen Worten, wenn der Suchbegriff "Foo Bar" lautet, muss unsere Suchfunktion Aufgabeneinträge zurückgeben, deren Titel oder Beschreibung entweder "Foo" oder "Bar" enthält.
• Bei der Suche muss die Groß-/Kleinschreibung beachtet werden.

Da unsere Suchfunktion nicht statisch ist, müssen wir sie mithilfe einer dynamischen Abfrage erstellen. Wir können dynamische Abfragen mit Spring Data Solr erstellen, indem wir unserem Spring Data Solr-Repository eine benutzerdefinierte Methode hinzufügen. Mit anderen Worten, wir müssen diesen Schritten folgen:

1. Erstellen Sie eine benutzerdefinierte Schnittstelle, die die hinzugefügte Methode deklariert.
2. Implementieren Sie die erstellte Schnittstelle.
3. Ändern Sie die Repository-Schnittstelle, um die erstellte Schnittstelle zu erweitern.

Diese Schritte werden im Folgenden ausführlicher beschrieben.

Erstellen der benutzerdefinierten Oberfläche

Zuerst müssen wir eine benutzerdefinierte Schnittstelle erstellen, die unsere benutzerdefinierte Suchmethode deklariert. Wir können dies tun, indem wir diesen Schritten folgen:

1. Erstellen Sie eine Schnittstelle namens CustomTodoDocumentRepository .
2. Deklarieren Sie die Suche() Methode. Diese Methode nimmt den verwendeten Suchbegriff als Methodenparameter und gibt eine Liste von TodoDocument zurück Objekte.

Der Quellcode des CustomTodoDocumentRepository Die Benutzeroberfläche sieht wie folgt aus:

public interface CustomTodoDocumentRepository {

    public List<TodoDocument> search(String searchTerm);

	//Other methods are omitted.
}

Implementieren der erstellten Schnittstelle

Zweitens müssen wir die benutzerdefinierte Schnittstelle implementieren, die wir zuvor erstellt haben. Wir können dies tun, indem wir diesen Schritten folgen:

1. Erstellen Sie eine Klasse namens TodoDocumentRepositoryImpl und implementieren Sie das CustomTodoDocumentRepository Schnittstelle.
2. Kommentieren Sie die Klasse mit @Repository Anmerkung.
3. Fügen Sie SolrTemplate hinzu Feld zur Klasse hinzufügen und mit @Resource annotieren Anmerkung.
4. Implementieren Sie die Suche() Methode.

Die Implementierung von search() Methode erfordert eine ausführlichere Beschreibung, die hier gegeben wird. Wir können die Suche() implementieren Methode, indem Sie diesen Schritten folgen:

1. Erhalten Sie die Wörter des Suchbegriffs.
2. Konstruieren Sie die verwendeten Suchkriterien, indem Sie die private createSearchConditions() aufrufen -Methode und Übergeben der Wörter des Suchbegriffs als Methodenparameter. Diese Methode erstellt die verwendeten Suchkriterien mithilfe der API der Kriterien Klasse.
3. Erstellen Sie die ausgeführte Abfrage, indem Sie eine neue SimpleQuery erstellen Objekt und übergeben Sie die erstellten Kriterien Objekt als Konstruktorparameter.
4. Erhalten Sie die Suchergebnisse, indem Sie queryForPage() aufrufen Methode des SolrTemplate Klasse. Übergeben Sie die erstellte Abfrage und den Typ der erwarteten Ergebnisobjekte als Methodenparameter.
5. Geben Sie die Suchergebnisse zurück, indem Sie getContent() aufrufen Methode der Seite Schnittstelle.

Der Quellcode von TodoDocumentRepositoryImpl Klasse sieht wie folgt aus:

import org.springframework.data.domain.Page;
import org.springframework.data.solr.core.SolrTemplate;
import org.springframework.data.solr.core.query.Criteria;
import org.springframework.data.solr.core.query.SimpleQuery;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository
public class TodoDocumentRepositoryImpl implements CustomTodoDocumentRepository {

    @Resource
    private SolrTemplate solrTemplate;

    @Override
    public List<TodoDocument> search(String searchTerm) {
        String[] words = searchTerm.split(" ");

        Criteria conditions = createSearchConditions(words);
        SimpleQuery search = new SimpleQuery(conditions);

        Page results = solrTemplate.queryForPage(search, TodoDocument.class);
        return results.getContent();
    }

    private Criteria createSearchConditions(String[] words) {
        Criteria conditions = null;

        for (String word: words) {
            if (conditions == null) {
                conditions = new Criteria("title").contains(word)
                        .or(new Criteria("description").contains(word));
            }
            else {
                conditions = conditions.or(new Criteria("title").contains(word))
                        .or(new Criteria("description").contains(word));
            }
        }

        return conditions;
    }

    //Other methods are omitted
}

Ändern der Repository-Schnittstelle

Drittens müssen wir unsere benutzerdefinierte Suche() erstellen Methode, die für die Benutzer unseres Repositorys sichtbar ist. Wir können dies tun, indem wir das CustomTodoDocumentRepository erweitern Schnittstelle. Der Quellcode des TodoDocumentRepository Die Benutzeroberfläche sieht wie folgt aus:

import org.springframework.data.solr.repository.SolrCrudRepository;

public interface TodoDocumentRepository extends CustomTodoDocumentRepository, SolrCrudRepository<TodoDocument, String> {

}

Wir haben jetzt eine benutzerdefinierte Suche() hinzugefügt -Methode in unser Spring Data Solr-Repository. Lassen Sie uns herausfinden, wie wir diese Methode verwenden können.

Mit der benutzerdefinierten Methode

Wir können die benutzerdefinierte Methode verwenden, indem wir search() ändern Methode des RepositoryTodoIndexService Klasse. Die neue Implementierung dieser Methode ist sehr einfach. Es ruft die Suchergebnisse ab, indem es search() aufruft -Methode unseres Spring Data Solr-Repositorys und gibt die Suchergebnisse zurück.

Der Quellcode des RepositoryTodoIndexService Klasse sieht wie folgt aus:

import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class RepositoryTodoIndexService implements TodoIndexService {

    @Resource
    private TodoDocumentRepository repository;

	//Other methods are omitted.

    @Override
    public List<TodoDocument> search(String searchTerm) {
        return repository.search(searchTerm);
    }
}

Zusammenfassung

Wir haben jetzt mit Spring Data Solr eine dynamische Suchfunktion implementiert. Obwohl unsere Suchfunktion eher einfach war, sollten wir nun auch komplexere Abfragen implementieren können.

Dieses Tutorial hat uns zwei Dinge beigebracht:

• Wir haben gelernt, wie wir mit Spring Data Solr Abfragen "manuell" erstellen können.
• Wir haben gelernt, dass wir dynamische Suchmethoden implementieren müssen, indem wir benutzerdefinierte Methoden zu einem einzigen Repository hinzufügen.

Der nächste Teil meines Spring Data Solr-Tutorials beschreibt, wie wir unsere Abfrageergebnisse sortieren können.

P.S. Die Beispielanwendung dieses Blogposts ist auf Github verfügbar.