XlsLoader.java

  1. package com.gh.mygreen.xlsmapper;

  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.lang.annotation.Annotation;
  6. import java.lang.reflect.Array;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.Method;
  9. import java.util.ArrayList;
  10. import java.util.Collections;
  11. import java.util.List;

  13. import org.apache.poi.ss.usermodel.Sheet;
  14. import org.apache.poi.ss.usermodel.Workbook;
  15. import org.apache.poi.ss.usermodel.WorkbookFactory;
  16. import org.slf4j.Logger;
  17. import org.slf4j.LoggerFactory;

  19. import com.gh.mygreen.xlsmapper.annotation.XlsFieldProcessor;
  20. import com.gh.mygreen.xlsmapper.annotation.XlsListener;
  21. import com.gh.mygreen.xlsmapper.annotation.XlsPostLoad;
  22. import com.gh.mygreen.xlsmapper.annotation.XlsPreLoad;
  23. import com.gh.mygreen.xlsmapper.annotation.XlsSheet;
  24. import com.gh.mygreen.xlsmapper.fieldaccessor.FieldAccessor;
  25. import com.gh.mygreen.xlsmapper.fieldaccessor.FieldAccessorFactory;
  26. import com.gh.mygreen.xlsmapper.fieldaccessor.FieldAccessorProxy;
  27. import com.gh.mygreen.xlsmapper.fieldaccessor.FieldAccessorProxyComparator;
  28. import com.gh.mygreen.xlsmapper.fieldprocessor.FieldProcessor;
  29. import com.gh.mygreen.xlsmapper.fieldprocessor.ProcessCase;
  30. import com.gh.mygreen.xlsmapper.localization.MessageBuilder;
  31. import com.gh.mygreen.xlsmapper.util.ArgUtils;
  32. import com.gh.mygreen.xlsmapper.util.ClassUtils;
  33. import com.gh.mygreen.xlsmapper.util.Utils;
  34. import com.gh.mygreen.xlsmapper.validation.MultipleSheetBindingErrors;
  35. import com.gh.mygreen.xlsmapper.validation.SheetBindingErrors;
  36. import com.gh.mygreen.xlsmapper.xml.AnnotationReader;


  39. /**
  40.  * ExcelのシートをJavaBeanにマッピングするクラス。
  41.  *
  42.  * @version 2.0
  43.  * @author T.TSUCHIE
  44.  *
  45.  */
  46. public class XlsLoader {

  48.     private static final Logger logger = LoggerFactory.getLogger(XlsLoader.class);

  50.     private Configuration configuration;

  52.     /**
  53.      * 独自のシステム情報を設定するコンストラクタ
  54.      * @param configuration システム情報
  55.      */
  56.     public XlsLoader(final Configuration configuration) {
  57.         this.configuration = configuration;
  58.     }

  60.     /**
  61.      * デフォルトのコンストラクタ
  62.      */
  63.     public XlsLoader() {
  64.         this(new Configuration());
  65.     }

  67.     /**
  68.      * Excelファイルの１シートを読み込み、任意のクラスにマッピングする。
  69.      *
  70.      * @param <P> シートをマッピングするクラスタイプ
  71.      * @param xlsIn 読み込みもとのExcelファイルのストリーム。
  72.      * @param clazz マッピング先のクラスタイプ。
  73.      * @return シートをマッピングしたオブジェクト。
  74.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、nullを返します。
  75.      * @throws IllegalArgumentException {@literal xlsIn == null or clazz == null}
  76.      * @throws XlsMapperException Excelファイルのマッピングに失敗した場合
  77.      * @throws IOException ファイルの読み込みに失敗した場合
  78.      *
  79.      */
  80.     public <P> P load(final InputStream xlsIn, final Class<P> clazz)  throws XlsMapperException, IOException {

  82.         ArgUtils.notNull(xlsIn, "xlsIn");
  83.         ArgUtils.notNull(clazz, "clazz");

  85.         return loadDetail(xlsIn, clazz).getTarget();
  86.     }

  88.     /**
  89.      * Excelファイルの1シートを読み込み、任意のクラスにマッピングする。
  90.      *
  91.      * @param <P> シートをマッピングするクラスタイプ
  92.      * @param xlsIn 読み込み元のExcelファイルのストリーム。
  93.      * @param clazz マッピング先のクラスタイプ。
  94.      * @return マッピングの詳細情報。
  95.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、nullを返します。
  96.      *
  97.      * @throws IllegalArgumentException {@literal xlsIn == null or clazz == null}
  98.      * @throws XlsMapperException Excelファイルのマッピングに失敗した場合
  99.      * @throws IOException ファイルの読み込みに失敗した場合
  100.      */
  101.     public <P> SheetBindingErrors<P> loadDetail(final InputStream xlsIn, final Class<P> clazz)
  102.             throws XlsMapperException, IOException {

  104.         ArgUtils.notNull(xlsIn, "xlsIn");
  105.         ArgUtils.notNull(clazz, "clazz");

  107.         final AnnotationReader annoReader = new AnnotationReader(configuration.getAnnotationMapping().orElse(null));

  109.         final XlsSheet sheetAnno = annoReader.getAnnotation(clazz, XlsSheet.class);
  110.         if(sheetAnno == null) {
  111.             throw new AnnotationInvalidException(sheetAnno, MessageBuilder.create("anno.notFound")
  112.                     .varWithClass("property", clazz)
  113.                     .varWithAnno("anno", XlsSheet.class)
  114.                     .format());
  115.         }

  117.         Workbook book = null;
  118.         try {
  119.             book = WorkbookFactory.create(xlsIn);

  121.         } finally {
  122.             if(book != null) {
  123.                 book.close();
  124.             }
  125.         }

  127.         try {
  128.             final Sheet[] xlsSheet = configuration.getSheetFinder().findForLoading(book, sheetAnno, annoReader, clazz);
  129.             return loadSheet(xlsSheet[0], clazz, annoReader);

  131.         } catch(SheetNotFoundException e) {
  132.             if(configuration.isIgnoreSheetNotFound()){
  133.                 logger.warn(MessageBuilder.create("log.skipNotFoundSheet").format(), e);
  134.                 return null;

  136.             } else {
  137.                 throw e;
  138.             }
  139.         }
  140.     }

  142.     /**
  143.      * Excelファイルの同じ形式の複数シートを読み込み、任意のクラスにマップする。
  144.      * <p>{@link XlsSheet#regex()}により、複数のシートが同じ形式で、同じクラスにマッピングすする際に使用します。</p>
  145.      *
  146.      * @param <P> シートをマッピングするクラスタイプ
  147.      * @param xlsIn 読み込み元のExcelファイルのストリーム。
  148.      * @param clazz マッピング先のクラスタイプ。
  149.      * @return マッピングした複数のシート。
  150.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、マッピング結果には含まれません。
  151.      * @throws IllegalArgumentException {@literal xlsIn == null or clazz == null}
  152.      * @throws XlsMapperException マッピングに失敗した場合
  153.      * @throws IOException ファイルの読み込みに失敗した場合
  154.      */
  155.     @SuppressWarnings("unchecked")
  156.     public <P> P[] loadMultiple(final InputStream xlsIn, final Class<P> clazz) throws XlsMapperException, IOException {

  158.         return loadMultipleDetail(xlsIn, clazz).getAll().stream()
  159.                 .map(s -> s.getTarget())
  160.                 .toArray(n -> (P[])Array.newInstance(clazz, n));
  161.     }

  163.     /**
  164.      * Excelファイルの同じ形式の複数シートを読み込み、任意のクラスにマップする。
  165.      * <p>{@link XlsSheet#regex()}により、複数のシートが同じ形式で、同じクラスにマッピングすする際に使用します。</p>
  166.      *
  167.      * @param <P> シートをマッピングするクラスタイプ
  168.      * @param xlsIn 読み込み元のExcelファイルのストリーム。
  169.      * @param clazz マッピング先のクラスタイプ。
  170.      * @return 複数のシートのマッピング結果。
  171.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、マッピング結果には含まれません。
  172.      * @throws IllegalArgumentException {@literal xlsIn == null or clazz == null}
  173.      * @throws XlsMapperException マッピングに失敗した場合
  174.      * @throws IOException ファイルの読み込みに失敗した場合
  175.      */
  176.     public <P> MultipleSheetBindingErrors<P> loadMultipleDetail(final InputStream xlsIn, final Class<P> clazz)
  177.             throws XlsMapperException, IOException {

  179.         ArgUtils.notNull(xlsIn, "xlsIn");
  180.         ArgUtils.notNull(clazz, "clazz");

  182.         final AnnotationReader annoReader = new AnnotationReader(configuration.getAnnotationMapping().orElse(null));

  184.         final XlsSheet sheetAnno = annoReader.getAnnotation(clazz, XlsSheet.class);
  185.         if(sheetAnno == null) {
  186.             throw new AnnotationInvalidException(sheetAnno, MessageBuilder.create("anno.notFound")
  187.                     .varWithClass("property", clazz)
  188.                     .varWithAnno("anno", XlsSheet.class)
  189.                     .format());
  190.         }

  192.         final MultipleSheetBindingErrors<P> multipleResult = new MultipleSheetBindingErrors<>();

  194.         Workbook book = null;
  195.         try {
  196.             book = WorkbookFactory.create(xlsIn);

  198.         } finally {
  199.             if(book != null) {
  200.                 book.close();
  201.             }
  202.         }

  204.         if(sheetAnno.number() == -1 && sheetAnno.name().isEmpty() && sheetAnno.regex().isEmpty()) {
  205.             // 読み込むシートの条件が指定されていない場合、全て読み込む
  206.             int sheetNum = book.getNumberOfSheets();
  207.             for(int i=0; i < sheetNum; i++) {
  208.                 final Sheet sheet = book.getSheetAt(i);

  210.                 multipleResult.addBindingErrors(loadSheet(sheet, clazz, annoReader));

  212.             }

  214.         } else {
  215.             // 読み込むシートの条件が指定されている場合
  216.             try {
  217.                 final Sheet[] xlsSheet = configuration.getSheetFinder().findForLoading(book, sheetAnno, annoReader, clazz);
  218.                 for(Sheet sheet : xlsSheet) {
  219.                     multipleResult.addBindingErrors(loadSheet(sheet, clazz, annoReader));

  221.                 }

  223.             } catch(SheetNotFoundException e) {
  224.                 if(configuration.isIgnoreSheetNotFound()){
  225.                     logger.warn(MessageBuilder.create("log.skipNotFoundSheet").format(), e);
  226.                 } else {
  227.                     throw e;
  228.                 }
  229.             }

  231.         }

  233.         return multipleResult;
  234.     }

  236.     /**
  237.      * Excelファイルの異なる形式の複数シートを読み込み、任意のクラスにマップする。
  238.      * <p>複数のシートの形式を一度に読み込む際に使用します。</p>
  239.      *
  240.      * @param xlsIn 読み込み元のExcelファイルのストリーム。
  241.      * @param classes マッピング先のクラスタイプの配列。
  242.      * @return マッピングした複数のシート。
  243.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、マッピング結果には含まれません。
  244.      * @throws IllegalArgumentException {@literal xlsIn == null or classes == null}
  245.      * @throws IllegalArgumentException {@literal calsses.length == 0}
  246.      * @throws XlsMapperException マッピングに失敗した場合
  247.      * @throws IOException ファイルの読み込みに失敗した場合
  248.      */
  249.     public Object[] loadMultiple(final InputStream xlsIn, final Class<?>[] classes)
  250.             throws XlsMapperException, IOException {
  251.         return loadMultipleDetail(xlsIn, classes).getAll().stream()
  252.                 .map(s -> s.getTarget())
  253.                 .toArray();
  254.     }

  256.     /**
  257.      * Excelファイルの異なる形式の複数シートを読み込み、任意のクラスにマップする。
  258.      * <p>複数のシートの形式を一度に読み込む際に使用します。</p>
  259.      *
  260.      * @param xlsIn 読み込み元のExcelファイルのストリーム。
  261.      * @param classes マッピング先のクラスタイプの配列。
  262.      * @return マッピングした複数のシートの結果。
  263.      *         {@link Configuration#isIgnoreSheetNotFound()}の値がtrueで、シートが見つからない場合、マッピング結果には含まれません。
  264.      * @throws IllegalArgumentException {@literal xlsIn == null or classes == null}
  265.      * @throws IllegalArgumentException {@literal calsses.length == 0}
  266.      * @throws IOException ファイルの読み込みに失敗した場合
  267.      * @throws XlsMapperException マッピングに失敗した場合
  268.      */
  269.     @SuppressWarnings({"unchecked", "rawtypes"})
  270.     public MultipleSheetBindingErrors<Object> loadMultipleDetail(final InputStream xlsIn, final Class<?>[] classes)
  271.             throws XlsMapperException, IOException {

  273.         ArgUtils.notNull(xlsIn, "xlsIn");
  274.         ArgUtils.notEmpty(classes, "classes");

  276.         final AnnotationReader annoReader = new AnnotationReader(configuration.getAnnotationMapping().orElse(null));

  278.         final MultipleSheetBindingErrors<Object> multipleStore = new MultipleSheetBindingErrors<>();

  280.         Workbook book = null;
  281.         try {
  282.             book = WorkbookFactory.create(xlsIn);

  284.         } finally {
  285.             if(book != null) {
  286.                 book.close();
  287.             }
  288.         }

  290.         for(Class<?> clazz : classes) {
  291.             final XlsSheet sheetAnno = clazz.getAnnotation(XlsSheet.class);
  292.             if(sheetAnno == null) {
  293.                 throw new AnnotationInvalidException(sheetAnno, MessageBuilder.create("anno.notFound")
  294.                         .varWithClass("property", clazz)
  295.                         .varWithAnno("anno", XlsSheet.class)
  296.                         .format());
  297.             }

  299.             try {
  300.                 final Sheet[] xlsSheet = configuration.getSheetFinder().findForLoading(book, sheetAnno, annoReader, clazz);
  301.                 for(Sheet sheet : xlsSheet) {
  302.                     multipleStore.addBindingErrors(loadSheet(sheet, (Class)clazz, annoReader));

  304.                 }

  306.             } catch(SheetNotFoundException ex){
  307.                 if(!configuration.isIgnoreSheetNotFound()){
  308.                     logger.warn(MessageBuilder.create("log.skipNotFoundSheet").format(), ex);
  309.                     throw ex;
  310.                 }
  311.             }

  313.         }

  315.         return multipleStore;
  316.     }

  318.     /**
  319.      * シートを読み込み、任意のクラスにマッピングする。
  320.      * @param sheet シート情報
  321.      * @param clazz マッピング先のクラスタイプ。
  322.      * @param annoReader
  323.      * @return シートのマッピング情報
  324.      * @throws XlsMapperException
  325.      *
  326.      */
  327.     private <P> SheetBindingErrors<P> loadSheet(final Sheet sheet, final Class<P> clazz, final AnnotationReader annoReader)
  328.             throws XlsMapperException {

  330.         // 値の読み込み対象のJavaBeanオブジェクトの作成
  331.         final P beanObj = configuration.createBean(clazz);

  333.         final SheetBindingErrors<P> errors =  configuration.getBindingErrorsFactory().create(beanObj);
  334.         errors.setSheetName(sheet.getSheetName());
  335.         errors.setSheetIndex(sheet.getWorkbook().getSheetIndex(sheet));

  337.         final LoadingWorkObject work = new LoadingWorkObject();
  338.         work.setAnnoReader(annoReader);
  339.         work.setErrors(errors);

  341.         // セルのキャッシュ情報の初期化
  342.         configuration.getCellFormatter().init(configuration.isCacheCellValueOnLoad());

  344.         final FieldAccessorFactory adpterFactory = new FieldAccessorFactory(annoReader);

  346.         // リスナークラスの@PreLoad用メソッドの実行
  347.         final XlsListener listenerAnno = annoReader.getAnnotation(beanObj.getClass(), XlsListener.class);
  348.         if(listenerAnno != null) {
  349.             for(Class<?> listenerClass : listenerAnno.value()) {
  350.                 final Object listenerObj = configuration.createBean(listenerClass);

  352.                 for(Method method : listenerObj.getClass().getMethods()) {
  353.                     if(annoReader.hasAnnotation(method, XlsPreLoad.class)) {
  354.                         Utils.invokeNeedProcessMethod(listenerObj, method, beanObj, sheet, configuration, work.getErrors(), ProcessCase.Load);
  355.                     }
  356.                 }
  357.             }

  359.         }

  361.         // @PreLoad用のメソッドの実行
  362.         for(Method method : clazz.getMethods()) {

  364.             if(annoReader.hasAnnotation(method, XlsPreLoad.class)) {
  365.                 Utils.invokeNeedProcessMethod(beanObj, method, beanObj, sheet, configuration, work.getErrors(), ProcessCase.Load);
  366.             }
  367.         }

  369.         final List<FieldAccessorProxy> accessorProxies = new ArrayList<>();

  371.         // public メソッドの処理
  372.         for(Method method : clazz.getMethods()) {
  373.             method.setAccessible(true);
  374.             for(Annotation anno : annoReader.getAnnotations(method)) {
  375.                 final XlsFieldProcessor annoFieldProcessor = anno.annotationType().getAnnotation(XlsFieldProcessor.class);
  376.                 if(ClassUtils.isAccessorMethod(method) && annoFieldProcessor != null) {
  377.                     // 登録済みのFieldProcessorの取得
  378.                     FieldProcessor<?> processor = configuration.getFieldProcessorRegistry().getProcessor(anno.annotationType());

  380.                     // アノテーションに指定されているFieldProcessorの場合
  381.                     if(processor == null && annoFieldProcessor.value().length > 0) {
  382.                         processor = configuration.createBean(annoFieldProcessor.value()[0]);

  384.                     }

  386.                     if(processor != null) {
  387.                         final FieldAccessor accessor = adpterFactory.create(method);
  388.                         final FieldAccessorProxy accessorProxy = new FieldAccessorProxy(anno, processor, accessor);
  389.                         if(!accessorProxies.contains(accessorProxy)) {
  390.                             accessorProxies.add(accessorProxy);
  391.                         }

  393.                     } else {
  394.                         // FieldProcessorが見つからない場合
  395.                         throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.XlsFieldProcessor.notResolve")
  396.                                 .varWithAnno("anno", anno.annotationType())
  397.                                 .format());
  398.                     }

  400.                 }

  402.                 if(anno instanceof XlsPostLoad) {
  403.                     work.addNeedPostProcess(new NeedProcess(beanObj, beanObj, method));
  404.                 }
  405.             }

  407.         }

  409.         // フィールドの処理
  410.         for(Field field : clazz.getDeclaredFields()) {

  412.             field.setAccessible(true);
  413.             for(Annotation anno : annoReader.getAnnotations(field)) {

  415.                 final XlsFieldProcessor annoFieldProcessor = anno.annotationType().getAnnotation(XlsFieldProcessor.class);
  416.                 if(annoFieldProcessor != null) {

  418.                     // 登録済みのFieldProcessorの取得
  419.                     FieldProcessor<?> processor = configuration.getFieldProcessorRegistry().getProcessor(anno.annotationType());

  421.                     // アノテーションに指定されているFieldProcessorの場合
  422.                     if(processor == null && annoFieldProcessor.value().length > 0) {
  423.                         processor = configuration.createBean(annoFieldProcessor.value()[0]);

  425.                     }

  427.                     if(processor != null) {
  428.                         final FieldAccessor accessor = adpterFactory.create(field);
  429.                         final FieldAccessorProxy accessorProxy = new FieldAccessorProxy(anno, processor, accessor);
  430.                         if(!accessorProxies.contains(accessorProxy)) {
  431.                             accessorProxies.add(accessorProxy);
  432.                         }

  434.                     } else {
  435.                         // FieldProcessorが見つからない場合
  436.                         throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.XlsFieldProcessor.notResolve")
  437.                                 .varWithAnno("anno", anno.annotationType())
  438.                                 .format());
  439.                     }

  441.                 }


  444.             }
  445.         }

  447.         // 順番を並び替えて保存処理を実行する
  448.         Collections.sort(accessorProxies, new FieldAccessorProxyComparator());
  449.         for(FieldAccessorProxy accessorProxy : accessorProxies) {
  450.             accessorProxy.loadProcess(sheet, beanObj, configuration, work);
  451.         }

  453.         // リスナークラスの@PostLoadの取得
  454.         if(listenerAnno != null) {
  455.             for(Class<?> listenerClass : listenerAnno.value()) {
  456.                 Object listenerObj = configuration.createBean(listenerClass);
  457.                 for(Method method : listenerObj.getClass().getMethods()) {
  458.                     if(annoReader.hasAnnotation(method, XlsPostLoad.class)) {
  459.                         work.addNeedPostProcess(new NeedProcess(beanObj, listenerObj, method));
  460.                     }
  461.                 }
  462.             }

  464.         }

  466.         //@PostLoadが付与されているメソッドの実行
  467.         for(NeedProcess need : work.getNeedPostProcesses()) {
  468.             Utils.invokeNeedProcessMethod(need.getProcess(), need.getMethod(), need.getTarget(), sheet, configuration, work.getErrors(), ProcessCase.Load);
  469.         }

  471.         // セルのキャッシュ情報の初期化
  472.         configuration.getCellFormatter().init(configuration.isCacheCellValueOnLoad());

  474.         return errors;
  475.     }

  477.     /**
  478.      * システム情報を取得します。
  479.      * @return 現在のシステム情報
  480.      */
  481.     public Configuration getConfiguration() {
  482.         return configuration;
  483.     }

  485.     /**
  486.      * システム情報を設定します。
  487.      * @param configuration システム情報
  488.      */
  489.     public void setConfiguration(Configuration configuration) {
  490.         this.configuration = configuration;
  491.     }

  493. }
Created with JaCoCo 0.8.5.201910111838