<p>In this article, I will discuss an example of the Spring Data Solr CRUD Application using Spring Boot. I have already discussed the Spring Data Solr such <strong><a href="https://dineshonjava.com/installing-configuring-apache-solr/">how to install Apache Solr</a></strong> and how to <strong><a href="https://dineshonjava.com/spring-data-solr-configuration-using-spring-boot/">configure the Spring Data Solr</a></strong> to your spring application.</p>
<p>Spring Data provides an easy and very generic way to create the repositories for each technology such as Solr, Cassandra, MongoDB, JPA etc. In <strong><a href="https://dineshonjava.com/spring-data-solr-tutorial/">Spring Data Solr tutorial</a></strong>, I have discussed how to <strong><a href="https://dineshonjava.com/creating-spring-data-solr-repositories/">create Spring Data Solr repositories</a></strong> using Spring Data interface or custom repository creation without using Spring Data repository interface. Also, we have learned to create <a href="https://dineshonjava.com/spring-data-solr-dynamic-queries/"><strong>dynamic Solr queries</strong></a> and <strong><a href="https://dineshonjava.com/spring-data-solr-sorting-with-example/">sorting the Solr query results</a></strong>. And how to render this <strong><a href="https://dineshonjava.com/spring-data-solr-pagination-example/">Solr query result with pagination</a></strong>.</p>
<p><img class="aligncenter size-full wp-image-4171" src="https://dineshonjava.com/wp-content/uploads/2018/06/Spring-Boot-Solr-Example.jpg" alt="Spring Data Solr CRUD Application" width="567" height="175" /></p>
<p>Let&#8217;s create an application with CRUD operation using Spring Data Solr and Spring Boot.</p>
<h2>Spring Data Solr CRUD Application</h2>
<p>As we know that the Apache Solr is an open source ready to deploy enterprise full-text search engine. But in this article, I will show you how to do a simple Solr configuration and how to interact with the Solr server. Let&#8217;s first <strong><a href="https://dineshonjava.com/installing-configuring-apache-solr/">start the Solr server</a> </strong>as we have configured in the previous articles as the following diagram:</p>
<p><img class="aligncenter size-full wp-image-4220" src="https://dineshonjava.com/wp-content/uploads/2018/09/start-solr.png" alt="start solr" width="467" height="128" /></p>
<p>As you can see in the above diagram, the Solr server is started now and running at the 8983 port. You can see the running Solr by launching the Solr Admin UI in your web browser: <strong><a href="http://localhost:8983/solr/" rel="noopener">http://localhost:8983/solr/</a></strong> as the following:</p>
<p><img class="aligncenter size-full wp-image-4162" src="https://dineshonjava.com/wp-content/uploads/2018/06/running-solr.png" alt="running solr" width="1147" height="639" /></p>
<p>You can see the above diagram of the Solr server admin dashboard. Finally, you can create the collections in the Solr server. And we will use these collections into our application for CRUD operations. Let&#8217;s create collections by using the following command.</p>
<pre class="highlight">bin\solr create -c Order</pre>
<p>After creating the Order collection, let’s move to index this collection with Data using application.</p>
<h3>Adding Spring Data to application</h3>
<p>Spring team has created Spring Data projects to simplify DAO layer implementation and removing boilerplate codes. Like other Spring Data project. Spring Data Solr is also created for removing boilerplate codes and simplifying DAO implementation in the spring application. Let&#8217;s see how to add Spring Data Solr in your application by using the following Maven and Gradle dependency.</p>
<p><strong>Maven Dependency</strong><br />
Let’s start by adding the Spring Data Solr dependency on our pom.xml:</p>
<pre class="highlight"> 
<;dependency>; 
 <;groupId>;org.springframework.data<;/groupId>; 
 <;artifactId>;spring-data-solr<;/artifactId>; 
 <;version>;3.0.10.RELEASE<;/version>; 
<;/dependency>; 
</pre>
<p><strong>Gradle Dependency</strong><br />
Let’s start by adding the Spring Data Solr dependency on our build.gradle:</p>
<pre class="highlight"> 
{ 
compile group: 'org.springframework.data', name: 'spring-data-solr', version: '3.0.10.RELEASE' 
} 
</pre>
<p>You can configure the <a href="https://mvnrepository.com/artifact/org.springframework.data/spring-data-solr" rel="noopener">latest dependency</a> of the Spring Data Solr project in your application. Next, let&#8217;s define a document class for the Order collection in this application.</p>
<h3>Defining the Document Class</h3>
<p>In this application, we are using Order collection, so, let&#8217;s define a document called Order as the following class:</p>
<pre class="highlight"> 
package com.doj.app.pojo; 
 
import org.springframework.data.annotation.Id; 
import org.springframework.data.solr.core.mapping.Indexed; 
import org.springframework.data.solr.core.mapping.SolrDocument; 
 
/** 
* @author Dinesh.Rajput 
* 
*/ 
@SolrDocument(collection="Order") 
public class Order { 
 
@Id 
@Indexed(name = "oid", type = "long") 
private Long orderid; 
 
@Indexed(name = "oname", type = "string") 
private String orderName; 
 
@Indexed(name = "odesc", type = "string") 
private String orderDescription; 
 
@Indexed(name = "pname", type = "string") 
private String productName; 
 
@Indexed(name = "cname", type = "string") 
private String customerName; 
 
@Indexed(name = "cmobile", type = "string") 
private String customerMobile; 
 
public Long getOrderid() { 
return orderid; 
} 
 
public void setOrderid(Long orderid) { 
this.orderid = orderid; 
} 
 
public String getOrderName() { 
return orderName; 
} 
 
public void setOrderName(String orderName) { 
this.orderName = orderName; 
} 
 
public String getProductName() { 
return productName; 
} 
 
public void setProductName(String productName) { 
this.productName = productName; 
} 
 
public String getCustomerName() { 
return customerName; 
} 
 
public void setCustomerName(String customerName) { 
this.customerName = customerName; 
} 
 
public String getCustomerMobile() { 
return customerMobile; 
} 
 
public void setCustomerMobile(String customerMobile) { 
this.customerMobile = customerMobile; 
} 
 
public String getOrderDescription() { 
return orderDescription; 
} 
 
public void setOrderDescription(String orderDescription) { 
this.orderDescription = orderDescription; 
} 
 
} 
</pre>
<p>In the above document class, we have annotated this class <em>@SolrDocument</em> annotation. This annotation indicates that the Order class is a Solr document and indexed to collection name Order. In this class, you would notice, the fields are annotated with <em>@Indexed</em>. It indicates these fields will be indexed to the Order collection and will be searchable. Also, a field of the Order class &#8220;orderid&#8221; is annotated with <em>@Id</em> annotation. This means that the field &#8220;orderid&#8221; is like primary key of this a Solr document.</p>
<p>In the next section, I will define the Spring Data Solr repository interface for this application.</p>
<h3>Defining Repository Interface</h3>
<p>Let&#8217;s create a repository interface for the Order Solr collection and this interface extending a repository provided by Spring Data Solr. As the given class below:</p>
<pre class="highlight">package com.doj.app.repository; 
 
import org.springframework.data.domain.Page; 
import org.springframework.data.domain.Pageable; 
import org.springframework.data.solr.repository.Query; 
import org.springframework.data.solr.repository.SolrCrudRepository; 
 
import com.doj.app.pojo.Order; 
 
/** 
* @author Dinesh.Rajput 
* 
*/ 
public interface SolrOrderRepository extends SolrCrudRepository<;Order, Long>; { 
 
Order findByOrderid(Long orderid); 
 
@Query("odesc:*?0*") 
Page<;Order>; findByOrderDescription(String searchTerm, Pageable pageable); 
 
@Query("odesc:*?0* OR oname:*?0* OR pname:*?0*") 
Page<;Order>; findByCustomerQuery(String searchTerm, Pageable pageable); 
 
} 
</pre>
<p>The above repository interface, we have naturally parametrized this with Order and Long as our entity id. As we know that this is Spring Boot application, so we don&#8217;t need to configure Spring Data Solr manually for the Spring Boot application. The Spring Boot application will automatically configure the required configuration by default according to the library available on the classpath of the application. But we have to provide Apache Solr server address by configuring it with the application.properties file as the following:</p>
<h3>Application configuration file</h3>
<p>First, let&#8217;s see the configuration file for the Spring Boot application.<br />
<strong>application.properties</strong></p>
<pre class="highlight">spring.data.solr.host=http://localhost:8983/solr/ 
</pre>
<p>Let&#8217;s assume, if you don&#8217;t want to use default configuration of the Spring Boot application or you are not using the Spring Boot for this application then you have to explicitly configure the Spring Data Solr into this Spring Data Solr CRUD Application.</p>
<h3>Explicitly Java Based Configuration</h3>
<p>Let&#8217;s see the following Java-based configuration for the Spring Data Solr in the Spring Data Solr CRUD Application.</p>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.app.config; 
 
import org.apache.solr.client.solrj.SolrClient; 
import org.apache.solr.client.solrj.impl.HttpSolrClient; 
import org.springframework.beans.factory.annotation.Value; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.ComponentScan; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.data.solr.core.SolrTemplate; 
import org.springframework.data.solr.repository.config.EnableSolrRepositories; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
@Configuration 
@EnableSolrRepositories( 
		basePackages = "com.doj.app.repository") 
@ComponentScan 
public class SolrConfig { 
	 
 @Value("spring.data.solr.host") String solrURL; 
	 
 @Bean 
 public SolrClient solrClient() { 
 return new HttpSolrClient.Builder(solrURL).build(); 
 } 
 
 @Bean 
 public SolrTemplate solrTemplate(SolrClient client) throws Exception { 
 return new SolrTemplate(client); 
 } 
} 
 
</pre>
<p>We are using <em>@EnableSolrRepositories</em> to scan the packages for repositories.</p>
<blockquote><p><strong>Note</strong>: If multi-core is not enabled, then by default Spring Data will assume that Solr configuration is for a single core.</p></blockquote>
<p>Now, move to perform CRUD operation for this Solr collection in the Spring Data Solr CRUD Application.</p>
<h2>Indexing, Updating, Deleting, and Querying</h2>
<p>In order to search documents in Solr, documents should be indexed to Solr repository. Let&#8217;s create a controller class which takes request parameters and index to the Solr document Order.</p>
<pre class="highlight">package com.doj.app.controller; 
 
import java.util.List; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.data.domain.PageRequest; 
import org.springframework.web.bind.annotation.DeleteMapping; 
import org.springframework.web.bind.annotation.GetMapping; 
import org.springframework.web.bind.annotation.PathVariable; 
import org.springframework.web.bind.annotation.PostMapping; 
import org.springframework.web.bind.annotation.PutMapping; 
import org.springframework.web.bind.annotation.RequestBody; 
import org.springframework.web.bind.annotation.RestController; 
 
import com.doj.app.pojo.Order; 
import com.doj.app.repository.SolrOrderRepository; 
 
/** 
* @author Dinesh.Rajput 
* 
*/ 
@RestController 
public class OrderController { 
 
@Autowired 
SolrOrderRepository solrOrderRepository; 
 
@PostMapping("/order") 
public String createOrder(@RequestBody Order order){ 
String description = "Order Created"; 
solrOrderRepository.save(order); 
return description; 
} 
 
@GetMapping("/order/{orderid}") 
public Order readOrder(@PathVariable Long orderid){ 
return solrOrderRepository.findByOrderid(orderid); 
} 
 
@PutMapping("/order") 
public String updateOrder(@RequestBody Order order){ 
String description = "Order Updated"; 
solrOrderRepository.save(order); 
return description; 
} 
 
@DeleteMapping("/order/{orderid}") 
public String deleteOrder(@PathVariable Long orderid){ 
String description = "Order Deleted"; 
solrOrderRepository.delete(solrOrderRepository.findByOrderid(orderid)); 
return description; 
} 
 
@GetMapping("/order/desc/{orderDesc}/{page}") 
public List<;Order>; findOrder(@PathVariable String orderDesc, @PathVariable int page){ 
return solrOrderRepository.findByOrderDescription(orderDesc, PageRequest.of(page, 2)).getContent(); 
} 
 
@GetMapping("/order/search/{searchTerm}/{page}") 
public List<;Order>; findOrderBySearchTerm(@PathVariable String searchTerm, @PathVariable int page){ 
return solrOrderRepository.findByCustomerQuery(searchTerm, PageRequest.of(page, 2)).getContent(); 
} 
} 
</pre>
<p><strong>Create</strong></p>
<p>In the above controller class, we have created all CRUD operation and provided handler methods for these operations. Let&#8217;s run this application and index some data by using <em>createOrder()</em> request handler method with <em><strong>/order POST</strong></em> endpoint.</p>
<p><strong>Read</strong></p>
<p>In the above controller class, we have created <em>readOrder()</em> request handler method with <strong><em>/order/{orderid}</em> <em>GET</em></strong> endpoint to read the data from the Solr server using the Spring Data Solr.</p>
<p><strong>Update</strong></p>
<p>In the above controller class, we have created <em>updateOrder()</em> request handler method with<em><strong> /order PUT</strong></em> endpoint to update a given order value.</p>
<p><strong>Delete</strong></p>
<p>In the above controller class, we have created <em>deleteOrder()</em> request handler method with <em><strong>/order/{orderid} DELETE</strong></em> endpoint to delete a document from the Solr collection.</p>
<p>Let&#8217;s see the following the Solr dashboard after creating data into Order collection.</p>
<p><img class="aligncenter size-full wp-image-4221" src="https://dineshonjava.com/wp-content/uploads/2018/09/solr-data.png" alt="solr data" width="779" height="626" /></p>
<p> ;</p>
<h2>Summary</h2>
<p>This article has all about the Spring Data Solr with Spring Boot and the Apache Solr. It is a quick and practical introduction to Spring Data Solr, covering the basic configuration, defining repositories and perform CRUD operation. In this Spring Data Solr CRUD Application, we have created an application and this application available as a sample project on <strong><a href="https://github.com/dineshonjava/SpringBootSpringDataSolrCrudExample" rel="noopener">Github</a></strong>.</p>
<p> ;</p>
<p> ;</p>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/spring-data-solr-pagination-example/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 
									 </div> 
									</div>
<script type="text/javascript">
jQuery(document).ready(function($) {
 $.post('https://dineshonjava.com/wp-admin/admin-ajax.php', {action: 'mts_view_count', id: '4219'});
});
</script>
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…