Spring Data Solr Tutorial:Hinzufügen benutzerdefinierter Methoden zu allen Repositories

Spring

Wenn wir Spring Data Solr in einem realen Softwareprojekt verwenden, stehen die Chancen gut, dass wir früher oder später mit einer Anforderung konfrontiert werden, die besagt, dass unsere Anwendung in der Lage sein muss, sowohl mit einem lokalen Solr-Server als auch mit einer SolrCloud zu kommunizieren. Im Moment bedeutet die Erfüllung dieser Anforderung, dass wir allen Spring Data Solr-Repositories benutzerdefinierte Methoden hinzufügen müssen.

Dieser Blogbeitrag beschreibt, wie das gemacht wird.

Als Beispiel werden wir die Beispielanwendung des vorherigen Teils meines Spring Data Solr-Tutorials ändern. Während dieses Blogbeitrags werden wir die benutzerdefinierte Repository-Implementierung dieser Anwendung so ändern, dass alle ihre Methoden zu allen Repositorys hinzugefügt werden.

Wir können benutzerdefinierte Methoden zu allen Repositories hinzufügen, indem wir diesen Schritten folgen:

Erhalten Sie die erforderlichen Abhängigkeiten mit Maven
Erstellen Sie eine Schnittstelle, die die benutzerdefinierten Methoden deklariert.
Implementieren Sie die erstellte Schnittstelle.
Erstellen Sie eine benutzerdefinierte Repository-Factory-Bean.
Konfigurieren Sie Spring Data Solr für die Verwendung des benutzerdefinierten Repository-Factory-Beans.

Genug mit Geplauder. Fangen wir an.

Erforderliche Abhängigkeiten mit Maven erhalten

Die Beispielanwendung dieses Blogbeitrags verwendet einen Build-Snapshot von Spring Data Solr, da er eine bessere Unterstützung für die Implementierung benutzerdefinierter Repository-Factory-Beans bietet. Wir können die erforderlichen Abhängigkeiten erhalten, indem wir die folgenden Änderungen an unserer POM-Datei vornehmen:

Fügen Sie das Spring-Snapshot-Repository zu den Repositorys hinzu Abschnitt der pom.xml Datei.
Ändern Sie die Version der Spring Data Solr-Abhängigkeit.

Diese Schritte werden in den folgenden Unterabschnitten ausführlicher beschrieben.

Spring Snapshot-Repository verwenden

Wir können das Spring-Snapshot-Maven-Repository verwenden, indem wir unserer POM-Datei die folgende Repository-Konfiguration hinzufügen:

<repositories>
    <repository>
        <id>spring-snapshots</id>
        <name>Spring Snapshot Maven Repository</name>
        <url>http://repo.springsource.org/libs-snapshot</url>
    </repository>
</repositories>

Aktualisierung der Spring Data Solr-Version

Wir können den Build-Snapshot von Spring Data Solr verwenden, indem wir der pom.xml die folgende Abhängigkeitserklärung hinzufügen Datei.

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-solr</artifactId>
    <version>1.0.0.BUILD-SNAPSHOT</version>
</dependency>

Erstellen der benutzerdefinierten Repository-Schnittstelle

Wir können eine benutzerdefinierte Schnittstelle für unsere Repositories erstellen, indem wir diesen Schritten folgen:

Erstellen Sie eine Schnittstelle namens CustomBaseRepository die zwei Typparameter hat:Der Dokumenttyp (T ) und die ID des Dokuments (ID ).
Stellen Sie sicher, dass das CustomBaseRepository Schnittstelle erweitert das SolrCrudRepository Schnittstelle.
Annotieren Sie die Schnittstelle mit @NoRepositoryBean Anmerkung. Dadurch wird sichergestellt, dass Spring Data Solr nicht versucht, eine Implementierung für unsere Schnittstelle zu erstellen.
Fügen Sie die Methodendeklarationen von count() hinzu und update() Methoden zum CustomBaseRepository Schnittstelle.

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

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

import java.io.Serializable;

@NoRepositoryBean
public interface CustomBaseRepository<T, ID extends Serializable> extends SolrCrudRepository<T, ID> {

    public long count(String searchTerm);

    public void update(Todo todoEntry);
}

Unser nächster Schritt ist die Implementierung der erstellten Schnittstelle. Lassen Sie uns herausfinden, wie das gemacht wird.

Implementieren der benutzerdefinierten Repository-Schnittstelle

Wir können das benutzerdefinierte Repository implementieren, indem wir diesen Schritten folgen:

Erstellen Sie eine Klasse namens CustomBaseRepositoryImpl . Diese Klasse hat zwei Typparameter:den Typ des Dokuments (T ) und die Art der Dokument-ID (ID ).
Stellen Sie sicher, dass die erstellte Klasse das SimpleSolrRepository erweitert Klasse und implementiert das CustomBaseRepository Schnittstelle.
Erstellen Sie einen Konstruktor, der eine SolrOperations akzeptiert Objekt und der Typ der Dokumentenklasse als Konstruktorargumente. Die Implementierung dieses Konstruktors ruft einfach den Konstruktor der Oberklasse auf.
Implementieren Sie das update() Methode. Da die Implementierung dieser Methode in diesem Blogbeitrag beschrieben wurde, gehe ich hier nicht näher darauf ein.
Implementieren Sie count() Methode. Auch hier gehe ich nicht ins Detail, da die Implementierung dieser Methode bereits beschrieben wurde.

Der Quellcode des CustomBaseRepositoryImpl Klasse sieht wie folgt aus:

import org.springframework.data.solr.core.SolrOperations;
import org.springframework.data.solr.core.query.Criteria;
import org.springframework.data.solr.core.query.PartialUpdate;
import org.springframework.data.solr.core.query.SimpleQuery;
import org.springframework.data.solr.repository.support.SimpleSolrRepository;

import java.io.Serializable;

public class CustomBaseRepositoryImpl<T, ID extends Serializable> extends SimpleSolrRepository<T, ID> implements CustomBaseRepository<T, ID> {

    public CustomBaseRepositoryImpl(SolrOperations solrOperations, Class<T> entityClass) {
        super(solrOperations, entityClass);
    }

    @Override
    public long count(String searchTerm) {
        String[] words = searchTerm.split(" ");
        Criteria conditions = createSearchConditions(words);
        SimpleQuery countQuery = new SimpleQuery(conditions);

        return getSolrOperations().count(countQuery);
    }

    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;
    }

    @Override
    public void update(Todo todoEntry) {
        PartialUpdate update = new PartialUpdate("id", todoEntry.getId().toString());

        update.add("description", todoEntry.getDescription());
        update.add("title", todoEntry.getTitle());

        getSolrOperations().saveBean(update);
        getSolrOperations().commit();
    }
}

Lassen Sie uns umziehen und herausfinden, wie wir eine benutzerdefinierte Repository-Factory-Bean erstellen können.

Erstellen der benutzerdefinierten Repository-Factory-Bean

Das Repository-Factory-Bean ist eine Komponente, die für die Erstellung von Implementierungen für die Repository-Schnittstellen verantwortlich ist. Weil wir das CustomBaseRepositoryImpl verwenden wollen -Klasse als Implementierung unserer Spring Data Solr-Repositories müssen wir eine benutzerdefinierte Repository-Factory-Bean erstellen.

Wir können eine neue Repository-Factory-Bean erstellen, indem wir diesen Schritten folgen:

Erstellen Sie eine Klasse namens CustomSolrRepositoryFactoryBean die die SolrRepositoryFactoryBean erweitert Klasse.
Fügen Sie eine private CustomSolrRepositoryFactory hinzu -Klasse in die CustomSolrRepositoryFactory Bohnen Klasse. Diese Klasse erweitert die SolrRepositoryFactory-Klasse und hat zwei Typparameter:den Dokumenttyp (T ) und die Art der Dokument-ID (ID ).
Überschreiben Sie die doCreateRepositoryFactory() -Methode der SolrRepositoryFactoryBean Klasse. Die Implementierung dieser Methode gibt eine neue CustomSolrRepositoryFactory zurück Objekt.

Schauen wir uns die Implementierung der CustomSolrRepositoryFactory genauer an Klasse. Wir können es implementieren, indem wir diesen Schritten folgen:

Fügen Sie eine SolrOperations hinzu Feld in die CustomSolrRepositoryFactory Klasse.
Fügen Sie der CustomSolrRepositoryFactory einen Konstruktor hinzu Klasse. Diese Klasse übernimmt die verwendeten SolrOperations Objekt als Konstruktorargument. Seine Implementierung ruft einfach den Konstruktor der Oberklasse auf und setzt die empfangenen SolrOperations Objekt auf das Feld, das wir in Schritt eins erstellt haben.
Überschreiben Sie das getTargetRepository() Methode der SolrRepositoryFactory Klasse und geben ein neues CustomBaseRepositoryImpl zurück Objekt.
Überschreiben Sie getRepositoryBaseClass() Methode der SolrRepositoryFactory Klasse und geben den Typ unserer benutzerdefinierten Schnittstelle zurück.

Das ist es. Der Quellcode unserer benutzerdefinierten Repository-Factory-Bean sieht wie folgt aus:

import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;
import org.springframework.data.solr.core.SolrOperations;
import org.springframework.data.solr.repository.support.SolrRepositoryFactory;
import org.springframework.data.solr.repository.support.SolrRepositoryFactoryBean;

import java.io.Serializable;

public class CustomSolrRepositoryFactoryBean extends SolrRepositoryFactoryBean {

    @Override
    protected RepositoryFactorySupport doCreateRepositoryFactory() {
        return new CustomSolrRepositoryFactory(getSolrOperations());
    }

    private static class CustomSolrRepositoryFactory<T, ID extends Serializable> extends SolrRepositoryFactory {

        private final SolrOperations solrOperations;

        public CustomSolrRepositoryFactory(SolrOperations solrOperations) {
            super(solrOperations);
            this.solrOperations = solrOperations;
        }
		
        @Override
        protected Object getTargetRepository(RepositoryMetadata metadata) {
            return new CustomBaseRepositoryImpl<T, ID>(solrOperations, (Class<T>) metadata.getDomainType());
        }

		@Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return CustomBaseRepository.class;
        }
    }
}

Als Nächstes konfigurieren wir Spring Data Solr so, dass es die soeben erstellte Repository-Factory-Bean verwendet. Fangen wir an.

Spring Data Solr konfigurieren

Unser letzter Schritt besteht darin, Spring Data Solr so zu konfigurieren, dass es die neue Repository-Factory-Bean verwendet, die wir im vorherigen Schritt erstellt haben. Wir können dies tun, indem wir entweder eine Java-Konfigurationsklasse oder eine XML-Konfigurationsdatei verwenden. Beide Optionen werden in den folgenden Unterabschnitten beschrieben.

Hinweis: Die verschiedenen Konfigurationsdateien, die in den folgenden Unterabschnitten vorgestellt werden, sind der Übersichtlichkeit halber vereinfacht. In Wirklichkeit hat unsere Beispielanwendung unterschiedliche Konfigurationen für Entwicklungs- und Produktionsumgebung.

Java-Konfiguration

Wenn wir die Java-Konfiguration verwenden, können wir Spring Data Solr so konfigurieren, dass es eine benutzerdefinierte Repository-Factory-Bean verwendet, indem wir die repositoryFactoryBeanClass verwenden Attribut von @EnableJpaRepositories Anmerkung. Der Quellcode der Konfigurationsklasse sieht wie folgt aus:

import org.springframework.context.annotation.Configuration;
import org.springframework.data.solr.repository.config.EnableSolrRepositories;

@Configuration
@EnableSolrRepositories(
        basePackages = "net.petrikainulainen.spring.datasolr.todo.repository.solr",
        repositoryFactoryBeanClass = CustomSolrRepositoryFactoryBean.class
)
public class SolrContext {

    //Configuration is omitted.
}

XML-Konfiguration

Wenn wir die XML-Konfiguration verwenden, können wir Spring Data Solr so konfigurieren, dass es eine benutzerdefinierte Repository-Factory-Bean verwendet, indem wir die factory-class verwenden Attribut der Repositories Namespace-Element. Die XML-Konfigurationsdatei unseres Anwendungskontexts sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:solr="http://www.springframework.org/schema/data/solr"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/data/solr http://www.springframework.org/schema/data/solr/spring-solr.xsd">

    <!-- Enable Solr repositories and configure repository base package -->
    <solr:repositories base-package="net.petrikainulainen.spring.datasolr.todo.repository.solr" 
                       factory-class="net.petrikainulainen.spring.datasolr.todo.repository.solr.CustomSolrRepositoryFactoryBean"/>

    <!-- The configuration is omitted. -->
</Beans>

Zusammenfassung

Wir haben jetzt zwei benutzerdefinierte Methoden erstellt, die zu allen Repositories unserer Beispielanwendung hinzugefügt werden. Wie wir bereits gelernt haben, ergibt dieses Beispiel natürlich keinen Sinn, da unsere benutzerdefinierte Repository-Schnittstelle und ihre Implementierung an das TodoDocument gebunden sind Klasse.

Dieses Tutorial hat uns zwei Dinge beigebracht:

Wir können die @NoRepositoryBean verwenden -Anmerkung, um Spring Data Solr zu signalisieren, dass es keine Implementierung für die Schnittstelle erstellen soll, die mit @NoRepositoryBean annotiert ist Anmerkung.
Wir können eine benutzerdefinierte Repository-Factory-Bean konfigurieren, indem wir entweder die repositoryFactoryBeanClass verwenden -Attribut von @EnableSolrRepositories Anmerkung oder die Werksklasse Attribut der Repositories Namespace-Element.

Die Beispielanwendung dieses Blogbeitrags ist wie immer auf Github verfügbar.