AnnotationReader.java

  1. package com.gh.mygreen.xlsmapper.xml;

  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.util.HashMap;
  7. import java.util.Map;

  9. import com.gh.mygreen.xlsmapper.xml.bind.AnnotationInfo;
  10. import com.gh.mygreen.xlsmapper.xml.bind.ClassInfo;
  11. import com.gh.mygreen.xlsmapper.xml.bind.FieldInfo;
  12. import com.gh.mygreen.xlsmapper.xml.bind.MethodInfo;
  13. import com.gh.mygreen.xlsmapper.xml.bind.AnnotationMappingInfo;


  16. /**
  17.  * フィールド、メソッドのアノテーションへアクセスするためのクラス。
  18.  * <p>Javaソースに直接アノテーションを付与する場合と、XMLで定義する方法の両方をサポートする。
  19.  * 
  20.  * @version 2.0
  21.  * @author Naoki Takezoe
  22.  * @author T.TSUCHIE
  23.  *
  24.  */
  25. public class AnnotationReader {
  26.     
  27.     /**
  28.      * XMLで定義した情報。
  29.      * nullでもよい。
  30.      */
  31.     private final AnnotationMappingInfo xmlInfo;
  32.     
  33.     /**
  34.      * アノテーションを動的に組み立てるクラス。
  35.      */
  36.     private DynamicAnnotationBuilder annotationBuilder = DynamicAnnotationBuilder.getInstance();
  37.     
  38.     /**
  39.      * XMLで定義した情報を指定するコンストラクタ。
  40.      * @param xmlInfo XMLで定義したアノテーションの情報。{@link XmlIO}で読み込んで取得した値。指定しない場合はnull。
  41.      */
  42.     public AnnotationReader(final AnnotationMappingInfo xmlInfo) {
  43.         this.xmlInfo = xmlInfo;
  44.     }
  45.     
  46.     /**
  47.      * Returns all class annotations.
  48.      *
  49.      * @param clazz the target class
  50.      * @return all annotations present on target class
  51.      * @throws AnnotationReadException 
  52.      */
  53.     public Annotation[] getAnnotations(final Class<?> clazz) throws AnnotationReadException {
  54.         
  55.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  56.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  57.             final Map<String, Annotation> map = new HashMap<>();
  58.             
  59.             if(classInfo.isOverride()) {
  60.                 for(Annotation ann : clazz.getAnnotations()) {
  61.                     map.put(ann.annotationType().getName(), ann);
  62.                 }
  63.             }
  64.             
  65.             for(AnnotationInfo annInfo: classInfo.getAnnotationInfos()) {
  66.                 try {
  67.                     map.put(annInfo.getClassName(),
  68.                             annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo));
  69.                 } catch (ClassNotFoundException e) {
  70.                     throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  71.                 }
  72.             }
  73.             
  74.             return map.values().toArray(new Annotation[map.size()]);
  75.         }
  76.         
  77.         return clazz.getAnnotations();
  78.     }
  79.     
  80.     /**
  81.      * Returns a class annotation for the specified type if such an annotation is present, else null.
  82.      *
  83.      * @param <A> the type of the annotation
  84.      * @param clazz the target class
  85.      * @param annClass the Class object corresponding to the annotation type
  86.      * @return the target class's annotation for the specified annotation type if present on this element, else null
  87.      * @throws AnnotationReadException 
  88.      */
  89.     @SuppressWarnings("unchecked")
  90.     public <A extends Annotation> A getAnnotation(final Class<?> clazz, final Class<A> annClass) throws AnnotationReadException {
  91.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  92.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  93.             
  94.             if(classInfo.containsAnnotationInfo(annClass.getName())) {
  95.                 AnnotationInfo annInfo = classInfo.getAnnotationInfo(annClass.getName());
  96.                 try {
  97.                     return (A)annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo);
  98.                 } catch (ClassNotFoundException e) {
  99.                     throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  100.                 }
  101.             }
  102.         }
  103.         
  104.         return clazz.getAnnotation(annClass);
  105.     }
  106.     
  107.     /**
  108.      * メソッドに付与された指定したアノテーションを取得する。
  109.      * 
  110.      * @param method 取得対象のメソッド。
  111.      * @param annClas 取得対象のアノテーションのタイプ。
  112.      * @return
  113.      * @throws AnnotationReadException
  114.      */
  115.     @SuppressWarnings("unchecked")
  116.     public <A extends Annotation> A getAnnotation(final Method method, final Class<A> annClas) throws AnnotationReadException {
  117.         
  118.         final Class<?> clazz = method.getDeclaringClass();
  119.         
  120.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  121.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  122.             
  123.             if(classInfo.containsMethodInfo(method.getName())) {
  124.                 MethodInfo methodInfo = classInfo.getMethodInfo(method.getName());
  125.                 if(methodInfo != null && methodInfo.containsAnnotationInfo(annClas.getName())) {
  126.                     AnnotationInfo annInfo = methodInfo.getAnnotationInfo(annClas.getName());
  127.                     try {
  128.                         return (A)annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo);
  129.                     } catch (ClassNotFoundException e) {
  130.                         throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  131.                     }
  132.                 }
  133.             }
  134.         }
  135.         return method.getAnnotation(annClas);
  136.     }
  137.     
  138.     /**
  139.      * メソッドに付与されたアノテーションを持つか判定します。
  140.      * @since 2.0
  141.      * @param method 判定対象のメソッド
  142.      * @param annClass アノテーションのタイプ
  143.      * @return trueの場合、アノテーションを持ちます。
  144.      */
  145.     public <A extends Annotation> boolean hasAnnotation(final Method method, final Class<A> annClass) {
  146.         return getAnnotation(method, annClass) != null;
  147.     }
  148.     
  149.     /**
  150.      * メソッドに付与されたアノテーションを全て取得する。
  151.      * 
  152.      * @param method 取得対象のメソッド。
  153.      * @return 取得対象のアノテーションのタイプ。
  154.      * @throws AnnotationReadException
  155.      */
  156.     public Annotation[] getAnnotations(final Method method) throws AnnotationReadException {
  157.         
  158.         final Class<?> clazz = method.getDeclaringClass();
  159.         
  160.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  161.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  162.             
  163.             if(classInfo.containsMethodInfo(method.getName())) {
  164.                 final MethodInfo methodInfo = classInfo.getMethodInfo(method.getName());
  165.                 final Map<String, Annotation> map = new HashMap<>();
  166.                 
  167.                 if(methodInfo.isOverride()) {
  168.                     for(Annotation ann : method.getAnnotations()) {
  169.                         map.put(ann.annotationType().getName(), ann);
  170.                     }
  171.                 }
  172.                 
  173.                 for(AnnotationInfo annInfo: methodInfo.getAnnotationInfos()){
  174.                     try {
  175.                         map.put(annInfo.getClassName(),
  176.                                 annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo));
  177.                     } catch (ClassNotFoundException e) {
  178.                         throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  179.                     }
  180.                 }
  181.                 
  182.                 return map.values().toArray(new Annotation[map.size()]);
  183.             }
  184.         }
  185.         return method.getAnnotations();
  186.     }
  187.     
  188.     /**
  189.      * フィールドに付与されたアノテーションを指定して取得する。
  190.      * @param field 取得対象のフィールド
  191.      * @param annClass アノテーションのタイプ
  192.      * @return
  193.      * @throws AnnotationReadException
  194.      */
  195.     @SuppressWarnings("unchecked")
  196.     public <A extends Annotation> A getAnnotation(final Field field, final Class<A> annClass) throws AnnotationReadException {
  197.         
  198.         final Class<?> clazz = field.getDeclaringClass();
  199.         
  200.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  201.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  202.             
  203.             if(classInfo.containsFieldInfo(field.getName())) {
  204.                 FieldInfo fieldInfo = classInfo.getFieldInfo(field.getName());
  205.                 if(fieldInfo != null && fieldInfo.containsAnnotationInfo(annClass.getName())){
  206.                     AnnotationInfo annInfo = fieldInfo.getAnnotationInfo(annClass.getName());
  207.                     try {
  208.                         return (A)annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo);
  209.                     } catch (ClassNotFoundException e) {
  210.                         throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  211.                     }
  212.                 }
  213.             }
  214.         }
  215.         return field.getAnnotation(annClass);
  216.     }
  217.     
  218.     /**
  219.      * フィールドに付与されたアノテーションを持つか判定します。
  220.      * @since 2.0
  221.      * @param field 判定対象のフィールド
  222.      * @param annClass アノテーションのタイプ
  223.      * @return trueの場合、アノテーションを持ちます。
  224.      */
  225.     public <A extends Annotation> boolean hasAnnotation(final Field field, final Class<A> annClass) {
  226.         return getAnnotation(field, annClass) != null;
  227.     }
  228.     
  229.     /**
  230.      * フィールドに付与されたアノテーションを全て取得する。
  231.      * @param field 取得対象のフィールド
  232.      * @return
  233.      * @throws AnnotationReadException
  234.      */
  235.     public Annotation[] getAnnotations(final Field field) throws AnnotationReadException {
  236.         
  237.         final Class<?> clazz = field.getDeclaringClass();
  238.         
  239.         if(xmlInfo != null && xmlInfo.containsClassInfo(clazz.getName())) {
  240.             final ClassInfo classInfo = xmlInfo.getClassInfo(clazz.getName());
  241.             
  242.             if(classInfo.containsFieldInfo(field.getName())) {
  243.                 final FieldInfo fieldInfo = classInfo.getFieldInfo(field.getName());
  244.                 final Map<String, Annotation> map = new HashMap<>();
  245.                 
  246.                 if(fieldInfo.isOverride()) {
  247.                     for(Annotation ann : field.getAnnotations()) {
  248.                         map.put(ann.annotationType().getName(), ann);
  249.                     }
  250.                 }
  251.                 
  252.                 for(AnnotationInfo annInfo: fieldInfo.getAnnotationInfos()){
  253.                     try {
  254.                         map.put(annInfo.getClassName(), 
  255.                                 annotationBuilder.buildAnnotation(Class.forName(annInfo.getClassName()), annInfo));
  256.                     } catch (ClassNotFoundException e) {
  257.                         throw new AnnotationReadException(String.format("not found class '%s'", annInfo.getClassName()), e);
  258.                     }
  259.                 }
  260.                 return map.values().toArray(new Annotation[map.size()]);
  261.             }
  262.         }
  263.         return field.getAnnotations();
  264.     }
  265.     
  266.     public DynamicAnnotationBuilder getAnnotationBuilder() {
  267.         return annotationBuilder;
  268.     }
  269.     
  270.     public void setAnnotationBuilder(DynamicAnnotationBuilder annotationBuilder) {
  271.         this.annotationBuilder = annotationBuilder;
  272.     }
  273.     
  274. }
Created with JaCoCo 0.8.5.201910111838