import org.springframework.scheduling.annotation.Async; 
...
...
@Async
public static void 
    FlightDescription.indexFlightDescriptions
     (Collection<FlightDescription> flightdescriptions) {

   java.util.List<SolrInputDocument> documents = 
        new java.util.ArrayList<SolrInputDocument>();
   
   for (FlightDescription flightdescription : 
         flightdescriptions) {
     
     SolrInputDocument sid = new SolrInputDocument();
     sid.addField("id", "flightdescription_" + 
         flightdescription.getId());
     sid.addField("flightdescription.id_l", 
         flightdescription.getId());
     sid.addField("flightdescription.origin_s", 
         flightdescription.getOrigin());
     ...
     sid.addField("flightdescription.price_f", 
         flightdescription.getPrice());
     sid.addField("flightdescription_solrsummary_t", ...);
     documents.add(sid);
   }
   try {
     SolrServer solrServer = solrServer();
     solrServer.add(documents);
     solrServer.commit();
   } catch (Exception e) {
      e.printStackTrace();
   }
}

The given code shows that the indexFlightDescriptions method is annotated with Spring's @Async annotation, which means that it is invoked asynchronously. The method iterates over all the FlightDescription instances (passed as method argument) and creates a list of SolrInputDocument. The SolrJ's SolrInputDocument class represents a document that you want to feed to Solr server for indexing. The addField method of SolrInputDocument identifies the field that you want to add to the document.

The field name that is added by Roo to the SolrInputDocument has the following naming convention:

<entity-simple-name>.<field-name>_<field-type>

Here, entity-simple-name is the simple name of JPA entity, field-name is the name of the field, and field-type is the type of the field. So, the orgin field is added to SolrInputDocument with the name flightdescription.origin_s and price field is added with the name flightdescription.price_f.

If the JPA entity field type isn't Integer, String, Long, Boolean, Float, Double, or Date, then the field name with which the JPA entity field is added to SolrInputDocument is shown as follows:

<entity-simple-name>.<field-name>_t

For instance, the Flight class in flightapp-web project contains the flightDescription relationship field of type FlightDescription, which is added to SolrInputDocument with name flight.flightdescription_t (refer to the Flight_Roo_SolrSearch.aj AspectJ ITD file).

You might be wondering, why Roo doesn't add JPA entity fields with their exact name in the SolrInputDocument. Here is a short description of how Solr works:

SolrInputDocument represents a document that you add to Solr search server. The document consists of fields and you need to tell Solr search server, which of these fields should be indexed. It is important to note that if a field is not indexed, then you can't search or sort documents based on that field. You tell the Solr search server, which fields of a document should be indexed by specifying the fields in schema.xml file located in SOLR_HOMEexamplesolrconf directory. Solr has the concept of Dynamic Fields, wherein if a field follows a standard naming convention, then it is automatically indexed by Solr search server. The following XML fragment from the schema.xml file defines the dynamic fields that will be automatically indexed by Solr:

<dynamicField name="*_s"  type="string"  indexed="true"  
  stored="true"/>
<dynamicField name="*_l"  type="slong"   indexed="true"  
  stored="true"/>
<dynamicField name="*_t"  type="text"    indexed="true"  
  stored="true"/>
<dynamicField name="*_f"  type="sfloat"  indexed="true"  
  stored="true"/>

The given XML fragment instructs Solr to index any field that matches the pattern *_s, *_l, *_t, or *_f. So, now you can see the link between Roo generated field names and the dynamic fields defined by Solr.

The indexFlightDescriptions method also adds an id field name to the SolrInputDocument. It is mandatory for any SolrInputDocument to contain a field named id, which uniquely identifies the document in Solr index. By default, Roo sets the value of id field to "flightdescription_" + flightdescription.getId(). We'll see later in this section that this id field value is used for deleting the document from Solr index.

The indexFlightDescriptions method also adds an extra field, flightdescription_solrsummary_t, in SolrInputDocument so that it can be used to search all documents that have been indexed by Solr for FlightDescription JPA entity. Similarly, the indexFlightDescriptions method of Flight_Roo_SolrSearch.aj AspectJ ITD adds flight_solrsummary_t field in SolrInputDocument to allow searching for documents indexed by Solr for the Flight JPA entity.

The following code in the indexFlightDescriptions method adds the SolrInputDocuments to Solr index:

SolrServer solrServer = solrServer();
solrServer.add(documents);
solrServer.commit();

public static void 
  FlightDescription.indexFlightDescription(FlightDescription 
    flightdescription) {
    List<FlightDescription> flightdescriptions = 
      new ArrayList<FlightDescription>();
    flightdescriptions.add(flightdescription);
    indexFlightDescriptions(flightdescriptions);
}

As the given code shows, indexFlightDescription method delegates the responsibility of adding FlightDescription instance to Solr index to indexFlightDescriptions method.

@Async
public static void 
   FlightDescription.deleteIndex(FlightDescription 
     flightdescription) {
   SolrServer solrServer = solrServer();
   try {
     solrServer.deleteById("flightdescription_" + 
       flightdescription.getId());
     solrServer.commit();
   } catch (Exception e) {
     e.printStackTrace();
   }
}

In the given code, the deleteById method of SolrServer deletes the document (from Solr index), which has the id attribute value "flightdescription_" + flightdescription.getId(). The Spring's @Async annotation means that the deleteIndex method is invoked asynchronously.

import javax.persistence.PostPersist;
import javax.persistence.PostUpdate;
...
...
@PostUpdate
@PostPersist
private void FlightDescription.postPersistOrUpdate() {
    indexFlightDescription(this);
}

The @PostUpdate and @PostPersist JPA annotations indicate that postPersistOrUpdate method is invoked when FlightDescription JPA entity is updated or persisted in the database. The call to indexFlightDescription method suggests that the entity data is updated or added to the Solr index.

import javax.persistence.PreRemove;
...
...    
@PreRemove
private void FlightDescription.preRemove() {
  deleteIndex(this);
}

The @PreRemove JPA annotation means that the preRemove method is invoked before the JPA entity instance is removed from the database.

public static QueryResponse FlightDescription.search(SolrQuery query) {
    try {
        return solrServer().query(query);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new QueryResponse();
}

SolrQuery represents a query object, which contains the field information based on which the search has to be performed, the fields to return, and so on. The query method of SolrServer sends the search request to Solr search server using Apache Commons HttpClient and returns a QueryResponse object from which you can extract the Solr documents that matched the search query.

public static QueryResponse 
   FlightDescription.search(String queryString) {
    String searchString = 
      "FlightDescription_solrsummary_t:" + queryString;
    return search(new SolrQuery(searchString.toLowerCase()));
}

In the given code, the SolrQuery object is created using the searchString. The searchString specifies the Solr query used for finding matching Solr documents. As searchString already contains the constant value "FlightDescription_solrsummary_t:", which means that you can only search for Solr documents that contain "FlightDescription_solrsummary_t" field. If you remember from the earlier discussion, the "FlightDescription_solrsummary_t" field is only available in Solr documents which have been added corresponding to the FlightDescription entity.