Introduction to Spring Data Solr

1. Overview

In this article, we’ll explore the basics of Spring Data Solr in a practical manner.

Apache Solr is an open source ready to deploy enterprise full-text search engine. You can find more about the features of Solr on the official website.

We’ll show how to do a simple Solr configuration an of course how to interact with the server.

First, we need to start a Solr server and create a core to store data (which, by default Solr will create in schemaless mode).

2. Spring Data

Just as any other Spring Data project, Spring Data Solr has a clear goal to remove boilerplate codes, which we’ll definitely take advantage of.

2.1. Maven Dependency

Let’s start by adding the Spring Data Solr dependency to our pom.xml:

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-solr</artifactId>
    <version>2.0.5.RELEASE</version>
</dependency>

You can find the latest dependencies here.

2.2. Defining the Document

Let’s define a document called Product:

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

    @Indexed(name = "name", type = "string")
    private String name;

}

@SolrDocument annotation indicates that the Product class is a Solr document and indexed to core named product. Fields annotated with @Indexed are indexed in Solr and will be searchable.

2.3. Defining Repository Interface

Next, we need to create a repository interface by extending a repository provided by Spring Data Solr. We’ll naturally parametrize this with Product and String as our entity id:

public interface ProductRepository extends SolrCrudRepository<Product, String> {

    public List<Product> findByName(String name);

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

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

}

Notice how we’re defining three methods here, on top of the API provided by SolrCrudRepository. We’ll talk about these in the next few sections.

Also note that the Product.findByNamedQuery property is defined in Solr named query file solr-named-queries.properties in the classpath folder:

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

2.4. Java Configuration

Now we’ll explore the Spring configuration of Solr persistence layer:

@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("http://localhost:8983/solr");
    }

    @Bean
    public SolrTemplate solrTemplate(SolrClient client) throws Exception {
        return new SolrTemplate(client);
    }
}

We are using @EnableSolrRepositories to scan the packages for repositories. Note that we have specified the location of the named query properties file and enabled multi-core support.

If multi-core is not enabled, then by default Spring Data will assume that Solr configuration is for a single core. We’re enabling multi-core here, just for reference.

3. Indexing, Updating and Deleting

In order to search documents in Solr, documents should be indexed to Solr repository.

Following example indexes a product document in Solr repository simply by using the SolrCrudRepository’s save method:

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

Now let’s retrieve and update a document:

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

Documents can be deleted by simply calling the delete method:

productRepository.delete(retrievedProduct);

4. Querying

Let’s now explore different querying techniques provided by the Spring Data Solr API.

4.1. Method Name Query Generation

Method name based queries are generated by parsing the method name to generate the expected query to execute:

public List<Product> findByName(String name);

In our repository interface, we have findByName method which generates query based on method name:

List<Product> retrievedProducts = productRepository.findByName("Phone");

4.2. Query with @Query Annotation

Solr search queries can be created by having the query in a @Query annotation of a method. In our example findByCustomQuery is annotated with @Query annotation:

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

Let’s use this method to retrieve documents:

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

By calling the findByCustomQuery(“Phone”, new PageRequest(0, 10)) we obtain the first page of the product documents which contain the word “Phone” in any of its fields id or name.

4.3. Named Query

Named queries are similar to queries with @Query annotation except the queries are declared in a separate properties file:

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

Note that the @Query annotation is not required if the key (findByNamedQuery) of the query in properties file matches the method name.

Let’s retrieve some documents using named query method:

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

5. Conclusion

This article is a quick and practical introduction to Spring Data Solr, covering the a basic configuration, defining repositories and naturally – querying.

And as always, the examples used here are available as a sample project on Github.