Once indexing has been enabled, custom objects being stored in Red Hat JBoss Data Grid need to be assigned appropriate annotations.

As a basic requirement, all objects required to be indexed must be annotated with

In addition, all fields within the object that will be searched need to be annotated with @Field.

@Indexed
public class Person implements Serializable {
    @Field(store = Store.YES)
    private String name;
    @Field(store = Store.YES)
    private String description;
    @Field(store = Store.YES)
    private int age;
}

For other annotations and options, see Mapping Domain Objects to the Index Structure.

The key for each value must also be indexed, and the key instance must then be transformed in a String.

Red Hat JBoss Data Grid includes some default transformation routines for encoding common primitives, however to use a custom key you must provide an implementation of org.infinispan.query.Transformer.

The following example shows how to annotate your key type using org.infinispan.query.Transformer:

@Transformable(transformer = CustomTransformer.class)
public class CustomKey {

}

public class CustomTransformer implements Transformer {
    @Override
    public Object fromString(String s) {
        return new CustomKey(...);
    }

    @Override
    public String toString(Object customType) {
        CustomKey ck = (CustomKey) customType;
        return ck.toString();
    }
}

The two methods must implement a biunique correspondence.

For example, for any object A the following must be true:

A.equals(transformer.fromString(transformer.toString(A));

This assumes that the transformer is the appropriate Transformer implementation for objects of type A.

The following provides an example of how to set up and run a query in Red Hat JBoss Data Grid.

In this example, the Person object has been annotated using the following:

@Indexed
public class Person implements Serializable {
    @Field(store = Store.YES)
    private String name;
    @Field
    private String description;
    @Field(store = Store.YES)
    private int age;
}

Assuming several of these Person objects have been stored in JBoss Data Grid, they can be searched using querying. The following code creates a SearchManager and QueryBuilder instance:

SearchManager manager =	Search.getSearchManager(cache);
QueryBuilder builder = manager.buildQueryBuilderForClass(Person.class) .get();
Query luceneQuery = builder.keyword()
    .onField("name")
    .matching("FirstName")
    .createQuery();

The SearchManager and QueryBuilder are used to construct a Lucene query. The Lucene query is then passed to the SearchManager to obtain a CacheQuery instance:

CacheQuery query = manager.getQuery(luceneQuery);
List<Object> results = query.list();
for (Object result : results) {
    System.out.println("Found " + result);
}

This CacheQuery instance contains the results of the query, and can be used to produce a list or it can be used for repeat queries.