JAVA数据库建表工具类

前言：

在实际项目中会遇到建主题数据库的工作(主题数据库定义：面向特定的学科和应用领域，由若干的逻辑相关的数据源按照统一的标准规范整合形成，具有系统性和完整性，并通过统一的系统提供一站式服务的数据库。)，就是批量按照需求建表，此时就需要一些代码辅助操作。

思路：

1、相关人员会提供表结构文件，类似如下图：

2、提取有用信息，单独建立excle文件，如下图：

3、使用代码把信息读取出来，

4、生成SQL语句，

具体实现：

1、准备java代码需要依赖的jar包：

 <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>4.1.0</version>
        </dependency>
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
       <dependency>
            <groupId>org.apache.poi</groupId>
           <artifactId>poi-ooxml</artifactId>
           <version>4.1.0</version>
     </dependency>

2、测试用的实体类：

package com.test.word;

import java.io.Serializable;
/**
 * 模拟的实体类
 * @author xieh
 *
 */
public class Test  implements Serializable{
    private  int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Test [id=" + id + ", name=" + name + "]";
    }
}

3、操作excle表工具类：

package com.test.word;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFDataFormat;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

/**
 * excle工具类
 * 
 * @author xieh 2019/11/24 使用的jar包是：poi-4.1.0.jar 和 poi-ooxml-4.1.0.jar
 *
 */
public class ExcelUtil {
    
    /**
     * 读取excle内容：注意此方法不兼容.xlsx文件
     * @throws Exception
     */
    @SuppressWarnings("resource")
    public static List<Map<String, String>> excelRead() throws Exception {
        //用流的方式先读取到你想要的excel的文件
        //FileInputStream fis=new FileInputStream(new File(System.getProperty("user.dir")+"/src/excel.xls"));
        FileInputStream fis = new FileInputStream(new File("D:/a.xls"));
        // 解析excel
        POIFSFileSystem pSystem = new POIFSFileSystem(fis);
        // 获取整个excel
        HSSFWorkbook hb = new HSSFWorkbook(pSystem);
        System.out.println(hb.getNumCellStyles());
        // 获取第一个表单sheet
        HSSFSheet sheet = hb.getSheetAt(0);
        // 获取第一行
        int firstrow = sheet.getFirstRowNum();
        // 获取最后一行
        int lastrow = sheet.getLastRowNum();
        // 存取最后结果
        List<Map<String, String>> result = new ArrayList<Map<String, String>>();
        // 循环行数依次获取列数
        for (int i = firstrow; i < lastrow + 1; i++) {
            // 获取哪一行i
            Row row = sheet.getRow(i);
            // 存放每行的键值对结果
            Map<String, String> tempMap = new HashMap<String, String>();
            if (row != null) {
                // 获取这一行的第一列
                int firstcell = row.getFirstCellNum();
                // 获取这一行的最后一列
                int lastcell = row.getLastCellNum();
                // 创建一个集合，用处将每一行的每一列数据都存入集合中
                //List<String> list = new ArrayList<String>();
                for (int j = firstcell; j < lastcell; j++) {
                    // 获取第j列
                    Cell cell = row.getCell(j);
                    if (cell != null && !("").equals(cell.toString())) {
                        //System.out.print(cell + "\t");
                        //list.add(cell.toString());
                        tempMap.put("c" + j, cell.toString().trim());
                    }
                }
                // 存放每行的结果
                result.add(tempMap);
            }// row if end
            
        }// for end
        fis.close();
        System.out.println(result.toString());
        return result;
    }

    
    
    
    /**
     * 此方法兼容.xls 和 .xlsx格式，建议使用
     * @param path excle文件路径
     * @param sheetIndex  excle文件的Sheet页的下标，从0开始
     * @return excle表中的内容
     * @throws Exception
     */
    @SuppressWarnings("resource")
    public static List<Map<String, String>> excelXRead(String path,int sheetIndex) throws Exception {
        //用流的方式先读取到你想要的excel的文件
        //FileInputStream fis=new FileInputStream(new File(System.getProperty("user.dir")+"/src/excel.xls"));
         File excel = new File(path);
         String[] split = excel.getName().split("\\.");  //.是特殊字符，需要转义
         Workbook wb = null;
         FileInputStream  fis = null;
         
         //根据文件后缀（xls/xlsx）进行判断
         if ( "xls".equals(split[1])){
             fis = new FileInputStream(excel);   //文件流对象 
             wb = new HSSFWorkbook(fis);
             
         }else if ("xlsx".equals(split[1])){
             wb = new XSSFWorkbook(excel);
             
         }else {
             System.out.println("文件类型错误!");
             return new ArrayList<>();
             
         }    
         //开始解析
         Sheet sheet = wb.getSheetAt(sheetIndex);     //读取sheet 0
        // 获取第一行
        int firstrow = sheet.getFirstRowNum() + 1; //第一行是列名，所以不读
        // 获取最后一行
        int lastrow = sheet.getLastRowNum();
        // 存取最后结果
        List<Map<String, String>> result = new ArrayList<Map<String, String>>();
        // 循环行数依次获取列数
        for (int i = firstrow; i < lastrow + 1; i++) {
            // 获取哪一行i
            Row row = sheet.getRow(i);
            // 存放每行的键值对结果
            Map<String, String> tempMap = new HashMap<String, String>();
            if (row != null) {
                // 获取这一行的第一列
                int firstcell = row.getFirstCellNum();
                // 获取这一行的最后一列
                int lastcell = row.getLastCellNum();
                // 创建一个集合，用处将每一行的每一列数据都存入集合中
                //List<String> list = new ArrayList<String>();
                for (int j = firstcell; j < lastcell; j++) {
                    // 获取第j列
                    Cell cell = row.getCell(j);
                    if (cell != null && !("").equals(cell.toString())) {
                        //System.out.print(cell + "\t");
                        //list.add(cell.toString());
                        tempMap.put("c" + j, cell.toString().trim());
                    }
                }
                // 存放每行的结果
                result.add(tempMap);
            }// row if end
            
        }// for end
        
        if(null != fis){
            fis.close();
        }
        System.out.println(result.toString());
        return result;
    }
    
    
    /**
     * 创建和写入excle内容
     * @param exportList 实体类list
     * @param file 生成的文件路径
     * @throws Exception
     */
    public static void writeXls(List<Test> exportList, File file) throws Exception {
         
        String[] options = { "ID", "内容", "名字" };
        XSSFWorkbook book = new XSSFWorkbook();
 
        CreationHelper createHelper = book.getCreationHelper();
 
        XSSFCellStyle style = book.createCellStyle();
        XSSFCellStyle dateStyle = book.createCellStyle();
        XSSFDataFormat format = book.createDataFormat();
        style.setWrapText(true);
        dateStyle.setWrapText(true);
 
        XSSFSheet sheet = book.createSheet("sheet");
 
        sheet.setColumnWidth(3, 13000);
        sheet.setDefaultColumnWidth(20);
 
        XSSFRow firstRow = sheet.createRow(0);
        XSSFCell[] firstCells = new XSSFCell[3];
 
        CellStyle styleBlue = book.createCellStyle(); // 样式对象
        // 设置单元格的背景颜色为淡蓝色
        styleBlue.setWrapText(true);// 指定当单元格内容显示不下时自动换行
 
        Font font = book.createFont();
        //font.setBoldweight(Font.BOLDWEIGHT_BOLD);
        font.setFontName("宋体");
        font.setFontHeight((short) 280);
        style.setFont(font);
        dateStyle.setFont(font);
        dateStyle.setDataFormat(format.getFormat("yyyy-mm-dd"));
        styleBlue.setFont(font);
 
        for (int j = 0; j < options.length; j++) {
            firstCells[j] = firstRow.createCell(j);
            firstCells[j].setCellStyle(styleBlue);
            firstCells[j].setCellValue(new XSSFRichTextString(options[j]));
        }
        getExport(sheet, style, createHelper, exportList, dateStyle);
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
 
        OutputStream os = new FileOutputStream(file);
        book.write(os);
        os.close();
    }

    
    
    
    
    
    /**
     * excle实体数据写入
     * @param sheet
     * @param style
     * @param createHelper
     * @param exportList
     * @param dateStyle
     */
    private static void getExport(XSSFSheet sheet, XSSFCellStyle style, CreationHelper createHelper, List<Test> exportList,
            XSSFCellStyle dateStyle) {
        // 遍历实例类的list集合
        for (int i = 0; i < exportList.size(); i++) {
            // 创建行
            XSSFRow row = sheet.createRow(i + 1);
            
            // 实体类
            Test export = exportList.get(i);
            
            // 第一列
            XSSFCell hotelId = row.createCell(0);
            hotelId.setCellStyle(style);
            
            // 第二列
            XSSFCell hotelName = row.createCell(1);
            hotelName.setCellStyle(dateStyle);
            
            // 第三列
            XSSFCell chargeCount = row.createCell(2);
            chargeCount.setCellStyle(style);
            
            // 设置值
            hotelId.setCellValue(export.getId());
            hotelName.setCellValue("测试");
            chargeCount.setCellValue(export.getName());
 
            // ta.append("写入excel开始,行数是" + (i + 1) + "\n");
        }// for end
 
    }

    
    
    
    
    /**
     * 测试
     * 
     * @param args
     */
    public static void main(String[] args) {
        try {
            ExcelUtil.excelRead();
            ExcelUtil.excelXRead("D:/柱子.xlsx",0);
            ExcelUtil.excelXRead("D:/a.xls",0);
            List<Test> show = new ArrayList<Test>();
            Test test1 = new Test();
            test1.setId(1);
            test1.setName("xieh");
            
            Test test2 = new Test();
            test2.setId(2);
            test2.setName("xieh");
            show.add(test1);
            show.add(test2);
            ExcelUtil.writeXls(show, new File("D:/bbb.xls"));
            ExcelUtil.writeXls(show, new File("D:/aaa.xlsx"));
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

4、生成SQL表结构的工具类：

package com.test.word;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 数据库建表工具类
 * @author xieh 2019/11/27
 *
 */
public class SQLTableUtil {
    
    //private String mysql = "MYSQL";
    //private String mssql = "MSSQL";
    //private String oracle = "ORACLE";
    //private String psql = "PSQL";
    
    /**
     * MySQL数据库创建表SQL语句生成
     * @param listSqlFiled
     * @return
     */
    public static String createMYSQL(List<Map<String, String>> listSqlFiled){
        if(listSqlFiled != null && listSqlFiled.size()>0){
            List<String>  priKeyArray = new ArrayList<String>();// 主键集合
            StringBuilder sqlStr = new StringBuilder();
            // 获取第一个map，存在表名
            Map<String, String> mapFirst = listSqlFiled.get(0);
            /*int countMapFirst = 0;// 控制第一行的表名和表注释遍历次数
            for(Map.Entry<String, String> entry:mapFirst.entrySet()){
                if(countMapFirst == 0){
                    sqlStr.append("DROP TABLE IF EXISTS `"+ entry.getValue() +"`;\n");
                    sqlStr.append("CREATE TABLE `"+ entry.getValue() +"` (\n");
                }
                
            }*/
            sqlStr.append("DROP TABLE IF EXISTS `"+ mapFirst.get("c0") +"`;\n");
            sqlStr.append("CREATE TABLE `"+  mapFirst.get("c0") +"` (\n");
            
            int length = listSqlFiled.size();
            // 遍历list集合
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append("`"+ map.get("c1") +"`\t "+ map.get("c2") +"\t");
                // 是否为主键并且主键不能为空
                if(map.get("c3").equalsIgnoreCase("Y")){
                    priKeyArray.add(map.get("c1"));
                    sqlStr.append("NOT NULL COMMENT '"+map.get("c5")+"',\n");
                    //表示结束了到最后一行了，并且只有一个主键
                    if(i >= length - 1 && priKeyArray.size() == 1){// 只有一个主键时
                        sqlStr.append("PRIMARY KEY (`"+ priKeyArray.get(0) +"`)\n");
                        sqlStr.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");
                    // 表示到最后一行了，并且存在多个主键
                    }else if(i >= length - 1 && priKeyArray.size() > 1){// 多个主键时
                        sqlStr.append("PRIMARY KEY (");
                        // 遍历主键
                        for(int k = 0; k < priKeyArray.size(); k ++){
                            // 到最后一个主键时
                            if(k == priKeyArray.size() - 1){
                                sqlStr.append("`"+ priKeyArray.get(k) +"`) USING BTREE \n");
                            }else{
                                sqlStr.append("`"+ priKeyArray.get(k) +"`,");
                            }
                        }
                        sqlStr.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");
                    }
                
                // 非主键，直接判断是否允许为空
                }else {
                    // 表示没有主键，并且到最后一个了
                    if(priKeyArray.size() <=0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append("DEFAULT NULL COMMENT '"+map.get("c5")+"'\n");
                        }else{
                            sqlStr.append("NOT NULL COMMENT '"+map.get("c5")+"'\n");
                        }
                        sqlStr.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");
                    
                    // 表示有主键，并且是到最后一行了
                    }else if(priKeyArray.size() >0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append("DEFAULT NULL COMMENT '"+map.get("c5")+"',\n");
                        }else{
                            sqlStr.append("NOT NULL COMMENT '"+map.get("c5")+"',\n");
                        }
                        // 表示只有一个主键
                        if(priKeyArray.size() == 1){
                            sqlStr.append("PRIMARY KEY (`"+ priKeyArray.get(0) +"`)\n");
                            sqlStr.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");
                        // 表示有多个主键    
                        }else{
                            sqlStr.append("PRIMARY KEY (");
                            // 遍历主键
                            for(int k = 0; k < priKeyArray.size(); k ++){
                                // 到最后一个主键时
                                if(k == priKeyArray.size() - 1){
                                    sqlStr.append("`"+ priKeyArray.get(k) +"`) USING BTREE \n");
                                }else{
                                    sqlStr.append("`"+ priKeyArray.get(k) +"`,");
                                }
                            }
                            sqlStr.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");
                        }
                    
                    // 没有到最后一行继续追加
                    }else{
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append("DEFAULT NULL COMMENT '"+map.get("c5")+"',\n");
                        }else{
                            sqlStr.append("NOT NULL COMMENT '"+map.get("c5")+"',\n");
                        }
                    }
    
                }//
    
            }// for end
        
            return sqlStr.toString();
        }else{
            return "";
        }
    }
    
    /**
     * sqlserver数据库创建表SQL语句
     * @param listSqlFiled
     * @return
     */
    public static String createMSSQL(List<Map<String, String>> listSqlFiled){
        if(listSqlFiled != null && listSqlFiled.size()>0){
            StringBuilder sqlStr = new StringBuilder();
            // 获取第一个map，存在表名
            Map<String, String> mapFirst = listSqlFiled.get(0);
            sqlStr.append("IF EXISTS (SELECT * FROM sys.all_objects WHERE object_id = OBJECT_ID(N'[dbo].["+ mapFirst.get("c0") +"]') AND type IN ('U'))\n");
            sqlStr.append("DROP TABLE [dbo].["+  mapFirst.get("c0") +"]\n");
            sqlStr.append("GO\n");
            sqlStr.append("CREATE TABLE "+  mapFirst.get("c0") +" (\n");
            
            int length = listSqlFiled.size();
            // 遍历list集合：生成基本表结构阶段
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append("["+ map.get("c1") +"]\t "+ map.get("c2") +"\t");
                // 是否为主键并且主键不能为空
                if(map.get("c3").equalsIgnoreCase("Y")){
                    if(i >= length - 1){// 表示最后一个并且是主键
                        sqlStr.append("primary key     NOT NULL\n");
                        sqlStr.append(")");
                    }else{
                        sqlStr.append("primary key     NOT NULL ,\n");
                    }
                
                // 非主键，直接判断是否允许为空
                }else {
                    if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                        if(i >= length -1){// 表示允许为空并且是最后一个
                            sqlStr.append("DEFAULT NULL\n");
                            sqlStr.append(")");
                        }else{// 表示允许为空继续追加
                            sqlStr.append("DEFAULT NULL ,\n");
                        }
                    }else{// 不允许为空
                        if(i >= length -1){// 表示不允许为空并且是最后一个
                            sqlStr.append("NOT NULL\n");
                            sqlStr.append(")");
                        }else{// 表示不允许为空继续追加
                            sqlStr.append("NOT NULL ,\n");
                        }
                    }
                    
                }//
    
            }// for end基本表结构生成完成
            
            // 开始追加注释阶段
            sqlStr.append("\n");
            for(int i = 1; i < length; i ++){
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append("EXEC sp_addextendedproperty\n");
                sqlStr.append("'MS_Description', N'"+ map.get("c5") +"',\n");
                sqlStr.append("'SCHEMA', N'dbo',\n");
                sqlStr.append("'TABLE', N'"+  mapFirst.get("c0") +"',\n");
                sqlStr.append("'COLUMN', N'"+ map.get("c1") +"'\n");
                sqlStr.append("GO\n");
                sqlStr.append("\n");
            }
            return sqlStr.toString();
        }else{
            return "";
        }
    }
    
    
    
    /**
     * Oracle数据创建表SQL语句
     * @param listSqlFiled
     * @param dbUserName
     * @return
     */
    public static String createORACLE(List<Map<String, String>> listSqlFiled,String dbUserName){

        if(listSqlFiled != null && listSqlFiled.size()>0){
            List<String>  priKeyArray = new ArrayList<String>();// 主键集合
            StringBuilder sqlStr = new StringBuilder();
            // 获取第一个map，存在表名
            Map<String, String> mapFirst = listSqlFiled.get(0);
            sqlStr.append("create table "+ dbUserName +"."+ mapFirst.get("c0") +"(\n");
            int length = listSqlFiled.size();
            // 遍历list集合
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append(""+ map.get("c1") +"\t "+ map.get("c2") +"\t");
                // 是否为主键并且主键不能为空
                if(map.get("c3").equalsIgnoreCase("Y")){
                    priKeyArray.add(map.get("c1"));
                    sqlStr.append("NOT NULL,\n");
                    //表示结束了到最后一行了，并且只有一个主键
                    if(i >= length - 1 && priKeyArray.size() == 1){// 只有一个主键时
                        sqlStr.append("PRIMARY KEY ("+ priKeyArray.get(0) +")\n");
                        sqlStr.append(");\n");
                    // 表示到最后一行了，并且存在多个主键
                    }else if(i >= length - 1 && priKeyArray.size() > 1){// 多个主键时
                        sqlStr.append("PRIMARY KEY (");
                        // 遍历主键
                        for(int k = 0; k < priKeyArray.size(); k ++){
                            // 到最后一个主键时
                            if(k == priKeyArray.size() - 1){
                                sqlStr.append(""+ priKeyArray.get(k) +")\n");
                            }else{
                                sqlStr.append(""+ priKeyArray.get(k) +",");
                            }
                        }
                        sqlStr.append(");\n");
                    }
                
                // 非主键，直接判断是否允许为空
                }else {
                    // 表示没有主键，并且到最后一个了
                    if(priKeyArray.size() <=0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append("\n");
                        }else{
                            sqlStr.append("NOT NULL\n");
                        }
                        sqlStr.append(");\n");
                    
                    // 表示有主键，并且是到最后一行了
                    }else if(priKeyArray.size() >0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append(",\n");
                        }else{
                            sqlStr.append("NOT NULL,\n");
                        }
                        // 表示只有一个主键
                        if(priKeyArray.size() == 1){
                            sqlStr.append("PRIMARY KEY ("+ priKeyArray.get(0) +")\n");
                            sqlStr.append(");\n");
                        // 表示有多个主键    
                        }else{
                            sqlStr.append("PRIMARY KEY (");
                            // 遍历主键
                            for(int k = 0; k < priKeyArray.size(); k ++){
                                // 到最后一个主键时
                                if(k == priKeyArray.size() - 1){
                                    sqlStr.append(""+ priKeyArray.get(k) +")\n");
                                }else{
                                    sqlStr.append(""+ priKeyArray.get(k) +",");
                                }
                            }
                            sqlStr.append(");\n");
                        }
                    
                    // 没有到最后一行继续追加
                    }else{
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append(",\n");
                        }else{
                            sqlStr.append("NOT NULL,\n");
                        }
                    }
    
                }//
    
            }// for end
            
            sqlStr.append("\n");
            // 添加字段注释
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append("comment on column "+ dbUserName +"."+ mapFirst.get("c0") +"."+ map.get("c1")+" is '"+ map.get("c5")+"';\n");    
            }    
            return sqlStr.toString();
        }else{
            return "";
        }
    
    }
    
    
    /**
     * PostgreSQL数据库创建表SQL语句
     * @param listSqlFiled
     * @return
     */
    public static String createPSQL(List<Map<String, String>> listSqlFiled){
        if(listSqlFiled != null && listSqlFiled.size()>0){
            List<String>  priKeyArray = new ArrayList<String>();// 主键集合
            StringBuilder sqlStr = new StringBuilder();
            // 获取第一个map，存在表名
            Map<String, String> mapFirst = listSqlFiled.get(0);
            sqlStr.append("create table "+ mapFirst.get("c0") +"(\n");
            int length = listSqlFiled.size();
            // 遍历list集合
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append(""+ map.get("c1") +"\t "+ map.get("c2") +"\t");
                // 是否为主键并且主键不能为空
                if(map.get("c3").equalsIgnoreCase("Y")){
                    priKeyArray.add(map.get("c1"));
                    sqlStr.append("NOT NULL,\n");
                    //表示结束了到最后一行了，并且只有一个主键
                    if(i >= length - 1 && priKeyArray.size() == 1){// 只有一个主键时
                        sqlStr.append("PRIMARY KEY ("+ priKeyArray.get(0) +")\n");
                        sqlStr.append(");\n");
                    // 表示到最后一行了，并且存在多个主键
                    }else if(i >= length - 1 && priKeyArray.size() > 1){// 多个主键时
                        sqlStr.append("PRIMARY KEY (");
                        // 遍历主键
                        for(int k = 0; k < priKeyArray.size(); k ++){
                            // 到最后一个主键时
                            if(k == priKeyArray.size() - 1){
                                sqlStr.append(""+ priKeyArray.get(k) +")\n");
                            }else{
                                sqlStr.append(""+ priKeyArray.get(k) +",");
                            }
                        }
                        sqlStr.append(");\n");
                    }
                
                // 非主键，直接判断是否允许为空
                }else {
                    // 表示没有主键，并且到最后一个了
                    if(priKeyArray.size() <=0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append("\n");
                        }else{
                            sqlStr.append("NOT NULL\n");
                        }
                        sqlStr.append(");\n");
                    
                    // 表示有主键，并且是到最后一行了
                    }else if(priKeyArray.size() >0 && i >= length - 1){
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append(",\n");
                        }else{
                            sqlStr.append("NOT NULL,\n");
                        }
                        // 表示只有一个主键
                        if(priKeyArray.size() == 1){
                            sqlStr.append("PRIMARY KEY ("+ priKeyArray.get(0) +")\n");
                            sqlStr.append(");\n");
                        // 表示有多个主键    
                        }else{
                            sqlStr.append("PRIMARY KEY (");
                            // 遍历主键
                            for(int k = 0; k < priKeyArray.size(); k ++){
                                // 到最后一个主键时
                                if(k == priKeyArray.size() - 1){
                                    sqlStr.append(""+ priKeyArray.get(k) +")\n");
                                }else{
                                    sqlStr.append(""+ priKeyArray.get(k) +",");
                                }
                            }
                            sqlStr.append(");\n");
                        }
                    
                    // 没有到最后一行继续追加
                    }else{
                        if(map.get("c4").equalsIgnoreCase("Y")){// 允许为空
                            sqlStr.append(",\n");
                        }else{
                            sqlStr.append("NOT NULL,\n");
                        }
                    }
    
                }//
    
            }// for end
            
            sqlStr.append("\n");
            // 添加字段注释
            for(int i = 1; i < length; i ++){
                // 遍历map集合
                Map<String, String> map = listSqlFiled.get(i);
                if(map.size() == 0){// 此处判断不准确，最好的办法就是把excle表的底部多余的行右键删除掉
                    System.out.println("SQL语句不准确，请把excle表底部多余的行右键删除掉！");
                    continue;
                }
                sqlStr.append("comment on column "+ mapFirst.get("c0") +"."+ map.get("c1")+" is '"+ map.get("c5")+"';\n");    
            }    
            return sqlStr.toString();
        }else{
            return "";
        }
    
    
    }
    
    
    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        try {
            // 测试MySQL数据库
            List<Map<String, String>> excelXReadMYSQL = ExcelUtil.excelXRead("F:/cs.xlsx",0);
            System.out.println(createMYSQL(excelXReadMYSQL));
            
            // 测试SQLSERVER数据库
            List<Map<String, String>> excelXReadMSSQL = ExcelUtil.excelXRead("F:/cs.xlsx",1);
            System.out.println(createMSSQL(excelXReadMSSQL));
            
            // 测试Oracle数据库
            List<Map<String, String>> excelXReadORCL = ExcelUtil.excelXRead("F:/cs.xlsx",2);
            System.out.println(createORACLE(excelXReadORCL, "SCOTT"));
            
            // 测试PostgreSQL数据库
            List<Map<String, String>> excelXRead = ExcelUtil.excelXRead("F:/cs.xlsx",3);
            System.out.println(createPSQL(excelXRead));
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

使用注意：

多个表时：

程序空指针错误：

测试结果演示：PostgreSQL

create table T_ZHCS(
F_ID     SERIAL    NOT NULL,
F_CATA_ID     VARCHAR(100)    ,
F_SSJCK     VARCHAR(100)    ,
F_XXZYMC     VARCHAR(100)    ,
F_XXZYDM     VARCHAR(100)    ,
F_XXZYGS     VARCHAR(100)    ,
F_DATASET_TYPE     VARCHAR(100)    ,
F_REGION_CODE     VARCHAR(100)    ,
F_ORGAN_CODE     VARCHAR(100)    ,
F_XXZYTGF     VARCHAR(100)    ,
F_GXLX     VARCHAR(100)    ,
F_KFSX     VARCHAR(100)    ,
F_SRC_UPDATE_TIME     TIMESTAMP    ,
F_VALID_FLAG     VARCHAR(100)    ,
F_DATA_SOURCE_ID     VARCHAR(100)    ,
F_SYS_CREATE_TIME     TIMESTAMP    ,
F_SYS_UPDATE_TIME     TIMESTAMP    ,
F_SRC_TABLE_KEY     VARCHAR(100)    NOT NULL,
PRIMARY KEY (F_ID,F_SRC_TABLE_KEY)
);

comment on column T_ZHCS.F_ID is '主键';
comment on column T_ZHCS.F_CATA_ID is '资源目录ID（主键）';
comment on column T_ZHCS.F_SSJCK is '所属基础库';
comment on column T_ZHCS.F_XXZYMC is '信息资源名称';
comment on column T_ZHCS.F_XXZYDM is '信息资源代码';
comment on column T_ZHCS.F_XXZYGS is '信息资源格式';
comment on column T_ZHCS.F_DATASET_TYPE is '资源格式分类';
comment on column T_ZHCS.F_REGION_CODE is '区划编码';
comment on column T_ZHCS.F_ORGAN_CODE is '信息资源提供方编码';
comment on column T_ZHCS.F_XXZYTGF is '信息资源提供方名称';
comment on column T_ZHCS.F_GXLX is '共享类型';
comment on column T_ZHCS.F_KFSX is '开放属性';
comment on column T_ZHCS.F_SRC_UPDATE_TIME is '源系统数据更新时间';
comment on column T_ZHCS.F_VALID_FLAG is '数据有效标识';
comment on column T_ZHCS.F_DATA_SOURCE_ID is '数据来源';
comment on column T_ZHCS.F_SYS_CREATE_TIME is '系统登记时间';
comment on column T_ZHCS.F_SYS_UPDATE_TIME is '系统更新时间';
comment on column T_ZHCS.F_SRC_TABLE_KEY is '源表主键ID';

数据库执行：