Either approach for defining a custom analyzer begins with an @AnalyzerDef annotation on the relevant persistent class. In the chapter4 version of our VAPORware Marketplace application, let's define a custom analyzer to be used with the App entity's description field. It should strip out any HTML tags, and apply various token filters to reduce clutter and account for typos:

...
@AnalyzerDef(
   name="appAnalyzer",
   charFilters={    
      @CharFilterDef(factory=HTMLStripCharFilterFactory.class) 
   },
   tokenizer=@TokenizerDef(factory=StandardTokenizerFactory.class),
   filters={ 
      @TokenFilterDef(factory=StandardFilterFactory.class),
      @TokenFilterDef(factory=StopFilterFactory.class),
      @TokenFilterDef(factory=PhoneticFilterFactory.class, 
            params = {
         @Parameter(name="encoder", value="DoubleMetaphone")
            }),
      @TokenFilterDef(factory=SnowballPorterFilterFactory.class, 
            params = {
      @Parameter(name="language", value="English") 
      })
   }
)
...

The @AnalyzerDef annotation must have a name element set, and as previously discussed, an analyzer must always include one and only one tokenizer.

The charFilters and filters elements are optional. If set, they receive lists of one or more factory classes, for character filters and token filters respectively.

The @Analyzer annotation is used to select and apply a custom analyzer. This annotation may be placed on an individual field, or on the overall class where it will affect every field. In this case, we are only selecting our analyzer definition for the desciption field:

...
@Column(length = 1000)
@Field
@Analyzer(definition="appAnalyzer")
private String description;
...

It is possible to define multiple analyzers in a single class, by wrapping their @AnalyzerDef annotations within a plural @AnalyzerDefs:

...
@AnalyzerDefs({
   @AnalyzerDef(name="stripHTMLAnalyzer", ...),
   @AnalyzerDef(name="applyRegexAnalyzer", ...)
})
...

Obviously, where the @Analyzer annotation is later applied, its definition element has to match the appropriate @AnalyzerDef annotation's name element.

It is possible to wait until runtime to select a particular analyzer for a field. The most obvious scenario is an application supporting different languages, with analyzer definitions configured for each language. You would want to select the appropriate analyzer based on a language attribute for each object.

To support such a dynamic selection, an @AnalyzerDiscriminator annotation is added to a particular field or to the class as a whole. This code snippet uses the latter approach:

@AnalyzerDefs({
   @AnalyzerDef(name="englishAnalyzer", ...),
   @AnalyzerDef(name="frenchAnalyzer", ...)
})
@AnalyzerDiscriminator(impl=CustomerReviewDiscriminator.class)
public class CustomerReview {
   ...
   @Field
   private String language;
   ...
}

There are two analyzer definitions, one for English and the other for French, and the class CustomerReviewDiscriminator is declared responsible for deciding which to use. This class must implement the Discriminator interface, and its getAnalyzerDefinitionName method:

public class LanguageDiscriminator implements Discriminator {

   public String getAnalyzerDefinitionName(Object value, 
         Object entity, String field) {
      if( entity == null || !(entity instanceofCustomerReview) ) {
         return null;
      }
      CustomerReview review = (CustomerReview) entity;
      if(review.getLanguage() == null) {
         return null;
       } else if(review.getLanguage().equals("en")) {
         return "englishAnalyzer";
       } else if(review.getLanguage().equals("fr")) {
         return "frenchAnalyzer";
       } else {
         return null;
      }
   }

}

If the @AnalyzerDiscriminator annotation is placed on a field, then its value for the current object is automatically passed as the first parameter to getAnalyzerDefinitionName. If the annotation is placed on the class itself, then a null value is passed instead. The second parameter is the current entity object either way.

In this case, the discriminator is applied at the class level. So we cast that second parameter to type CustomerReview, and return the name of the appropriate analyzer based on the object's language field. If the language is unknown or if there are other issues, then the method simply returns null, telling Hibernate Search to fall back to the default analyzer.