MapCommentSetterFactory.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.LinkedHashMap;
  8. import java.util.Map;
  9. import java.util.Optional;

  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;

  14. import com.gh.mygreen.xlsmapper.util.ArgUtils;
  15. import com.gh.mygreen.xlsmapper.util.Utils;

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