excle导入 文件file上传ajxa请求

Posted 2021-03-23 yjava

第一次写导入excle文件的功能,需求点击选择文件上传,然后点击确定后文件上传请求后台接口,保存数据.最初选择layui的 upload控件,发现它有两种方式,一时点击选择文件就触发请求后台接口,不符合我现在的需求;另外一种就是点击上传文件,然后在点击其他按钮事件触发后台接口的请求,问题是这里要求文件的格式只能是图片,最终选择放弃,选择了最原始的 input  type = " file "  下面是前端页面的代码,以及ajax的请求代码

<div>
    <div class="contain">
        <div class="wenzi">附件上传</div>
        <div class="form_msg">
            <form action="" enctype="multipart/form-data" method="post" >
                <input id="file" type="file"  name="file" />
                <button type="button" class="xiazai" id="excleMuban">Excel模板下载</button>
            </form>
            <div class="rec_buttom">
                <button class="layui-btn layui-btn-normal" id="save">确定</button>
                <button class="layui-btn layui-btn-normal" id="cancel">取消</button>
            </div>
        </div>
    </div>
</div>

<script>
    $(document).ready(function() {
        $(‘#cancel‘).click(function() {
            parent.location.reload();
        })
        $("#excleMuban").click(function(){
            //调用导出接口
            window.location.href=‘${ctx}/exindustry/exportTemplate‘;
        });
        $("#save").click(function(){
            var fileM=document.querySelector("#file");
            //获取文件对象，files是文件选取控件的属性，存储的是文件选取控件选取的文件对象，类型是一个数组
            var fileObj = fileM.files[0];
            // 创建
            var formData = new FormData();
            // 获取文件
            formData.append("file", fileObj);
            console.log(formData)
            $.ajax({
                url: ‘${ctx}/exindustry/upload‘,
                type: "post",
                dataType: "json",
                data: formData,
                cache: false,
                contentType: false,
                processData: false,
                success: function (result) {
                    if(result.code==0){
                        layer.msg(result.msg,{icon: 6,time:2000}, function () {
                            //重新加载父页面
                            parent.location.reload();
                        });
                    }else {
                        layer.msg(result.msg,{icon: 5,time:2000});
                    }
                },
            });
        });
    })
</script>

springMVC文件的配置  这里可以设置支持文件的格式,以及文件的大小,这里我没有写,需要的可以自己加一下,我贴在下面了

<!-- 支持文件上传 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设定默认编码 -->
        <property name="defaultEncoding" value="UTF-8"></property>

    </bean>

<property name="maxUploadSize" value="10485760000"></property><!-- 最大上传文件大小 -->
<property name="maxInMemorySize" value="10960"></property>

后台接口代码

/**
     * 导入Excel文件保存数据
     */
    @RequestMapping("/upload")
    @ResponseBody
    public JSONObject upload(@RequestBody MultipartFile file,
            HttpServletRequest request, HttpServletResponse response) {
        JSONObject result = new JSONObject();
        String path = request.getSession().getServletContext()
                .getRealPath("upload")
                + DateFormatUtils.format(new Date(), "/yyyy/MM/dd");
        int okCount = 0;
        int failCount = 0;
        try {
            String fileName = file.getOriginalFilename();
            String filetype=fileName.substring(fileName.lastIndexOf("."),fileName.length());
            if(StringUtils.isBlank(filetype) || (!filetype.equals(".xls") && !filetype.equals(".xlsx"))){
                result.put("code", 0);
                result.put("message", "文件类型错误，需要xls或xlsx类型文件！");
                htmlUtil.writerJson(response, result);
                return result;
            }
            // 文件名以当前时间戳替换，防止重名
            fileName = Long.toString(System.currentTimeMillis())
                    + fileName.substring(fileName.lastIndexOf("."))
                    .toLowerCase();
            File targetFile = new File(path, fileName);
            if (!targetFile.exists()) {
                targetFile.mkdirs();
            }
            file.transferTo(targetFile);
            ExcelUtil eu = new ExcelUtil();
            // 从第一行开始读取
            eu.setStartReadPos(1);

            String src_xlspath = path+"/"+fileName;
            //String dist_xlsPath = "D:1.xls";
            List<Object> rowList;
            rowList = eu.readExcel(src_xlspath);

            if(rowList!=null && rowList.size()>0){
                for(int i=0; i<rowList.size();i++){
                    ArrayList strList = (ArrayList) rowList.get(i);
                    ExIndustryEntity exIndustryEntity = new ExIndustryEntity();
                    for(int j=0; j<5;j++){
                        String str = (String) strList.get(j);
                        switch (j) {
                            case 0:
                                exIndustryEntity.setName(str);
                                break;
                            case 1:
                                exIndustryEntity.setArea(str);
                                break;
                            case 2:
                                exIndustryEntity.setYield(str);
                                break;
                            case 3:
                                exIndustryEntity.setValue(str);
                                break;
                            default:
                                exIndustryEntity.setYear(str);
                                break;
                        }
                    }
                    JSONObject json = exIndustryService.savaExIndustry(exIndustryEntity);
                    if("0".equals(json.getString("code"))){
                        okCount++;
                    }else {
                        failCount++;
                    }
                }
            }
            result.put("code",0);
            result.put("msg","导入成功 "+okCount+" 条,失败 "+failCount+" 条");
        } catch (Exception e) {
            result.put("code", 0);
            result.put("message", "excel导入失败！");
            e.printStackTrace();
        }
        return result;
    }

用的excle工具类

package com.center.utils;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.*;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * Excel文件操作工具类，包括读、写、合并等功能
 * 
 * @group : tgb8
 * @Version : 1.00
 * @Date : 2014-10-29 上午12:40:44
 */
public class ExcelUtil {

    // %%%%%%%%-------常量部分 开始----------%%%%%%%%%
    /**
     * 默认的开始读取的行位置为第一行（索引值为0）
     */
    private final static int READ_START_POS = 0;

    /**
     * 默认结束读取的行位置为最后一行（索引值=0，用负数来表示倒数第n行）
     */
    private final static int READ_END_POS = 0;

    /**
     * 默认Excel内容的开始比较列位置为第一列（索引值为0）
     */
    private final static int COMPARE_POS = 0;

    /**
     * 默认多文件合并的时需要做内容比较（相同的内容不重复出现）
     */
    private final static boolean NEED_COMPARE = true;

    /**
     * 默认多文件合并的新文件遇到名称重复时，进行覆盖
     */
    private final static boolean NEED_OVERWRITE = true;

    /**
     * 默认只操作一个sheet
     */
    private final static boolean ONLY_ONE_SHEET = false;

    /**
     * 默认读取第一个sheet中（只有当ONLY_ONE_SHEET = true时有效）
     */
    private final static int SELECTED_SHEET = 0;

    /**
     * 默认从第一个sheet开始读取（索引值为0）
     */
    private final static int READ_START_SHEET = 0;

    /**
     * 默认在最后一个sheet结束读取（索引值=0，用负数来表示倒数第n行）
     */
    private final static int READ_END_SHEET = 0;

    /**
     * 默认打印各种信息
     */
    private final static boolean PRINT_MSG = true;

    // %%%%%%%%-------常量部分 结束----------%%%%%%%%%

    // %%%%%%%%-------字段部分 开始----------%%%%%%%%%
    /**
     * Excel文件路径
     */
    private String excelPath = "data.xlsx";

    /**
     * 设定开始读取的位置，默认为0
     */
    private int startReadPos = READ_START_POS;

    /**
     * 设定结束读取的位置，默认为0，用负数来表示倒数第n行
     */
    private int endReadPos = READ_END_POS;

    /**
     * 设定开始比较的列位置，默认为0
     */
    private int comparePos = COMPARE_POS;

    /**
     * 设定汇总的文件是否需要替换，默认为true
     */
    private boolean isOverWrite = NEED_OVERWRITE;

    /**
     * 设定是否需要比较，默认为true(仅当不覆写目标内容是有效，即isOverWrite=false时有效)
     */
    private boolean isNeedCompare = NEED_COMPARE;

    /**
     * 设定是否只操作第一个sheet
     */
    private boolean onlyReadOneSheet = ONLY_ONE_SHEET;

    /**
     * 设定操作的sheet在索引值
     */
    private int selectedSheetIdx = SELECTED_SHEET;

    /**
     * 设定操作的sheet的名称
     */
    private String selectedSheetName = "";

    /**
     * 设定开始读取的sheet，默认为0
     */
    private int startSheetIdx = READ_START_SHEET;

    /**
     * 设定结束读取的sheet，默认为0，用负数来表示倒数第n行
     */
    private int endSheetIdx = READ_END_SHEET;

    /**
     * 设定是否打印消息
     */
    private boolean printMsg = PRINT_MSG;

    // %%%%%%%%-------字段部分 结束----------%%%%%%%%%

    public ExcelUtil() {

    }

    public ExcelUtil(String excelPath) {
        this.excelPath = excelPath;
    }

    /**
     * 还原设定（其实是重新new一个新的对象并返回）
     * 
     * @return
     */
    public ExcelUtil RestoreSettings() {
        ExcelUtil instance = new ExcelUtil(this.excelPath);
        return instance;
    }

    /**
     * 自动根据文件扩展名，调用对应的读取方法
     * 
     * @Title: writeExcel
     * @Date : 2014-9-11 下午01:50:38
     * @param xlsPath
     * @throws IOException
     */
    public List<Object> readExcel() throws IOException {
        return readExcel(this.excelPath);
    }

    /**
     * 自动根据文件扩展名，调用对应的读取方法
     * 
     * @Title: writeExcel
     * @Date : 2014-9-11 下午01:50:38
     * @param xlsPath
     * @throws IOException
     */
    public List<Object> readExcel(String xlsPath) throws IOException {

        // 扩展名为空时，
        if (xlsPath.equals("")) {
            throw new IOException("文件路径不能为空！");
        } else {
            File file = new File(xlsPath);
            if (!file.exists()) {
                throw new IOException("文件不存在！");
            }
        }

        // 获取扩展名
        String ext = xlsPath.substring(xlsPath.lastIndexOf(".") + 1);

        try {

            if ("xls".equals(ext)) { // 使用xls方式读取
                return readExcel_xls(xlsPath);
            } else if ("xlsx".equals(ext)) { // 使用xlsx方式读取
                return readExcel_xlsx(xlsPath);
            } else { // 依次尝试xls、xlsx方式读取
                out("您要操作的文件没有扩展名，正在尝试以xls方式读取...");
                try {
                    return readExcel_xls(xlsPath);
                } catch (IOException e1) {
                    out("尝试以xls方式读取，结果失败！，正在尝试以xlsx方式读取...");
                    try {
                        return readExcel_xlsx(xlsPath);
                    } catch (IOException e2) {
                        out("尝试以xls方式读取，结果失败！
请您确保您的文件是Excel文件，并且无损，然后再试。");
                        throw e2;
                    }
                }
            }
        } catch (IOException e) {
            throw e;
        }
    }

    /**
     * 自动根据文件扩展名，调用对应的写入方法
     * 
     * @Title: writeExcel
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @throws IOException
     */
    public void writeExcel(List<Row> rowList) throws IOException {
        writeExcel(rowList, excelPath);
    }

    /**
     * 自动根据文件扩展名，调用对应的写入方法
     * 
     * @Title: writeExcel
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @param xlsPath
     * @throws IOException
     */
    public void writeExcel(List<Row> rowList, String xlsPath)
            throws IOException {

        // 扩展名为空时，
        if (xlsPath.equals("")) {
            throw new IOException("文件路径不能为空！");
        }

        // 获取扩展名
        String ext = xlsPath.substring(xlsPath.lastIndexOf(".") + 1);

        try {

            if ("xls".equals(ext)) { // 使用xls方式写入
                writeExcel_xls(rowList, xlsPath);
            } else if ("xlsx".equals(ext)) { // 使用xlsx方式写入
                writeExcel_xlsx(rowList, xlsPath);
            } else { // 依次尝试xls、xlsx方式写入
                out("您要操作的文件没有扩展名，正在尝试以xls方式写入...");
                try {
                    writeExcel_xls(rowList, xlsPath);
                } catch (IOException e1) {
                    out("尝试以xls方式写入，结果失败！，正在尝试以xlsx方式读取...");
                    try {
                        writeExcel_xlsx(rowList, xlsPath);
                    } catch (IOException e2) {
                        out("尝试以xls方式写入，结果失败！
请您确保您的文件是Excel文件，并且无损，然后再试。");
                        throw e2;
                    }
                }
            }
        } catch (IOException e) {
            throw e;
        }
    }

    /**
     * 修改Excel（97-03版，xls格式）
     * 
     * @Title: writeExcel_xls
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @param dist_xlsPath
     * @throws IOException
     */
    public void writeExcel_xls(List<Row> rowList, String dist_xlsPath)
            throws IOException {
        writeExcel_xls(rowList, excelPath, dist_xlsPath);
    }

    /**
     * 修改Excel（97-03版，xls格式）
     * 
     * @Title: writeExcel_xls
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @param src_xlsPath
     * @param dist_xlsPath
     * @throws IOException
     */
    public void writeExcel_xls(List<Row> rowList, String src_xlsPath,
                               String dist_xlsPath) throws IOException {

        // 判断文件路径是否为空
        if (dist_xlsPath == null || dist_xlsPath.equals("")) {
            out("文件路径不能为空");
            throw new IOException("文件路径不能为空");
        }
        // 判断文件路径是否为空
        if (src_xlsPath == null || src_xlsPath.equals("")) {
            out("文件路径不能为空");
            throw new IOException("文件路径不能为空");
        }

        // 判断列表是否有数据，如果没有数据，则返回
        if (rowList == null || rowList.size() == 0) {
            out("文档为空");
            return;
        }

        try {
            HSSFWorkbook wb = null;

            // 判断文件是否存在
            File file = new File(dist_xlsPath);
            if (file.exists()) {
                // 如果复写，则删除后
                if (isOverWrite) {
                    file.delete();
                    // 如果文件不存在，则创建一个新的Excel
                    // wb = new HSSFWorkbook();
                    // wb.createSheet("Sheet1");
                    wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
                } else {
                    // 如果文件存在，则读取Excel
                    wb = new HSSFWorkbook(new FileInputStream(file));
                }
            } else {
                // 如果文件不存在，则创建一个新的Excel
                // wb = new HSSFWorkbook();
                // wb.createSheet("Sheet1");
                wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
            }

            // 将rowlist的内容写到Excel中
            writeExcel(wb, rowList, dist_xlsPath);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 修改Excel（97-03版，xls格式）
     * 
     * @Title: writeExcel_xls
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @param dist_xlsPath
     * @throws IOException
     */
    public void writeExcel_xlsx(List<Row> rowList, String dist_xlsPath)
            throws IOException {
        writeExcel_xls(rowList, excelPath, dist_xlsPath);
    }

    /**
     * 修改Excel（2007版，xlsx格式）
     * 
     * @Title: writeExcel_xlsx
     * @Date : 2014-9-11 下午01:50:38
     * @param rowList
     * @param xlsPath
     * @throws IOException
     */
    public void writeExcel_xlsx(List<Row> rowList, String src_xlsPath,
                                String dist_xlsPath) throws IOException {

        // 判断文件路径是否为空
        if (dist_xlsPath == null || dist_xlsPath.equals("")) {
            out("文件路径不能为空");
            throw new IOException("文件路径不能为空");
        }
        // 判断文件路径是否为空
        if (src_xlsPath == null || src_xlsPath.equals("")) {
            out("文件路径不能为空");
            throw new IOException("文件路径不能为空");
        }

        // 判断列表是否有数据，如果没有数据，则返回
        if (rowList == null || rowList.size() == 0) {
            out("文档为空");
            return;
        }

        try {
            // 读取文档
            XSSFWorkbook wb = null;

            // 判断文件是否存在
            File file = new File(dist_xlsPath);
            if (file.exists()) {
                // 如果复写，则删除后
                if (isOverWrite) {
                    file.delete();
                    // 如果文件不存在，则创建一个新的Excel
                    // wb = new XSSFWorkbook();
                    // wb.createSheet("Sheet1");
                    wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
                } else {
                    // 如果文件存在，则读取Excel
                    wb = new XSSFWorkbook(new FileInputStream(file));
                }
            } else {
                // 如果文件不存在，则创建一个新的Excel
                // wb = new XSSFWorkbook();
                // wb.createSheet("Sheet1");
                wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
            }
            // 将rowlist的内容添加到Excel中
            writeExcel(wb, rowList, dist_xlsPath);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * //读取Excel 2007版，xlsx格式
     * 
     * @Title: readExcel_xlsx
     * @Date : 2014-9-11 上午11:43:11
     * @return
     * @throws IOException
     */
    public List<Object> readExcel_xlsx() throws IOException {
        return readExcel_xlsx(excelPath);
    }

    /**
     * //读取Excel 2007版，xlsx格式
     * 
     * @Title: readExcel_xlsx
     * @Date : 2014-9-11 上午11:43:11
     * @return
     * @throws Exception
     */
    public List<Object> readExcel_xlsx(String xlsPath) throws IOException {
        // 判断文件是否存在
        File file = new File(xlsPath);
        if (!file.exists()) {
            throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
        }

        XSSFWorkbook wb = null;
        List<Object> rowList = new ArrayList<Object>();
        try {
            FileInputStream fis = new FileInputStream(file);
            // 去读Excel
            wb = new XSSFWorkbook(fis);

            // 读取Excel 2007版，xlsx格式
            rowList = readExcel(wb);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return rowList;
    }

    /***
     * 读取Excel(97-03版，xls格式)
     * 
     * @throws IOException
     * 
     * @Title: readExcel
     * @Date : 2014-9-11 上午09:53:21
     */
    public List<Object> readExcel_xls() throws IOException {
        return readExcel_xls(excelPath);
    }

    /***
     * 读取Excel(97-03版，xls格式)
     * 
     * @throws Exception
     * 
     * @Title: readExcel
     * @Date : 2014-9-11 上午09:53:21
     */
    public List<Object> readExcel_xls(String xlsPath) throws IOException {

        // 判断文件是否存在
        File file = new File(xlsPath);
        if (!file.exists()) {
            throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
        }

        HSSFWorkbook wb = null;// 用于Workbook级的操作，创建、删除Excel
        List<Object> rowList = new ArrayList<Object>();

        try {
            // 读取Excel
            wb = new HSSFWorkbook(new FileInputStream(file));

            // 读取Excel 97-03版，xls格式
            rowList = readExcel(wb);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return rowList;
    }

    /***
     * 读取单元格的值
     * 
     * @Title: getCellValue
     * @Date : 2014-9-11 上午10:52:07
     * @param cell
     * @return
     */
    @SuppressWarnings("deprecation")
    private String getCellValue(Cell cell) {
        Object result = "";
        if (cell != null) {
            switch (cell.getCellType()) {
            case Cell.CELL_TYPE_STRING:
                result = cell.getStringCellValue();
                break;
            case Cell.CELL_TYPE_NUMERIC:
                String str = null;
                double d = cell.getNumericCellValue();
                if (d - (int) d < Double.MIN_VALUE) {
                    str = Integer.toString((int) d);
                } else {
                    str = Double.toString(cell.getNumericCellValue());
                    DecimalFormat df = new DecimalFormat("####.######");
                    str = df.format(cell.getNumericCellValue());
                }
                /*if(HSSFDateUtil.isCellDateFormatted(cell)){
                    //用于转化为日期格式
                    Date date = cell.getDateCellValue();
                    DateFormat formater = new SimpleDateFormat("yyyy-MM-dd");
                    str = formater.format(d);
                }*/
                result = str;
                break;
            case Cell.CELL_TYPE_BOOLEAN:
                result = cell.getBooleanCellValue();
                break;
            case Cell.CELL_TYPE_FORMULA:
                result = cell.getCellFormula();
                break;
            case Cell.CELL_TYPE_ERROR:
                result = cell.getErrorCellValue();
                break;
            case Cell.CELL_TYPE_BLANK:
                break;
            default:
                break;
            }
        }
        return result.toString();
    }

    /**
     * 通用读取Excel
     * 
     * @Title: readExcel
     * @Date : 2014-9-11 上午11:26:53
     * @param wb
     * @return
     */
    private List<Object> readExcel(Workbook wb) {
        List<Object> rowList = new ArrayList<Object>();
        int sheetCount = 1;// 需要操作的sheet数量

        Sheet sheet = null;

        if (onlyReadOneSheet) { // 只操作一个sheet
            // 获取设定操作的sheet(如果设定了名称，按名称查，否则按索引值查)
            sheet = selectedSheetName.equals("") ? wb
                    .getSheetAt(selectedSheetIdx) : wb
                    .getSheet(selectedSheetName);
        } else { // 操作多个sheet
            sheetCount = wb.getNumberOfSheets();
        }
//        sheetCount = wb.getNumberOfSheets();

        // 获取sheet数目
        for (int t = startSheetIdx; t < sheetCount + endSheetIdx; t++) {
            // 获取设定操作的sheet
            if (!onlyReadOneSheet) {
                sheet = wb.getSheetAt(t);
            }
//            sheet = wb.getSheetAt(t);

            // 获取最后行号
            int lastRowNum = sheet.getLastRowNum();

            if (lastRowNum > 0) { // 如果>0，表示有数据
                out("
开始读取名为【" + sheet.getSheetName() + "】的内容：");
            }

            Row row = null;
            // 循环读取
            //默认从第三行开始读取
            for (int i = 1; i <= lastRowNum + endReadPos; i++) {
                row = sheet.getRow(i);
                if (row != null) {
                    List<String> cellList = new ArrayList<String>();
                    //for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {
                    //for (int j = 0; j < row.getLastCellNum(); j++) {
                    for (int j = 0; j < 21; j++) {
                        String value = getCellValue(row.getCell(j));
                        //if (!value.equals("")) {
                            cellList.add(value);
                        //}
                    }
                    rowList.add(cellList);
                }
            }
        }
        return rowList;
    }

    /**
     * 修改Excel，并另存为
     * 
     * @Title: WriteExcel
     * @Date : 2014-9-11 下午01:33:59
     * @param wb
     * @param rowList
     * @param xlsPath
     */
    private void writeExcel(Workbook wb, List<Row> rowList, String xlsPath) {

        if (wb == null) {
            out("操作文档不能为空！");
            return;
        }

        Sheet sheet = wb.getSheetAt(0);// 修改第一个sheet中的值

        // 如果每次重写，那么则从开始读取的位置写，否则果获取源文件最新的行。
        int lastRowNum = isOverWrite ? startReadPos : sheet.getLastRowNum() + 1;
        int t = 0;// 记录最新添加的行数
        out("要添加的数据总条数为：" + rowList.size());
        for (Row row : rowList) {
            if (row == null)
                continue;
            // 判断是否已经存在该数据
            int pos = findInExcel(sheet, row);

            Row r = null;// 如果数据行已经存在，则获取后重写，否则自动创建新行。
            if (pos >= 0) {
                sheet.removeRow(sheet.getRow(pos));
                r = sheet.createRow(pos);
            } else {
                r = sheet.createRow(lastRowNum + t++);
            }

            // 用于设定单元格样式
            CellStyle newstyle = wb.createCellStyle();

            // 循环为新行创建单元格
            for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
                Cell cell = r.createCell(i);// 获取数据类型
                cell.setCellValue(getCellValue(row.getCell(i)));// 复制单元格的值到新的单元格
                // cell.setCellStyle(row.getCell(i).getCellStyle());//出错
                if (row.getCell(i) == null)
                    continue;
                //copyCellStyle(row.getCell(i).getCellStyle(), newstyle); // 获取原来的单元格样式
                cell.setCellStyle(newstyle);// 设置样式
                // sheet.autoSizeColumn(i);//自动跳转列宽度
            }
        }
        out("其中检测到重复条数为:" + (rowList.size() - t) + " ，追加条数为：" + t);

        // 统一设定合并单元格
        setMergedRegion(sheet);

        try {
            // 重新将数据写入Excel中
            FileOutputStream outputStream = new FileOutputStream(xlsPath);
            wb.write(outputStream);
            outputStream.flush();
            outputStream.close();
        } catch (Exception e) {
            out("写入Excel时发生错误！ ");
            e.printStackTrace();
        }
    }

    /**
     * 查找某行数据是否在Excel表中存在，返回行数。
     * 
     * @Title: findInExcel
     * @Date : 2014-9-11 下午02:23:12
     * @param sheet
     * @param row
     * @return
     */
    private int findInExcel(Sheet sheet, Row row) {
        int pos = -1;

        try {
            // 如果覆写目标文件，或者不需要比较，则直接返回
            if (isOverWrite || !isNeedCompare) {
                return pos;
            }
            for (int i = startReadPos; i <= sheet.getLastRowNum() + endReadPos; i++) {
                Row r = sheet.getRow(i);
                if (r != null && row != null) {
                    String v1 = getCellValue(r.getCell(comparePos));
                    String v2 = getCellValue(row.getCell(comparePos));
                    if (v1.equals(v2)) {
                        pos = i;
                        break;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return pos;
    }



    /**
     * 获取合并单元格的值
     * 
     * @param sheet
     * @param row
     * @param column
     * @return
     */
    public void setMergedRegion(Sheet sheet) {
        int sheetMergeCount = sheet.getNumMergedRegions();

        for (int i = 0; i < sheetMergeCount; i++) {
            // 获取合并单元格位置
            CellRangeAddress ca = sheet.getMergedRegion(i);
            int firstRow = ca.getFirstRow();
            if (startReadPos - 1 > firstRow) {// 如果第一个合并单元格格式在正式数据的上面，则跳过。
                continue;
            }
            int lastRow = ca.getLastRow();
            int mergeRows = lastRow - firstRow;// 合并的行数
            int firstColumn = ca.getFirstColumn();
            int lastColumn = ca.getLastColumn();
            // 根据合并的单元格位置和大小，调整所有的数据行格式，
            for (int j = lastRow + 1; j <= sheet.getLastRowNum(); j++) {
                // 设定合并单元格
                sheet.addMergedRegion(new CellRangeAddress(j, j + mergeRows,
                        firstColumn, lastColumn));
                j = j + mergeRows;// 跳过已合并的行
            }
        }
    }

    /**
     * 打印消息，
     * 
     * @param msg
     *            消息内容
     * @param tr
     *            换行
     */
    private void out(String msg) {
        if (printMsg) {
            out(msg, true);
        }
    }

    /**
     * 打印消息，
     * 
     * @param msg
     *            消息内容
     * @param tr
     *            换行
     */
    private void out(String msg, boolean tr) {
        if (printMsg) {
            System.out.print(msg + (tr ? "
" : ""));
        }
    }

    public String getExcelPath() {
        return this.excelPath;
    }

    public void setExcelPath(String excelPath) {
        this.excelPath = excelPath;
    }

    public boolean isNeedCompare() {
        return isNeedCompare;
    }

    public void setNeedCompare(boolean isNeedCompare) {
        this.isNeedCompare = isNeedCompare;
    }

    public int getComparePos() {
        return comparePos;
    }

    public void setComparePos(int comparePos) {
        this.comparePos = comparePos;
    }

    public int getStartReadPos() {
        return startReadPos;
    }

    public void setStartReadPos(int startReadPos) {
        this.startReadPos = startReadPos;
    }

    public int getEndReadPos() {
        return endReadPos;
    }

    public void setEndReadPos(int endReadPos) {
        this.endReadPos = endReadPos;
    }

    public boolean isOverWrite() {
        return isOverWrite;
    }

    public void setOverWrite(boolean isOverWrite) {
        this.isOverWrite = isOverWrite;
    }

    public boolean isOnlyReadOneSheet() {
        return onlyReadOneSheet;
    }

    public void setOnlyReadOneSheet(boolean onlyReadOneSheet) {
        this.onlyReadOneSheet = onlyReadOneSheet;
    }

    public int getSelectedSheetIdx() {
        return selectedSheetIdx;
    }

    public void setSelectedSheetIdx(int selectedSheetIdx) {
        this.selectedSheetIdx = selectedSheetIdx;
    }

    public String getSelectedSheetName() {
        return selectedSheetName;
    }

    public void setSelectedSheetName(String selectedSheetName) {
        this.selectedSheetName = selectedSheetName;
    }

    public int getStartSheetIdx() {
        return startSheetIdx;
    }

    public void setStartSheetIdx(int startSheetIdx) {
        this.startSheetIdx = startSheetIdx;
    }

    public int getEndSheetIdx() {
        return endSheetIdx;
    }

    public void setEndSheetIdx(int endSheetIdx) {
        this.endSheetIdx = endSheetIdx;
    }

    public boolean isPrintMsg() {
        return printMsg;
    }

    public void setPrintMsg(boolean printMsg) {
        this.printMsg = printMsg;
    }
}