[jboss-dev-forums] [JBoss Microcontainer Development] - Re: Adding getAnnotationsAnnotatedWith() to MDR

[kabir.khan@jboss.com]

Some more changes to AbstractMDL to avoid having to iterate over the contexts every time


  | ===================================================================
  | --- src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java	(revision 97282)
  | +++ src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java	(working copy)
  | @@ -22,6 +22,8 @@
  |  package org.jboss.metadata.plugins.loader;
  |  
  |  import java.lang.annotation.Annotation;
  | +import java.util.ArrayList;
  | +import java.util.List;
  |  
  |  import org.jboss.metadata.spi.loader.MetaDataLoader;
  |  import org.jboss.metadata.spi.retrieval.AnnotationItem;
  | @@ -31,6 +33,7 @@
  |  import org.jboss.metadata.spi.retrieval.MetaDataRetrieval;
  |  import org.jboss.metadata.spi.retrieval.MetaDatasItem;
  |  import org.jboss.metadata.spi.retrieval.ValidTime;
  | +import org.jboss.metadata.spi.retrieval.basic.BasicAnnotationsItem;
  |  import org.jboss.metadata.spi.retrieval.helper.AnnotationToMetaDataBridge;
  |  import org.jboss.metadata.spi.retrieval.helper.AnnotationsToMetaDatasBridge;
  |  import org.jboss.metadata.spi.scope.ScopeKey;
  | @@ -54,6 +57,8 @@
  |     /** The scope key */
  |     private ScopeKey scopeKey;
  |     
  | +   private volatile AnnotationsAnnotatedWithCache cache;
  | +   
  |     /**
  |      * Create a new AbstractMetaDataLoader.
  |      */
  | @@ -92,7 +97,47 @@
  |     {
  |        return retrieveAnnotations();
  |     }
  | +   
  | +   protected AnnotationsAnnotatedWithCache getAnnotationsAnnotatedWithCache()
  | +   {
  | +      if (cache == null)
  | +      {
  | +         synchronized (this)
  | +         {
  | +            if (cache == null)
  | +            {
  | +               cache = new AnnotationsAnnotatedWithCache();
  | +            }
  | +         }
  | +      }
  | +      return cache;
  | +   }
  |  
  | +   public AnnotationsItem retrieveAnnotationsAnnotatedWith(Class<? extends Annotation> meta)
  | +   {
  | +      AnnotationsItem item = getAnnotationsAnnotatedWithCache().getAnnotationsAnnotatedWith(meta);
  | +      if (item == null)
  | +      {
  | +         AnnotationsItem annotations = retrieveAnnotations();
  | +         List<AnnotationItem<? extends Annotation>> values = new ArrayList<AnnotationItem<? extends Annotation>>(annotations.getAnnotations().length);
  | +         for (AnnotationItem<? extends Annotation> current : annotations.getAnnotations())
  | +         {
  | +            for (Annotation ann : current.getAnnotation().annotationType().getAnnotations())
  | +            {
  | +               if (meta == ann.annotationType())
  | +               {
  | +                  values.add(current);
  | +                  break;
  | +               }
  | +            }
  | +         }
  | +         item = new BasicAnnotationsItem(this, values.toArray(new AnnotationItem[values.size()]));
  | +         cache.addAnnotationsAnnotatedWith(meta, item);
  | +      }
  | +      return item;
  | +   }
  | +
  | +
  |     @SuppressWarnings("unchecked")
  |     public <T> MetaDataItem<T> retrieveMetaData(Class<T> type)
  |     {
  | @@ -141,5 +186,12 @@
  |     public void invalidate()
  |     {
  |        validTime.invalidate();
  | +      invalidateAnnotationsAnnotatedWithCache();
  |     }
  | +   
  | +   protected void invalidateAnnotationsAnnotatedWithCache()
  | +   {
  | +      if (cache != null)
  | +         cache.invalidate();
  | +   }
  |  }
  | 

The cache is basically just a wrapper around a map

  | public class AnnotationsAnnotatedWithCache
  | {
  |    private ConcurrentMap<Class<? extends Annotation>, AnnotationsItem> annotationsByMetaAnnotation = new ConcurrentHashMap<Class<? extends Annotation>, AnnotationsItem>();
  |    
  |    public AnnotationsItem getAnnotationsAnnotatedWith(Class<? extends Annotation> meta)
  |    {
  |        AnnotationsItem annotationsItem = annotationsByMetaAnnotation.get(meta);
  |        if (annotationsItem != null)
  |           return annotationsItem;
  |        return null;
  |    }
  |    
  |    public void addAnnotationsAnnotatedWith(Class<? extends Annotation> meta, AnnotationsItem item)
  |    {
  |       annotationsByMetaAnnotation.putIfAbsent(meta, item);
  |    }
  |    
  |    public void invalidate()
  |    {
  |       annotationsByMetaAnnotation.clear();
  |    }
  | }
  | 
AMDL.invalidateCache() gets called when annotations are added/removed from MemoryMetaDataLoader, which seems to be the only AMDL subclass that changes the annotations

View the original post : http://www.jboss.org/index.html?module=bb&op=viewtopic&p=4269050#4269050

Reply to the post : http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=4269050