Tag Archives: annotations

[repost ]My first Custom Annotation

original:http://sujitpal.blogspot.com/2008/03/my-first-custom-annotation.html

In a previous post, I noted that although I did not know much about how annotations worked, I seem to be using them more and more nowadays. I guess it was only a matter of time before I found a use-case where I would need to write my own annotation. Anyway, the opportunity presented itself when I was trying to write out a JPA @Entity bean described in my previous post out to a Lucene index. This post describes the annotation itself, and how I used it in my index building code.

My objective was to annotate some of the fields in my @Entity beans to tell the indexing process that these fields should be picked up. Additionally, I wanted to specify the Store and Index attributes that will govern how they will be stored and indexed.

To do this, I created the following Annotation class. The Storable and Indexable enums have elements that shadow the Field.Store and Field.Index enums in Lucene.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// IndexMeta.java
package com.mycompany.myapp.indexing;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Property level annotation to indicate indexing meta-information.
 * Bean properties that should be indexed should be annotated with this.
 * Additional field level indexing metadata is supplied through the 
 * attributes Indexable and Storable. 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface IndexMeta {

  public enum Indexable {NO, NO_NORMS, TOKENIZED, UN_TOKENIZED};
  public enum Storable {COMPRESS, NO, YES};

  Indexable indexable() default Indexable.NO;
  Storable storable() default Storable.NO;
}

To test this, we created two BookArticle objects in the database. Since BookArticle objects inherit from Article objects, we need to annotate properties in both classes. This is shown below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Article.java
package com.mycompany.myapp.persistence;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

import com.mycompany.myapp.indexing.IndexMeta;
import com.mycompany.myapp.indexing.IndexMeta.Indexable;
import com.mycompany.myapp.indexing.IndexMeta.Storable;

/**
 * The article superclass table contains all the common fields.
 */
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
@DiscriminatorColumn(discriminatorType=DiscriminatorType.INTEGER, name="articleTypeId")
public abstract class Article extends ModelBase {

  @IndexMeta(indexable=Indexable.UN_TOKENIZED, storable=Storable.YES)
  private String articleId;
  @IndexMeta(indexable=Indexable.TOKENIZED, storable=Storable.YES)
  private String title;
  @IndexMeta(indexable=Indexable.TOKENIZED, storable=Storable.YES)
  private String summary;
  @IndexMeta(indexable=Indexable.NO, storable=Storable.YES)
  private String url;
  private String fileLocation;

  ... getters and setters removed ...  
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// BookArticle.java
package com.mycompany.myapp.persistence;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

import com.mycompany.myapp.indexing.IndexMeta;
import com.mycompany.myapp.indexing.IndexMeta.Indexable;
import com.mycompany.myapp.indexing.IndexMeta.Storable;

/**
 * Models a book article.
 */
@Entity
@DiscriminatorValue("2")
public class BookArticle extends Article {

  private static final long serialVersionUID = -2274023497279749079L;

  @IndexMeta(indexable=Indexable.TOKENIZED, storable=Storable.YES)
  private String authorName;
  private String publisherName;
  private String isbnNumber;

  ... getters and setters removed ...
}

Finally, we use Java 1.5’s new reflection methods to find and apply the annotations during our indexing process. The JUnit test below shows how to get all the BookArticle beans from the database using JPA, and then passing the beans to a Lucene IndexWriter.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
// IndexingTest.java
package com.mycompany.myapp.indexing;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.IndexWriter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.mycompany.myapp.indexing.IndexMeta.Indexable;
import com.mycompany.myapp.indexing.IndexMeta.Storable;
import com.mycompany.myapp.persistence.BookArticle;

/**
 * Test case to demonstrate indexing using the IndexMeta annotation.
 */
public class IndexingTest {

  private final Log log = LogFactory.getLog(getClass());

  private final String INDEX_LOCATION = "/tmp/testindex";

  private EntityManagerFactory emf;
  private EntityManager em;
  private IndexWriter indexWriter;

  @Before
  public void setUp() throws Exception {
    emf = Persistence.createEntityManagerFactory("myapp");
    em = emf.createEntityManager();
    indexWriter = new IndexWriter(INDEX_LOCATION, new StandardAnalyzer(), true);
  }

  @After
  public void tearDown() throws Exception {
    em.close();
    emf.close();
    indexWriter.optimize();
    indexWriter.close();
  }

  /**
   * Builds a Lucene index using the List of beans returned by a Query.
   * @throws Exception if one is thrown.
   */
  @Test
  public void testBuildIndex() throws Exception {
    // get the indexing metadata
    Map<String,IndexMeta> indexingMetadata = 
      buildIndexingMetadata(BookArticle.class);
    // get the data
    Query q = em.createQuery("select ba from BookArticle ba");
    List<BookArticle> articles = 
      (List<BookArticle>) q.getResultList();
    for (BookArticle article : articles) {
      Document doc = new Document();
      for (String fieldName : indexingMetadata.keySet()) {
        String value = getFieldValue(article, fieldName);
        if (value == null) {
          continue;
        }
        IndexMeta indexMeta = indexingMetadata.get(fieldName);
        Store storeProperty = getStoreProperty(indexMeta.storable());
        Index indexProperty = getIndexProperty(indexMeta.indexable());
        org.apache.lucene.document.Field f = 
          new org.apache.lucene.document.Field(
          fieldName, value, storeProperty, indexProperty);
        doc.add(f);
      }
      indexWriter.addDocument(doc);
    }
  }

  /**
   * Reflectively gets the String value of the named bean property. If an 
   * exception occurs, the value returned is null.
   * @param obj the Article object.
   * @param fieldName the name of the bean property.
   * @return the String value of the bean property.
   */
  private String getFieldValue(Object obj, String fieldName) {
    try {
      return String.valueOf(BeanUtils.getProperty(obj, fieldName));
    } catch (Exception e) {
      return null;
    }
  }

  /**
   * Reflectively build a Map of bean property name to the annotated IndexMeta
   * properties. Climbs the object tree until the Object class is reached.
   * @param type the Article type to build the Index metadata for.
   * @return a Map of bean property name to the associated IndexMeta annotation.
   */
  private Map<String,IndexMeta> buildIndexingMetadata(Class<?> type) {
    Map<String,IndexMeta> indexingMetadata = 
      new HashMap<String,IndexMeta>();
    do {
      Field[] fields = type.getDeclaredFields();
      for (Field field : fields) {
        IndexMeta indexMeta = field.getAnnotation(IndexMeta.class);
        if (indexMeta == null) {
          // no annotation, no lucene field
          continue;
        }
        indexingMetadata.put(field.getName(), indexMeta);
      }
      type = type.getSuperclass();
    } while (type != Object.class);
    return indexingMetadata;
  }

  /**
   * Helper method to map the Field.Index value from IndexMeta.Indexable
   * @param indexable an instance of Indexable.
   * @return an instance of Field.Index.
   */
  private Index getIndexProperty(Indexable indexable) {
    switch(indexable) {
      case NO_NORMS:
        return Index.NO_NORMS;
      case TOKENIZED:
        return Index.TOKENIZED;
      case UN_TOKENIZED:
        return Index.UN_TOKENIZED;
      case NO:
      default:
        return Index.NO;
    }
  }

  /**
   * Helper method to return Field.Store value for IndexMeta.Storable.
   * @param storable an instance of Storable.
   * @return an instance of Field.Store.
   */
  private Store getStoreProperty(Storable storable) {
    switch(storable) {
      case COMPRESS:
        return Store.COMPRESS;
      case YES:
        return Store.YES;
      case NO:
      default:
        return Store.NO;
    }
  }
}

And of course, the obligatory screenshot of what this index looks like in Luke.

I hope this has been useful. I had read about annotations in the official annotation documentation and in the O’Reilly Java 1.5 Tiger – A Developer’s Handbook by Brett McLaughlin and David Flanagan, but I could never come up with a use-case where I would need to build my own. This example may resonate a little better with Java developers who use ORMs and Lucene.

On a somewhat related note, check out Steve Yegge’s blog post “Execution in the Kingdom of Nouns“. Not only is it quite hilarious, it is also the clearest analogy I have seen that explains the differences between Object Oriented programming and functional programming. Why related? Well, we started with classes and interfaces. Java 1.5 gave us Enums and Annotations. Maybe it is time Java gave us Function objects as well, so we can use them directly when requirements dictate, rather than setting up anonymous holder classes to do the same thing.