PositionSetterFactory.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.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;

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

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