PositionGetterFactory.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.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.CellPosition;
  16. import com.gh.mygreen.xlsmapper.util.Utils;

  18. /**
  19.  * {@link PositionGetter}のインスタンスを作成する
  20.  * 
  21.  * @since 2.0
  22.  * @author T.TSUCHIE
  23.  *
  24.  */
  25. public class PositionGetterFactory {
  26.     
  27.     private static final Logger log = LoggerFactory.getLogger(PositionGetterFactory.class);
  28.     
  29.     /**
  30.      * フィールドの位置情報を取得するためのアクセッサを作成します。
  31.      * @param beanClass フィールドが定義されているクラス情報
  32.      * @param fieldName フィールドの名称
  33.      * @return 位置情報のgetterが存在しない場合は空を返す。
  34.      * @throws IllegalArgumentException {@literal beanClass == null or fieldName == null}
  35.      * @throws IllegalArgumentException {@literal fieldName.isEmpty() = true}
  36.      */
  37.     public Optional<PositionGetter> create(final Class<?> beanClass, final String fieldName) {
  38.         
  39.         ArgUtils.notNull(beanClass, "beanClass");
  40.         ArgUtils.notEmpty(fieldName, "fieldName");
  41.         
  42.         // フィールド Map positionsの場合
  43.         Optional<PositionGetter> positionGetter = createMapField(beanClass, fieldName);
  44.         if(positionGetter.isPresent()) {
  45.             return positionGetter;
  46.         }
  47.         
  48.         // setter メソッドの場合
  49.         positionGetter = createMethod(beanClass, fieldName);
  50.         if(positionGetter.isPresent()) {
  51.             return positionGetter;
  52.         }
  53.         
  54.         // フィールド + positionの場合
  55.         positionGetter = createField(beanClass, fieldName);
  56.         if(positionGetter.isPresent()) {
  57.             return positionGetter;
  58.         }
  59.         
  60.         
  61.         return Optional.empty();
  62.         
  63.         
  64.     }
  65.     
  66.     private Optional<PositionGetter> createMapField(final Class<?> beanClass, final String fieldName) {
  67.         
  68.         final Field positionsField;
  69.         try {
  70.             positionsField = beanClass.getDeclaredField("positions");
  71.             positionsField.setAccessible(true);
  72.             
  73.         } catch (NoSuchFieldException | SecurityException e) {
  74.             // フィールドが見つからない場合は、何もしない。
  75.             return Optional.empty();
  76.         }
  77.         
  78.         if(!Map.class.isAssignableFrom(positionsField.getType())) {
  79.             return Optional.empty();
  80.         }
  81.         
  82.         final ParameterizedType type = (ParameterizedType) positionsField.getGenericType();
  83.         final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
  84.         final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
  85.         
  86.         if(keyType.equals(String.class) && valueType.equals(CellPosition.class)) {
  87.             return Optional.of(new PositionGetter() {
  88.                 
  89.                 @SuppressWarnings("unchecked")
  90.                 @Override
  91.                 public Optional<CellPosition> get(final Object beanObj) {
  92.                     ArgUtils.notNull(beanObj, "beanObj");
  93.                     
  94.                     try {
  95.                         Map<String, CellPosition> positionsMapObj = (Map<String, CellPosition>) positionsField.get(beanObj);
  96.                         if(positionsMapObj == null) {
  97.                             return Optional.empty();
  98.                         }
  99.                         
  100.                         return Optional.ofNullable(positionsMapObj.get(fieldName));
  101.                         
  102.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  103.                         throw new RuntimeException("fail access positions field.", e);
  104.                     }
  105.                 }
  106.             });
  107.             
  108.         } else if(keyType.equals(String.class) && valueType.equals(Point.class)) {
  109.             
  110.             return Optional.of(new PositionGetter() {
  111.                 
  112.                 @SuppressWarnings("unchecked")
  113.                 @Override
  114.                 public Optional<CellPosition> get(final Object beanObj) {
  115.                     ArgUtils.notNull(beanObj, "beanObj");
  116.                     
  117.                     try {
  118.                         Map<String, Point> positionsMapObj = (Map<String, Point>) positionsField.get(beanObj);
  119.                         if(positionsMapObj == null) {
  120.                             return Optional.empty();
  121.                         }
  122.                         
  123.                         return Optional.ofNullable(positionsMapObj.get(fieldName))
  124.                                 .map(a -> CellPosition.of(a));
  125.                         
  126.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  127.                         throw new RuntimeException("fail access positions field.", e);
  128.                     }
  129.                 }
  130.             });
  131.             
  132.             
  133.         } else if(keyType.equals(String.class) && valueType.equals(org.apache.poi.ss.util.CellAddress.class)) {
  134.             
  135.             return Optional.of(new PositionGetter() {
  136.                 
  137.                 @SuppressWarnings("unchecked")
  138.                 @Override
  139.                 public Optional<CellPosition> get(final Object beanObj) {
  140.                     ArgUtils.notNull(beanObj, "beanObj");
  141.                     
  142.                     try {
  143.                         Map<String, org.apache.poi.ss.util.CellAddress> positionsMapObj = (Map<String, org.apache.poi.ss.util.CellAddress>) positionsField.get(beanObj);
  144.                         if(positionsMapObj == null) {
  145.                             return Optional.empty();
  146.                         }
  147.                         
  148.                         return Optional.ofNullable(positionsMapObj.get(fieldName))
  149.                                 .map(a -> CellPosition.of(a));
  150.                         
  151.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  152.                         throw new RuntimeException("fail access positions field.", e);
  153.                     }
  154.                 }
  155.             });
  156.             
  157.             
  158.         } else {
  159.             // タイプが一致しない場合
  160.             log.warn("not match generics type of positions. key type:{}, value type:{}.", keyType.getName(), valueType.getName());
  161.             return Optional.empty();
  162.         }
  163.         
  164.     }
  165.     
  166.     private Optional<PositionGetter> createMethod(final Class<?> beanClass, final String fieldName) {
  167.         
  168.         final String positionMethodName = "get" + Utils.capitalize(fieldName) + "Position";
  169.         
  170.         final Method method;
  171.         try {
  172.             method = beanClass.getDeclaredMethod(positionMethodName);
  173.             method.setAccessible(true);
  174.             
  175.         } catch (NoSuchMethodException | SecurityException e) {
  176.             return Optional.empty();
  177.         }
  178.         
  179.         if(method.getReturnType().equals(CellPosition.class)) {
  180.             return Optional.of(new PositionGetter() {
  181.                 
  182.                 @Override
  183.                 public Optional<CellPosition> get(final Object beanObj) {
  184.                     ArgUtils.notNull(beanObj, "beanObj");
  185.                     
  186.                     try {
  187.                         final CellPosition address = (CellPosition)method.invoke(beanObj);
  188.                         return Optional.ofNullable(address);
  189.                         
  190.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  191.                         throw new RuntimeException("fail access positions getter method.", e);
  192.                     }
  193.                     
  194.                 }
  195.             });
  196.             
  197.         } else if(method.getReturnType().equals(Point.class)) {
  198.             return Optional.of(new PositionGetter() {
  199.                 
  200.                 @Override
  201.                 public Optional<CellPosition> get(final Object beanObj) {
  202.                     ArgUtils.notNull(beanObj, "beanObj");
  203.                     
  204.                     try {
  205.                         final Point point = (Point)method.invoke(beanObj);
  206.                         return Optional.ofNullable(point).map(p -> CellPosition.of(p));
  207.                         
  208.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  209.                         throw new RuntimeException("fail access positions getter method.", e);
  210.                     }
  211.                     
  212.                 }
  213.             });
  214.             
  215.         } else if(method.getReturnType().equals(org.apache.poi.ss.util.CellAddress.class)) {
  216.             return Optional.of(new PositionGetter() {
  217.                 
  218.                 @Override
  219.                 public Optional<CellPosition> get(final Object beanObj) {
  220.                     ArgUtils.notNull(beanObj, "beanObj");
  221.                     
  222.                     try {
  223.                         final org.apache.poi.ss.util.CellAddress address = (org.apache.poi.ss.util.CellAddress)method.invoke(beanObj);
  224.                         return Optional.ofNullable(address).map(a -> CellPosition.of(a));
  225.                         
  226.                     } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  227.                         throw new RuntimeException("fail access positions getter method.", e);
  228.                     }
  229.                     
  230.                 }
  231.             });
  232.         }
  233.         
  234.         return Optional.empty();
  235.         
  236.     }
  237.     
  238.     private Optional<PositionGetter> createField(final Class<?> beanClass, final String fieldName) {
  239.         
  240.         final String positionFieldName = fieldName + "Position";
  241.         
  242.         final Field positionField;
  243.         try {
  244.             positionField = beanClass.getDeclaredField(positionFieldName);
  245.             positionField.setAccessible(true);
  246.             
  247.         } catch (NoSuchFieldException | SecurityException e) {
  248.             return Optional.empty();
  249.         }
  250.         
  251.         if(positionField.getType().equals(CellPosition.class)) {
  252.             
  253.             return Optional.of(new PositionGetter() {
  254.                 
  255.                 @Override
  256.                 public Optional<CellPosition> get(final Object beanObj) {
  257.                     ArgUtils.notNull(beanObj, "beanObj");
  258.                     
  259.                     try {
  260.                         final CellPosition address = (CellPosition) positionField.get(beanObj);
  261.                         return Optional.ofNullable(address);
  262.                         
  263.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  264.                         throw new RuntimeException("fail access position field.", e);
  265.                     }
  266.                 }
  267.             });
  268.             
  269.         } else if(positionField.getType().equals(Point.class)) {
  270.             
  271.             return Optional.of(new PositionGetter() {
  272.                 
  273.                 @Override
  274.                 public Optional<CellPosition> get(final Object beanObj) {
  275.                     ArgUtils.notNull(beanObj, "beanObj");
  276.                     
  277.                     try {
  278.                         final Point point = (Point) positionField.get(beanObj);
  279.                         return Optional.ofNullable(point).map(p -> CellPosition.of(p));
  280.                         
  281.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  282.                         throw new RuntimeException("fail access position field.", e);
  283.                     }
  284.                 }
  285.             });
  286.             
  287.         } else if(positionField.getType().equals(org.apache.poi.ss.util.CellAddress.class)) {
  288.             
  289.             return Optional.of(new PositionGetter() {
  290.                 
  291.                 @Override
  292.                 public Optional<CellPosition> get(final Object beanObj) {
  293.                     ArgUtils.notNull(beanObj, "beanObj");
  294.                     
  295.                     try {
  296.                         final org.apache.poi.ss.util.CellAddress address = (org.apache.poi.ss.util.CellAddress) positionField.get(beanObj);
  297.                         return Optional.ofNullable(address).map(a -> CellPosition.of(a));
  298.                         
  299.                     } catch (IllegalArgumentException | IllegalAccessException e) {
  300.                         throw new RuntimeException("fail access position field.", e);
  301.                     }
  302.                 }
  303.             });
  304.         
  305.         }
  306.         
  307.         return Optional.empty();
  308.     }
  309.     
  310. }
Created with JaCoCo 0.8.5.201910111838