PropertyTypeNavigator.java

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

  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.ParameterizedType;
  6. import java.lang.reflect.Type;
  7. import java.util.Collection;
  8. import java.util.LinkedList;
  9. import java.util.Map;
  10. import java.util.concurrent.ConcurrentHashMap;

  12. import com.gh.mygreen.xlsmapper.util.PropertyPath.Token;

  14. /**
  15.  * クラス定義からプロパティのクラスタイプを取得する。
  16.  * <p>プロパティは式言語の形式に似た形式をとることが可能で、フィールドにもアクセスできます。</p>
  17.  * 
  18.  * 
  19.  * @since 2.0
  20.  * @author T.TSUCHIE
  21.  *
  22.  */
  23. public class PropertyTypeNavigator {
  24.     
  25.     /**
  26.      * 非公開のプロパティにアクセス可能かどうか。
  27.      */
  28.     private boolean allowPrivate;
  29.     
  30.     /**
  31.      * クラスタイプの解析ができない場合に処理を終了するかどうか。
  32.      */
  33.     private boolean ignoreNotResolveType;
  34.     
  35.     /**
  36.      * プロパティの解析結果をキャッシュするかどうか。
  37.      */
  38.     private boolean cacheWithPath;
  39.     
  40.     /**
  41.      * プロパティの式を解析して、トークンに分解するクラス。
  42.      */
  43.     private final PropertyPathTokenizer tokenizer = new PropertyPathTokenizer();
  44.     
  45.     /**
  46.      * プロパティの解析結果をキャッシュデータ
  47.      */
  48.     private final Map<String, PropertyPath> cacheData = new ConcurrentHashMap<>();
  49.     
  50.      /**
  51.      * プロパティの値を取得する。
  52.      * <p>オプションはデフォルト値で処理する。</p>
  53.      * @param rootClass 取得元となるクラス
  54.      * @param property プロパティの式。
  55.      * @return プロパティのクラスタイプ。
  56.      * @throws IllegalArgumentException peropety is null or empty.
  57.      * @throws PropertyAccessException 存在しないプロパティを指定した場合など。
  58.      * @throws IllegalStateException リストやマップにアクセスする際にGenericsタイプが設定されておらずクラスタイプが取得できない場合。
  59.      *         ただし、オプションignoreNotResolveType = falseのとき。
  60.      */
  61.     public static Object get(final Class<?> rootClass, final String property) {
  62.         return new PropertyTypeNavigator().getPropertyType(rootClass, property);
  63.     }
  64.     
  65.     /**
  66.      * デフォルトコンストラクタ
  67.      */
  68.     public PropertyTypeNavigator() {
  69.         
  70.     }
  71.     
  72.     /**
  73.      * プロパティの値を取得する。
  74.      * 
  75.      * @param rootClass 取得元となるクラス
  76.      * @param property プロパティの式。
  77.      * @return プロパティのクラスタイプ。
  78.      * @throws IllegalArgumentException peropety is null or empty.
  79.      * @throws PropertyAccessException 存在しないプロパティを指定した場合など。
  80.      * @throws IllegalStateException リストやマップにアクセスする際にGenericsタイプが設定されておらずクラスタイプが取得できない場合。
  81.      *         ただし、オプションignoreNotResolveType = falseのとき。
  82.      */
  83.     public Class<?> getPropertyType(final Class<?> rootClass, final String property) {
  84.         
  85.         ArgUtils.notEmpty(property, "property");
  86.         
  87.         final PropertyPath path = parseProperty(property);
  88.         final LinkedList<Object> stack = new LinkedList<>();
  89.         Class<?> targetClass = rootClass;
  90.         for(Token token : path.getPathAsToken()) {
  91.             
  92.             targetClass = accessProperty(targetClass, token, stack);
  93.             if(targetClass == null) {
  94.                 return null;
  95.             }
  96.         }
  97.         
  98.         return targetClass;
  99.         
  100.     }
  101.     
  102.     /**
  103.      * プロパティの式をパースして、{@link PropertyPath} オブジェクトに変換する。
  104.      * @param property プロパティアクセス用の式
  105.      * @return 式を解析した結果 {@link PropertyPath}
  106.      */
  107.     private PropertyPath parseProperty(final String property) {
  108.         
  109.         if(isCacheWithPath()) {
  110.             return cacheData.computeIfAbsent(property, k -> tokenizer.parse(k));
  111.         } else {
  112.             return tokenizer.parse(property);
  113.         }
  114.         
  115.     }
  116.     
  117.     private Class<?> accessProperty(final Class<?> targetClass, final Token token, final LinkedList<Object> stack) {
  118.         
  119.         if(token instanceof Token.Separator) {
  120.             return accessPropertyBySeparator(targetClass, (Token.Separator)token, stack);
  121.             
  122.         } else if(token instanceof Token.Name) {
  123.             return accessPropertyByName(targetClass, (Token.Name)token, stack);
  124.             
  125.         } else if(token instanceof Token.Key) {
  126.             return accessPropertyByKey(targetClass, (Token.Key)token, stack);
  127.         }
  128.         
  129.         throw new IllegalStateException("not support token type : " + token.getValue());
  130.         
  131.     }
  132.     
  133.     private Class<?> accessPropertyBySeparator(final Class<?> targetClass, final Token.Separator token, final LinkedList<Object> stack) {
  134.         
  135.         return targetClass;
  136.         
  137.     }
  138.     
  139.     private Class<?> accessPropertyByName(final Class<?> targetClass, final Token.Name token, final LinkedList<Object> stack) {
  140.         
  141.         // メソッドアクセス
  142.         final String getterMethodName = "get" + Utils.capitalize(token.getValue());
  143.         try {
  144.             Method getterMethod = allowPrivate ? 
  145.                     targetClass.getDeclaredMethod(getterMethodName) : targetClass.getMethod(getterMethodName);
  146.             getterMethod.setAccessible(true);
  147.             
  148.             // Collectionなどの場合、メソッド情報をスタックに積んでおく
  149.             stack.push(getterMethod);
  150.             
  151.             return getterMethod.getReturnType();
  152.             
  153.         } catch (NoSuchMethodException | SecurityException e) {
  154.             // not found method
  155.             
  156.         }
  157.         
  158.         // boolean用メソッドアクセス
  159.         final String booleanMethodName = "is" + Utils.capitalize(token.getValue());
  160.         try {
  161.             Method getterMethod = allowPrivate ? 
  162.                     targetClass.getDeclaredMethod(booleanMethodName) : targetClass.getMethod(booleanMethodName);;
  163.             getterMethod.setAccessible(true);
  164.             
  165.             return getterMethod.getReturnType();
  166.             
  167.         } catch (NoSuchMethodException | SecurityException e) {
  168.             // not found method
  169.             
  170.         }
  171.         
  172.         // フィールドアクセス
  173.         final String fieldName = token.getValue();
  174.         try {
  175.             Field field = allowPrivate ? 
  176.                     targetClass.getDeclaredField(fieldName) : targetClass.getField(fieldName);
  177.             field.setAccessible(true);
  178.             
  179.             // Collectionなどの場合、メソッド情報をスタックに積んでおく
  180.             stack.push(field);
  181.             
  182.             return field.getType();
  183.             
  184.         } catch (NoSuchFieldException | SecurityException e) {
  185.             // not found field
  186.             
  187.         }
  188.         
  189.         throw new PropertyAccessException("not found property : " + token.getValue());
  190.         
  191.     }
  192.     
  193.     private Class<?> accessPropertyByKey(final Class<?> targetClass, final Token.Key token, final LinkedList<Object> stack) {
  194.         
  195.         final Object parent = stack.isEmpty() ? null : stack.pollFirst();
  196.         if(parent == null) {
  197.             return null;
  198.         }
  199.         if(Collection.class.isAssignableFrom(targetClass)) {
  200.             
  201.             Type argType = null;
  202.             if(parent instanceof Method) {
  203.                 // getterメソッドのからGenericsのタイプを取得する
  204.                 Type type = ((Method)parent).getGenericReturnType();
  205.                 if(!ParameterizedType.class.isAssignableFrom(type.getClass())) {
  206.                     if(ignoreNotResolveType) {
  207.                         return null;
  208.                     } else {
  209.                         throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  210.                     }
  211.                 }
  212.                 argType = ((ParameterizedType)type).getActualTypeArguments()[0];
  213.                 
  214.             } else if(parent instanceof Field) {
  215.                 Type type = ((Field)parent).getGenericType();
  216.                 if(!ParameterizedType.class.isAssignableFrom(type.getClass())) {
  217.                     if(ignoreNotResolveType) {
  218.                         return null;
  219.                     } else {
  220.                         throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  221.                     }
  222.                 }
  223.                 
  224.                 argType = ((ParameterizedType)type).getActualTypeArguments()[0];
  225.                 
  226.             } else if(parent instanceof ParameterizedType) {
  227.                 ParameterizedType type = (ParameterizedType) parent;
  228.                 argType = type.getActualTypeArguments()[0];
  229.                 
  230.             } else {
  231.                 if(ignoreNotResolveType) {
  232.                     return null;
  233.                 } else {
  234.                     throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  235.                 }
  236.             }
  237.             
  238.             if(argType == null) {
  239.                 return null;
  240.             }
  241.             
  242.             if(argType instanceof Class) {
  243.                 return (Class<?>)argType;
  244.                 
  245.             } else if(argType instanceof ParameterizedType) {
  246.                 ParameterizedType paramType = ((ParameterizedType)argType);
  247.                 stack.push(paramType);
  248.                 return (Class<?>)paramType.getRawType();
  249.             }
  250.             
  251.         } else if (targetClass.isArray()) {
  252.             
  253.             return targetClass.getComponentType();
  254.             
  255.         } else if(Map.class.isAssignableFrom(targetClass)) {
  256.             
  257.             Type argType = null;
  258.             if(parent instanceof Method) {
  259.                 // getterメソッドのからGenericsのタイプを取得する
  260.                 Type type = ((Method)parent).getGenericReturnType();
  261.                 if(!ParameterizedType.class.isAssignableFrom(type.getClass())) {
  262.                     if(ignoreNotResolveType) {
  263.                         return null;
  264.                     } else {
  265.                         throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  266.                     }
  267.                 }
  268.                 argType = ((ParameterizedType)type).getActualTypeArguments()[1];
  269.                 
  270.             } else if(parent instanceof Field) {
  271.                 Type type = ((Field)parent).getGenericType();
  272.                 if(!ParameterizedType.class.isAssignableFrom(type.getClass())) {
  273.                     if(ignoreNotResolveType) {
  274.                         return null;
  275.                     } else {
  276.                         throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  277.                     }
  278.                 }
  279.                 argType = ((ParameterizedType)type).getActualTypeArguments()[1];
  280.                 
  281.             } else if(parent instanceof ParameterizedType) {
  282.                 ParameterizedType type = (ParameterizedType) parent;
  283.                 argType = type.getActualTypeArguments()[1];
  284.                 
  285.             } else {
  286.                 if(ignoreNotResolveType) {
  287.                     return null;
  288.                 } else {
  289.                     throw new IllegalStateException("not resolve generics type with property : " + token.getValue());
  290.                 }
  291.             }
  292.             
  293.             if(argType == null) {
  294.                 return null;
  295.             }
  296.             
  297.             if(argType instanceof Class) {
  298.                 return (Class<?>)argType;
  299.                 
  300.             } else if(argType instanceof ParameterizedType) {
  301.                 ParameterizedType paramType = ((ParameterizedType)argType);
  302.                 stack.push(paramType);
  303.                 return (Class<?>)paramType.getRawType();
  304.             }
  305.             
  306.         }
  307.         
  308.         throw new PropertyAccessException("not support key access : " + targetClass.getName());
  309.         
  310.     }
  311.     
  312.     /**
  313.      * 今までのキャッシュデータをクリアする。
  314.      */
  315.     public void clearCache() {
  316.         this.cacheData.clear();
  317.     }
  318.     
  319.     /**
  320.      * 実行時オプション - 非公開のプロパティにアクセス可能かどうか。
  321.      * @return true: アクセスを許可する。false: デフォルト値。
  322.      */
  323.     public boolean isAllowPrivate() {
  324.         return allowPrivate;
  325.     }
  326.     
  327.     /**
  328.      * 実行時オプション - 非公開のプロパティにアクセス可能かどうか。
  329.      * @param allowPrivate true: アクセスを許可する。
  330.      */
  331.     public void setAllowPrivate(boolean allowPrivate) {
  332.         this.allowPrivate = allowPrivate;
  333.     }
  334.     
  335.     /**
  336.      * クラスタイプの解析ができない場合に処理を終了するかどうか。
  337.      * <p>ListなどでGenericsタイプが指定されていでクラスタイプが取得できないときに、nullを返すかどうか指定します。</p>
  338.      * @return true:その時点で処理を終了する。
  339.      */
  340.     public boolean isIgnoreNotResolveType() {
  341.         return ignoreNotResolveType;
  342.     }
  343.     
  344.     /**
  345.      * クラスタイプの解析ができない場合に処理を終了するかどうか。
  346.      * <p>ListなどでGenericsタイプが指定されていでクラスタイプが取得できないときに、nullを返すかどうか指定します。</p>
  347.      * @param ignoreNotResolveType true:その時点で処理を終了する。
  348.      */
  349.     public void setIgnoreNotResolveType(boolean ignoreNotResolveType) {
  350.         this.ignoreNotResolveType = ignoreNotResolveType;
  351.     }
  352.     
  353.     
  354.     /**
  355.      * プロパティの解析結果をキャッシュするかどうか。
  356.      * @return true: キャッシュする。false: デフォルト値。
  357.      */
  358.     public boolean isCacheWithPath() {
  359.         return cacheWithPath;
  360.     }
  361.     
  362.     /**
  363.      * プロパティの解析結果をキャッシュするかどうか。
  364.      * @param cacheWithPath true: キャッシュする。
  365.      */
  366.     public void setCacheWithPath(boolean cacheWithPath) {
  367.         this.cacheWithPath = cacheWithPath;
  368.     }
  369.     
  370. }
Created with JaCoCo 0.8.5.201910111838