Introduzione a Spring Data Solr

1. Panoramica

In questo articolo, esploreremo le basi di Spring Data Solr in modo pratico.

Apache Solr è un open source pronto per la distribuzione del motore di ricerca full-text aziendale. Puoi trovare ulteriori informazioni sulle funzionalità di Solr sul sito ufficiale.

Mostreremo come eseguire una semplice configurazione di Solr e ovviamente come interagire con il server.

Per prima cosa, dobbiamo avviare un server Solr e creare un core per memorizzare i dati (che, per impostazione predefinita, Solr creerà in modalità senza schema).

2. Dati di primavera

Proprio come qualsiasi altro progetto Spring Data, Spring Data Solr ha un chiaro obiettivo di rimuovere i codici boilerplate, di cui trarremo sicuramente vantaggio.

2.1. Dipendenza da Maven

Iniziamo aggiungendo la dipendenza Spring Data Solr al nostro pom.xml :

 org.springframework.data spring-data-solr 2.0.5.RELEASE 

Puoi trovare le ultime dipendenze qui.

2.2. Definizione del documento

Definiamo un documento chiamato Product :

@SolrDocument(solrCoreName = "product") public class Product { @Id @Indexed(name = "id", type = "string") private String id; @Indexed(name = "name", type = "string") private String name; }

L' annotazione @SolrDocument indica che la classe Product è un documento Solr e indicizzata al prodotto con nome principale . I campi annotati con @Indexed sono indicizzati in Solr e saranno ricercabili.

2.3. Definizione dell'interfaccia del repository

Successivamente, dobbiamo creare un'interfaccia del repository estendendo un repository fornito da Spring Data Solr. Lo parametrizzeremo naturalmente con Product e String come ID entità:

public interface ProductRepository extends SolrCrudRepository { public List findByName(String name); @Query("id:*?0* OR name:*?0*") public Page findByCustomQuery(String searchTerm, Pageable pageable); @Query(name = "Product.findByNamedQuery") public Page findByNamedQuery(String searchTerm, Pageable pageable); }

Notare come stiamo definendo tre metodi qui, oltre all'API fornita da SolrCrudRepository . Ne parleremo nelle prossime sezioni.

Si noti inoltre che la proprietà Product.findByNamedQuery è definita nel file di query Solr denominato solr-named-queries.properties nella cartella classpath:

Product.findByNamedQuery=id:*?0* OR name:*?0*

2.4. Configurazione Java

Ora esploreremo la configurazione Spring del layer di persistenza Solr:

@Configuration @EnableSolrRepositories( basePackages = "com.baeldung.spring.data.solr.repository", namedQueriesLocation = "classpath:solr-named-queries.properties", multicoreSupport = true) @ComponentScan public class SolrConfig { @Bean public SolrClient solrClient() { return new HttpSolrClient("//localhost:8983/solr"); } @Bean public SolrTemplate solrTemplate(SolrClient client) throws Exception { return new SolrTemplate(client); } }

Stiamo usando @EnableSolrRepositories per scansionare i pacchetti per i repository. Notare che abbiamo specificato la posizione del file delle proprietà della query denominata e abilitato il supporto multi-core.

Se il multi-core non è abilitato, per impostazione predefinita Spring Data presumerà che la configurazione di Solr sia per un singolo core. Stiamo abilitando il multi-core qui, solo per riferimento.

3. Indicizzazione, aggiornamento ed eliminazione

Per cercare documenti in Solr, i documenti dovrebbero essere indicizzati nel repository Solr.

L'esempio seguente indicizza un documento di prodotto nel repository Solr semplicemente utilizzando il metodo di salvataggio di SolrCrudRepository :

Product phone = new Product(); phone.setId("P0001"); phone.setName("Phone"); productRepository.save(phone);

Ora recuperiamo e aggiorniamo un documento:

Product retrievedProduct = productRepository.findOne("P0001"); retrievedProduct.setName("Smart Phone"); productRepository.save(retrievedProduct);

I documenti possono essere eliminati semplicemente chiamando il metodo di eliminazione:

productRepository.delete(retrievedProduct);

4. Interrogare

Esploriamo ora diverse tecniche di query fornite dall'API Spring Data Solr.

4.1. Generazione query nome metodo

Le query basate sul nome del metodo vengono generate analizzando il nome del metodo per generare la query prevista da eseguire:

public List findByName(String name);

Nella nostra interfaccia del repository, abbiamo il metodo findByName che genera query in base al nome del metodo:

List retrievedProducts = productRepository.findByName("Phone");

4.2. Query con annotazione @Query

Le query di ricerca Solr possono essere create inserendo la query in un'annotazione @Query di un metodo. Nel nostro esempio findByCustomQuery è annotato con l' annotazione @Query :

@Query("id:*?0* OR name:*?0*") public Page findByCustomQuery(String searchTerm, Pageable pageable);

Usiamo questo metodo per recuperare i documenti:

Page result = productRepository.findByCustomQuery("Phone", new PageRequest(0, 10));

Chiamando findByCustomQuery (“Phone”, new PageRequest (0, 10)) si ottiene la prima pagina dei documenti del prodotto che contengono la parola “Phone” in uno qualsiasi dei suoi campi id o name .

4.3. Query denominata

Le query denominate sono simili alle query con l' annotazione @Query tranne per il fatto che le query sono dichiarate in un file delle proprietà separato:

@Query(name = "Product.findByNamedQuery") public Page findByNamedQuery(String searchTerm, Pageable pageable);

Notare che l' annotazione @Query non è richiesta se la chiave ( findByNamedQuery ) della query nel file delle proprietà corrisponde al nome del metodo.

Recuperiamo alcuni documenti utilizzando il metodo di query denominato:

Page result = productRepository.findByNamedQuery("one", new PageRequest(0, 10));

5. conclusione

Questo articolo è un'introduzione rapida e pratica a Spring Data Solr, che copre la configurazione di base, la definizione dei repository e, naturalmente, l'esecuzione di query.

E come sempre, gli esempi usati qui sono disponibili come progetto di esempio su Github.