MapPositionSetterFactory.java

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

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

  12. import org.apache.poi.ss.util.CellAddress;
  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.CellPosition;
  18. import com.gh.mygreen.xlsmapper.util.Utils;

  20. /**
  21.  * {@link MapPositionSetter}のインスタンスを作成する
  22.  *
  23.  * @since 2.0
  24.  * @author T.TSUCHIE
  25.  *
  26.  */
  27. public class MapPositionSetterFactory {
  28.     
  29.     private static final Logger log = LoggerFactory.getLogger(MapPositionSetterFactory.class);
  30.     
  31.     /**
  32.      * フィールドの位置情報を設定するためのアクセッサを作成します。
  33.      * @param beanClass フィールドが定義されているクラス情報
  34.      * @param fieldName フィールドの名称
  35.      * @return 位置情報のsetterが存在しない場合は空を返す。
  36.      * @throws IllegalArgumentException {@literal beanClass == null or fieldName == null}
  37.      * @throws IllegalArgumentException {@literal fieldName.isEmpty() = true}
  38.      */
  39.     public Optional<MapPositionSetter> create(final Class<?> beanClass, final String fieldName) {
  40.         
  41.         ArgUtils.notNull(beanClass, "beanClass");
  42.         ArgUtils.notEmpty(fieldName, "fieldName");
  43.         
  44.         // フィールド Map positionsの場合
  45.         Optional<MapPositionSetter> mapPositionSetter = createMapField(beanClass, fieldName);
  46.         if(mapPositionSetter.isPresent()) {
  47.             return mapPositionSetter;
  48.         }
  49.         
  50.         // setter メソッドの場合
  51.         mapPositionSetter = createMethod(beanClass, fieldName);
  52.         if(mapPositionSetter.isPresent()) {
  53.             return mapPositionSetter;
  54.         }
  55.         
  56.         // フィールド + positionの場合
  57.         mapPositionSetter = createField(beanClass, fieldName);
  58.         if(mapPositionSetter.isPresent()) {
  59.             return mapPositionSetter;
  60.         }
  61.         
  62.         
  63.         return Optional.empty();
  64.     }
  65.     
  66.     private String createMapKey(final String fieldName, final String key) {
  67.         return String.format("%s[%s]", fieldName, key);
  68.     }
  69.     
  70.     /**
  71.      * {@link Map}フィールドに位置情報が格納されている場合。
  72.      * <p>キーはフィールド名。</p>
  73.      * <p>マップの値は、{@link CellPosition}、{@link Point}、{@link CellAddress}をサポートする。</p>
  74.      * 
  75.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  76.      * @param fieldName フィールド名
  77.      * @return 位置情報の設定用クラス
  78.      */
  79.     private Optional<MapPositionSetter> createMapField(final Class<?> beanClass, final String fieldName) {
  80.         
  81.         final Field positionsField;
  82.         try {
  83.             positionsField = beanClass.getDeclaredField("positions");
  84.             positionsField.setAccessible(true);
  85.             
  86.         } catch (NoSuchFieldException | SecurityException e) {
  87.             // フィールドが見つからない場合は、何もしない。
  88.             return Optional.empty();
  89.         }
  90.         
  91.         if(!Map.class.isAssignableFrom(positionsField.getType())) {
  92.             return Optional.empty();
  93.         }
  94.         
  95.         final ParameterizedType type = (ParameterizedType) positionsField.getGenericType();
  96.         final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
  97.         final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
  98.         
  99.         if(keyType.equals(String.class) && valueType.equals(CellPosition.class)) {
  100.             return Optional.of(new MapPositionSetter() {
  101.                 
  102.                 @SuppressWarnings("unchecked")
  103.                 @Override
  104.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  105.                     ArgUtils.notNull(beanObj, "beanObj");
  106.                     ArgUtils.notNull(position, "position");
  107.                     
  108.                     try {
  109.                         Map<String, CellPosition> positionsMapObj = (Map<String, CellPosition>) positionsField.get(beanObj);
  110.                         if(positionsMapObj == null) {
  111.                             positionsMapObj = new LinkedHashMap<>();
  112.                             positionsField.set(beanObj, positionsMapObj);
  113.                         }
  114.                         
  115.                         final String mapKey = createMapKey(fieldName, key);
  116.                         
  117.                         positionsMapObj.put(mapKey, position);
  118.                         
  119.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  120.                         throw new RuntimeException("fail access positions field.", e);
  121.                     }
  122.                 }
  123.             });
  124.             
  125.         } else if(keyType.equals(String.class) && valueType.equals(Point.class)) {
  126.             
  127.             return Optional.of(new MapPositionSetter() {
  128.                 
  129.                 @SuppressWarnings("unchecked")
  130.                 @Override
  131.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  132.                     ArgUtils.notNull(beanObj, "beanObj");
  133.                     ArgUtils.notNull(position, "position");
  134.                     
  135.                     try {
  136.                         Map<String, Point> positionsMapObj = (Map<String, Point>) positionsField.get(beanObj);
  137.                         if(positionsMapObj == null) {
  138.                             positionsMapObj = new LinkedHashMap<>();
  139.                             positionsField.set(beanObj, positionsMapObj);
  140.                         }
  141.                         
  142.                         final String mapKey = createMapKey(fieldName, key);
  143.                         positionsMapObj.put(mapKey, position.toPoint());
  144.                         
  145.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  146.                         throw new RuntimeException("fail access positions field.", e);
  147.                     }
  148.                 }
  149.             });
  150.             
  151.             
  152.         } else if(keyType.equals(String.class) && valueType.equals(CellAddress.class)) {
  153.             
  154.             return Optional.of(new MapPositionSetter() {
  155.                 
  156.                 @SuppressWarnings("unchecked")
  157.                 @Override
  158.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  159.                     ArgUtils.notNull(beanObj, "beanObj");
  160.                     ArgUtils.notNull(position, "position");
  161.                     
  162.                     try {
  163.                         Map<String, CellAddress> positionsMapObj = (Map<String, CellAddress>) positionsField.get(beanObj);
  164.                         if(positionsMapObj == null) {
  165.                             positionsMapObj = new LinkedHashMap<>();
  166.                             positionsField.set(beanObj, positionsMapObj);
  167.                         }
  168.                         
  169.                         final String mapKey = createMapKey(fieldName, key);
  170.                         positionsMapObj.put(mapKey, position.toCellAddress());
  171.                         
  172.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  173.                         throw new RuntimeException("fail access positions field.", e);
  174.                     }
  175.                 }
  176.             });
  177.             
  178.             
  179.         } else {
  180.             // タイプが一致しない場合
  181.             log.warn("not match generics type of positions. key type:{}, value type:{}.", keyType.getName(), valueType.getName());
  182.             return Optional.empty();
  183.         }
  184.         
  185.     }
  186.     
  187.     /**
  188.      * setterメソッドによる位置情報を格納する場合。
  189.      * <p>{@code set + <フィールド名> + Position}のメソッド名</p>
  190.      * <p>引数として、{@link CellPosition}、{@link Point}、{@code int（列番号）, int（行番号）}、 {@link CellAddress}をサポートする。</p>
  191.      * 
  192.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  193.      * @param fieldName フィールド名
  194.      * @return 位置情報の設定用クラス
  195.      */
  196.     private Optional<MapPositionSetter> createMethod(final Class<?> beanClass, final String fieldName) {
  197.         
  198.         final String positionMethodName = "set" + Utils.capitalize(fieldName) + "Position";
  199.         
  200.         try {
  201.             final Method method = beanClass.getDeclaredMethod(positionMethodName, String.class, CellPosition.class);
  202.             method.setAccessible(true);
  203.             
  204.             return Optional.of(new MapPositionSetter() {
  205.                 
  206.                 
  207.                 @Override
  208.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  209.                     ArgUtils.notNull(beanObj, "beanObj");
  210.                     ArgUtils.notNull(position, "position");
  211.                     
  212.                     try {
  213.                         method.invoke(beanObj, key, position);
  214.                         
  215.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  216.                         throw new RuntimeException("fail access position field.", e);
  217.                     }
  218.                     
  219.                 }
  220.             });
  221.             
  222.         } catch (NoSuchMethodException | SecurityException e) {
  223.             
  224.         }
  225.         
  226.         try {
  227.             final Method method = beanClass.getDeclaredMethod(positionMethodName, String.class, Point.class);
  228.             method.setAccessible(true);
  229.             
  230.             return Optional.of(new MapPositionSetter() {
  231.                 
  232.                 
  233.                 @Override
  234.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  235.                     ArgUtils.notNull(beanObj, "beanObj");
  236.                     ArgUtils.notNull(position, "position");
  237.                     
  238.                     try {
  239.                         method.invoke(beanObj, key, position.toPoint());
  240.                         
  241.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  242.                         throw new RuntimeException("fail access position field.", e);
  243.                     }
  244.                     
  245.                 }
  246.             });
  247.             
  248.         } catch (NoSuchMethodException | SecurityException e) {
  249.             
  250.         }
  251.         
  252.         try {
  253.             final Method method = beanClass.getDeclaredMethod(positionMethodName, String.class, CellAddress.class);
  254.             method.setAccessible(true);
  255.             
  256.             return Optional.of(new MapPositionSetter() {
  257.                 
  258.                 
  259.                 @Override
  260.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  261.                     ArgUtils.notNull(beanObj, "beanObj");
  262.                     ArgUtils.notNull(position, "position");
  263.                     
  264.                     try {
  265.                         method.invoke(beanObj, key, position.toCellAddress());
  266.                         
  267.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  268.                         throw new RuntimeException("fail access position field.", e);
  269.                     }
  270.                     
  271.                 }
  272.             });
  273.             
  274.         } catch (NoSuchMethodException | SecurityException e) {
  275.             
  276.         }
  277.         
  278.         try {
  279.             final Method method = beanClass.getDeclaredMethod(positionMethodName, String.class, Integer.TYPE, Integer.TYPE);
  280.             method.setAccessible(true);
  281.             
  282.             return Optional.of(new MapPositionSetter() {
  283.                 
  284.                 
  285.                 @Override
  286.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  287.                     ArgUtils.notNull(beanObj, "beanObj");
  288.                     ArgUtils.notNull(position, "position");
  289.                     
  290.                     try {
  291.                         method.invoke(beanObj, key, position.getColumn(), position.getRow());
  292.                         
  293.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  294.                         throw new RuntimeException("fail access position field.", e);
  295.                     }
  296.                     
  297.                 }
  298.             });
  299.             
  300.         } catch (NoSuchMethodException | SecurityException e) {
  301.             
  302.         }
  303.         
  304.         return Optional.empty();
  305.         
  306.     }
  307.     
  308.     /**
  309.      * フィールドによる位置情報を格納する場合。
  310.      * <p>{@code <フィールド名> + Position}のメソッド名</p>
  311.      * <p>引数として、{@link CellPosition}、{@link Point}、 {@link CellAddress}をサポートする。</p>
  312.      * 
  313.      * @param beanClass フィールドが定義してあるクラスのインスタンス
  314.      * @param fieldName フィールド名
  315.      * @return 位置情報の設定用クラス
  316.      */
  317.     private Optional<MapPositionSetter> createField(final Class<?> beanClass, final String fieldName) {
  318.         
  319.         final String positionFieldName = fieldName + "Position";
  320.         
  321.         final Field positionField;
  322.         try {
  323.             positionField = beanClass.getDeclaredField(positionFieldName);
  324.             positionField.setAccessible(true);
  325.             
  326.         } catch (NoSuchFieldException | SecurityException e) {
  327.             return Optional.empty();
  328.         }
  329.         
  330.         if(!Map.class.isAssignableFrom(positionField.getType())) {
  331.             return Optional.empty();
  332.         }
  333.         
  334.         final ParameterizedType type = (ParameterizedType) positionField.getGenericType();
  335.         final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
  336.         final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
  337.         
  338.         if(keyType.equals(String.class) && valueType.equals(CellPosition.class)) {
  339.             
  340.             return Optional.of(new MapPositionSetter() {
  341.                 
  342.                 @SuppressWarnings("unchecked")
  343.                 @Override
  344.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  345.                     ArgUtils.notNull(beanObj, "beanObj");
  346.                     ArgUtils.notNull(position, "position");
  347.                     
  348.                    try {
  349.                        Map<String, CellPosition> positionMapObj = (Map<String, CellPosition>) positionField.get(beanObj);
  350.                        if(positionMapObj == null) {
  351.                            positionMapObj = new LinkedHashMap<>();
  352.                            positionField.set(beanObj, positionMapObj);
  353.                        }
  354.                        
  355.                        positionMapObj.put(key, position);
  356.                        
  357.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  358.                         throw new RuntimeException("fail access position field.", e);
  359.                     }
  360.                 }
  361.             });
  362.             
  363.         } else if(keyType.equals(String.class) && valueType.equals(Point.class)) {
  364.             
  365.             return Optional.of(new MapPositionSetter() {
  366.                 
  367.                 @SuppressWarnings("unchecked")
  368.                 @Override
  369.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  370.                     ArgUtils.notNull(beanObj, "beanObj");
  371.                     ArgUtils.notNull(position, "position");
  372.                     
  373.                     try {
  374.                         Map<String, Point> positionMapObj = (Map<String, Point>) positionField.get(beanObj);
  375.                         if(positionMapObj == null) {
  376.                             positionMapObj = new LinkedHashMap<>();
  377.                             positionField.set(beanObj, positionMapObj);
  378.                         }
  379.                         
  380.                         
  381.                         positionMapObj.put(key, position.toPoint());
  382.                         
  383.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  384.                         throw new RuntimeException("fail access position field.", e);
  385.                     }
  386.                 }
  387.             });
  388.             
  389.         } else if(keyType.equals(String.class) && valueType.equals(CellAddress.class)) {
  390.             
  391.             return Optional.of(new MapPositionSetter() {
  392.                 
  393.                 @SuppressWarnings("unchecked")
  394.                 @Override
  395.                 public void set(final Object beanObj, final CellPosition position, final String key) {
  396.                     ArgUtils.notNull(beanObj, "beanObj");
  397.                     ArgUtils.notNull(position, "position");
  398.                     
  399.                     try {
  400.                         Map<String, CellAddress> positionMapObj = (Map<String, CellAddress>) positionField.get(beanObj);
  401.                         if(positionMapObj == null) {
  402.                             positionMapObj = new LinkedHashMap<>();
  403.                             positionField.set(beanObj, positionMapObj);
  404.                         }
  405.                         
  406.                         
  407.                         positionMapObj.put(key, position.toCellAddress());
  408.                         
  409.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  410.                         throw new RuntimeException("fail access position field.", e);
  411.                     }
  412.                 }
  413.             });
  414.         
  415.         }
  416.         
  417.         return Optional.empty();
  418.     }
  419. }
Created with JaCoCo 0.8.5.201910111838