添加新的时刻表导入格式（带工时）

1、重构时刻表导入逻辑，重构相关文件到包com.bsth.service.schedule.timetable下 2、修改相关的controller，servcie，entity（添加gs属性） 3、添加导入格式对应的ktr文件 4、修改前端时刻表显示指令，去除之前的班型和配档数修改，添加工时修改 5、数据库时刻表班型信息表添加gs字段，字典表添加新的时刻表导入格式

添加新的时刻表导入格式（带工时）
1、重构时刻表导入逻辑，重构相关文件到包com.bsth.service.schedule.timetable下 2、修改相关的controller，servcie，entity（添加gs属性） 3、添加导入格式对应的ktr文件 4、修改前端时刻表显示指令，去除之前的班型和配档数修改，添加工时修改 5、数据库时刻表班型信息表添加gs字段，字典表添加新的时刻表导入格式
徐烜 · 徐烜
1 parent aa9c5bb7
Showing 20 changed files with 1241 additions and 542 deletions
pom.xml
src/main/java/com/bsth/controller/schedule/core/TTInfoDetailController_facade.java
src/main/java/com/bsth/controller/schedule/core/legacy/TTInfoDetailController.java
src/main/java/com/bsth/entity/schedule/TTInfoBxDetail.java
src/main/java/com/bsth/service/schedule/TTInfoDetailService.java
src/main/java/com/bsth/service/schedule/datatools/TTInfoDetailDataToolsImpl.java
src/main/java/com/bsth/service/schedule/impl/TTInfoDetailServiceImpl.java
src/main/java/com/bsth/service/schedule/timetable/ExcelData.java
src/main/java/com/bsth/service/schedule/timetable/ExcelFormatType.java
src/main/java/com/bsth/service/schedule/timetable/TimetableExcelData.java
src/main/java/com/bsth/service/schedule/timetable/TimetableExcelFormatType.java
src/main/java/com/bsth/service/schedule/timetable/strategy/TimetableExcelDataImportStrategy.java
src/main/java/com/bsth/service/schedule/timetable/strategy/TimetableExcelDataValidateStrategy.java
src/main/java/com/bsth/service/schedule/timetable/strategy/impl/TimetableExcelDataImportStrategyImpl.java
src/main/java/com/bsth/service/schedule/timetable/strategy/impl/TimetableExcelDataValidateStrategyImpl.java
src/main/java/com/bsth/service/schedule/utils/DataToolsProperties.java
src/main/resources/datatools/config-cloud.properties
src/main/resources/datatools/config-dev.properties
src/main/resources/datatools/config-prod.properties
src/main/resources/datatools/config-test.properties
@@ -184,6 +184,12 @@
 			<groupId>pentaho-kettle</groupId>
 			<artifactId>kettle-core</artifactId>
 			<version>6.0.1.0-386</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.xmlgraphics</groupId>
+                    <artifactId>batik-js</artifactId>
+                </exclusion>
+            </exclusions>
 		</dependency>
 		<dependency>
 			<groupId>pentaho-kettle</groupId>
@@ -12,7 +12,7 @@ import com.bsth.controller.schedule.BController_facade;
 import com.bsth.service.schedule.TTInfoDetailService;
 import com.bsth.service.schedule.datatools.TTInfoDetailForEdit;
 import com.bsth.service.schedule.datatools.TTinfoDetailDynamicData;
-import com.bsth.service.schedule.timetable.ExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
 import com.bsth.service.schedule.utils.DataToolsFile;
 import com.bsth.service.schedule.utils.DataToolsFileType;
 import org.apache.commons.lang3.StringUtils;
@@ -143,7 +143,7 @@ public class TTInfoDetailController_facade extends BController_facade&lt;Long, TTIn
                 throw new Exception("线路版本未知");
             }
             ttInfoDetailService.validateExcelSheet(filename, sheetname, lineid, linename, lineversion,
-                    ExcelFormatType.getEnum(excelFormatType));
+                    TimetableExcelFormatType.fromDesc(excelFormatType));
             rtn.put("status", ResponseCode.SUCCESS);
         } catch (Exception exp) {
             rtn.put("status", ResponseCode.ERROR);
@@ -7,7 +7,7 @@ import com.bsth.entity.schedule.TTInfoDetail;
 import com.bsth.service.schedule.TTInfoDetailService;
 import com.bsth.service.schedule.datatools.TTInfoDetailForEdit;
 import com.bsth.service.schedule.datatools.TTinfoDetailDynamicData;
-import com.bsth.service.schedule.timetable.ExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
 import com.bsth.service.schedule.utils.DataToolsFile;
 import com.bsth.service.schedule.utils.DataToolsFileType;
 import com.bsth.service.schedule.utils.MyHttpUtils;
@@ -54,7 +54,7 @@ public class TTInfoDetailController extends BController&lt;TTInfoDetail, Long&gt; {
                 throw new Exception("线路版本未知");
             }
             ttInfoDetailService.validateExcelSheet(filename, sheetname, lineid, linename, lineversion,
-                    ExcelFormatType.getEnum(excelFormatType));
+                    TimetableExcelFormatType.fromDesc(excelFormatType));
             rtn.put("status", ResponseCode.SUCCESS);
         } catch (Exception exp) {
             rtn.put("status", ResponseCode.ERROR);
@@ -34,14 +34,17 @@ public class TTInfoBxDetail extends BEntity {
     /** 路牌班型1 */
     @Convert(converter = BxTypeConverter.class)
-    @Column(nullable = false)
+    @Column(columnDefinition = "default '_null_'", nullable = false)
     private BxType bxType1;
     /** 路牌班型2 */
-    @Column(nullable = false)
     @Convert(converter = BxTypeConverter.class)
+    @Column(columnDefinition = "default '_null_'", nullable = false)
     private BxType bxType2;
     /** 路牌配档数 */
     private String bxPds;
+    /** 工时 */
+    @Column(nullable = false)
+    private String gs;
     /** 版本控制 */
     @Version
@@ -122,4 +125,11 @@ public class TTInfoBxDetail extends BEntity {
         this.version = version;
     }
+    public String getGs() {
+        return gs;
+    }
+
+    public void setGs(String gs) {
+        this.gs = gs;
+    }
 }
@@ -4,7 +4,7 @@ import com.bsth.entity.schedule.TTInfoDetail;
 import com.bsth.service.schedule.datatools.TTInfoDetailForEdit;
 import com.bsth.service.schedule.datatools.TTinfoDetailDynamicData;
 import com.bsth.service.schedule.exception.ScheduleException;
-import com.bsth.service.schedule.timetable.ExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
 import com.bsth.service.schedule.utils.DataToolsFile;
 import com.bsth.service.schedule.utils.DataToolsFileType;
@@ -77,7 +77,7 @@ public interface TTInfoDetailService extends BService&lt;TTInfoDetail, Long&gt; {
      * @param sheetname sheet名字
      * @param lineid 线路id
      * @param lineversion 线路版本
-     * @param excelFormatType 版本
+     * @param timetableExcelFormatType 时刻表excel格式类型
      */
     void validateExcelSheet(
             String filename,
@@ -85,7 +85,7 @@ public interface TTInfoDetailService extends BService&lt;TTInfoDetail, Long&gt; {
             Integer lineid,
             String linename,
             Integer lineversion,
-            ExcelFormatType excelFormatType) throws ScheduleException;
+            TimetableExcelFormatType timetableExcelFormatType) throws ScheduleException;
     /**
      * 验证关联的线路标准信息（以后放到规则引擎里去做）。
@@ -3,7 +3,9 @@ package com.bsth.service.schedule.datatools;
 import com.bsth.entity.StationRoute;
 import com.bsth.service.StationRouteService;
 import com.bsth.service.schedule.exception.ScheduleException;
-import com.bsth.service.schedule.timetable.ExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelData;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+import com.bsth.service.schedule.timetable.strategy.impl.TimetableExcelDataImportStrategyImpl;
 import com.bsth.service.schedule.utils.*;
 import jxl.Sheet;
 import jxl.Workbook;
@@ -14,7 +16,6 @@ import org.apache.commons.lang3.StringUtils;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.util.CellRangeAddress;
-import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.joda.time.DateTime;
 import org.joda.time.LocalTime;
 import org.joda.time.format.DateTimeFormat;
@@ -22,7 +23,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.stereotype.Service;
 import java.awt.*;
@@ -84,126 +84,144 @@ public class TTInfoDetailDataToolsImpl implements DataToolsService, TTInfoDetail
         try {
             LOGGER.info("//---------------- 导入时刻表明细 start... ----------------//");
-            if (params.get("lineversion") == null) {
-                throw new Exception("线路版本未知");
-            }
-
-            String filename = file.getAbsolutePath(); // xls xlsx 文件名
-            String sheetname = String.valueOf(params.get("sheetname")); // sheet名字
-            Long ttid = Long.valueOf(String.valueOf(params.get("ttid"))); // 时刻表id
-            Long xlid = Long.valueOf(String.valueOf(params.get("xlid"))); // 线路id
-            Integer lineid = Integer.valueOf(String.valueOf(params.get("lineinfo"))); // 线路标准id
-            String xlname = String.valueOf(params.get("xlname")); // 线路名字
-            String ttname = String.valueOf(params.get("ttname")); // 时刻表名字
-            Integer lineversion = Integer.valueOf(params.get("lineversion").toString()); // 线路路由版本
-            ExcelFormatType excelFormatType = ExcelFormatType.getEnum(String.valueOf(params.get("excelFormatType"))); // 格式
-
-            LOGGER.info("参数1, xls文件名={},sheet名字={}", filename, sheetname);
-            LOGGER.info("参数2, 线路id={},线路名字={}", xlid, xlname);
-            LOGGER.info("参数3, 时刻表id={},时刻表名字={}", ttid, ttname);
-
-            LOGGER.info("转换xls文件格式成文本格式...");
-            // 1、修改已经上传的excel文件，在每个起点站后标示数字，表示第几个班次
-            // 2、由于格式问题，需要把内容都转换成字符串
-            List<String> colList = new ArrayList<>();
-
-            // poi api，并读取第一行数据，组合成站点列表，逗号分隔
-            org.apache.poi.ss.usermodel.Workbook poi_workbook;
-            org.apache.poi.ss.usermodel.Sheet poi_sheet;
-            if (DataToolsFileType.XLS.isThisType(file)) {
-                poi_workbook = DataToolsFileType.XLS.getWorkBook(file);
-            } else if (DataToolsFileType.XLSX.isThisType(file)) {
-                poi_workbook = DataToolsFileType.XLSX.getWorkBook(file);
-            } else {
-                throw new Exception("不是xls xlsx文件!");
-            }
-            poi_sheet = poi_workbook.getSheet(sheetname);
-            int rownums = poi_sheet.getLastRowNum() + 1;
-            int colnums = poi_sheet.getRow(0).getLastCellNum();
-            Row firstrow = poi_sheet.getRow(0);
-            for (int i = 0; i < colnums; i++) {
-                org.apache.poi.ss.usermodel.Cell cell = firstrow.getCell(i);
-                if (i == 0) {
-                    colList.add(PoiUtils.getStringValueFromCell(cell).trim());
-                } else {
-                    // 站点名字后加->数字形式标示成不同的字段
-                    colList.add(PoiUtils.getStringValueFromCell(cell).trim().replaceAll("(->\\d+)", "") + "->" + i);
-                }
-            }
-
-            // jxl api
-            File fileCal = new File(filename + "_stringType.xls");
-            WritableWorkbook writableWorkbook = Workbook.createWorkbook(fileCal);
-            WritableSheet sheet1 = writableWorkbook.createSheet(sheetname, 0);
-            for (int i = 0; i < colnums; i++) { // 第一行数据
-                sheet1.addCell(new Label(i, 0, colList.get(i)));
-            }
-            for (int i = 1; i < rownums; i++) { // 第二行开始
-                for (int j = 0; j < colnums; j++) {
-                    // poi读
-                    String cellContent = PoiUtils.getStringValueFromCell(
-                            poi_sheet.getRow(i).getCell(j)
-                    ).replaceAll("\\s*", "");
-                    // jxl写
-                    sheet1.addCell(new Label(j, i, cellContent));
-                }
-            }
-            writableWorkbook.write();
-            writableWorkbook.close();
-
-            // 2、删除原有数据
-            // 操作在ktr内部执行
-
-            // 3、导入时刻表
-
-            // 计算表头参数
-            Workbook book = Workbook.getWorkbook(fileCal);
-            Sheet sheet_exp = book.getSheet(sheetname);
-            List<String> columnames = new ArrayList<>();
-            for (int i = 0; i < sheet_exp.getColumns(); i++) { // 获取第一行，数据，作为列名
-                columnames.add(sheet_exp.getCell(i, 0).getContents());
-            }
-            LOGGER.info("表头={}", StringUtils.join(columnames.toArray(), ","));
-
-            // 创建ktr转换所需参数
-            Map<String, Object> ktrParms = new HashMap<>();
-            // 元数据ktr
-            File mktrFile = new File(this.getClass().getResource(
-                    dataToolsProperties.getTtinfodetailMetadatainputktr()).toURI());
-            // 实际数据ktr
-            File ktrFile2_version = new File(this.getClass().getResource(
-                    dataToolsProperties.getTtinfodetailDatainputktr2version()).toURI());
-            // 实际数据ktr2
-            File ktrFile2_version2 = new File(this.getClass().getResource(
-                    dataToolsProperties.getTtinfodetailDatainputktr2version2()).toURI());
-
-
-            // 通用参数，转换文件路径，excel输入文件路径，错误输出文件路径
-            ktrParms.put("transpath", mktrFile.getAbsolutePath());
-            ktrParms.put("filepath", fileCal.getAbsolutePath());
-            ktrParms.put("erroroutputdir", dataToolsProperties.getTransErrordir());
-
-            // 附加参数
-            if (excelFormatType == ExcelFormatType.Normal) {
-                ktrParms.put("injectktrfile", ktrFile2_version.getAbsolutePath()); // 注入元数据的ktr文件
-            } else if (excelFormatType == ExcelFormatType.Dynamic) {
-                ktrParms.put("injectktrfile", ktrFile2_version2.getAbsolutePath()); // 注入元数据的ktr文件
-            } else {
-                throw new ScheduleException("未知ExcelFormatType");
-            }
-
-            ktrParms.put("sheetname", sheetname); // sheet工作区的名字
-            ktrParms.put("lineinfoid", lineid); // 线路标准id
-            ktrParms.put("xlname", xlname); // 线路名称
-            ktrParms.put("xlid", xlid); // 线路id
-            ktrParms.put("ttinfoname", ttname); // 时刻表名称
-            ktrParms.put("ttid", ttid.intValue()); // 时刻表id
-            ktrParms.put("lineversion", lineversion); // 站点路由版本
-            ktrParms.put("excelfieldnames", StringUtils.join(columnames.toArray(), ",")); // 时刻表excel输入字段名，以逗号连接
-            columnames.remove(0);
-            ktrParms.put("normalizefieldnames", StringUtils.join(columnames.toArray(), ",")); // 数据范式化字段名，以逗号连接
-
-            dataToolsService.importData(fileCal, ktrParms);
+            TimetableExcelData timetableExcelData = TimetableExcelData.withImportBuilder()
+                    .setExcelFilePath(file.getAbsolutePath())
+                    .setExcelSheetName(String.valueOf(params.get("sheetname")))
+                    .setTtInfoId(Long.valueOf(String.valueOf(params.get("ttid"))))
+                    .setLineId(Integer.valueOf(String.valueOf(params.get("xlid"))))
+                    .setLineInfoId(Integer.valueOf(String.valueOf(params.get("lineinfo"))))
+                    .setLineName(String.valueOf(params.get("xlname")))
+                    .setTtInfoName(String.valueOf(params.get("ttname")))
+                    .setLineRouteVersion(Integer.valueOf(String.valueOf(params.get("lineversion"))))
+                    .setTimetableExcelFormatType(TimetableExcelFormatType.fromDesc(
+                            String.valueOf(params.get("excelFormatType"))))
+                    .setDataToolsService(this.dataToolsService)
+                    .setDataToolsProperties(this.dataToolsProperties)
+                    .setTimetableExcelDataImportStrategy(new TimetableExcelDataImportStrategyImpl())
+                    .build();
+
+            timetableExcelData.doImport();
+
+//            if (params.get("lineversion") == null) {
+//                throw new Exception("线路版本未知");
+//            }
+//
+//            String filename = file.getAbsolutePath(); // xls xlsx 文件名
+//            String sheetname = String.valueOf(params.get("sheetname")); // sheet名字
+//            Long ttid = Long.valueOf(String.valueOf(params.get("ttid"))); // 时刻表id
+//            Long xlid = Long.valueOf(String.valueOf(params.get("xlid"))); // 线路id
+//            Integer lineid = Integer.valueOf(String.valueOf(params.get("lineinfo"))); // 线路标准id
+//            String xlname = String.valueOf(params.get("xlname")); // 线路名字
+//            String ttname = String.valueOf(params.get("ttname")); // 时刻表名字
+//            Integer lineversion = Integer.valueOf(params.get("lineversion").toString()); // 线路路由版本
+//            ExcelFormatType excelFormatType = ExcelFormatType.getEnum(String.valueOf(params.get("excelFormatType"))); // 格式
+//
+//            LOGGER.info("参数1, xls文件名={},sheet名字={}", filename, sheetname);
+//            LOGGER.info("参数2, 线路id={},线路名字={}", xlid, xlname);
+//            LOGGER.info("参数3, 时刻表id={},时刻表名字={}", ttid, ttname);
+//
+//            LOGGER.info("转换xls文件格式成文本格式...");
+//            // 1、修改已经上传的excel文件，在每个起点站后标示数字，表示第几个班次
+//            // 2、由于格式问题，需要把内容都转换成字符串
+//            List<String> colList = new ArrayList<>();
+//
+//            // poi api，并读取第一行数据，组合成站点列表，逗号分隔
+//            org.apache.poi.ss.usermodel.Workbook poi_workbook;
+//            org.apache.poi.ss.usermodel.Sheet poi_sheet;
+//            if (DataToolsFileType.XLS.isThisType(file)) {
+//                poi_workbook = DataToolsFileType.XLS.getWorkBook(file);
+//            } else if (DataToolsFileType.XLSX.isThisType(file)) {
+//                poi_workbook = DataToolsFileType.XLSX.getWorkBook(file);
+//            } else {
+//                throw new Exception("不是xls xlsx文件!");
+//            }
+//            poi_sheet = poi_workbook.getSheet(sheetname);
+//            int rownums = poi_sheet.getLastRowNum() + 1;
+//            int colnums = poi_sheet.getRow(0).getLastCellNum();
+//            Row firstrow = poi_sheet.getRow(0);
+//            for (int i = 0; i < colnums; i++) {
+//                org.apache.poi.ss.usermodel.Cell cell = firstrow.getCell(i);
+//                if (i == 0) {
+//                    colList.add(PoiUtils.getStringValueFromCell(cell).trim());
+//                } else {
+//                    // 站点名字后加->数字形式标示成不同的字段
+//                    colList.add(PoiUtils.getStringValueFromCell(cell).trim().replaceAll("(->\\d+)", "") + "->" + i);
+//                }
+//            }
+//
+//            // jxl api
+//            File fileCal = new File(filename + "_stringType.xls");
+//            WritableWorkbook writableWorkbook = Workbook.createWorkbook(fileCal);
+//            WritableSheet sheet1 = writableWorkbook.createSheet(sheetname, 0);
+//            for (int i = 0; i < colnums; i++) { // 第一行数据
+//                sheet1.addCell(new Label(i, 0, colList.get(i)));
+//            }
+//            for (int i = 1; i < rownums; i++) { // 第二行开始
+//                for (int j = 0; j < colnums; j++) {
+//                    // poi读
+//                    String cellContent = PoiUtils.getStringValueFromCell(
+//                            poi_sheet.getRow(i).getCell(j)
+//                    ).replaceAll("\\s*", "");
+//                    // jxl写
+//                    sheet1.addCell(new Label(j, i, cellContent));
+//                }
+//            }
+//            writableWorkbook.write();
+//            writableWorkbook.close();
+//
+//            // 2、删除原有数据
+//            // 操作在ktr内部执行
+//
+//            // 3、导入时刻表
+//
+//            // 计算表头参数
+//            Workbook book = Workbook.getWorkbook(fileCal);
+//            Sheet sheet_exp = book.getSheet(sheetname);
+//            List<String> columnames = new ArrayList<>();
+//            for (int i = 0; i < sheet_exp.getColumns(); i++) { // 获取第一行，数据，作为列名
+//                columnames.add(sheet_exp.getCell(i, 0).getContents());
+//            }
+//            LOGGER.info("表头={}", StringUtils.join(columnames.toArray(), ","));
+//
+//            // 创建ktr转换所需参数
+//            Map<String, Object> ktrParms = new HashMap<>();
+//            // 元数据ktr
+//            File mktrFile = new File(this.getClass().getResource(
+//                    dataToolsProperties.getTtinfodetailMetadatainputktr()).toURI());
+//            // 实际数据ktr
+//            File ktrFile2_version = new File(this.getClass().getResource(
+//                    dataToolsProperties.getTtinfodetailDatainputktr2version()).toURI());
+//            // 实际数据ktr2
+//            File ktrFile2_version2 = new File(this.getClass().getResource(
+//                    dataToolsProperties.getTtinfodetailDatainputktr2version2()).toURI());
+//
+//
+//            // 通用参数，转换文件路径，excel输入文件路径，错误输出文件路径
+//            ktrParms.put("transpath", mktrFile.getAbsolutePath());
+//            ktrParms.put("filepath", fileCal.getAbsolutePath());
+//            ktrParms.put("erroroutputdir", dataToolsProperties.getTransErrordir());
+//
+//            // 附加参数
+//            if (excelFormatType == ExcelFormatType.Normal) {
+//                ktrParms.put("injectktrfile", ktrFile2_version.getAbsolutePath()); // 注入元数据的ktr文件
+//            } else if (excelFormatType == ExcelFormatType.Dynamic) {
+//                ktrParms.put("injectktrfile", ktrFile2_version2.getAbsolutePath()); // 注入元数据的ktr文件
+//            } else {
+//                throw new ScheduleException("未知ExcelFormatType");
+//            }
+//
+//            ktrParms.put("sheetname", sheetname); // sheet工作区的名字
+//            ktrParms.put("lineinfoid", lineid); // 线路标准id
+//            ktrParms.put("xlname", xlname); // 线路名称
+//            ktrParms.put("xlid", xlid); // 线路id
+//            ktrParms.put("ttinfoname", ttname); // 时刻表名称
+//            ktrParms.put("ttid", ttid.intValue()); // 时刻表id
+//            ktrParms.put("lineversion", lineversion); // 站点路由版本
+//            ktrParms.put("excelfieldnames", StringUtils.join(columnames.toArray(), ",")); // 时刻表excel输入字段名，以逗号连接
+//            columnames.remove(0);
+//            ktrParms.put("normalizefieldnames", StringUtils.join(columnames.toArray(), ",")); // 数据范式化字段名，以逗号连接
+//
+//            dataToolsService.importData(fileCal, ktrParms);
             LOGGER.info("//---------------- 导入时刻表明细 success... ----------------//");
         } catch (Exception exp) {
@@ -28,8 +28,9 @@ import com.bsth.service.schedule.datatools.ExcelPoiOperator;
 import com.bsth.service.schedule.datatools.TTInfoDetailForEdit;
 import com.bsth.service.schedule.datatools.TTinfoDetailDynamicData;
 import com.bsth.service.schedule.exception.ScheduleException;
-import com.bsth.service.schedule.timetable.ExcelData;
-import com.bsth.service.schedule.timetable.ExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelData;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+import com.bsth.service.schedule.timetable.strategy.impl.TimetableExcelDataValidateStrategyImpl;
 import com.bsth.service.schedule.utils.*;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.DateFormatUtils;
@@ -404,13 +405,26 @@ public class TTInfoDetailServiceImpl extends BServiceImpl&lt;TTInfoDetail, Long&gt; im
     }
     @Override
-    public void validateExcelSheet(String filename, String sheetname, Integer lineid, String linename, Integer lineversion, ExcelFormatType excelFormatType) throws ScheduleException {
-        ExcelData excelData = new ExcelData(
-                filename, sheetname, lineid,
-                lineService, guideboardInfoService,
-                lineversion, stationRouteService,
-                excelFormatType);
-        excelData.validateExcelSheet();
+    public void validateExcelSheet(
+            String filename,
+            String sheetname,
+            Integer lineid,
+            String linename,
+            Integer lineversion,
+            TimetableExcelFormatType timetableExcelFormatType
+    ) throws ScheduleException {
+        TimetableExcelData timetableExcelData = TimetableExcelData.withValidateBuilder()
+                .setExcelFilePath(filename)
+                .setExcelSheetName(sheetname)
+                .setLineId(lineid)
+                .setLineRouteVersion(lineversion)
+                .setLineService(this.lineService)
+                .setStationRouteService(this.stationRouteService)
+                .setGuideboardInfoService(this.guideboardInfoService)
+                .setTimetableExcelFormatType(timetableExcelFormatType)
+                .setTimetableExcelDataValidateStrategy(new TimetableExcelDataValidateStrategyImpl())
+                .build();
+        timetableExcelData.doValidate();
     }
     @Override
-package com.bsth.service.schedule.timetable;
-
-import com.bsth.entity.Line;
-import com.bsth.entity.LsStationRoute;
-import com.bsth.entity.schedule.GuideboardInfo;
-import com.bsth.service.LineService;
-import com.bsth.service.StationRouteService;
-import com.bsth.service.schedule.GuideboardInfoService;
-import com.bsth.service.schedule.exception.ScheduleException;
-import com.bsth.service.schedule.utils.DataToolsFile;
-import com.bsth.service.schedule.utils.DataToolsFileType;
-import com.bsth.service.schedule.utils.PoiUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.Row;
-import org.apache.poi.ss.usermodel.Sheet;
-import org.apache.poi.ss.usermodel.Workbook;
-import org.springframework.util.CollectionUtils;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * 时刻表Excel数据类。
- */
-public class ExcelData {
-
-    /** 导入后的Excel文件对象 */
-    private DataToolsFile dataToolsFile;
-    /** 数据sheet名 */
-    private String sheetName;
-    /** 线路 */
-    private Line line;
-    /** 线路路由列表（包含上下行的起终点站） */
-    private List<LsStationRoute> lsStationRouteList;
-    /** 路牌列表 */
-    private List<GuideboardInfo> guideboardInfoList;
-    /** excel数据格式 */
-    private ExcelFormatType excelFormatType;
-
-    public DataToolsFile getDataToolsFile() {
-        return dataToolsFile;
-    }
-
-    public void setDataToolsFile(DataToolsFile dataToolsFile) {
-        this.dataToolsFile = dataToolsFile;
-    }
-
-    public String getSheetName() {
-        return sheetName;
-    }
-
-    public void setSheetName(String sheetName) {
-        this.sheetName = sheetName;
-    }
-
-    public Line getLine() {
-        return line;
-    }
-
-    public void setLine(Line line) {
-        this.line = line;
-    }
-
-    public List<LsStationRoute> getLsStationRouteList() {
-        return lsStationRouteList;
-    }
-
-    public void setLsStationRouteList(List<LsStationRoute> lsStationRouteList) {
-        this.lsStationRouteList = lsStationRouteList;
-    }
-
-    public List<GuideboardInfo> getGuideboardInfoList() {
-        return guideboardInfoList;
-    }
-
-    public void setGuideboardInfoList(List<GuideboardInfo> guideboardInfoList) {
-        this.guideboardInfoList = guideboardInfoList;
-    }
-
-    public ExcelFormatType getExcelFormatType() {
-        return excelFormatType;
-    }
-
-    public void setExcelFormatType(ExcelFormatType excelFormatType) {
-        this.excelFormatType = excelFormatType;
-    }
-
-    /**
-     * 构造函数
-     * @param filePath 文件路径
-     * @param sheetName sheet名字
-     * @param lineId 线路Id
-     * @param lineService LineServiceImpl
-     * @param guideboardInfoService GuideboardInfoServiceImpl
-     * @param lineRouteVersion 线路路由版本
-     * @param stationRouteService StationRouteServiceImpl
-     * @param excelFormatType excel数据格式
-     * @throws ScheduleException
-     * @see com.bsth.service.impl.LineServiceImpl
-     * @see com.bsth.service.schedule.impl.GuideboardInfoServiceImpl
-     * @see com.bsth.service.impl.StationRouteServiceImpl
-     */
-    public ExcelData(
-            String filePath, String sheetName,
-            Integer lineId, LineService lineService, GuideboardInfoService guideboardInfoService,
-            Integer lineRouteVersion, StationRouteService stationRouteService,
-            ExcelFormatType excelFormatType) throws ScheduleException {
-        // 获取Excel文件对象，类型
-        File file = new File(filePath);
-        this.dataToolsFile = new DataToolsFile();
-        this.dataToolsFile.setFile(file);
-        if (DataToolsFileType.XLS.isThisType(file)) {
-            this.dataToolsFile.setFileType(DataToolsFileType.XLS);
-        } else if (DataToolsFileType.XLSX.isThisType(file)) {
-            this.dataToolsFile.setFileType(DataToolsFileType.XLSX);
-        } else {
-            throw new ScheduleException("不是xls xlsx文件！");
-        }
-
-        // sheet名字
-        this.sheetName = sheetName;
-        // 线路
-        this.line = lineService.findById(lineId);
-        // 线路路由列表
-        Map<String, Object> p1 = new HashMap<>();
-        p1.put("line.id_eq", lineId);
-        p1.put("stationMark_in", "B,E"); // 起点站
-        p1.put("destroy_eq", 0); // 未撤销
-        p1.put("versions_eq", lineRouteVersion); // 带线路版本
-        lsStationRouteList = (List<LsStationRoute>) stationRouteService.list_ls(p1);
-        // 路牌列表
-        p1.clear();
-        p1.put("xl.id_eq", lineId);
-        p1.put("isCancel_eq", false);
-        guideboardInfoList = guideboardInfoService.list(p1);
-
-        // excel数据格式
-        this.excelFormatType = excelFormatType;
-    }
-
-    /**
-     * 验证路由名字。
-     * @param colNum 列标号（从0开始）
-     * @param routeName 路由名字
-     * @throws ScheduleException
-     */
-    private void validateRouteName(int colNum, String routeName) throws ScheduleException {
-        List<LsStationRoute> lsStationRoutes = new ArrayList<>();
-        for (LsStationRoute lsStationRoute : this.lsStationRouteList) {
-            if ("B".equals(lsStationRoute.getStationMark()) && routeName.equals(lsStationRoute.getStationName())) {
-                lsStationRoutes.add(lsStationRoute);
-            }
-        }
-
-        if (CollectionUtils.isEmpty(lsStationRoutes)) {
-            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中不是起点站",
-                    colNum + 1, routeName, this.line.getName()));
-        } else if (lsStationRoutes.size() > 1) {
-            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中上下行都是起点站",
-                    colNum + 1, routeName, this.line.getName()));
-        } else if (StringUtils.isEmpty(lsStationRoutes.get(0).getStationCode())) {
-            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中没有站点编码",
-                    colNum + 1, routeName, this.line.getName()));
-        }
-
-    }
-
-    /**
-     * 验证路牌名字。
-     * @param colNum excelSheet 列index
-     * @param guideboardName 路牌名字
-     * @throws ScheduleException
-     */
-    private void validateGuideboardName(int colNum, String guideboardName) throws ScheduleException {
-        List<GuideboardInfo> guideboardInfos = new ArrayList<>();
-        for (GuideboardInfo guideboardInfo : this.guideboardInfoList) {
-            if (guideboardName.equals(guideboardInfo.getLpName())) {
-                guideboardInfos.add(guideboardInfo);
-            }
-        }
-
-        if (CollectionUtils.isEmpty(guideboardInfos)) {
-            throw new ScheduleException(String.format("第%d行，第1列的路牌在%s中不存在",
-                    colNum + 1, this.line.getName()));
-        } else if (guideboardInfos.size() > 1) {
-            throw new ScheduleException(String.format("第%d行，第1列的路牌在%s中重复",
-                    colNum + 1, this.line.getName()));
-        }
-    }
-
-    /**
-     * 验证发车时间内容。
-     * @param rowNum excelSheet 行index
-     * @param colNum excelSheet 列index
-     * @param fcsjContent 发车时间内容
-     * @throws ScheduleException
-     */
-    private void validateFcsjContent(int rowNum, int colNum, String fcsjContent) throws ScheduleException {
-        if (this.excelFormatType == ExcelFormatType.Normal) {
-            // 班次时间验证，正则表达式，格式hh:mm或者hhmm
-            String rex1 = "^([01]?[0-9]|2[0-3]):[0-5][0-9]$"; // hh:mm格式
-            String rex2 = "^([01]?[0-9]|2[0-3]),[0-5][0-9]$"; // hh,mm格式
-            String rex3 = "^([01]?[0-9]|2[0-3])[0-5][0-9]$"; // hhmm格式
-            Pattern p1 = Pattern.compile(rex1);
-            Pattern p2 = Pattern.compile(rex2);
-            Pattern p3 = Pattern.compile(rex3);
-
-            Matcher m1 = p1.matcher(fcsjContent.trim());
-            Matcher m2 = p2.matcher(fcsjContent.trim());
-            Matcher m3 = p3.matcher(fcsjContent.trim());
-            if ((!m1.matches()) && (!m2.matches()) && (!m3.matches())) {
-                throw new ScheduleException(String.format("第%d行，第%d列的发车时间格式不正确，格式应为hh:mm或hh,mm或hhmm",
-                        rowNum + 1, colNum + 1));
-            }
-        } else if (this.excelFormatType == ExcelFormatType.Dynamic) {
-            String rex1 = "^(\u62a5|\u51fa)?([01]?[0-9]|2[0-3]):[0-5][0-9]$"; // (报|出)hh:mm格式
-            String rex2 = "^([01]?[0-9]|2[0-3]):[0-5][0-9](X|\u203b)?$"; // hh:mm(X|※)格式
-            Pattern p1 = Pattern.compile(rex1);
-            Pattern p2 = Pattern.compile(rex2);
-            Matcher m1 = p1.matcher(fcsjContent.trim());
-            Matcher m2 = p2.matcher(fcsjContent.trim());
-            if ((!m1.matches()) && (!m2.matches())) {
-                throw new ScheduleException(String.format(
-                        "第%d行，第%d列的发车时间格式不正确，格式应为(报|出)hh:mm或hh:mm(X|※)",
-                        rowNum + 1, colNum + 1));
-            }
-        } else {
-            throw new ScheduleException("未知ExcelFormatType");
-        }
-
-    }
-
-    private List<Integer> calcuExcelSheetColIndexList(Workbook workbook) throws ScheduleException {
-        // 有些列不需要参与计算，找出参与计算的列
-        List<Integer> colIndexList = new ArrayList<>();
-        Sheet sheet = workbook.getSheet(this.sheetName);
-        Row firstRow = sheet.getRow(0); // 获取第一行数据列
-        for (int i = 0; i < firstRow.getLastCellNum(); i++) {
-            if (excelFormatType == ExcelFormatType.Normal) {
-                colIndexList.add(i);
-            } else if (excelFormatType == ExcelFormatType.Dynamic) {
-                String cell_con = StringUtils.trimToEmpty(
-                        PoiUtils.getStringValueFromCell(firstRow.getCell(i))); // trimToEmpty
-                if ("报到".equals(cell_con) ||
-                        "到场".equals(cell_con) ||
-                        "离场".equals(cell_con) ||
-                        "总公里".equals(cell_con) ||
-                        "营业公里".equals(cell_con) ||
-                        "空驶公里".equals(cell_con) ||
-                        "总工时".equals(cell_con) ||
-                        "营业工时".equals(cell_con) ||
-                        "营运班次".equals(cell_con)) {
-                    // 这些列全部祛除
-                    continue;
-                } else {
-                    colIndexList.add(i);
-                }
-            } else {
-                throw new ScheduleException("未知excelFormatType");
-            }
-        }
-        return colIndexList;
-    }
-
-    /**
-     * 验证老系统ExcelSheet格式。
-     * @throws ScheduleException
-     */
-    public void validateExcelSheet() throws ScheduleException {
-        try {
-            Workbook workbook = this.dataToolsFile.getFileType().getWorkBook(
-                    this.dataToolsFile.getFile()
-            );
-
-            Sheet sheet = workbook.getSheet(this.sheetName);
-            int rowNums = sheet.getLastRowNum() + 1; // 基于0 base的，长度加1
-            int colNums = sheet.getRow(0).getLastCellNum(); // 不需要加1，就是长度
-
-            if (rowNums == 0 || colNums == 0) { // 工作区是否为空
-                throw new Exception(String.format("%s 工作区没有数据！", this.sheetName));
-            } else {
-                if (rowNums <= 1 || rowNums <= 1) {
-                    throw new Exception(String.format("工作区至少包含2行2列的数据"));
-                } else {
-                    List<Integer> colIndexList = this.calcuExcelSheetColIndexList(workbook);
-                    Row firstRow = sheet.getRow(0); // 获取第一行数据列
-                    for (int n = 0; n < colIndexList.size(); n++) {
-                        int i = colIndexList.get(n);
-                        String cell_con = StringUtils.trimToEmpty(
-                                PoiUtils.getStringValueFromCell(firstRow.getCell(i))); // trimToEmpty
-
-                        if (StringUtils.isEmpty(cell_con)) {
-                            throw new Exception(String.format("第1行，第%d列数据不能为空", i + 1));
-                        } else {
-                            // 正则表达式去除右侧数字
-//                            cell_con = cell_con.replaceAll("[\\d+]", "");
-//                            cell_con = cell_con.replaceAll("(\\d+)$", "");
-
-                            // 如果站名中有类似->{数字}，使用正则表达式过滤掉
-                            cell_con = cell_con.replaceAll("(->\\d+)", "");
-
-                            if (i == 0) { // 第一列必须是路牌2个字
-                                if (!"路牌".equals(cell_con.trim())) {
-                                    throw new Exception("第1行，第1列数据必须是路牌2个字");
-                                }
-                            } else { // 排除出场，进场，其余内容到站点路由里查询，以各个方向的起点站为查询依据
-                                if ((!"出场".equals(cell_con.trim())) &&
-                                        (!"进场".equals(cell_con.trim()))) {
-                                    validateRouteName(i, cell_con.trim()); // 验证路由名字
-                                }
-
-                            }
-                        }
-                    }
-
-                    // 验证路牌内容
-                    Map<String, Integer> gbindexmap = new HashMap<>(); // 记录每个路牌在第几行
-                    for (int i = 1; i < rowNums; i++) { // 从第2行开始验证数据
-                        Cell cell = sheet.getRow(i).getCell(0); // 获取第1列
-                        String bcell_con = StringUtils.trimToEmpty(
-                                PoiUtils.getStringValueFromCell(cell)); // trimToEmpty
-                        if (StringUtils.isEmpty(bcell_con)) {
-                            throw new Exception(String.format("第%d行，第1列路牌无数据", i + 1));
-                        } else if (gbindexmap.get(bcell_con.trim()) != null) {
-                            throw new Exception(String.format("第%d行，第1列的路牌数据与第%d行，第1列数据重复",
-                                    i + 1,
-                                    gbindexmap.get(bcell_con.trim())));
-                        } else {
-                            validateGuideboardName(i, bcell_con.trim()); // 验证路牌名字
-                            gbindexmap.put(bcell_con.trim(), i + 1);
-                        }
-                    }
-
-                    // 验证发车时间格式
-                    for (int i = 1; i < rowNums; i++) { // 从第2行开始验证数据
-                        Row row = sheet.getRow(i);
-                        for (int n = 1; n < colIndexList.size(); n++) { // 从第2列开始
-                            int j = colIndexList.get(n);
-                            String bcell_con = StringUtils.trimToEmpty(
-                                    PoiUtils.getStringValueFromCell(
-                                            row.getCell(j))).replaceAll("\\s*", ""); // trimToEmpty
-                            if (StringUtils.isNotEmpty(bcell_con)) {
-                                validateFcsjContent(i, j, bcell_con);
-                            }
-                        }
-                    }
-                }
-
-            }
-
-        } catch (Exception exp) {
-            exp.printStackTrace();
-            throw new ScheduleException(exp.getMessage());
-        }
-    }
-
-}
-package com.bsth.service.schedule.timetable;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonValue;
-
-/**
- * 导入时刻表时，excel的数据格式类型。
- */
-public enum ExcelFormatType {
-    Normal("normal"), // 老系统格式
-    Dynamic("dynamic"); // 自动生成的导出格式
-
-    private String flag;
-
-    @JsonCreator
-    ExcelFormatType(String flag) {
-        this.flag = flag;
-    }
-
-    @JsonValue
-    public String getFlag() {
-        return flag;
-    }
-
-    public void setFlag(String flag) {
-        this.flag = flag;
-    }
-
-    public static ExcelFormatType getEnum(String str) {
-        if ("normal".equals(str)) {
-            return Normal;
-        } else if ("dynamic".equals(str)) {
-            return Dynamic;
-        } else {
-            throw new IllegalArgumentException("未知ExcelFormatType");
-        }
-    }
-}
+package com.bsth.service.schedule.timetable;
+
+import com.bsth.entity.Line;
+import com.bsth.entity.LsStationRoute;
+import com.bsth.entity.schedule.GuideboardInfo;
+import com.bsth.service.LineService;
+import com.bsth.service.StationRouteService;
+import com.bsth.service.schedule.GuideboardInfoService;
+import com.bsth.service.schedule.exception.ScheduleException;
+import com.bsth.service.schedule.timetable.strategy.TimetableExcelDataImportStrategy;
+import com.bsth.service.schedule.timetable.strategy.TimetableExcelDataValidateStrategy;
+import com.bsth.service.schedule.utils.*;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 时刻表Excel数据类，用于验证，导入，导出时刻表数据。
+ * 混合Builder和Strategy模式。
+ */
+public class TimetableExcelData {
+    /** 日志记录器 */
+    private final static Logger LOG = LoggerFactory.getLogger(TimetableExcelData.class);
+
+    // ------------------ 公共属性及方法，如下：------------------- //
+    /** 待导入excel workbook对象 */
+    private Workbook excelWorkBook;
+    /** 待导入excel workbook 工作区对象 */
+    private Sheet excelWorkBookSheet;
+    /** 时刻表excel格式类型 */
+    private TimetableExcelFormatType timetableExcelFormatType;
+
+    // 内部标识excel单元格类
+    public static class TimetableExcelInternalCell {
+        /** 是否可用（默认不可用） */
+        public Boolean isEnable = false;
+        /** 单元格内容 */
+        public String cellContent;
+
+        //------------- 班次类型（发车时间单元格 isFcsjCell = true）-----------//
+        /** 是否是班次 */
+        public Boolean isBc = false;
+        /** 是否是出场班次 */
+        public Boolean isOutBc = false;
+        /** 是否是进场班次 */
+        public Boolean isInBc = false;
+
+        //------------- 单元格类型 -------------//
+        /** 是否表头Cell */
+        public Boolean isHeadCell = false;
+        /** 是否路牌名字Cell */
+        public Boolean isLpNameCell = false;
+        /** 是否发车时间Cell */
+        public Boolean isFcsjCell = false;
+        /** 是否工时Cell */
+        public Boolean isGsCell = false;
+    }
+    /** 内部Excel单元格二维数组 */
+    private TimetableExcelInternalCell[][] internalExcelCells;
+    // 初始化内部标识excel单元格
+    private void initInternalExcelCells() {
+        int rowCount = this.excelWorkBookSheet.getLastRowNum() + 1; // 基于0 base的，长度加1
+        Assert.isTrue(rowCount > 1, String.format("%s 工作区没有数据！", this.excelWorkBookSheet.getSheetName()));
+        int colCount = this.excelWorkBookSheet.getRow(0).getLastCellNum(); // 不需要加1，就是长度
+        Assert.isTrue(colCount > 0, String.format("%s 工作区第一行没有数据！", this.excelWorkBookSheet.getSheetName()));
+
+        this.internalExcelCells = new TimetableExcelInternalCell[rowCount][colCount];
+        for (int rowNum = 0; rowNum < rowCount; rowNum ++) {
+            for (int colNum = 0; colNum < colCount; colNum ++) {
+                TimetableExcelInternalCell cell = new TimetableExcelInternalCell();
+                String cell_con = StringUtils.trimToEmpty(PoiUtils.getStringValueFromCell(
+                        this.excelWorkBookSheet.getRow(rowNum).getCell(colNum))
+                        .replaceAll("\\s*", "")); // trimToEmpty
+
+                // 如果站名中有类似->{数字}，使用正则表达式过滤掉
+                cell_con = cell_con.replaceAll("(->\\d+)", "");
+
+                cell.cellContent = cell_con;
+                cell.isEnable = true;
+                this.internalExcelCells[rowNum][colNum] = cell;
+            }
+        }
+
+    }
+
+    // ------------------ 验证相关属性及方法，如下：---------------- //
+    /** 线路信息 */
+    private Line line;
+    /** 线路站点路由列表（包含上下行的起终点站） */
+    private List<LsStationRoute> lsStationRouteList;
+    /** 路牌列表 */
+    private List<GuideboardInfo> guideboardInfoList;
+    /** 时刻表excel验证策略 */
+    private TimetableExcelDataValidateStrategy timetableExcelDataValidateStrategy;
+    /**
+     * 验证excel时刻表。
+     */
+    public void doValidate() throws ScheduleException {
+        this.timetableExcelDataValidateStrategy.doValidate(
+                this.internalExcelCells,
+                this.timetableExcelFormatType,
+                this.line,
+                this.lsStationRouteList,
+                this.guideboardInfoList);
+    }
+
+    // ------------------ 导入相关属性及方法，如下：---------------- //
+    /** 导入的Excel文件路径 */
+    private String excelFilePath;
+    /** 数据工具服务 */
+    private DataToolsService dataToolsService;
+    /** 配置数据导入导出用到的配置信息 */
+    private DataToolsProperties dataToolsProperties;
+    /** ktr转换所需参数对象 */
+    private Map<String, Object> ktrParams = new HashMap<>();
+    /** 时刻表excel导入策略 */
+    private TimetableExcelDataImportStrategy timetableExcelDataImportStrategy;
+    /**
+     * 导入excel时刻表。
+     */
+    public void doImport() throws ScheduleException {
+        this.timetableExcelDataImportStrategy.doImport(
+                this.excelWorkBookSheet,
+                this.excelFilePath,
+                this.dataToolsService,
+                this.dataToolsProperties,
+                this.ktrParams,
+                this.internalExcelCells,
+                this.timetableExcelFormatType);
+    }
+
+
+    // ----------- 构造函数 ---------- //
+    public TimetableExcelData(ValidateBuilder validateBuilder) {
+        // 公共属性
+        this.excelWorkBook = validateBuilder.excelWorkBook;
+        this.excelWorkBookSheet = validateBuilder.excelWorkBookSheet;
+        this.timetableExcelFormatType = validateBuilder.timetableExcelFormatType;
+        // 验证用属性
+        this.line = validateBuilder.line;
+        this.lsStationRouteList = validateBuilder.lsStationRouteList;
+        this.guideboardInfoList = validateBuilder.guideboardInfoList;
+        this.timetableExcelDataValidateStrategy = validateBuilder.timetableExcelDataValidateStrategy;
+
+        // 构造内部Excel单元格二维数组
+        this.initInternalExcelCells();
+    }
+    public TimetableExcelData(ImportBuilder importBuilder) {
+        // 公共属性
+        this.excelWorkBook = importBuilder.excelWorkBook;
+        this.excelWorkBookSheet = importBuilder.excelWorkBookSheet;
+        this.timetableExcelFormatType = importBuilder.timetableExcelFormatType;
+        // 导入用属性
+        this.excelFilePath = importBuilder.excelFilePath;
+        this.dataToolsService = importBuilder.dataToolsService;
+        this.dataToolsProperties = importBuilder.dataToolsProperties;
+        this.ktrParams = importBuilder.ktrParams;
+        this.timetableExcelDataImportStrategy = importBuilder.timetableExcelDataImportStrategy;
+
+        LOG.info("参数组1, xls文件名={},sheet名字={}",
+                this.excelFilePath, this.ktrParams.get("sheetname"));
+        LOG.info("参数组2, 线路id={},线路名字={},线路版本={}",
+                this.ktrParams.get("xlid"), this.ktrParams.get("xlname"), this.ktrParams.get("lineversion"));
+        LOG.info("参数组3, 时刻表id={},时刻表名字={}",
+                this.ktrParams.get("ttid"), this.ktrParams.get("ttinfoname"));
+
+        // 构造内部Excel单元格二维数组
+        this.initInternalExcelCells();
+    }
+
+    // ----------- builder类 ----------- //
+    public static ValidateBuilder withValidateBuilder() {
+        return new ValidateBuilder();
+    }
+    /**
+     * 验证excel时刻表数据用builder。
+     */
+    public static class ValidateBuilder {
+        private ValidateBuilder() {}
+
+        /** 导入的Excel文件路径 */
+        private String excelFilePath;
+        /** 导入的Excel sheet名字 */
+        private String excelSheetName;
+        /** 线路Id */
+        private Integer lineId;
+        /** 线路路由版本 */
+        private Integer lineRouteVersion;
+        /** 线路信息service */
+        private LineService lineService;
+        /** 站点路由信息service */
+        private StationRouteService stationRouteService;
+        /** 路牌信息service */
+        private GuideboardInfoService guideboardInfoService;
+        /** 时刻表excel格式类型 */
+        private TimetableExcelFormatType timetableExcelFormatType;
+        /** 时刻表excel验证策略 */
+        private TimetableExcelDataValidateStrategy timetableExcelDataValidateStrategy;
+
+        public ValidateBuilder setExcelFilePath(String excelFilePath) {
+            this.excelFilePath = excelFilePath;
+            return this;
+        }
+
+        public ValidateBuilder setExcelSheetName(String excelSheetName) {
+            this.excelSheetName = excelSheetName;
+            return this;
+        }
+
+        public ValidateBuilder setLineId(Integer lineId) {
+            this.lineId = lineId;
+            return this;
+        }
+
+        public ValidateBuilder setLineRouteVersion(Integer lineRouteVersion) {
+            this.lineRouteVersion = lineRouteVersion;
+            return this;
+        }
+
+        public ValidateBuilder setLineService(LineService lineService) {
+            this.lineService = lineService;
+            return this;
+        }
+
+        public ValidateBuilder setStationRouteService(StationRouteService stationRouteService) {
+            this.stationRouteService = stationRouteService;
+            return this;
+        }
+
+        public ValidateBuilder setGuideboardInfoService(GuideboardInfoService guideboardInfoService) {
+            this.guideboardInfoService = guideboardInfoService;
+            return this;
+        }
+
+        public ValidateBuilder setTimetableExcelFormatType(TimetableExcelFormatType timetableExcelFormatType) {
+            this.timetableExcelFormatType = timetableExcelFormatType;
+            return this;
+        }
+
+        public ValidateBuilder setTimetableExcelDataValidateStrategy(TimetableExcelDataValidateStrategy timetableExcelDataValidateStrategy) {
+            this.timetableExcelDataValidateStrategy = timetableExcelDataValidateStrategy;
+            return this;
+        }
+
+        // ---------------- 内部生成的属性 ------------------ //
+        /** 待导入excel workbook对象 */
+        private Workbook excelWorkBook;
+        /** 待导入excel workbook工作区对象 */
+        private Sheet excelWorkBookSheet;
+        /** 线路信息 */
+        private Line line;
+        /** 线路站点路由列表（包含上下行的起终点站） */
+        private List<LsStationRoute> lsStationRouteList;
+        /** 路牌列表 */
+        private List<GuideboardInfo> guideboardInfoList;
+
+        public TimetableExcelData build() throws ScheduleException {
+            // 0、检测时刻表excel业务格式
+            if (this.timetableExcelFormatType == null) {
+                throw new ScheduleException("导入的Excel类型为空！");
+            }
+
+            // 1、检测excel文件，创建excel workbook对象
+            // 1-1、检测文件是否存在
+            Assert.hasText(this.excelFilePath, "导入的Excel文件路径为空！");
+            File file = new File(this.excelFilePath);
+            if (!file.exists()) {
+                throw new ScheduleException("导入的Excel文件[" + this.excelFilePath + "]不存在！");
+            }
+            // 1-2、检测文件类型
+            DataToolsFile dataToolsFile = new DataToolsFile();
+            dataToolsFile.setFile(file);
+            if (DataToolsFileType.XLS.isThisType(file)) {
+                dataToolsFile.setFileType(DataToolsFileType.XLS);
+            } else if (DataToolsFileType.XLSX.isThisType(file)) {
+                dataToolsFile.setFileType(DataToolsFileType.XLSX);
+            } else {
+                throw new ScheduleException("导入的Excel文件[" + this.excelFilePath + "]内部不是xls,xlsx文件！");
+            }
+            // 1-3、创建workbook
+            this.excelWorkBook = dataToolsFile.getFileType().getWorkBook(dataToolsFile.getFile());
+            // 1-4、检测sheet名字
+            Assert.hasText(this.excelSheetName, "导入的Excel sheet名字为空！");
+            this.excelWorkBookSheet = this.excelWorkBook.getSheet(this.excelSheetName);
+            if (this.excelWorkBookSheet == null) {
+                throw new ScheduleException("导入的Excel文件sheet[" + this.excelSheetName + "]不存在！");
+            }
+
+            // 2、获取线路信息，站点路由信息
+            // 2-1、线路信息
+            Assert.notNull(this.lineService, "线路信息service为空！");
+            Assert.notNull(this.lineId, "线路Id为空！");
+            this.line = this.lineService.findById(this.lineId);
+            if (this.line == null) {
+                throw new ScheduleException("线路[id=" + this.lineId + "]不存在！");
+            }
+            // 2-2、站点路由信息
+            Assert.notNull(this.stationRouteService, "站点路由信息service为空！");
+            Assert.notNull(this.lineRouteVersion, "线路站点路由版本为空！");
+            Map<String, Object> p1 = new HashMap<>();
+            p1.put("line.id_eq", this.lineId);
+            p1.put("stationMark_in", "B,E"); // 起点站
+            p1.put("destroy_eq", 0); // 未撤销
+            p1.put("versions_eq", this.lineRouteVersion); // 带线路版本
+            this.lsStationRouteList = (List<LsStationRoute>) this.stationRouteService.list_ls(p1);
+            if (CollectionUtils.isEmpty(this.lsStationRouteList)) {
+                throw new ScheduleException("线路[" + this.line.getName() + "]，站点路由[版本=" + this.lineRouteVersion + "]信息为空");
+            }
+
+            // 3、获取路牌信息
+            Assert.notNull(this.guideboardInfoService, "路牌信息service为空！");
+            p1.clear();
+            p1.put("xl.id_eq", this.lineId);
+            p1.put("isCancel_eq", false);
+            this.guideboardInfoList = guideboardInfoService.list(p1);
+            if (CollectionUtils.isEmpty(this.guideboardInfoList)) {
+                throw new ScheduleException("线路[" + this.line.getName() + "]路牌信息为空！");
+            }
+
+            // 4、验证策略类
+            Assert.notNull(this.timetableExcelDataValidateStrategy, "时刻表excel验证策略类为空！");
+
+            return new TimetableExcelData(this);
+        }
+    }
+
+    public static ImportBuilder withImportBuilder() {
+        return new ImportBuilder();
+    }
+    public static class ImportBuilder {
+        private ImportBuilder() {}
+
+        /** 导入的Excel文件路径 */
+        private String excelFilePath;
+        /** 导入的Excel sheet名字 */
+        private String excelSheetName;
+        /** 时刻表Id */
+        private Long ttInfoId;
+        /** 线路Id */
+        private Integer lineId;
+        /** 线路标准信息Id */
+        private Integer lineInfoId;
+        /** 线路名字 */
+        private String lineName;
+        /** 时刻表名字 */
+        private String ttInfoName;
+        /** 线路路由版本 */
+        private Integer lineRouteVersion;
+        /** 时刻表excel格式类型 */
+        private TimetableExcelFormatType timetableExcelFormatType;
+        /** 数据工具服务 */
+        private DataToolsService dataToolsService;
+        /** 配置数据导入导出用到的配置信息 */
+        private DataToolsProperties dataToolsProperties;
+        /** 时刻表excel导入策略 */
+        private TimetableExcelDataImportStrategy timetableExcelDataImportStrategy;
+
+        public ImportBuilder setExcelFilePath(String excelFilePath) {
+            this.excelFilePath = excelFilePath;
+            return this;
+        }
+
+        public ImportBuilder setExcelSheetName(String excelSheetName) {
+            this.excelSheetName = excelSheetName;
+            return this;
+        }
+
+        public ImportBuilder setTtInfoId(Long ttInfoId) {
+            this.ttInfoId = ttInfoId;
+            return this;
+        }
+
+        public ImportBuilder setLineId(Integer lineId) {
+            this.lineId = lineId;
+            return this;
+        }
+
+        public ImportBuilder setLineInfoId(Integer lineInfoId) {
+            this.lineInfoId = lineInfoId;
+            return this;
+        }
+
+        public ImportBuilder setLineName(String lineName) {
+            this.lineName = lineName;
+            return this;
+        }
+
+        public ImportBuilder setTtInfoName(String ttInfoName) {
+            this.ttInfoName = ttInfoName;
+            return this;
+        }
+
+        public ImportBuilder setLineRouteVersion(Integer lineRouteVersion) {
+            this.lineRouteVersion = lineRouteVersion;
+            return this;
+        }
+
+        public ImportBuilder setTimetableExcelFormatType(TimetableExcelFormatType timetableExcelFormatType) {
+            this.timetableExcelFormatType = timetableExcelFormatType;
+            return this;
+        }
+
+        public ImportBuilder setDataToolsService(DataToolsService dataToolsService) {
+            this.dataToolsService = dataToolsService;
+            return this;
+        }
+
+        public ImportBuilder setDataToolsProperties(DataToolsProperties dataToolsProperties) {
+            this.dataToolsProperties = dataToolsProperties;
+            return this;
+        }
+
+        public ImportBuilder setTimetableExcelDataImportStrategy(TimetableExcelDataImportStrategy timetableExcelDataImportStrategy) {
+            this.timetableExcelDataImportStrategy = timetableExcelDataImportStrategy;
+            return this;
+        }
+
+        // ---------------- 内部生成的属性 ------------------ //
+        /** 待导入excel workbook对象 */
+        private Workbook excelWorkBook;
+        /** 待导入excel workbook工作区对象 */
+        private Sheet excelWorkBookSheet;
+        /** ktr转换所需参数对象 */
+        private Map<String, Object> ktrParams = new HashMap<>();
+
+        public TimetableExcelData build() throws ScheduleException {
+            // 0、验证策略类
+            Assert.notNull(this.timetableExcelDataImportStrategy, "时刻表excel导入策略类为空！");
+
+            // 注意：这里不做其他验证，业务上导入前必须验证的（调用验证用的builder）
+            File file = new File(this.excelFilePath);
+            DataToolsFile dataToolsFile = new DataToolsFile();
+            dataToolsFile.setFile(file);
+            if (DataToolsFileType.XLS.isThisType(file)) {
+                dataToolsFile.setFileType(DataToolsFileType.XLS);
+            } else if (DataToolsFileType.XLSX.isThisType(file)) {
+                dataToolsFile.setFileType(DataToolsFileType.XLSX);
+            }
+            this.excelWorkBook = dataToolsFile.getFileType().getWorkBook(dataToolsFile.getFile());
+            this.excelWorkBookSheet = this.excelWorkBook.getSheet(this.excelSheetName);
+
+            // 设置ktr转换参数
+            this.ktrParams.put("erroroutputdir", this.dataToolsProperties.getTransErrordir()); // 错误文件输出路径
+            this.ktrParams.put("sheetname", this.excelSheetName); // sheet工作区的名字
+            this.ktrParams.put("lineinfoid", this.lineInfoId); // 线路标准id
+            this.ktrParams.put("xlname", this.lineName); // 线路名称
+            this.ktrParams.put("xlid", this.lineId); // 线路id
+            this.ktrParams.put("ttinfoname", this.ttInfoName); // 时刻表名称
+            this.ktrParams.put("ttid", this.ttInfoId.intValue()); // 时刻表id
+            this.ktrParams.put("lineversion", this.lineRouteVersion); // 站点路由版本
+
+            return new TimetableExcelData(this);
+        }
+    }
+
+}
+package com.bsth.service.schedule.timetable;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import org.springframework.util.Assert;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 时刻表excel格式类型。
+ */
+public enum TimetableExcelFormatType {
+    Normal("normal"), // 一般格式
+    NormalWithGs("normalWithGs"), // 一般格式（路牌列后加一列工时列）
+    Dynamic("dynamic"); // 自动生成时刻表的导出格式
+
+    private static Map<String, TimetableExcelFormatType> descMapEnum = new HashMap<>();
+    static {
+        descMapEnum.put("normal", Normal);
+        descMapEnum.put("normalWithGs", NormalWithGs);
+        descMapEnum.put("dynamic", Dynamic);
+    }
+
+    private String desc;
+    @JsonValue
+    public String getDesc() {
+        return desc;
+    }
+
+    public void setDesc(String desc) {
+        this.desc = desc;
+    }
+
+    @JsonCreator
+    TimetableExcelFormatType(String desc) {
+        this.desc = desc;
+    }
+
+    public static TimetableExcelFormatType fromDesc(String desc) {
+        Assert.hasText(desc, "excel导入格式为空！");
+        Assert.notNull(descMapEnum.get(desc), "未知的excel导入格式[" + desc + "]！");
+        return descMapEnum.get(desc);
+    }
+}
+package com.bsth.service.schedule.timetable.strategy;
+
+import com.bsth.service.schedule.exception.ScheduleException;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelData.TimetableExcelInternalCell;
+import com.bsth.service.schedule.utils.DataToolsProperties;
+import com.bsth.service.schedule.utils.DataToolsService;
+import org.apache.poi.ss.usermodel.Sheet;
+
+import java.util.Map;
+
+/**
+ * 时刻表excel验证策略接口。
+ */
+public interface TimetableExcelDataImportStrategy {
+    /**
+     * 导入excel时刻表。
+     * @param excelWorkBookSheet 待导入excel workbook 工作区对象
+     * @param excelFilePath 导入的Excel文件路径
+     * @param dataToolsService dataToolsService
+     * @param dataToolsProperties dataToolsProperties
+     * @param ktrParams ktr转换所需参数对象
+     * @param internalExcelCells 内部Excel单元格二维数组
+     * @param timetableExcelFormatType 时刻表excel格式
+     * @throws ScheduleException 导入异常
+     */
+    void doImport(
+            Sheet excelWorkBookSheet,
+            String excelFilePath,
+            DataToolsService dataToolsService,
+            DataToolsProperties dataToolsProperties,
+            Map<String, Object> ktrParams,
+            TimetableExcelInternalCell[][] internalExcelCells,
+            TimetableExcelFormatType timetableExcelFormatType
+    ) throws ScheduleException;
+}
+package com.bsth.service.schedule.timetable.strategy;
+
+import com.bsth.entity.Line;
+import com.bsth.entity.LsStationRoute;
+import com.bsth.entity.schedule.GuideboardInfo;
+import com.bsth.service.schedule.exception.ScheduleException;
+import com.bsth.service.schedule.timetable.TimetableExcelData.TimetableExcelInternalCell;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+
+import java.util.List;
+
+/**
+ * 时刻表excel验证策略接口。
+ */
+public interface TimetableExcelDataValidateStrategy {
+    /**
+     * 验证excel时刻表。
+     * @param internalExcelCells 内部Excel单元格二维数组
+     * @param timetableExcelFormatType 时刻表excel格式
+     * @param line 线路信息
+     * @param lsStationRouteList 线路站点路由列表（包含上下行的起终点站）
+     * @param guideBoardInfoList 路牌列表
+     * @throws ScheduleException 验证异常
+     */
+    void doValidate(
+            TimetableExcelInternalCell[][] internalExcelCells,
+            TimetableExcelFormatType timetableExcelFormatType,
+            Line line,
+            List<LsStationRoute> lsStationRouteList,
+            List<GuideboardInfo> guideBoardInfoList
+    ) throws ScheduleException;
+}
+package com.bsth.service.schedule.timetable.strategy.impl;
+
+import com.bsth.service.schedule.exception.ScheduleException;
+import com.bsth.service.schedule.timetable.TimetableExcelData.TimetableExcelInternalCell;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+import com.bsth.service.schedule.timetable.strategy.TimetableExcelDataImportStrategy;
+import com.bsth.service.schedule.utils.DataToolsProperties;
+import com.bsth.service.schedule.utils.DataToolsService;
+import jxl.write.Label;
+import jxl.write.WritableSheet;
+import jxl.write.WritableWorkbook;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 时刻表excel导入策略实现。
+ */
+public class TimetableExcelDataImportStrategyImpl implements TimetableExcelDataImportStrategy {
+    /** 日志记录器 */
+    private final static Logger LOG = LoggerFactory.getLogger(TimetableExcelDataImportStrategyImpl.class);
+
+    @Override
+    public void doImport(
+            Sheet excelWorkBookSheet,
+            String excelFilePath,
+            DataToolsService dataToolsService,
+            DataToolsProperties dataToolsProperties,
+            Map<String, Object> ktrParams,
+            TimetableExcelInternalCell[][] internalExcelCells,
+            TimetableExcelFormatType timetableExcelFormatType
+    ) throws ScheduleException {
+        // 注意：这里不做验证，业务上导入前必须验证的（调用验证用的builder）
+
+        // 1、创建内部单元格数据
+        // 1-1、计算第一行，并设置单元格属性
+        for (int colNum = 0; colNum < internalExcelCells[0].length; colNum ++) {
+            TimetableExcelInternalCell cell = internalExcelCells[0][colNum];
+            cell.isHeadCell = true;
+
+            // 2-1-1、第一行，第一列为路牌
+            if (colNum == 0) {
+                cell.isLpNameCell = true;
+                continue;
+            }
+            // 2-1-1-1、第一行，第二列可能是工时
+            if (colNum == 1 && timetableExcelFormatType == TimetableExcelFormatType.NormalWithGs) {
+                cell.isGsCell = true;
+                continue;
+            }
+
+            // 2-1-2、如果导入格式是Dynamic，忽略指定列
+            if (timetableExcelFormatType == TimetableExcelFormatType.Dynamic) {
+                if ("报到".equals(cell.cellContent) ||
+                        "到场".equals(cell.cellContent) ||
+                        "离场".equals(cell.cellContent) ||
+                        "总公里".equals(cell.cellContent) ||
+                        "营业公里".equals(cell.cellContent) ||
+                        "空驶公里".equals(cell.cellContent) ||
+                        "总工时".equals(cell.cellContent) ||
+                        "营业工时".equals(cell.cellContent) ||
+                        "营运班次".equals(cell.cellContent)) {
+                    // 这些列都忽略，不参与计算
+                    cell.isEnable = false;
+                }
+            }
+
+        }
+
+        // 1-2、根据第一行的单元格验证后的设置的属性，设置其余行单元格的属性
+        for (int rowNum = 1; rowNum < internalExcelCells.length; rowNum ++) {
+            for (int colNum = 0; colNum < internalExcelCells[rowNum].length; colNum ++) {
+                TimetableExcelInternalCell cell = internalExcelCells[rowNum][colNum];
+                TimetableExcelInternalCell firstRowCell = internalExcelCells[0][colNum];
+                if (firstRowCell.isEnable) {
+                    cell.isLpNameCell = firstRowCell.isLpNameCell;
+                    cell.isGsCell = firstRowCell.isGsCell;
+                }
+            }
+        }
+
+        // 2、重新构造一个新的单元格数组，去除enable=false的，根据类型合并路牌和工时
+        List<List<TimetableExcelInternalCell>> newEnabledExcelCells = new ArrayList<>();
+        for (int rowNum = 0; rowNum < internalExcelCells.length; rowNum ++) {
+            List<TimetableExcelInternalCell> newEnabledExcelRowCells = new ArrayList<>();
+            newEnabledExcelCells.add(newEnabledExcelRowCells);
+
+            for (int colNum = 0; colNum < internalExcelCells[rowNum].length; colNum ++) {
+                TimetableExcelInternalCell cell = internalExcelCells[rowNum][colNum];
+                if (!cell.isEnable) {
+                    continue;
+                }
+                if (cell.isGsCell) { // 如果匹配到工时单元格，需要合并到前一个单元格中
+                    // 前一个单元格就是当前已经保存的行单元格列表的最后一个
+                    TimetableExcelInternalCell preNewEnabledCell =
+                            newEnabledExcelRowCells.get(newEnabledExcelRowCells.size() - 1);
+                    // 合并成 路牌1->工时1 这种格式
+                    preNewEnabledCell.cellContent = preNewEnabledCell.cellContent + "->" + cell.cellContent;
+                } else {
+                    newEnabledExcelRowCells.add(cell);
+                }
+            }
+        }
+
+        // 3、计算其他ktr参数
+        // 3-1、计算字段名相关参数
+        List<String> columnNames = new ArrayList<>();
+        for (int colNum = 0; colNum < newEnabledExcelCells.get(0).size(); colNum ++) {
+            TimetableExcelInternalCell cell = newEnabledExcelCells.get(0).get(colNum);
+            if (colNum == 0) {
+                columnNames.add(cell.cellContent);
+            } else {
+                columnNames.add(cell.cellContent + "->" + colNum);
+            }
+        }
+
+        LOG.info("表头参数={}", StringUtils.join(columnNames.toArray(), ","));
+        ktrParams.put("excelfieldnames", StringUtils.join(columnNames.toArray(), ",")); // 时刻表excel输入字段名，以逗号连接
+        columnNames.remove(0);
+        ktrParams.put("normalizefieldnames", StringUtils.join(columnNames.toArray(), ",")); // 数据范式化字段名，以逗号连接
+
+        // 3-2、计算excel内容文件参数
+        File fileCal = new File(excelFilePath + "_stringType.xls");
+        try {
+            WritableWorkbook writableWorkbook = jxl.Workbook.createWorkbook(fileCal);
+            WritableSheet sheet1 = writableWorkbook.createSheet(excelWorkBookSheet.getSheetName(), 0);
+            for (int rowNum = 0; rowNum < newEnabledExcelCells.size(); rowNum ++) {
+                for (int colNum = 0; colNum < newEnabledExcelCells.get(rowNum).size(); colNum ++) {
+                    TimetableExcelInternalCell cell = newEnabledExcelCells.get(rowNum).get(colNum);
+                    sheet1.addCell(new Label(colNum, rowNum, cell.cellContent));
+                }
+            }
+            writableWorkbook.write();
+            writableWorkbook.close();
+            ktrParams.put("filepath", fileCal.getAbsolutePath());
+        } catch (Exception exp) {
+            exp.printStackTrace();
+            throw new ScheduleException("导入时刻表异常！");
+        }
+
+        // 3-3、计算ktr路径相关参数
+        try {
+            // 元数据ktr
+            File mktrFile = new File(this.getClass().getResource(
+                    dataToolsProperties.getTtinfodetailMetadatainputktr()).toURI());
+            ktrParams.put("transpath", mktrFile.getAbsolutePath());
+
+            // 实际数据ktr
+            if (timetableExcelFormatType == TimetableExcelFormatType.Normal) {
+                File normal_ktrFile = new File(this.getClass().getResource(
+                        dataToolsProperties.getTtinfodetailDatainputktr2version()).toURI());
+                ktrParams.put("injectktrfile", normal_ktrFile.getAbsolutePath());
+            } else if (timetableExcelFormatType == TimetableExcelFormatType.NormalWithGs) {
+                File noramlwithgs_ktrFile = new File(this.getClass().getResource(
+                        dataToolsProperties.getTtinfodetailDatainputktr2normalwithgs()).toURI());
+                ktrParams.put("injectktrfile", noramlwithgs_ktrFile.getAbsolutePath());
+            } else if (timetableExcelFormatType == TimetableExcelFormatType.Dynamic) {
+                File dynamic_ktrFile = new File(this.getClass().getResource(
+                        dataToolsProperties.getTtinfodetailDatainputktr2version2()).toURI());
+                ktrParams.put("injectktrfile", dynamic_ktrFile.getAbsolutePath());
+            } else {
+                throw new ScheduleException("未知的TimetableExcelFormatType格式[" + timetableExcelFormatType + "]");
+            }
+
+        } catch (Exception exp) {
+            exp.printStackTrace();
+            throw new ScheduleException("导入时刻表异常！");
+        }
+
+        // 3-4、执行ktr
+        dataToolsService.importData(fileCal, ktrParams);
+    }
+}
+package com.bsth.service.schedule.timetable.strategy.impl;
+
+import com.bsth.entity.Line;
+import com.bsth.entity.LsStationRoute;
+import com.bsth.entity.schedule.GuideboardInfo;
+import com.bsth.service.schedule.exception.ScheduleException;
+import com.bsth.service.schedule.timetable.TimetableExcelFormatType;
+import com.bsth.service.schedule.timetable.TimetableExcelData.TimetableExcelInternalCell;
+import com.bsth.service.schedule.timetable.strategy.TimetableExcelDataValidateStrategy;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 时刻表excel验证策略实现类。
+ */
+public class TimetableExcelDataValidateStrategyImpl implements TimetableExcelDataValidateStrategy {
+    // 使用第一行单元格的属性设其他行单元格的属性
+    private void setInternalExcelCellPropertyWithFirstRowCell(TimetableExcelInternalCell[][] internalExcelCells) {
+        for (int rowNum = 1; rowNum < internalExcelCells.length; rowNum ++) {
+            for (int colNum = 0; colNum < internalExcelCells[rowNum].length; colNum ++) {
+                TimetableExcelInternalCell cell = internalExcelCells[rowNum][colNum];
+                TimetableExcelInternalCell firstRowCell = internalExcelCells[0][colNum];
+                if (firstRowCell.isEnable) {
+                    cell.isBc = firstRowCell.isBc;
+                    cell.isInBc = firstRowCell.isInBc;
+                    cell.isOutBc = firstRowCell.isOutBc;
+
+                    cell.isLpNameCell = firstRowCell.isLpNameCell;
+                    cell.isFcsjCell = firstRowCell.isFcsjCell;
+                    cell.isGsCell = firstRowCell.isGsCell;
+                }
+            }
+        }
+    }
+
+    // 验证路由名字cell
+    private void validateRouteContentCell(
+            int colNum,
+            String routeName,
+            Line line,
+            List<LsStationRoute> lsStationRouteList) throws ScheduleException {
+        if (StringUtils.isEmpty(routeName)) {
+            throw new ScheduleException(String.format("第1行，第%d列数据不能为空", colNum + 1));
+        }
+
+        List<LsStationRoute> lsStationRoutes = new ArrayList<>();
+        for (LsStationRoute lsStationRoute : lsStationRouteList) {
+            if ("B".equals(lsStationRoute.getStationMark()) && routeName.equals(lsStationRoute.getStationName())) {
+                lsStationRoutes.add(lsStationRoute);
+            }
+        }
+
+        if (CollectionUtils.isEmpty(lsStationRoutes)) {
+            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中不是起点站",
+                    colNum + 1, routeName, line.getName()));
+        } else if (lsStationRoutes.size() > 1) {
+            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中上下行都是起点站",
+                    colNum + 1, routeName, line.getName()));
+        } else if (StringUtils.isEmpty(lsStationRoutes.get(0).getStationCode())) {
+            throw new ScheduleException(String.format("第1行，第%d列数据%s在%s站点路由中没有站点编码",
+                    colNum + 1, routeName, line.getName()));
+        }
+
+    }
+
+    // 验证路牌名字cell
+    private void validateGuideboardContentCell(
+            int rowNum,
+            String guideboardName,
+            Line line,
+            List<GuideboardInfo> guideboardInfoList) throws ScheduleException {
+        if (StringUtils.isEmpty(guideboardName)) {
+            throw new ScheduleException(String.format("第%d行，第1列路牌无数据", rowNum + 1));
+        }
+
+        List<GuideboardInfo> guideboardInfos = new ArrayList<>();
+        for (GuideboardInfo guideboardInfo : guideboardInfoList) {
+            if (guideboardName.equals(guideboardInfo.getLpName())) {
+                guideboardInfos.add(guideboardInfo);
+            }
+        }
+
+        if (CollectionUtils.isEmpty(guideboardInfos)) {
+            throw new ScheduleException(String.format("第%d行，第1列的路牌在%s中不存在",
+                    rowNum + 1, line.getName()));
+        } else if (guideboardInfos.size() > 1) {
+            throw new ScheduleException(String.format("第%d行，第1列的路牌在%s中重复",
+                    rowNum + 1, line.getName()));
+        }
+    }
+
+    // Normal，NormalWithGs格式下的发车时间格式
+    private static Pattern p1 = Pattern.compile("^([01]?[0-9]|2[0-3]):[0-5][0-9]$"); // hh:mm格式
+    private static Pattern p2 = Pattern.compile("^([01]?[0-9]|2[0-3]),[0-5][0-9]$"); // hh,mm格式
+    private static Pattern p3 = Pattern.compile("^([01]?[0-9]|2[0-3])[0-5][0-9]$"); // hhmm格式
+    // Dynamic格式下的发车时间格式
+    private static Pattern p1_1 = Pattern.compile("^([\u62a5]|[\u51fa])?([01]?[0-9]|2[0-3]):[0-5][0-9]$"); // (报|出)hh:mm格式
+    private static Pattern p2_1 = Pattern.compile("^([01]?[0-9]|2[0-3]):[0-5][0-9]([X]|[\u203b])?$"); // hh:mm(X|※)格式
+    // 验证发车时间cell
+    private void validateFcsjContentCell(
+            int rowNum,
+            int colNum,
+            String fcsjContent, TimetableExcelFormatType timetableExcelFormatType) throws ScheduleException {
+        if (timetableExcelFormatType == TimetableExcelFormatType.Normal ||
+                timetableExcelFormatType == TimetableExcelFormatType.NormalWithGs) {
+            Matcher m1 = p1.matcher(fcsjContent.trim());
+            Matcher m2 = p2.matcher(fcsjContent.trim());
+            Matcher m3 = p3.matcher(fcsjContent.trim());
+            boolean expected = m1.matches() || m2.matches() || m3.matches();
+            if (!expected) {
+                throw new ScheduleException(String.format("第%d行，第%d列的发车时间格式不正确，格式应为hh:mm或hh,mm或hhmm",
+                        rowNum + 1, colNum + 1));
+            }
+        } else if (timetableExcelFormatType == TimetableExcelFormatType.Dynamic) {
+            Matcher m1 = p1_1.matcher(fcsjContent.trim());
+            Matcher m2 = p2_1.matcher(fcsjContent.trim());
+            boolean expected = m1.matches() || m2.matches();
+            if (!expected) {
+                throw new ScheduleException(String.format(
+                        "第%d行，第%d列的发车时间格式不正确，格式应为(报|出)hh:mm或hh:mm(X|※)",
+                        rowNum + 1, colNum + 1));
+            }
+        } else {
+            throw new ScheduleException(String.format("未知的导入格式[%s]", timetableExcelFormatType.getDesc()));
+        }
+    }
+
+    private static Pattern p5 = Pattern.compile("^[-\\+]?[.\\d]*$"); // 浮点数
+    // 验证工时cell
+    private void validateGsContentCell(int rowNum, int colNum, String gsContent) throws ScheduleException {
+        Matcher m1 = p5.matcher(gsContent.trim());
+        boolean expected = m1.matches();
+        if (!expected) {
+            throw new ScheduleException(String.format("第%d行，第%d列的工时格式不正确，格式应为整数或浮点数",
+                    rowNum + 1, colNum + 1));
+        }
+        Double gs = new Double(gsContent.trim());
+        if (gs < 0) {
+            throw new ScheduleException(String.format("第%d行，第%d列的工时值必须大于0",
+                    rowNum + 1, colNum + 1));
+        }
+    }
+
+    /**
+     * 验证excel时刻表。
+     * @param internalExcelCells 内部Excel单元格二维数组
+     * @param timetableExcelFormatType 时刻表excel格式
+     * @param line 线路信息
+     * @param lsStationRouteList 线路站点路由列表（包含上下行的起终点站）
+     * @param guideBoardInfoList 路牌列表
+     * @throws ScheduleException 验证异常
+     */
+    @Override
+    public void doValidate(
+            TimetableExcelInternalCell[][] internalExcelCells,
+            TimetableExcelFormatType timetableExcelFormatType,
+            Line line,
+            List<LsStationRoute> lsStationRouteList,
+            List<GuideboardInfo> guideBoardInfoList) throws ScheduleException {
+        // 1、验证数据行，列
+        int rowCount = internalExcelCells.length;
+        int colCount = internalExcelCells[0].length;
+        if (rowCount <= 1 || colCount <= 1) {
+            throw new ScheduleException("工作区至少包含2行2列的数据");
+        }
+
+        // 2、验证单元格信息
+        // 2-1、验证第1行数据（表头行数据）
+        for (int colNum = 0; colNum < colCount; colNum ++) {
+            TimetableExcelInternalCell cell = internalExcelCells[0][colNum];
+            cell.isHeadCell = true;
+
+            // 2-1-1、第一行，第一列必须路牌2个字
+            if (colNum == 0) {
+                if (!"路牌".equals(cell.cellContent)) {
+                    throw new ScheduleException("第1行，第1列数据必须是路牌2个字");
+                }
+                cell.isLpNameCell = true;
+                continue;
+            }
+            // 2-1-1-1、如果导入格式是NormalWithGs，第一行，第二列必须工时2个字
+            if (colNum == 1 && timetableExcelFormatType == TimetableExcelFormatType.NormalWithGs) {
+                if (!"工时".equals(cell.cellContent)) {
+                    throw new ScheduleException("第1行，第2列数据必须是工时2个字");
+                }
+                cell.isGsCell = true;
+                continue;
+            }
+
+            // 2-1-2、如果导入格式是Dynamic，忽略指定列
+            if (timetableExcelFormatType == TimetableExcelFormatType.Dynamic) {
+                if ("报到".equals(cell.cellContent) ||
+                        "到场".equals(cell.cellContent) ||
+                        "离场".equals(cell.cellContent) ||
+                        "总公里".equals(cell.cellContent) ||
+                        "营业公里".equals(cell.cellContent) ||
+                        "空驶公里".equals(cell.cellContent) ||
+                        "总工时".equals(cell.cellContent) ||
+                        "营业工时".equals(cell.cellContent) ||
+                        "营运班次".equals(cell.cellContent)) {
+                    // 这些列都忽略，不参与计算
+                    cell.isEnable = false;
+                    continue;
+                }
+            }
+
+            // 2-1-3、出场，进场班次，不验证路由
+            if ("出场".equals(cell.cellContent)) {
+                cell.isBc = true;
+                cell.isOutBc = true;
+                continue;
+            }
+            if ("进场".equals(cell.cellContent)) {
+                cell.isBc = true;
+                cell.isInBc = true;
+                continue;
+            }
+
+            // 2-1-4、其他情况作为站点路由验证
+            cell.isBc = true;
+            cell.isFcsjCell = true;
+            this.validateRouteContentCell(colNum, cell.cellContent, line, lsStationRouteList); // 验证路由名字
+
+        }
+
+        // 2-2、根据第1行的单元格验证后的设置的属性，设置其余行单元格的属性
+        this.setInternalExcelCellPropertyWithFirstRowCell(internalExcelCells);
+
+        // 2-3、验证具体路牌单元格（第1列）
+        Map<String, Integer> gbIndexMap = new HashMap<>(); // 记录每个路牌在第几行
+        for (int rowNum = 1; rowNum < rowCount; rowNum ++) {
+            TimetableExcelInternalCell cell = internalExcelCells[rowNum][0];
+            if (StringUtils.isEmpty(cell.cellContent)) {
+                throw new ScheduleException(String.format("第%d行，第1列路牌无数据", rowNum + 1));
+            } else if (gbIndexMap.get(cell.cellContent) != null) {
+                throw new ScheduleException(String.format("第%d行，第1列的路牌数据与第%d行，第1列数据重复",
+                        rowNum + 1,
+                        gbIndexMap.get(cell.cellContent)));
+            } else {
+                this.validateGuideboardContentCell(rowNum, cell.cellContent, line, guideBoardInfoList); // 验证路牌名字
+                gbIndexMap.put(cell.cellContent, rowNum + 1);
+            }
+        }
+
+        // 2-4、验证其余单元格（第2行，第2列开始）
+        for (int rowNum = 1; rowNum < rowCount; rowNum ++) {
+            for (int colNum = 1; colNum < colCount; colNum ++) {
+                TimetableExcelInternalCell cell = internalExcelCells[rowNum][colNum];
+                if (!cell.isEnable) {
+                    continue;
+                }
+
+                if (cell.isBc) {
+                    // 对应路牌对应单元格没有发车班次
+                    if (StringUtils.isNotEmpty(cell.cellContent)) {
+                        this.validateFcsjContentCell(rowNum, colNum, cell.cellContent, timetableExcelFormatType);
+                    }
+                } else if (cell.isGsCell) {
+                    if (StringUtils.isNotEmpty(cell.cellContent)) {
+                        this.validateGsContentCell(rowNum, colNum, cell.cellContent);
+                    }
+                } else {
+                    throw new ScheduleException(String.format("第%d行，第%d列的单元格内容既不是发车时间，也不是工时！",
+                            rowNum + 1, colNum + 1));
+                }
+            }
+        }
+    }
+}
@@ -87,6 +87,9 @@ public class DataToolsProperties {
     /** 时刻表明细信息导入2（带版本），使用生成时刻表格式 */
     @NotNull
     private String ttinfodetailDatainputktr2version2;
+    /** 时刻表明细信息导入2，一般格式（路牌列后加一列工时列）参看 TimetableExcelFormatType */
+    @NotNull
+    private String ttinfodetailDatainputktr2normalwithgs;
     /** 排班规则信息导入 */
     @NotNull
     private String scheduleruleDatainputktr;
@@ -373,6 +376,14 @@ public class DataToolsProperties {
         this.ttinfodetailDatainputktr2version2 = ttinfodetailDatainputktr2version2;
     }
+    public String getTtinfodetailDatainputktr2normalwithgs() {
+        return ttinfodetailDatainputktr2normalwithgs;
+    }
+
+    public void setTtinfodetailDatainputktr2normalwithgs(String ttinfodetailDatainputktr2normalwithgs) {
+        this.ttinfodetailDatainputktr2normalwithgs = ttinfodetailDatainputktr2normalwithgs;
+    }
+
     public String getVehicleDatasyncktr() {
         return vehicleDatasyncktr;
     }
@@ -44,6 +44,8 @@ datatools.ttinfodetail_datainputktr2=/datatools/ktrs/ttinfodetailDataInput2.ktr
 datatools.ttinfodetail_datainputktr2version=/datatools/ktrs/ttinfodetailDataInput2_version.ktr
 # 时刻表明细信息导入2（版本化），使用生成时刻表格式
 datatools.ttinfodetail_datainputktr2version2=/datatools/ktrs/ttinfodetailDataInput2_version_2.ktr
+# 时刻表明细信息导入2，一般格式（路牌列后加一列工时列）
+datatools.ttinfodetail_datainputktr2normalwithgs=/datatools/ktrs/ttinfodetailDataInput2_normalwithgs.ktr
 # 车辆配置信息导入
 datatools.carsconfig_datainputktr=/datatools/ktrs/carsConfigDataInput.ktr
@@ -43,6 +43,8 @@ datatools.ttinfodetail_datainputktr2=/datatools/ktrs/ttinfodetailDataInput2.ktr
 datatools.ttinfodetail_datainputktr2version=/datatools/ktrs/ttinfodetailDataInput2_version.ktr
 # 时刻表明细信息导入2（版本化），使用生成时刻表格式
 datatools.ttinfodetail_datainputktr2version2=/datatools/ktrs/ttinfodetailDataInput2_version_2.ktr
+# 时刻表明细信息导入2，一般格式（路牌列后加一列工时列）
+datatools.ttinfodetail_datainputktr2normalwithgs=/datatools/ktrs/ttinfodetailDataInput2_normalwithgs.ktr
 # 车辆配置信息导入
 datatools.carsconfig_datainputktr=/datatools/ktrs/carsConfigDataInput.ktr
@@ -44,6 +44,8 @@ datatools.ttinfodetail_datainputktr2=/datatools/ktrs/ttinfodetailDataInput2.ktr
 datatools.ttinfodetail_datainputktr2version=/datatools/ktrs/ttinfodetailDataInput2_version.ktr
 # 时刻表明细信息导入2（版本化），使用生成时刻表格式
 datatools.ttinfodetail_datainputktr2version2=/datatools/ktrs/ttinfodetailDataInput2_version_2.ktr
+# 时刻表明细信息导入2，一般格式（路牌列后加一列工时列）
+datatools.ttinfodetail_datainputktr2normalwithgs=/datatools/ktrs/ttinfodetailDataInput2_normalwithgs.ktr
 # 车辆配置信息导入
 datatools.carsconfig_datainputktr=/datatools/ktrs/carsConfigDataInput.ktr
@@ -44,6 +44,8 @@ datatools.ttinfodetail_datainputktr2=/datatools/ktrs/ttinfodetailDataInput2.ktr
 datatools.ttinfodetail_datainputktr2version=/datatools/ktrs/ttinfodetailDataInput2_version.ktr
 # 时刻表明细信息导入2（版本化），使用生成时刻表格式
 datatools.ttinfodetail_datainputktr2version2=/datatools/ktrs/ttinfodetailDataInput2_version_2.ktr
+# 时刻表明细信息导入2，一般格式（路牌列后加一列工时列）
+datatools.ttinfodetail_datainputktr2normalwithgs=/datatools/ktrs/ttinfodetailDataInput2_normalwithgs.ktr
 # 车辆配置信息导入
 datatools.carsconfig_datainputktr=/datatools/ktrs/carsConfigDataInput.ktr