ArrayCommentSetterFactory.java

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

  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.ParameterizedType;
  7. import java.util.ArrayList;
  8. import java.util.LinkedHashMap;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Optional;

  13. import org.slf4j.Logger;
  14. import org.slf4j.LoggerFactory;

  16. import com.gh.mygreen.xlsmapper.util.ArgUtils;
  17. import com.gh.mygreen.xlsmapper.util.Utils;

  19. /**
  20.  * {@link ArrayCommentSetter}のインスタンスを作成する
  21.  *
  22.  * @since 2.1
  23.  * @author T.TSUCHIE
  24.  *
  25.  */
  26. public class ArrayCommentSetterFactory {
  27.     
  28.     private static final Logger log = LoggerFactory.getLogger(ArrayCommentSetterFactory.class);
  29.     
  30.     /**
  31.      * フィールドの位置情報を設定するためのアクセッサを作成します。
  32.      * @param beanClass フィールドが定義されているクラス情報
  33.      * @param fieldName フィールドの名称
  34.      * @return ラベル情報のsetterが存在しない場合は空を返す。
  35.      * @throws IllegalArgumentException {@literal beanClass == null or fieldName == null}
  36.      * @throws IllegalArgumentException {@literal fieldName.isEmpty() = true}
  37.      */
  38.     public Optional<ArrayCommentSetter> create(final Class<?> beanClass, final String fieldName) {
  39.         
  40.         ArgUtils.notNull(beanClass, "beanClass");
  41.         ArgUtils.notEmpty(fieldName, "fieldName");
  42.         
  43.         // フィールド Map commentsの場合
  44.         Optional<ArrayCommentSetter> arrayCommentSetter = createMapField(beanClass, fieldName);
  45.         if(arrayCommentSetter.isPresent()) {
  46.             return arrayCommentSetter;
  47.         }
  48.         
  49.         // setter メソッドの場合
  50.         arrayCommentSetter = createMethod(beanClass, fieldName);
  51.         if(arrayCommentSetter.isPresent()) {
  52.             return arrayCommentSetter;
  53.         }
  54.         
  55.         // フィールド + commentの場合
  56.         arrayCommentSetter = createField(beanClass, fieldName);
  57.         if(arrayCommentSetter.isPresent()) {
  58.             return arrayCommentSetter;
  59.         }
  60.         
  61.         
  62.         return Optional.empty();
  63.     }
  64.     
  65.     private String createMapKey(final String fieldName, final int index) {
  66.         return String.format("%s[%d]", fieldName, index);
  67.     }
  68.     
  69.     /**
  70.      * {@link Map}フィールドにラベル情報が格納されている場合。
  71.      * <p>キーはフィールド名。</p>
  72.      * 
  73.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  74.      * @param fieldName フィールド名
  75.      * @return ラベル情報の設定用クラス
  76.      */
  77.     private Optional<ArrayCommentSetter> createMapField(final Class<?> beanClass, final String fieldName) {
  78.         
  79.         final Field commentsField;
  80.         try {
  81.             commentsField = beanClass.getDeclaredField("comments");
  82.             commentsField.setAccessible(true);
  83.             
  84.         } catch (NoSuchFieldException | SecurityException e) {
  85.             // フィールドが見つからない場合は、何もしない。
  86.             return Optional.empty();
  87.         }
  88.         
  89.         if(!Map.class.isAssignableFrom(commentsField.getType())) {
  90.             return Optional.empty();
  91.         }
  92.         
  93.         final ParameterizedType type = (ParameterizedType) commentsField.getGenericType();
  94.         final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
  95.         final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
  96.         
  97.         if(keyType.equals(String.class) && valueType.equals(String.class)) {
  98.             return Optional.of(new ArrayCommentSetter() {
  99.                 
  100.                 @SuppressWarnings("unchecked")
  101.                 @Override
  102.                 public void set(final Object beanObj, final String comment, final int index) {
  103.                     ArgUtils.notNull(beanObj, "beanObj");
  104.                     ArgUtils.notEmpty(comment, "comment");
  105.                     
  106.                     try {
  107.                         Map<String, String> commentsMapObj = (Map<String, String>) commentsField.get(beanObj);
  108.                         if(commentsMapObj == null) {
  109.                             commentsMapObj = new LinkedHashMap<>();
  110.                             commentsField.set(beanObj, commentsMapObj);
  111.                         }
  112.                         
  113.                         final String mapKey = createMapKey(fieldName, index);
  114.                         
  115.                         commentsMapObj.put(mapKey, comment);
  116.                         
  117.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  118.                         throw new RuntimeException("fail access comments field.", e);
  119.                     }
  120.                 }
  121.             });
  122.             
  123.         } else {
  124.             // タイプが一致しない場合
  125.             log.warn("not match generics type of comments. key type:{}, value type:{}.", keyType.getName(), valueType.getName());
  126.             return Optional.empty();
  127.         }
  128.         
  129.     }
  130.     
  131.     /**
  132.      * setterメソッドによるラベル情報を格納する場合。
  133.      * <p>{@code set + <フィールド名> + Comments}のメソッド名</p>
  134.      * 
  135.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  136.      * @param fieldName フィールド名
  137.      * @return ラベル情報の設定用クラス
  138.      */
  139.     private Optional<ArrayCommentSetter> createMethod(final Class<?> beanClass, final String fieldName) {
  140.         
  141.         final String commentMethodName = "set" + Utils.capitalize(fieldName) + "Comment";
  142.         
  143.         try {
  144.             final Method method = beanClass.getDeclaredMethod(commentMethodName, Integer.TYPE, String.class);
  145.             method.setAccessible(true);
  146.             
  147.             return Optional.of(new ArrayCommentSetter() {
  148.                 
  149.                 
  150.                 @Override
  151.                 public void set(final Object beanObj, final String comment, final int index) {
  152.                     ArgUtils.notNull(beanObj, "beanObj");
  153.                     ArgUtils.notEmpty(comment, "comment");
  154.                     
  155.                     try {
  156.                         method.invoke(beanObj, index, comment);
  157.                         
  158.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  159.                         throw new RuntimeException("fail access comment field.", e);
  160.                     }
  161.                     
  162.                 }
  163.             });
  164.             
  165.         } catch (NoSuchMethodException | SecurityException e) {
  166.             
  167.         }
  168.         
  169.         return Optional.empty();
  170.         
  171.     }
  172.     
  173.     /**
  174.      * フィールドによるラベル情報を格納する場合。
  175.      * <p>{@code <フィールド名> + Comment}のメソッド名</p>
  176.      * 
  177.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  178.      * @param fieldName フィールド名
  179.      * @return ラベル情報の設定用クラス
  180.      */
  181.     private Optional<ArrayCommentSetter> createField(final Class<?> beanClass, final String fieldName) {
  182.         
  183.         final String commentFieldName = fieldName + "Comment";
  184.         
  185.         final Field commentField;
  186.         try {
  187.             commentField = beanClass.getDeclaredField(commentFieldName);
  188.             commentField.setAccessible(true);
  189.             
  190.         } catch (NoSuchFieldException | SecurityException e) {
  191.             return Optional.empty();
  192.         }
  193.         
  194.         if(!List.class.isAssignableFrom(commentField.getType())) {
  195.             return Optional.empty();
  196.         }
  197.         
  198.         final ParameterizedType type = (ParameterizedType) commentField.getGenericType();
  199.         final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[0];
  200.         
  201.         if(valueType.equals(String.class)) {
  202.             
  203.             return Optional.of(new ArrayCommentSetter() {
  204.                 
  205.                 @SuppressWarnings("unchecked")
  206.                 @Override
  207.                 public void set(final Object beanObj, final String comment, final int index) {
  208.                     ArgUtils.notNull(beanObj, "beanObj");
  209.                     ArgUtils.notEmpty(comment, "comment");
  210.                     
  211.                    try {
  212.                        List<String> commentListObj = (List<String>) commentField.get(beanObj);
  213.                        if(commentListObj == null) {
  214.                            commentListObj = new ArrayList<>();
  215.                            commentField.set(beanObj, commentListObj);
  216.                        }
  217.                        
  218.                        Utils.addListWithIndex(commentListObj, comment, index);
  219.                        
  220.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  221.                         throw new RuntimeException("fail access comment field.", e);
  222.                     }
  223.                 }
  224.             });
  225.             
  226.         }
  227.         
  228.         return Optional.empty();
  229.     }
  230. }
Created with JaCoCo 0.8.5.201910111838