读取数据表中的文件字节流

矫情吗；* 2022-04-24 12:16 173阅读 0赞

### 文章目录 ###

*  开发背景
 *   *  需求背景
     *  分析解决
 *  源码
 *   *  核心依赖
     *  Java源码
     *   *  工具类
         *  通用模块
         *  实体类
         *  Dao
         *  Service
         *  核心库
         *  函数
         *  Controller
         *  BootStrap启动类
     *  配置文件
 *  测试结果

# 开发背景 #

## 需求背景 ##

由于以前的文件存在于SQLServer数据表中，而这种对文件的保存方式是十份不友好的，比如说这个项目中的`file`数据表就是这种情况，由于在其中存入了近10G的文件，这导致该表数据量十份臃肿，比如说我们执行一条简单的SQL，如下：

Select * From file

由于数据量过大，该条查询语句往往会执行上半天时间，如果再多执行几次这种文件查询操作，系统就直接卡死，因而原来的这种文件存储方式是存在巨大的风险的，所以说我需要将存储于表中的数据文件导出成真正的文件，以此来解决现今所面临的问题。

## 分析解决 ##

从上面我们可以看出，整个的业务逻辑是比较的简单的，就是将文件从数据表中读出，然后写成真正的文件。因而这里就无需多做说明。

这里需要重点说说其技术实现。

由于上述表中存在大量的信息，单纯的查询操作往往会导致程序卡死，并且一次性的读取上G的文件数据本身也并不合理 ，因而我这里采用的是分页查询。也就是说通过先统计该表信息的总条数，然后循环遍历，每次读取10条，直至全部数据读取完毕。

至于为什么每次读取10条，其主要是经过测试之后得出的，测试数据如下：

file表：
    文件总数：12224
    当前文件数：180
    当前文件总容量：550M
    时间：1小时10分即70分钟
    最大文件大小：30M
    平均文件大小：
    550M/180=3.05M
    
    平均每小时生成文件容量：
    550M/(70/60)=471.43M
    
    预估文件总大小：
    12224*3.05=37283.2M=36.4G
    
    预估总共用时：
    37283.2M/471.43M=79小时
    即file表生成完毕，耗时需要：79/34=3.29天

通过初步测试，我们得出，在该表中，最大的单个文件为30M，平均为3.05M，而一次性读取的数据，控制在100M以内是比较合理的，如果一次性读取过多，会加重系统内存以及数据IO负担，而一次性读取过少，会导致很多时间浪费在查询上，并不合理，所以说最终我将一次性读取的信息条数定为10条。平均每次读取30.5M的数据，最大读取300M数据量。

由于不同的文件表有不同的规则，比如说案卷附件表，需要在导出附件文件的同时关联查出文件编号，最终将附件文件放在案卷编号文件夹下；而封面、详情页等属于文件表，则需要关联文件表，读取文件名称（类似于书名），将附件文件放入到文件名称文件夹下。

换言之，不同的附件文件表拥有不同的规则（也就是函数），这对于我来说是一个新的挑战，在这里，我采用的是函数式编程（即使用`@FunctionalInterface`注解），通过在遍历文件时动态的传入附件文件函数，以此来确定该附件文件到底执行什么样的导出方法。

# 源码 #

## 核心依赖 ##

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <scope>runtime</scope>
        </dependency>
        
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>

## Java源码 ##

### 工具类 ###

PathUtil

package com.lyc.sqlserver.util;
    
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.entity.ProjectPath;
    
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/20 13:48 * @description: 文件路径工具类 **/
    public class PathUtil { 
    
        /** * 返回PathUtil实例 * @return */
        public static PathUtil newPathUtil(){ 
            return new PathUtil();
        }
    
        /** * 获取文件完整路径 * @param file 文件对象 * @param folderPath 文件夹路径 * @return */
        public String getFileFullPath(Map<String,Object> file, String folderPath) { 
            // 获取文件路径
            String filePath = getFilePath(file);
            // 返回文件完整路径
            return folderPath
                    + CommonConstant.Separators.BACK_SLASH
                    + filePath;
        }
    
        /** * 获取文件路径 * @param file 文件对象 * @return */
        private String getFilePath(Map<String,Object> file) { 
            // 返回文件路径
            return getString(file.get("fname"));
        }
    
        /** * 获取文件夹路径 * @param pathMap 项目路径集合 * @return */
        public String getFolderPath(Map<String,Object> pathMap) { 
            // 文件夹路径 = 系统绝对路径 + 项目名 + 数据表名 + 档案编号
            return CommonConstant.ProjectPathName.SYSTEM_PATH
                    + CommonConstant.Separators.BACK_SLASH
                    + getProjectName(pathMap.get(CommonConstant.ProjectPropertyName.PROJECT))
                    + CommonConstant.Separators.BACK_SLASH
                    + getString(pathMap.get(CommonConstant.ProjectPropertyName.TABLE));
        }
    
        /** * 获取项目名 * @param o * @return */
        public String getProjectName(Object o) { 
            ProjectPath projectPath = (ProjectPath) o;
            return projectPath.getName();
        }
    
        /** * 将对象转换成字符串 * @param o 文件夹名称 * @return */
        public String getString(Object o) { 
            return String.valueOf(o);
        }
    
        /** * 获取默认的文件完整路径 * @param fileName * @param folderPath * @return */
        public String getFileFullPathDefault(String fileName, String folderPath) { 
            // 返回文件完整路径
            return folderPath
                    + CommonConstant.Separators.BACK_SLASH
                    + fileName;
        }
    }

FileUtil

package com.lyc.sqlserver.util;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author: zhangzhenyi * @date: 2019/4/20 14:39 * @description: 文件工具类 **/
    @Slf4j
    public class FileUtil { 
    
        /** * 返回创建的FileUtil对象 * @return */
        public static FileUtil newFileUtil(){ 
            return new FileUtil();
        }
    
        /** * 获取文件字节码并返回 * @param fileContent 字节码对象 * @return */
        public byte[] getByte(Object fileContent) { 
            if(fileContent instanceof byte[]){ 
                return (byte[]) fileContent;
            }
            // 如果不存在，就创建一个空对象，防止空指针异常现象的发生
            return new byte[0];
        }
    
        /** * 生成附件文件 * @param fileFullPath 文件全路径 * @param fileByteArray 文件字节流 */
        public void generateFile(String fileFullPath, byte[] fileByteArray) { 
            FileOutputStream outputStream = null;
            try { 
                outputStream = new FileOutputStream(fileFullPath);
                // 读取的字节对象
                for(byte eleb : fileByteArray){ 
                    outputStream.write(eleb);
                }
            } catch (IOException e) { 
                log.error("生成文件出错！故障码：{}",e);
                e.printStackTrace();
            } finally { 
                // 获取文件输入流
                try { 
                    outputStream.flush();
                    outputStream.close();
                } catch (IOException e) { 
                    log.error("文件流关闭出错！故障码：{}",e);
                    e.printStackTrace();
                }
            }
    
        }
    
        /** * 如果文件夹路径不存在，则创建 * @param fileFullPath 文件夹全路径 */
        public void generateFolder(String fileFullPath) { 
            File folder = new File(fileFullPath);
            while(!folder.exists()){ 
                folder.mkdirs();
            }
        }
    
    }

FieldFormatUtil

package com.lyc.sqlserver.util;
    
    import com.google.common.collect.Maps;
    import lombok.var;
    
    import java.util.Date;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/3/29 11:22 * @description: Map<String,Object> 类型的数据格式化成对应的格式并返回 **/
    public class FieldFormatUtil { 
    
        private final Map<String,Object> map;
        private final DataConvertUtil dataConvertUtil;
    
    
        /** * FieldFormatUtil 构造函数 * @param map */
        public FieldFormatUtil(Map<String,Object> map) { 
            if(null != map) {    // 如果不为空，则获取数据
                this.map = map;
            } else {   // 否则设置一个默认的空对象
                this.map = Maps.newHashMap();
            }
            dataConvertUtil = DataConvertUtil.newDataConvertUtil();
        }
    
        /** * 创建一个FieldFormatUtil 对象 * @param map * @return */
        public static FieldFormatUtil newFieldFormatUtil(Map<String,Object> map){ 
            return new FieldFormatUtil(map);
        }
    
        /** * 获取整型数据 * @param k * @return */
        public int getInt(String k){ 
            var obj = this.map.get(k);
            return dataConvertUtil.getInt(obj);
        }
    
        /** * 获取Long型数据 * @param k * @return */
        public Long getLong(String k) { 
            var obj = this.map.get(k);
            return dataConvertUtil.getLong(obj);
        }
    
        /** * 获取String型数据 * @param k * @return */
        public String getString(String k) { 
            var obj = this.map.get(k);
            return dataConvertUtil.getString(obj);
        }
    
        /** * 获取Double类型的数据 * @param k * @return */
        public Double getDouble(String k) { 
            var obj = this.map.get(k);
            return dataConvertUtil.getDouble(obj);
        }
    
        /** * 获取时间类型的数据 * @param k * @return */
        public Date getDate(String k) { 
            var obj = this.map.get(k);
            return dataConvertUtil.getDate(obj);
        }
    
        /** * 获取double类型的数据 * @param k * @return */
        public float getFloat(String k) { 
            var obj = this.map.get(k);
            return dataConvertUtil.getFloat(obj);
        }
    
    }

DataConvertUtil

package com.lyc.sqlserver.util;
    
    import lombok.NoArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.joda.time.DateTime;
    
    import java.util.Date;
    
    /** * @author: zhangzhenyi * @date: 2019/3/29 11:37 * @description: 数据类型转换工具 **/
    @Slf4j
    @NoArgsConstructor
    public class DataConvertUtil { 
    
        /** * 创建一个DataConvertUtil对象 * @return */
        public static DataConvertUtil newDataConvertUtil(){ 
            return new DataConvertUtil();
        }
    
        /** * 将对象转换成字符串 * @param o * @return */
        public String getString(Object o){ 
            String str = String.valueOf(o);
            if("null".equals(str) ){ 
                return null;
            }
            return String.valueOf(o);
        }
    
        /** * 将对象转换成字符串 * @param o * @return */
        public Long getLong(Object o){ 
            return Long.valueOf(String.valueOf(o));
        }
    
        /** * 将对象转换成int * @return */
        public int getInt(Object o){ 
            String str = String.valueOf(o);
            if("null".equals(str) ){ 
                return 0;
            }
            return Integer.valueOf(str);
        }
    
        /** * 将对象转换成Double类型数据 * @param o * @return */
        public double getDouble(Object o){ 
            return Double.valueOf(String.valueOf(o));
        }
    
        /** * 将对象转换成Date * @param obj * @return */
        public Date getDate(Object obj) { 
            if(obj instanceof Long){   // 如果是long类型
                // 则将其转换成Long数据类型
                Long timeLong = Long.valueOf(String.valueOf(obj));
                // 将long类型的数据转换成DateTime数据类型
                DateTime dateTime = new DateTime(timeLong);
                // 将Long类型的数据转换成时间
                return dateTime.toDate();
            } else {   // 否则直接返回一个空值
                return null;
            }
        }
    
        /** * 将对象转换成double * @param obj * @return */
        public float getFloat(Object obj) { 
            if(obj != null){ 
                return Float.valueOf(String.valueOf(obj));
            }
            return 0L;
        }
    
    }

### 通用模块 ###

CommonConstant

package com.lyc.sqlserver.common;
    
    /** * @author: zhangzhenyi * @date: 2019/4/19 17:28 * @description: 系统常量 **/
    public class CommonConstant { 
    
        /** * 返回状态 */
        public interface ResponseStatus{ 
            // 成功
            String SUCCESS_NAME = "SUCCESS";
            // 失败
            String ERROR_NAME = "ERROR";
        }
    
        /** * 分隔符 */
        public interface Separators{ 
            // 反斜杠
            String BACK_SLASH = "\\";
            // 斜杠
            String SLASH = "/";
            // 横杠
            String WHIPPLETREE = "-";
        }
    
        /** * 项目属性名 */
        public interface ProjectPropertyName{ 
            // 项目名
            String PROJECT = "project";
            // 表名
            String TABLE = "table";
            // 排序字段
            String SORT_FIELD = "sortField";
            // 条目名集合
            String ITEM_NAME_LIST = "itemNameList";
            // 条目
            String ITEM = "item";
            // 文件字段
            String FILE_FIELD = "fileField";
        }
    
        /** * Fileatt表 */
        public interface Fileatt{ 
            // 档案编号
            String FILE_NO = "topid";
        }
    
        /** * 项目路径名称 */
        public interface ProjectPathName{ 
            // 表名集合
            String TABLE_LIST = "tableList";
            // 档案编号
            String FILE_NUMBER = "fileNumber";
            // 档案编号列表
            String FILE_NUMBER_LIST = "fileNumberList";
            // 文件名
            String FILE = "file";
            // 系统文件路径
            String SYSTEM_PATH = "C:\\Users\\HP\\Desktop\\image";
        }
    
    }

FileCommon

package com.lyc.sqlserver.common;
    
    import java.util.Map;
    
    /** * File 常用接口 */
    public interface FileCommon { 
    
        /** * 获取文件名 * @param item 信息条目 * @return */
        String getFileName(Map<String, Object> item);
    
        /** * 生成文件 * @param fileFullPath 文件全路径 * @param fileByteArray 文件字节流 */
        void generateFile(String fileFullPath, byte[] fileByteArray);
    
        /** * 获取字节码对象，并返回 * @param item 信息条目 * @return */
        byte[] getFileByteArray(Map<String,Object> item);
    
    }

GenerateFunction

package com.lyc.sqlserver.common;
    
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 10:30 * @description: 文件生成函数（函数式编程） **/
    @FunctionalInterface
    public interface GenerateFunction { 
    
        /** * 生成函数 * @param pathMap 工程属性 */
        void generate(Map<String, Object> pathMap);
    
    }

Tables

package com.lyc.sqlserver.common;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    
    /** * 项目中用大的所有的表 */
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public enum Tables { 
    
        // 数据表、排序字段、文件名1、文件名2、文件1、文件2
        FILE("file","fileID","fname",null,"file_content",null)
        ,BB("BB","BB_BBMC","BB_MKID","BB_BBMC","BB_DATA",null),
        ...;
    
        private String tableName;
        private String sortedField;
        private String fileName1;
        private String fileName2;
        private String file;
        private String file2;
    
    }

### 实体类 ###

ProjectPath

package com.lyc.sqlserver.entity;
    
    import lombok.*;
    
    /** * @author: zhangzhenyi * @date: 2019/4/20 13:58 * @description: 项目路径 **/
    @Getter
    @Setter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class ProjectPath { 
    
        private String code;
        private String name;
    
    }

TableFunctionEntity

package com.lyc.sqlserver.entity;
    
    import com.lyc.sqlserver.common.GenerateFunction;
    import lombok.*;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 11:03 * @description: 表函数实体类 **/
    @Getter
    @Setter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class TableFunctionEntity { 
    
        // 表名
        private String tableName;
        // 生成函数
        private GenerateFunction generateFunction;
    
    }

### Dao ###

ItemDao

package com.lyc.sqlserver.dao;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 9:27 * @description: 表内条目信息 Dao **/
    @Mapper
    public interface ItemDao { 
    
        /** * 分页查询列表 * * @param table 表名 * @param sortedField 排序字段 * @param start 查询起始点 * @param size 本次查询条数 * @return */
        @Select("select '${table}' as tableName,* from ${table} ORDER BY ${sortedField} Offset #{start} Row Fetch Next #{size} Rows Only")
        List<Map<String,Object>> selectListPageQuery(@Param("table") String table, @Param("sortedField") String sortedField, @Param("start") int start, @Param("size") int size);
    
        /** * 获取信息的总条数 * @param table * @return */
        @Select("select count(1) from ${table}")
        int getCount(@Param("table") String table);
    
    }

TreepnameDao

package com.lyc.sqlserver.dao;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    
    import java.util.List;
    import java.util.Map;
    
    /** * 项目工程表Dao */
    @Mapper
    public interface TreepnameDao { 
    
        /** * 从数据库中读取项目 * @return */
        @Select("select * from treepname")
        List<Map<String,Object>> selectList();
    
    }

### Service ###

ItemService

package com.lyc.sqlserver.service;
    
    import com.lyc.sqlserver.core.PageQueryService;
    import com.lyc.sqlserver.dao.ItemDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 9:38 * @description: 表内信息条目 Service **/
    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Service
    public class ItemService { 
    
        @Autowired
        private ItemDao itemDao;
        @Autowired
        private PageQueryService pageQueryService;
    
        /** * 根据条目信息生成文件 * @param pathMap 文件路径集合 */
        public void generateFilesByItem(Map<String,Object> pathMap) { 
            // 分批条目信息，然后生成文件
            pageQueryService.traverse(pathMap, itemDao);
        }
    
    }

ProjectService

package com.lyc.sqlserver.service;
    
    import com.google.common.collect.Maps;
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.dao.TreepnameDao;
    import com.lyc.sqlserver.entity.ProjectPath;
    import com.lyc.sqlserver.util.FieldFormatUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 9:34 * @description: 项目工程 Service **/
    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Service
    public class ProjectService { 
    
        @Autowired
        private TreepnameDao treepnameDao;
        @Autowired
        private TableService tableService;
    
        /** * 获取项目名 * @return */
        public ProjectPath getProjectName() { 
            // 从数据库中获取项目列表
            List<Map<String,Object>> projectList = treepnameDao.selectList();
            // 从列表中获取第一个项目（默认只有一个项目）
            Map<String,Object> project = projectList.get(0);
            FieldFormatUtil fieldFormatUtil = FieldFormatUtil.newFieldFormatUtil(project);
            // 从项目中获取项目名
            return ProjectPath.builder()
                    .code(fieldFormatUtil.getString("num"))
                    .name(fieldFormatUtil.getString("index_name"))
                    .build();
        }
    
    
        /** * 从数据库中读取数据，然后生成文件 */
        public void generateFilesByProject() { 
            // 创建项目路径容器
            Map<String,Object> pathMap = Maps.newHashMap();
            // 获取项目名
            ProjectPath projectName = getProjectName();
            // 将项目名添加到容器中
            pathMap.put(CommonConstant.ProjectPropertyName.PROJECT,projectName);
            // 根据表名批量生成文件
            tableService.generateFilesByTable(pathMap);
        }
    
    }

SQLServerService

package com.lyc.sqlserver.service;
    
    import com.lyc.sqlserver.dao.ItemDao;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/3/26 22:24 * @description: SQLServer Service **/
    @Slf4j
    @Service
    public class SQLServerService { 
    
        @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
        @Autowired
        private ItemDao itemDao;
    
        /** * 分页查询列表 * * @param table * @param start * @param size * @return */
        public List<Map<String,Object>> selectListPageQuery(String table, String sortedField, int start, int size) { 
            log.info("调用表：{},排序字段：{},开始点：{},查询数：{}",table,sortedField,start,size);
            return itemDao.selectListPageQuery(table,sortedField,start,size);
        }
    
        /** * 获取信息的总条数 * @param table * @return */
        public int getCount(String table) { 
            return itemDao.getCount(table);
        }
    
    }

TableService

package com.lyc.sqlserver.service;
    
    import com.google.common.collect.Lists;
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.common.Tables;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/19 18:04 * @description: **/
    @Service
    public class TableService { 
    
        @Autowired
        private ItemService itemService;
    
        /** * 获取全部的表名 * @return */
        public List<String> getTableNames(){ 
            // 表名集合
            List<String> tableNameList = Lists.newArrayList();
            // 循环遍历所有数据表，将表名放入到tableNameList容器中
            for(Tables table : Tables.values()){ 
                tableNameList.add(table.getTableName());
            }
            // 返回添加后的结果
            return tableNameList;
        }
    
        /** * 根据表名生成文件 * @param pathMap */
        public void generateFilesByTable(Map<String,Object> pathMap) { 
            // 获取所有的表
            List<String> tableNameList = getTableNames();
            // 循环遍历根据每一张表生成文件
            tableNameList.forEach(tableName -> { 
                // 将表名放入到容器中
                pathMap.put(CommonConstant.ProjectPropertyName.TABLE,tableName);
                // 将排序字段放入到容器中
                pathMap.put(CommonConstant.ProjectPropertyName.SORT_FIELD,getSortedField(tableName));
                // 根据条目信息生成文件
                itemService.generateFilesByItem(pathMap);
            });
        }
    
        /** * 获取当前表的排序字段 * @param tableName * @return */
        private String getSortedField(String tableName) { 
            // 循环遍历所有数据表
            for(Tables table : Tables.values()){ 
                if(table.getTableName().equals(tableName)){   // 如果当前表与传入的表名相一致，则获取当前表的排序字段
                    // 返回当前表的排序字段
                    return table.getSortedField();
                }
            }
            // 实际上这种情况是不可能出现的
            return null;
        }
    
    }

### 核心库 ###

GenerateCore

package com.lyc.sqlserver.core;
    
    import com.google.common.collect.Lists;
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.common.GenerateFunction;
    import com.lyc.sqlserver.core.generate.TableFunction;
    import com.lyc.sqlserver.entity.TableFunctionEntity;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/20 18:27 * @description: 文件生成核心服务类 **/
    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Service
    public class GenerateCore { 
    
        /** * 选择生成器 * @param itemList 表名 * @param table 排序字段 * @param pathMap 项目属性集合 */
        public void choiceGenerator(List<Map<String,Object>> itemList, String table, Map<String,Object> pathMap) { 
            // 获取所有的生成规则
            List<TableFunctionEntity> generateFunctionList = TableFunction.newTableFunction().getGenerateFunctionList();
            // 接收选出的GenerateFunction
            List<GenerateFunction> generateFunctions = Lists.newArrayList();
            // 循环遍历选出当前表的生成规则
            generateFunctionList.forEach(generateFunction -> { 
                if(generateFunction.getTableName().equals(table)){ 
                    generateFunctions.add(generateFunction.getGenerateFunction());
                }
            });
            // 循环遍历条目
            itemList.forEach(item -> { 
                // 将当前条目放入到项目属性集合中
                pathMap.put(CommonConstant.ProjectPropertyName.ITEM,item);
                // 利用当前表的生成规则将条目中的文件字节码生成文件
                generateFunctions.get(0).generate(pathMap);
            });
        }
    
    }

PageQueryService

package com.lyc.sqlserver.core;
    
    import com.google.common.collect.Lists;
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.dao.ItemDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/20 18:00 * @description: 分页查询服务类 **/
    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Service
    public class PageQueryService { 
    
        @Autowired
        private GenerateCore generateCore;
    
        /** * 遍历函数 * @param pathMap 项目属性集合 * @param itemDao 条目Dao */
        public void traverse(Map<String,Object> pathMap, ItemDao itemDao) { 
            // 表名
            String table = String.valueOf(pathMap.get(CommonConstant.ProjectPropertyName.TABLE));
            // 排序字段
            String sortedField = String.valueOf(pathMap.get(CommonConstant.ProjectPropertyName.SORT_FIELD));
            // 获取表内信息总条数
            int total = itemDao.getCount(table);
            if(total != 0){    // 如果信息条数不等于0，则执行数据查询操作，否则则不会执行
                // 采用没有线程池的遍历方式
                traverseWithoutThreadPool(total,table,sortedField,itemDao,pathMap);
            }
        }
    
        /** * 采用没有线程池的遍历方式 * @param total 信息的总条数 * @param table 表名 * @param sortedField 排序字段 * @param itemDao 条目Dao * @param pathMap 项目属性集合 */
        private void traverseWithoutThreadPool(int total, String table, String sortedField, ItemDao itemDao, Map<String,Object> pathMap) { 
            // 最后一次读取的信息数
            int lastCount = 0;
            // 每次读取的最大信息条数
            int cycleTime = 10;
            // 线程调用的总次数
            int threadCount = 0;
            // 1、如果当前信息条数小于等于循环周期数，则默认只执行一次
            if(total < cycleTime){ 
                // 线程调用次数
                threadCount = 1;
            } else {    // 2、如果当前信息条数大于循环周期数
                // 最后一次读取的信息条数
                lastCount = total % cycleTime;
                if(lastCount == 0){    // 2.1、整除情况 执行次数 = 信息总数 / 循环周期数
                    threadCount = total / cycleTime;
                } else {   // 2.2、不能整除情况 执行次数 = 信息总数 / 循环周期数 + 1
                    threadCount = total / cycleTime + 1;
                }
            }
            for(int i = 1; i <= threadCount; i ++){      // 循环遍历开始执行
                List<Map<String,Object>> itemList = Lists.newArrayList();
                // 信息开始读取的位置
                final int start = (i - 1) * cycleTime;
                // 1、如果threadCount为1
                if(threadCount == 1){ 
                    // 本次读取的信息条数为总条数
                    itemList = itemDao.selectListPageQuery(table,sortedField,start, total);
                } else {   // 2、如果threadCount不为1
                    if(i < threadCount){  // 2.1、如果不是最后一次循环，则每次都是整周期读取数据
                        itemList = itemDao.selectListPageQuery(table,sortedField,start, cycleTime);
                    } else {   // 2.2、如果是最后一次循环，则读取剩余的信息条数
                        final int size = total - start;
                        itemList = itemDao.selectListPageQuery(table,sortedField,start, size);
                    }
                }
                // 将查询出的数据表文件字节码生成相应的文件
                generateCore.choiceGenerator(itemList,table,pathMap);
            }
        }
    
    }

### 函数 ###

TableFunction

package com.lyc.sqlserver.core.generate;
    
    import com.google.common.collect.Lists;
    import com.lyc.sqlserver.common.GenerateFunction;
    import com.lyc.sqlserver.common.Tables;
    import com.lyc.sqlserver.core.generate.generateFunction.*;
    import com.lyc.sqlserver.entity.TableFunctionEntity;
    
    import java.util.List;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 10:41 * @description: 表函数 **/
    public class TableFunction { 
    
        // 函数集合
        List<TableFunctionEntity> generateFunctionList = Lists.newArrayList();
    
        /** * 返回创建的TableFunction对象 * @return */
        public static TableFunction newTableFunction(){ 
            return new TableFunction();
        }
    
        /** * 获取FileFunctionEntity实例 * @return */
        private TableFunctionEntity getFileFunctionEntity(){ 
            // 实例化fileattFunction对象
            GenerateFunction fileFunction = FileFunction.newFileFunction();
            return TableFunctionEntity.builder()
                    .tableName(Tables.FILE.getTableName())
                    .generateFunction(fileFunction)
                    .build();
        }
    
    	/** * 获取BBFunctionEntity实例 * @return */
        private TableFunctionEntity getBBFunctionEntity() { 
            // 实例化fileattFunction对象
            GenerateFunction bBFunction = BBFunction.newBBFunction();
            return TableFunctionEntity.builder()
                    .tableName(Tables.BB.getTableName())
                    .generateFunction(bBFunction)
                    .build();
        }
    
        /** * 获取文件生成函数集合 * @return */
        public List<TableFunctionEntity> getGenerateFunctionList(){ 
            // 将FileattFunctionEntity实例放入到容器中
            generateFunctionList.add(getFileFunctionEntity());
            generateFunctionList.add(getBBFunctionEntity());
            ...
            return generateFunctionList;
        }
    
    }

BBFunction

package com.lyc.sqlserver.core.generate.generateFunction;
    
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.common.FileCommon;
    import com.lyc.sqlserver.common.GenerateFunction;
    import com.lyc.sqlserver.common.Tables;
    import com.lyc.sqlserver.util.FileUtil;
    import com.lyc.sqlserver.util.PathUtil;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 10:38 * @description: BB表函数 **/
    @Slf4j
    public class BBFunction implements GenerateFunction, FileCommon { 
    
        /** * 返回BBFunction实例 * @return */
        public static BBFunction newBBFunction(){ 
            return new BBFunction();
        }
    
        /** * BB表内文件生成函数 * @param pathMap 工程属性 */
        @Override
        public void generate(Map<String, Object> pathMap) { 
            // 创建PathUtil实例
            PathUtil pathUtil = PathUtil.newPathUtil();
            // 创建FileUtil实例
            FileUtil fileUtil = FileUtil.newFileUtil();
            // 获取当前条目
            Map<String, Object> item = (Map<String, Object>) pathMap.get(CommonConstant.ProjectPropertyName.ITEM);
            // 获取文件夹路径
            String folderPath = pathUtil.getFolderPath(pathMap);
            // 如果文件夹不存在，则创建
            fileUtil.generateFolder(folderPath);
            // 获取文件名
            String fileName = getFileName(item);
            // 获取文件全路径
            String fileFullPath = pathUtil.getFileFullPathDefault(fileName,folderPath);
            // 获取文件字节码
            byte[] fileByteArray = getFileByteArray(item);
            // 生成文件
            generateFile(fileFullPath,fileByteArray);
        }
    
        @Override
        public String getFileName(Map<String, Object> item) { 
            // 获取文件名称1
            String fileName1 = String.valueOf(item.get(Tables.BB.getFileName1()));
            // 获取文件名称2
            String fileName2 = String.valueOf(item.get(Tables.BB.getFileName2()));
            // 名称拼接后返回
            return fileName1 + CommonConstant.Separators.WHIPPLETREE + fileName2;
        }
    
        /** * 生成文件 * @param fileFullPath 文件全路径 * @param fileByteArray 文件字节流 */
        @Override
        public void generateFile(String fileFullPath, byte[] fileByteArray) { 
            // 创建FileUtil实例
            FileUtil fileUtil = FileUtil.newFileUtil();
            fileUtil.generateFile(fileFullPath,fileByteArray);
            log.info("当前生成的文件为：{}",fileFullPath);
        }
    
        /** * 获取文件字节流 * @param item * @return */
        @Override
        public byte[] getFileByteArray(Map<String, Object> item) { 
            return FileUtil.newFileUtil().getByte(item.get(Tables.BB.getFile()));
        }
    
    }

FileFunction

package com.lyc.sqlserver.core.generate.generateFunction;
    
    import com.lyc.sqlserver.common.CommonConstant;
    import com.lyc.sqlserver.common.FileCommon;
    import com.lyc.sqlserver.common.GenerateFunction;
    import com.lyc.sqlserver.common.Tables;
    import com.lyc.sqlserver.util.FileUtil;
    import com.lyc.sqlserver.util.PathUtil;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/4/21 10:54 * @description: Fileatt表函数 **/
    @Slf4j
    public class FileFunction implements GenerateFunction, FileCommon { 
    
        /** * 返回FileattFunction实例 * @return */
        public static FileFunction newFileattFunction(){ 
            return new FileFunction();
        }
    
        /** * 获取文件名 * @param item 文件条目 * @return */
        public String getFileName(Map<String, Object> item){ 
            // 从对象中获取文件名
            Object fname = item.get(Tables.FILE.getFileName1());
            if(fname != null){   // 如果不为空，则将其格式化成字符串，然后返回
                return String.valueOf(fname);
            }
            // 否则生成的文件名一律为ERROR
            return CommonConstant.ResponseStatus.ERROR_NAME;
        }
    
        /** * Fileatt表内文件生成函数 * @param pathMap 工程属性 */
        @Override
        public void generate(Map<String, Object> pathMap) { 
            // 创建PathUtil实例
            PathUtil pathUtil = PathUtil.newPathUtil();
            // 创建FileUtil实例
            FileUtil fileUtil = FileUtil.newFileUtil();
            // 获取当前条目
            Map<String, Object> item = (Map<String, Object>) pathMap.get(CommonConstant.ProjectPropertyName.ITEM);
            // 获取文件夹路径
            String folderPath = getFolderPath(pathMap,item);
            // 如果文件夹不存在，则创建
            fileUtil.generateFolder(folderPath);
            // 获取文件名
            String fileName = getFileName(item);
            // 获取文件全路径
            String fileFullPath = pathUtil.getFileFullPathDefault(fileName,folderPath);
            // 获取文件字节码
            byte[] fileByteArray = getFileByteArray(item);
            // 生成文件
            generateFile(fileFullPath,fileByteArray);
        }
    
        /** * 生成文件 * @param fileFullPath 文件全路径 * @param fileByteArray 文件字节流 */
        public void generateFile(String fileFullPath, byte[] fileByteArray) { 
            // 创建FileUtil实例
            FileUtil fileUtil = FileUtil.newFileUtil();
            fileUtil.generateFile(fileFullPath,fileByteArray);
            log.info("当前生成的文件为：{}",fileFullPath);
        }
    
        /** * 获取字节码对象，并返回 * @param item 文件条目 * @return */
        @Override
        public byte[] getFileByteArray(Map<String, Object> item) { 
            // 获取文件字节码并返回
            return FileUtil.newFileUtil().getByte(item.get(Tables.FILE.getFile()));
        }
    
        /** * 获取Fileatt文件路径 * @param pathMap 工程属性 * @return */
        public String getFolderPath(Map<String,Object> pathMap, Map<String, Object> item) { 
            // 获取案卷编号
            String fileNo = String.valueOf(item.get(CommonConstant.Fileatt.FILE_NO));
            // 创建PathUtil实例
            PathUtil pathUtil = PathUtil.newPathUtil();
            // 文件夹路径 = 系统绝对路径 + 项目名 + 数据表名 + 案卷编号
            return CommonConstant.ProjectPathName.SYSTEM_PATH
                    + CommonConstant.Separators.BACK_SLASH
                    + pathUtil.getProjectName(pathMap.get(CommonConstant.ProjectPropertyName.PROJECT))
                    + CommonConstant.Separators.BACK_SLASH
                    + pathUtil.getString(pathMap.get(CommonConstant.ProjectPropertyName.TABLE))
                    + CommonConstant.Separators.BACK_SLASH
                    + fileNo;
        }
    
    }

其它`com.lyc.sqlserver.core.generate.generateFunction`包下的类与上面的类似，在此忽略不计。

### Controller ###

SQLServerController

package com.lyc.sqlserver.controller;
    
    import com.lyc.sqlserver.service.ProjectService;
    import com.lyc.sqlserver.service.SQLServerService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    import java.util.Map;
    
    /** * @author: zhangzhenyi * @date: 2019/3/26 22:24 * @description: SQLServer Controller **/
    @Slf4j
    @RestController
    public class SQLServerController { 
    
        @Autowired
        private SQLServerService sqlServerService;
        @Autowired
        private ProjectService projectService;
    
        /** * 分页查询列表 * @return */
        @GetMapping("/selectListPageQueryFrom/{table}/{sortedField}/{start}/{size}")
        public List<Map<String,Object>> selectListPageQuery(
                @PathVariable("table") String table,
                @PathVariable("sortedField") String sortedField,
                @PathVariable("start") int start,
                @PathVariable("size") int size
        ){ 
            return sqlServerService.selectListPageQuery(table,sortedField,start,size);
        }
    
        /** * 获取信息的总条数 * @param table * @return */
        @GetMapping("/countFrom/{table}")
        public int getCount(@PathVariable("table") String table){ 
            return sqlServerService.getCount(table);
        }
    
        /** * 从数据库中读取数据，然后生成文件 * @return */
        @GetMapping("/generateFiles")
        public String generateFiles(){ 
            // 从数据库中读取数据，然后生成文件
            projectService.generateFilesByProject();
            return "文件生成成功！";
        }
    
    }

### BootStrap启动类 ###

SQLServerApplication

package com.lyc.sqlserver;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    /** * @author: zhangzhenyi * @date: 2019/3/26 22:20 * @description: SQLServer Bootstrap 启动类 **/
    @SpringBootApplication
    @EnableEurekaClient
    public class SQLServerApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SQLServerApplication.class,args);
        }
    
    }

## 配置文件 ##

application.yml

# spring连接数据库驱动
    spring:
      application:
        # 服务名称
        name: sqlserver-server
      datasource:
        driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
        url: jdbc:sqlserver://localhost:1433;DatabaseName=pDemoCQ
        username: sa
        password: 123456
    
    # jpa自动创建不存在的数据表
      jpa:
        show-sql: true
        hibernate:
          ddl-auto: update
          use-new-id-generator-mappings: true
      jackson:
        serialization:
          indent_output: false
    
    # 服务端口号
    server:
      port: 8089
    
    eureka:
      instance:
        # 指明使用IP而不是服务名称来注册自身服务。因为Eureka默认是使用域名进行服务注册和解析
        prefer-ip-address: true
      client:
        register-with-eureka: true
        fetch-registry: true
        service-url:
          defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/
    
    ### mybatis config ###
    mybatis:
      type-aliases-package: com.lyc.sqlserver.entity

# 测试结果 #

通过执行下述方法，我们就可以批量生成自己所需要的文件了。

http://localhost:8089/generateFiles

上述读取的文件字节流为简单的`byte[]`数组，通过`FileOutputStream`的`write(eleb)`方法即可写出到文件中，这个反倒是比较的简单，剩下的就是在一旁静静的喝水，等待。