Solr und MyCoRe

Dieses Kapitel beschäftigt sich mit der Einbindung der Suchmaschine Apache Solr in MyCoRe. Das MyCoRe-Release 2023.06 LTS wird erfolgreich mit Solr 8.11.4 eingesetzt und das 2024.06 LTS wird mit Solr 9.7 getestet.

Falls noch kein Solr-Server zur Verfügung steht, kann er gemäß der Anleitung im Abschnitt Einrichtung eines Solr-Servers installiert werden.

Begrifflichkeiten

Im Zusammenhang mit der Nutzung der Properties und Kommandos zur Konfiguration von Solr-Cores in MyCoRe sind vorab einige Begiffe zu definieren.

Configuration Set (config_set)

beschreibt ein vorgefertigtes Template, welches alternativ zu dem in Solr mitgelieferten _default-Template zum Erstellen eines neuen Cores eingesetzt werden kann. Die Configuration Sets sind für alle MyCoRe-Anwendungen auf dem selben Release-Stand gleich. Seit MyCoRe 2024.06 LTS werden sie zusammen mit der MyCoRe-Solr-Komponente ausgeliefert.

Core Configuration Type (core_config_type)

bezeichnet eine Variante der Konfiguration. Seit MyCoRe 2024.06 LTS können eigene Core-Typen definiert werden. Durch MyCoRe festgelegt sind die beiden Typen main und classification. Der Name des Types entspricht dem Pfad zu den JSON-API-Vorlagen für das Solr-Schema in den einzelnen MyCoRe-Modulen (z. B..../{modulname}/config/solr/{core_config_type}/solr-schema.json). Es ist möglich, dass zwei Kerne den gleichen Typ zugewiesen haben und somit die gleichen Daten parallel in zwei Kernen indexiert werden.

CoreId (core_id)

ist eine fiktive ID, mit der die einzelnen Cores in einer MyCoRe-Anwendung bezeichnet werden. Sie wird vor allem für die Konfiguration benutzt. Standardmäßig werden die IDs anlog zu den passenden Konfigurationstypen mit main und classification vergeben.

CoreName (core_name)

ist der konkrete Name des Cores auf dem Solr-Server.

Grundlegende Konfiguration

Nun müssen für jede MyCoRe-Anwendung ein oder mehrere Solr-Cores angelegt werden. Die Konfiguration der Kerne unterscheidet sich je nach Solr Installation. Wird Solr als Cloud-Installation betrieben, so wird die Konfiguration über die seit 2024.06 LTS verfügbaren Solr-Cloud-CLI-Kommandos durchgeführt. Für eine reguläre (Standalone) Solr-Installation werden Templates (Configuration Sets) für die Basiskonfiguration durch MyCoRe über GitHub bereitgestellt oder per MyCoRe-Kommando erzeugt.

Solr-Cores

Zunächst muss die Solr-Server-URL der MyCoRe-Anwendung über ein Property (siehe MyCoRe-Konfigurationsverzeichnis) bekannt gemacht werden. Weiterhin können für die einzelnen CoreIds der CoreName und falls abweichend auch die Solr-URLs definiert werden. Die CoreId main ist dabei immer erforderlich. Weitere CoreIds wie classification sind optional.
Es ist möglich, den Core auf einem anderen Solr Server zu erstellen und zu benutzen.
In diesem Fall muss das Property MCR.Solr.Core.{core_id}.ServerURL gesetzt werden.

1
2
3
4

MCR.Solr.ServerURL=http://localhost:8983/
MCR.Solr.Core.main.Name=my_core_name
MCR.Solr.Core.main.ServerURL=%MCR.Solr.ServerURL%
...

Alternativ können die CoreIds über die MyCoRe-CLI registriert werden. Diese Einstelllungen sind jedoch nicht persistent.

Bis MyCoRe 2023.06 LTS:

1
2

register solr core with name {0} as core {1}
register solr core with name my_core_name as core main

Ab MyCoRe 2024.06 LTS:

1
2
3
4
5

register solr core with name {0} as core {1}
add type {0} to solr core {1}

register solr core with name my_core_name as core main
add type main to solr core main

Authentifizierung

Ab Version 2024.06 bietet MyCoRe die Möglichkeit, Solr-Server mit einer Authentifizierung zu nutzen. Im Solr können fein granular für verschiedene Funktionen und Cores die benötigten Rechten konfiguriert werden. Für die Administration, Suche und Indexierung können in MyCoRe verschiedene Logins über folgende Properties gesetzt werden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

 MCR.Solr.Server.Auth.Admin.Class=org.mycore.solr.auth.MCRSolrBasicPropertyAuthentication
 MCR.Solr.Server.Auth.Admin.Username=meinAdmin
 MCR.Solr.Server.Auth.Admin.Password=geheim123

 MCR.Solr.Server.Auth.Index.Class=org.mycore.solr.auth.MCRSolrBasicPropertyAuthentication
 MCR.Solr.Server.Auth.Index.Username=meinIndexer
 MCR.Solr.Server.Auth.Index.Password=geheim321

 MCR.Solr.Server.Auth.Search.Class=org.mycore.solr.auth.MCRSolrBasicPropertyAuthentication
 MCR.Solr.Server.Auth.Search.Username=meinSucher
 MCR.Solr.Server.Auth.Search.Password=geheim231

Die Authentifizierung wird über die Basic Authentication von Solr realisiert. Dazu wird die Konfigurationsdatei security.json auf dem Solr Server gepflegt. Die Authentifizierung erfolgt über das Senden eines Authorization-Headers in den Solr-Requests. Wenn die Properties nicht gesetzt sind, führt MyCoRe keine Authentifizierung gegenüber Solr durch.

Der Search-Nutzer benötigt das Recht read der Index-Nutzer die Rechte read und update und der Admin-Nutzer das Recht all. Wenn mehrere Anwendungen auf den gleichen Solr-Server zugreifen, ist es ratsam, für jede Anwendung eigene Nutzer mit den entsprechenden Rechten passend zu den jeweiligen Kernen/Collections zu erstellen.

Erstellen und Erweitern der Configsets

Ab MyCoRe 2024.06 LTS können die Configsets in der Anwendung definiert und erweitert werden. Dazu werden die benötigten Dateien im Resource-Verzeichnis eines oder mehrerer MyCoRe-Module abgelegt und über Properties spezifiert. Über den Mechanismus "Dynamische Properties" kann die Konfiguration auch über verschiedene Module hinweg erfolgen.
Die Default-Konfiguration kann in der MyCoRe-Solr-Komponente gefunden werden. Sie lässt sich bei Bedarf erweitern:

1
2
3

MCR.Solr.ConfigSet.mycore_classification.Class=org.mycore.solr.cloud.configsets.MCRSolrResourceConfigSetProvider
MCR.Solr.ConfigSet.mycore_classification.Files=managed-schema,solrconfig.xml,stopwords.txt,synonyms.txt
MCR.Solr.ConfigSet.mycore_classification.Base=configset/mycore_main/conf/

Base stellt den Pfad zu den Konfigurationsdateien dar. Die Dateien welche in Files aufgeführt sind, werden als ein ZIP-Archiv gepackt, welches per Kommando erzeugt oder an die Solr-Cloud gesendet wird. Die Dateien werden über den ResourceResolver-Mechanismus geladen.

Die Einrichtung der Solr-Kerne ist abhängig von der Art des Solr-Servers und des verwendeten MyCoRe-Releases.

Standalone Solr-Server (bis MyCoRe 2023.06 LTS)

Configuration Sets laden

1
2

 cd  .../solr/server/solr/configsets
 git clone https://github.com/MyCoRe-Org/mycore_solr_configset_main.git mycore_main 

Alternativ kann das Verzeichnis auch manuell heruntergeladen und in diesen Ordner kopiert werden.

Analog kann das Configset für den Klassifikations-Core installiert werden:

1

 git clone https://github.com/MyCoRe-Org/mycore_solr_configset_classification.git mycore_classification

Standard Solr Core (main) erzeugen

Basierend auf den bereitgestellten Configuration Sets werden nun Solr-Cores erzeugt. Als Name des main Cores kann der Name der MyCoRe-Anwendung gewählt werden.

1
2

.../solr/bin/solr create -c {core_name} -d {config_set}
.../solr/bin/solr create -c my_core_name -d mycore_main

Standalone Solr-Server (ab MyCoRe 2024.06 LTS)

Configuration Sets laden

Die MyCoRe-Config-Sets sind direkt im Modul mycore-solr enthalten. Da Anwendungen die Configuration Sets erweitern (z.B. Dateien ergänzen) können, sollte das vollständige Configuration Set über die MyCoRe-Kommandozeile generiert werden:

1
2

 export solr configset mycore_main to folder /tmp/solr_configsets
 export solr configset mycore_classification to folder /tmp/solr_configsets

1
2
3

 cd .../solr/server/solr/configsets
 mkdir -p %configset_name%/conf
 unzip /path/to/configset.zip -d %configset_name%/conf

Solr-Core(s) erzeugen

Basierend auf den bereitgestellten Configuration Sets werden nun Solr-Cores erzeugt. Als Name des main Cores kann der Name der MyCoRe-Anwendung gewählt werden.

1
2

.../solr/bin/solr create -c {core_name} -d {config_set}
.../solr/bin/solr create -c my_core_name -d mycore_main

Solr-Cloud-Instanz (ab MyCoRe 2024.06 LTS)

Configuration Sets laden

Seit MyCoRe 2024.06 LTS bietet MyCoRe die Möglichkeit, die Configuration Sets direkt in die Solr-Cloud zu laden und anschließend die Kerne(Collections) zu erstellen. Hierfür wird die Solr-ConfigSet-API und die Solr-Collection-API verwendet.

Die ConfigSet-API erwartet ein ZIP-Archiv, welches die Konfigurationsdateien enthält, dass bedeutet MyCoRe muss die Konfiguration aus einer Quelle laden können und diese in ein ZIP-Archiv packen und dieses an die Solr-Cloud senden. Hierfür wird das Interface MCRSolrConfigSetProvider verwendet. Dieses Interface muss von einer Klasse implementiert werden, die die Konfigurationen bereitstellt. Für den Standardfall, dass die Konfigurationen aus dem Klassenpfad zu laden sind, liefert MyCoRe die Klasse MCRSolrResourceConfigSetProvider.

Die Configuration Sets mycore_main und mycore_classification sind direkt im Modul mycore-solr enthalten und können direkt per MyCoRe-CLI geladen werden. Wichtig ist dafür das für den passenden Kern das richtige Configuration Set festgelegt ist. Dies kann über das Property MCR.Solr.Core.{core_id}.ConfigSetTemplate erfolgen. Für die Kerne main und classification sind die Configuration Sets mycore_main und mycore_classification in der MyCoRe-Solr-Komponente vordefiniert.

1
2
3
4
5
6
7

# eigener Kern
MCR.Solr.Core.custom.Name=my_core_name
MCR.Solr.Core.custom.ConfigSetTemplate=mycore_main

# in MyCoRe vordefiniert
MCR.Solr.Core.main.ConfigSetTemplate=mycore_main
MCR.Solr.Core.classification.ConfigSetTemplate=mycore_classification

Über die MyCoRe-CLI kann das Configuration Set geladen werden:

1
2

upload local config set for {0}
upload local config set for main

In der Solr-Cloud-Instanz können die Configuration Sets nicht für einen weiteren Kern wiederverwendet werden, da beim Aktualisieren mit der Schema-API auch das Configuration Set modifiziert wird. Daher werden sie in der Solr-Cloud unter einem bestimmten modifizierten Namen abgelegt, welcher sich nach dem Muster $CoreId_$ConfigSetName zusammensetzt. Das Configuration Set mycore_main wird also in der Solr-Cloud beispielsweise unter dem Namen main_mycore_main abgelegt.

Erzeugen des Solr-Cores

Die MyCoRe-CLI bietet die Möglichkeit, die Solr-Cores direkt in der Solr-Cloud zu erstellen. Hierfür wird die Solr-Collection-API verwendet. Folgende Kommandos können verwendet werden:

1
2

create collection for core {0}
create collection for core main

Die Collection wird mit dem Standardwert für die Anzahl der Shards erstellt.
Diese können über das Property MCR.Solr.Core.{core_id}.ShardCount angepasst werden.

Über die Solr-Web-Oberfläche kann geprüft werden, ob der Core richtig angelegt wurde (http://localhost:8983/solr/#/~cores).

Über das MyCoRe-Kommando show solr configuration kann eine Liste der zu setzenden Properties in der CLI angezeigt werden.

Solr Schema laden

Da verschiedene MyCoRe Komponenten und Module individuelle Suchfelder und Datentypen benötigen, können diese direkt in den Modulen definiert werden. Mittels eines MyCoRe-Kommandos werden diese Definitonsdateien ausgelesen und über die Solr Schema API in den Core geschrieben.

Die Konfiguration der Solr-Suchfelder, Request-Handler, ... wurden seit MyCoRe 2018.06 LTS auf die Module und Komponenten aufgeteilt, in denen sie verwendet werden. Die Basisfelder / -Konfiguration für alle MyCoRe-Anwendungen befindet sich in der Komponente mycore-solr.

Je nach Anwendungsfall kann es sein, dass neben dem Solr-Core vom Typ main weitere Definitionen für andere Core Typen (z. B. classification) erstellt werden müssen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{mycore-module}/src/main/resources/components/{module_name}/config/solr
or
{application-module}/src/main/resources/config/{application-module}/solr

 .../main - the core that use each MyCoRe application
   .../solr-schema.json - vorhanden, wenn das Modul das Solr-Schema erweitert
   .../solr-config.json - vorhanden, wenn das Modul die Solr-Konfiguration erweitert

 .../{other_type} - other core definitions
   .../solr-schema.json - vorhanden, wenn das Modul das Solr-Schema erweitert
   .../solr-config.json - vorhanden, wenn das Modul die Solr-Konfiguration erweitert

Die JSON-Dateien bestehen aus Json-Arrays, die Kommandos der Solr-Schema bzw. Solr-Configuration API enthalten. Sollen bereits bestehende / in MyCoRe vorhandene Felder oder ihre Definition geändert werden, kann dies über replace-Anweisungen in den JSON-Konfigurationsdateien erfolgen.

In Solr wird die anwenderseitige Konfiguration in der gesonderten Datei configoverlay.json im jeweiligen Kern abgelegt. Hier können Einträge aus den Gruppen stehen, welche im Property MCR.Solr.ObserverConfigTypes definiert sind. Ggf. sind in diesen Definitionen auch Verweise auf eigene Solr-FieldTypes vorhanden. Diese Elemente (z. B. ein RequestHandler) müssen beim Reload der Solr-Kern-Konfiguration vorher gelöscht werden. Um nicht all Konfigurationen wahllos zu löschen, sind diese im mycore.properties des jeweiligen Datenmodells explizit zum Löschen anzugeben.

1

MCR.Solr.ObserverConfigTypes.{observedType}.toClean={my_request_handler},...

Über ein MyCoRe-CLI Kommando wird die Konfiguration geladen. Im Normalfall lautet das Kommando:

1
2

mycore.sh reload solr configuration {core_config_type} in core {core_id}
mycore.sh reload solr configuration main in core main

Anschließend sollte noch einmal über die Solr-Web-Oberfläche geprüft werden, ob der Core vollständig konfiguriert wurde. Weiterhin sollte im MyCoRe-Log / in der Kommandozeile geprüft werden, ob Solr sämtliche Konfigurationskommandos ausgeführt hat. Ist alles okay, so ist der Core betriebsbereit.

(siehe Solr Control Script Reference, Schema API und Config API)

Textextraktion mit Tika

Standardmäßig findet die Textextraktion aus den Dokumenten innerhalb von Solr statt. Jedoch raten die Entwickler von Solr davon ab, die Textextraktion im produktiven Betrieb zu nutzen und empfehlen die Textextraktion vorab durchzuführen. Hierfür kann das Property MCR.Solr.Indexer.File.AccumulatorList genutzt werden. Dieses Property erwartet eine Liste von Klassen, welche zusätzliche Solr-Felder aus Dateien extrahieren und für die Indexierung bereitstellen. Für die Textextraktion mit Tika kann die Klasse org.mycore.solr.index.file.tika.MCRSolrRemoteTikaAccumulator verwendet werden. Diese Klasse sendet die Dateien an einen Tika-Server, welcher die Textextraktion durchführt. Die extrahierten Texte werden als JSON an die MyCoRe-Anwendung zurückgegeben. Anschließend wird für jeden JSON-Key in der Antwort ein MCRTikaMapper verwendet, um die extrahierten Texte verschiedenen Solr-Feldern zuzuweisen. Eine Beispielkonfiguration sieht wie folgt aus:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

 # In MyCoRe vordefiniert
 MCR.Solr.Indexer.File.AccumulatorList=org.mycore.solr.index.file.tika.MCRSolrRemoteTikaAccumulator

 # Standard Mapper
 MCR.Solr.Tika.Mapper.Default.Class=org.mycore.solr.index.file.tika.MCRTikaNOPMapper

 # Mapper für das Feld X-TIKA:content
 MCR.Solr.Tika.Mapper.x_tika_content.Class=org.mycore.solr.index.file.tika.MCRSimpleTikaMapper
 MCR.Solr.Tika.Mapper.x_tika_content.StripNamespace=true
 MCR.Solr.Tika.Mapper.x_tika_content.MultiValueField=true

 # (nicht vordefiniert) Properties um Tika zu konfigurieren
 # Aktivierung des Accumulators durch das setzen der URL
 MCR.Solr.Tika.ServerURL=https://mein-tika-server.de:9998/tika
 # keine Dateien mehr an solr senden
 MCR.Solr.FileIndexStrategy=org.mycore.solr.index.file.tika.MCRTikaSolrFileStrategy
 # maximale Dateigröße in Byte z.B. 1GB
 MCR.Solr.Tika.MaxFileSize=1073741824

Der SimpleTikaMapper ist ein einfacher Mapper, welcher die extrahierten Texte in ein Solr-Feld schreibt. Ein JSON-Dokument von Tika sieht wie folgt aus:

1
2
3
4
5
6
7
8

{
    ....
    "X-TIKA:content": "Der extrahierte Text",
    "access_permission:can_modify": "true",
    "pdf:docinfo:producer": "iText® 7.1.15 ©2000-2021 iText Group NV (AGPL-version)",
    "pdf:docinfo:created": "2021-08-02T14:14:13Z",
    "pdf:containsDamagedFont": "false"
}

In der Beispielkonfiguration von oben ist der Default-Mapper ein MCRTikaNOPMapper (MCRTikaNoOperationMapper). Dieser Mapper ignoriert den JSON-Key für den es konfiguriert ist. Für den x_tika_content Key wird der MCRSimpleTikaMapper verwendet. Dieser Mapper schreibt den extrahierten Text in das Solr-Feld mit dem angepassten Namen des JSON-Keys. Dabei werden alle Zeichen die keine Buchstaben oder Zahlen sind entfernt und der Text in Kleinbuchstaben umgewandelt. Außerdem besteht die Möglichkeit den Namespace des JSON-Keys zu entfernen. Je nach dem ob der Wert des JSON-Keys ein Array ist, kann das Feld als MultiValue-Feld gesetzt werden (MultiValueField=true) oder ob der Wert als String konkateniert werden soll. Aus dem Beispiel JSON-Dokument wird also der Wert des x_tika_content Keys in das Solr-Feld content geschrieben.

1
2
3

...
<field name="content">Der extrahierte Text</field>
...

Das Solr-Document

Die in Solr zu speichernden Daten werden als Solr-Document über eine Kette von XSLT-Transformationen generiert, welches dann an den Solr-Server gesendet wird. Hierfür ist das Property MCR.URIResolver.xslImports.solr-document zuständig. Grundsätzlich in der Kette enthalten sind die Stylesheets solr-basetemplate.xsl und mycoreobject-dynamicfields.xsl. Weitere Transformer können dieser Kette angefügt werden (siehe Beispielcode). Der an Solr ausgehende Datenstrom läßt sich im Web-Browser mit der URL http://{myapp}/receive/{mycore_id}?XSL.Style=solrdocument überprüfen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="3.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                exclude-result-prefixes="xlink mcrxsl">

    <xsl:import href="xslImport:solr-document:viaf2solr.xsl"/>

    <xsl:template match="mycoreobject[contains(@ID,'_{my_datamodel}_')]">
        <xsl:apply-imports/>
        <!-- field name="viaf_name_all" type="text_general" multiValued="true" stored="true" -->
        <xsl:for-each select="./metadata/def.preferredName/preferredName">
            <field name="viaf_name_all">
                <xsl:value-of select="fullname/text()"/>
            </field>
        </xsl:for-each>
        ...
    </xsl:template>
</xsl:stylesheet>
        

Über verschiedene rebuild Kommandos (siehe Kommandos zur Arbeit mit Solr) können die Daten in den Solr Core eingespielt werden. Um alle Daten zu indexieren, kann beispielsweise folgendes Kommando verwendet werden:

1

 rebuild solr metadata and content index in core main

Eigene Request-Handler einbinden

MyCoRe verhindert grundsätzlich den Gebrauch eigener Solr-Request-Handler solange diese nicht MyCoRe bekannt sind. Aus Sicherheitsgründen sind zunächst nur die Handler /select und /update zugelassen. Sollen weitere Handler benutzt werden, müssen diese im Property MCR.Solr.Proxy.WhiteList hinzugefügt werden. Dies kann mit folgender Konfiguration erfolgen:

1

 MCR.Solr.Proxy.WhiteList=%MCR.Solr.Proxy.WhiteList%,/myhandler

Solr und Content Security Policy

Mit Solr 8 kommt bei den Responses die Content Security Policy (CSP) im Header zum tragen. Diese Policies werden in MyCoRe an die Layout-Komponenten weiter gegeben. Nutzt die Webseite externe Referenzen, kann das zu Konflikten führen. Um die CSP zu überschreiben, wurde das folgende Property eingeführt. Es kann die CSP aus Solr ersetzen oder, wenn es leer ist, diese abschalten.

1
2
3

  MCR.Solr.HTTPResponseHeader.Content-Security-Policy=default-src 'none'; base-uri 'none'; connect-src 'self';
    form-action 'self'; font-src 'self'; frame-ancestors 'none'; img-src 'self'; media-src 'self'; 
    style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' https://...; worker-src 'self';

Properties für die Solr-Komponente

Solr Kommandos für die MyCoRe CLI

Folgende Kommandos stehen für die Arbeit mit Solr an der Kommandozeile zur Verfügung. Achtung: Verwenden Sie bei der Arbeit mit Solr-Kommandos die CLI (mycore.sh) stets im interaktiven Modus. Andernfalls besteht die Gefahr, dass Operationen nicht vollständig ausgeführt werden! Die Core ID für den Standard Solr Core in MyCoRe ist main.

Solr-Cloud Commands

Solr Core Admin Commands

Solr Index and Search Commands

Solr-Abfragen über die MyCoRe-Java-API

Mit diesen Code-Schnipseln soll demonstriert werden, wie ein Zugriff auf die Solr-Daten mittels MyCoRe-API erfolgen kann.

Bis 2023.06 LTS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

 import org.apache.solr.client.solrj.SolrClient;
 import org.apache.solr.client.solrj.SolrQuery;
 import org.apache.solr.client.solrj.SolrServerException;
 import org.apache.solr.common.SolrDocumentList;
 import org.mycore.solr.MCRSolrClientFactory;
 import org.mycore.solr.MCRSolrUtils;

 ...
 SolrClient solrClient = MCRSolrClientFactory.getMainSolrClient();
 //oder:
 SolrClient solrClient = MCRSolrClientFactory.get("{coreID}").getClient();

 SolrQuery query = new SolrQuery();
 query.setQuery("title:foo");
 query.setRows(10);
 SolrDocumentList results = solrClient.query(query).getResults();
 ...

Ab 2024.06 LTS

Seit Version 2024.06 LTS unterstützt MyCoRe die Authentifizierung von Solr-Abfragen. Deshalb sollte diese ab jetzt immer (unabhängig davon, ob die Authentifizierung tatsächlich konfiguriert ist) bei der Implementierung berücksichtigt werden. Die Klasse MCRSolrAuthenticationManager enthält Methoden, die die in MyCoRe konfigurierte Authentifizierung zu einem SolrRequest oder zu einem HttpRequest.Builder hinzufügen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

 import org.apache.solr.client.solrj.SolrClient;
 import org.apache.solr.client.solrj.SolrQuery;
 import org.apache.solr.client.solrj.SolrServerException;
 import org.apache.solr.client.solrj.request.QueryRequest;
 import org.apache.solr.client.solrj.response.QueryResponse;
 import org.apache.solr.common.SolrDocumentList;
 import org.apache.solr.common.SolrInputDocument;
 import org.mycore.solr.auth.MCRSolrAuthenticationManager;

 ...
 SolrClient solrClient = MCRSolrCoreManager.getMainSolrClient();
 //oder:
 SolrClient solrClient = MCRSolrCoreManager.get("{coreID}").get().getClient();

 SolrQuery query = new SolrQuery();
 query.setQuery("title:foo");
 query.setRows(10);
 QueryRequest queryRequest = new QueryRequest(query);
 MCRSolrAuthenticationManager.getInstance().applyAuthentication(queryRequest, MCRSolrAuthenticationLevel.SEARCH);

 try {
   QueryResponse process = queryRequest.process(solrClient);
   SolrDocumentList results = process.getResults();
 } catch (SolrServerException e) {
     throw new RuntimeException(e); // handle this
 }

 ...