ArrayPositionSetterFactory.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.ArrayList;
  9. import java.util.LinkedHashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Optional;

  14. import org.apache.poi.ss.util.CellAddress;
  15. import org.slf4j.Logger;
  16. import org.slf4j.LoggerFactory;

  18. import com.gh.mygreen.xlsmapper.util.ArgUtils;
  19. import com.gh.mygreen.xlsmapper.util.CellPosition;
  20. import com.gh.mygreen.xlsmapper.util.Utils;

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