ClassUtils.java

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

  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.util.Optional;

  8. import com.github.mygreen.cellformatter.lang.ArgUtils;

  10. /**
  11.  * クラスやメソッドに関するユーティリティクラス。
  12.  * また、リフレクションについても処理する。
  13.  * 
  14.  * @since 2.0
  15.  * @author T.TSUCHIE
  16.  *
  17.  */
  18. public class ClassUtils {
  19.     
  20.     /**
  21.      * メソッドがアクセッサメソッド（getter/setter）か判定します。
  22.      * 
  23.      * @param method メソッド情報
  24.      * @return trueの場合、アクセッサメソッド。
  25.      */
  26.     public static boolean isAccessorMethod(final Method method) {
  27.         
  28.         return isGetterMethod(method)
  29.                 || isBooleanGetterMethod(method)
  30.                 || isSetterMethod(method);
  31.         
  32.     }
  33.     
  34.     /**
  35.      * メソッドがgetterの書式かどうか判定する。
  36.      * ただし、boolean型にたいするisは{@link #isBooleanGetterMethod(Method)}で判定すること。
  37.      * <ol>
  38.      *  <li>メソッド名が'get'か始まっていること。</li>
  39.      *  <li>メソッド名が4文字以上であること。</li>
  40.      *  <li>引数がないこと。</li>
  41.      *  <li>戻り値が存在すること。</li>
  42.      * </ol>
  43.      * @param method メソッド情報
  44.      * @return trueの場合はgetterメソッドである。
  45.      */
  46.     public static boolean isGetterMethod(final Method method) {
  47.         
  48.         final String methodName = method.getName();
  49.         if(!methodName.startsWith("get")) {
  50.             return false;
  51.             
  52.         } else if(methodName.length() <= 3) {
  53.             return false;
  54.         }
  55.         
  56.         if(method.getParameterCount() > 0) {
  57.             return false;
  58.         }
  59.         
  60.         if(method.getReturnType().equals(Void.class)) {
  61.             return false;
  62.         }
  63.         
  64.         return true;
  65.         
  66.     }
  67.     
  68.     /**
  69.      * メソッドがsetterの書式かどうか判定する。
  70.      * <ol>
  71.      *  <li>メソッド名が'set'か始まっていること。</li>
  72.      *  <li>メソッド名が4文字以上であること。</li>
  73.      *  <li>引数が1つのみ存在すること</li>
  74.      *  <li>戻り値は、検証しません。</li>
  75.      * </ol>
  76.      * @param method メソッド情報
  77.      * @return trueの場合はsetterメソッドである。
  78.      */
  79.     public static boolean isSetterMethod(final Method method) {
  80.         
  81.         final String methodName = method.getName();
  82.         if(!methodName.startsWith("set")) {
  83.             return false;
  84.             
  85.         } else if(methodName.length() <= 3) {
  86.             return false;
  87.         }
  88.         
  89.         if(method.getParameterCount() != 1) {
  90.             return false;
  91.         }
  92.         
  93.         return true;
  94.         
  95.     }
  96.     
  97.     /**
  98.      * メソッドがプリミティブ型のbooleanに対するgetterの書式かどうか判定する。
  99.      * <ol>
  100.      *  <li>メソッド名が'is'か始まっていること。</li>
  101.      *  <li>メソッド名が3文字以上であること。</li>
  102.      *  <li>引数がないこと。</li>
  103.      *  <li>戻り値がプリミティブのboolean型であること。</li>
  104.      * </ol>
  105.      * 
  106.      * @param method メソッド情報
  107.      * @return trueの場合はboolean型のgetterメソッドである。
  108.      */
  109.     public static boolean isBooleanGetterMethod(final Method method) {
  110.         
  111.         final String methodName = method.getName();
  112.         if(!methodName.startsWith("is")) {
  113.             return false;
  114.             
  115.         } else if(methodName.length() <= 2) {
  116.             return false;
  117.         }
  118.         
  119.         if(method.getParameterCount() > 0) {
  120.             return false;
  121.         }
  122.         
  123.         if(!isPrimitiveBoolean(method.getReturnType())) {
  124.             return false;
  125.         }
  126.         
  127.         return true;
  128.     }
  129.     
  130.     /**
  131.      * タイプがプリミティブのboolean型かどうか判定する。
  132.      * @param type 判定対象のクラスタイプ。
  133.      * @return trueの場合、プリミティブのboolean型。
  134.      * @throws IllegalArgumentException {@literal type == null.}
  135.      */
  136.     public static boolean isPrimitiveBoolean(final Class<?> type) {
  137.         ArgUtils.notNull(type, "type");
  138.         
  139.         if(type.isPrimitive() && boolean.class.isAssignableFrom(type)) {
  140.             return true;
  141.         }
  142.         
  143.         return false;
  144.     }
  145.     
  146.     /**
  147.      * クラスから、指定したフィールド情報を取得します。
  148.      * @param targetClass フィールドが定義されているクラス
  149.      * @param propertyName プロパティ名
  150.      * @param propertyType プロパティタイプ
  151.      * @return 存在しない場合、空を返します。
  152.      */
  153.     public static Optional<Field> extractField(final Class<?> targetClass, final String propertyName, final Class<?> propertyType) {
  154.         
  155.         final Field field;
  156.         try {
  157.             field = targetClass.getDeclaredField(propertyName);
  158.         } catch (NoSuchFieldException | SecurityException e) {
  159.             return Optional.empty();
  160.         }
  161.         
  162.         field.setAccessible(true);
  163.         
  164.         if(!field.getType().equals(propertyType)) {
  165.             return Optional.empty();
  166.             
  167.         }
  168.         
  169.         return Optional.of(field);
  170.         
  171.     }
  172.     
  173.     /**
  174.      * クラスから、指定したgetterメソッド情報を取得します。
  175.      * @param targetClass し抽出先のクラス
  176.      * @param propertyName プロパティ名
  177.      * @param propertyType プロパティタイプ
  178.      * @return 存在しない場合、空を返します。
  179.      */
  180.     public static Optional<Method> extractGetter(final Class<?> targetClass, final String propertyName, final Class<?> propertyType) {
  181.         
  182.         final String methodName = "get" + Utils.capitalize(propertyName);
  183.         
  184.         Method method;
  185.         try {
  186.             method = targetClass.getMethod(methodName);
  187.             
  188.         } catch (NoSuchMethodException | SecurityException e) {
  189.             return Optional.empty();
  190.         }
  191.         
  192.         method.setAccessible(true);
  193.         
  194.         if(method.getParameterCount() > 0) {
  195.             return Optional.empty();
  196.         }
  197.         
  198.         if(!method.getReturnType().equals(propertyType)) {
  199.             return Optional.empty();
  200.         }
  201.         
  202.         return Optional.of(method);
  203.     }
  204.     
  205.     /**
  206.      * クラスから、指定したboolean型のgetterメソッド情報を取得します。
  207.      * @param targetClass 抽出先のクラス
  208.      * @param propertyName プロパティ名
  209.      * @return 存在しない場合、空を返します。
  210.      */
  211.     public static Optional<Method> extractBooleanGetter(final Class<?> targetClass, final String propertyName) {
  212.         
  213.         final String methodName = "is" + Utils.capitalize(propertyName);
  214.         
  215.         Method method;
  216.         try {
  217.             method = targetClass.getMethod(methodName);
  218.             
  219.         } catch (NoSuchMethodException | SecurityException e) {
  220.             return Optional.empty();
  221.         }
  222.         
  223.         method.setAccessible(true);
  224.         
  225.         if(!method.getReturnType().equals(boolean.class)) {
  226.             return Optional.empty();
  227.         }
  228.         
  229.         return Optional.of(method);
  230.     }
  231.     
  232.     /**
  233.      * クラスから、指定したsetterメソッド情報を取得します。
  234.      * @param targetClass 抽出先のクラス
  235.      * @param propertyName プロパティ名
  236.      * @param propertyType プロパティタイプ
  237.      * @return 存在しない場合、空を返します。
  238.      */
  239.     public static Optional<Method> extractSetter(final Class<?> targetClass, final String propertyName, final Class<?> propertyType) {
  240.         
  241.         final String methodName = "set" + Utils.capitalize(propertyName);
  242.         
  243.         Method method;
  244.         try {
  245.             method = targetClass.getMethod(methodName, propertyType);
  246.         } catch (NoSuchMethodException | SecurityException e) {
  247.             return Optional.empty();
  248.         }
  249.         
  250.         method.setAccessible(true);
  251.         
  252.         return Optional.of(method);
  253.     }
  254.     
  255.     /**
  256.      * アノテーションの指定した属性値を取得する。
  257.      * <p>アノテーションの修飾子はpublicである必要があります。</p>
  258.      * @param anno アノテーションのインスタンス
  259.      * @param attrName 属性名
  260.      * @param attrType 属性のタイプ。
  261.      * @return 属性を持たない場合、空を返す。
  262.      */
  263.     @SuppressWarnings("unchecked")
  264.     public static <T> Optional<T> getAnnotationAttribute(final Annotation anno, final String attrName, final Class<T> attrType) {
  265.         
  266.         try {
  267.             final Method method = anno.annotationType().getMethod(attrName);
  268.             method.setAccessible(true);
  269.             if(!attrType.equals(method.getReturnType())) {
  270.                 return Optional.empty();
  271.             }
  272.             
  273.             final Object value = method.invoke(anno);
  274.             return Optional.of((T)value);
  275.             
  276.         } catch (Exception e) {
  277.             return Optional.empty();
  278.         }
  279.         
  280.     }
  281.     
  282.     /**
  283.      * アノテーションの指定した属性値を持つかどうか判定する。
  284.      * <p>アノテーションの修飾子はpublicである必要があります。</p>
  285.      * @param anno アノテーションのインスタンス
  286.      * @param attrName 属性名
  287.      * @param attrType 属性のタイプ。
  288.      * @return 属性を持つ場合trueを返す。
  289.      */
  290.     public static <T>  boolean hasAnnotationAttribute(final Annotation anno, final String attrName, final Class<T> attrType) {
  291.         
  292.         return getAnnotationAttribute(anno, attrName, attrType).isPresent();
  293.         
  294.     }
  295.     
  296. }
Created with JaCoCo 0.8.5.201910111838