2018.11.11 10:44:52字数 96阅读 1320

除了引用SpringBoot基本包之外，还需要引入对Excel操作的包，如下：


<dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml
         此版本需高于3.17,等于也行吧-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.17</version>
        </dependency>

1. 工具类

   import org.apache.commons.collections.CollectionUtils;
   import org.apache.commons.lang3.BooleanUtils;
   import org.apache.commons.lang3.CharUtils;
   import org.apache.commons.lang3.StringUtils;
   import org.apache.commons.lang3.math.NumberUtils;
   import org.apache.poi.hssf.usermodel.HSSFDateUtil;
   import org.apache.poi.hssf.usermodel.HSSFWorkbook;
   import org.apache.poi.ss.usermodel.*;
   import org.apache.poi.xssf.usermodel.XSSFWorkbook;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.http.MediaType;
   import org.springframework.web.multipart.MultipartFile;

   import javax.servlet.http.HttpServletResponse;
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.lang.reflect.Constructor;
   import java.lang.reflect.Field;
   import java.math.BigDecimal;
   import java.net.URLEncoder;
   import java.util.*;
   import java.util.concurrent.atomic.AtomicInteger;
   import java.util.stream.Collectors;
   import java.util.stream.Stream;

   public class ExcelUtils {

       private final static Logger log = LoggerFactory.getLogger(ExcelUtils.class);
   private final static String EXCEL2003 = "xls";
   private final static String EXCEL2007 = "xlsx";
   /**
    * 读取Excel文件
    * @param path
    * @param cls
    * @param file
    * @param <T>
    * @return
    */
       public static <T> List<T> readExcel(String path, Class<T> cls,MultipartFile file){
       String fileName = file.getOriginalFilename();
       //jx
       if("".equals(fileName)){
           fileName = file.getName();
       }
       if (!fileName.matches("^.+\\.(?i)(xls)$") &amp;&amp; !fileName.matches("^.+\\.(?i)(xlsx)$")) {
           log.error("上传文件格式不正确");
       }
       List&lt;T&gt; dataList = new ArrayList&lt;&gt;();
       //03，07两种文档方式实现下面这个接口
       Workbook workbook = null;
       try {
           InputStream is = file.getInputStream();
           if (fileName.endsWith(EXCEL2007)) {</code></pre>
   //                FileInputStream is = new FileInputStream(new File(path));
   
                       workbook = new XSSFWorkbook(is);
   
                   }
   
                   if (fileName.endsWith(EXCEL2003)) {
   
   //                FileInputStream is = new FileInputStream(new File(path));
   
                       workbook = new HSSFWorkbook(is);
   
                   }
   
                   if (workbook != null) {
   
                       //类映射  注解 value-->bean columns
   
                       Map> classMap = new HashMap<>();
   
                       List fields = Stream.of(cls.getDeclaredFields()).collect(Collectors.toList());
   
                       fields.forEach(
   
                               field -> {
   
                                   ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
   
                                   if (annotation != null) {
   
                                       String value = annotation.value();
   
                                       if (StringUtils.isBlank(value)) {
   
                                           return;//return起到的作用和continue是相同的 语法
   
                                       }
   
                                       if (!classMap.containsKey(value)) {
   
                                           classMap.put(value, new ArrayList<>());
   
                                       }
   
                                       field.setAccessible(true);
   
                                       classMap.get(value).add(field);
   
                                   }
   
                               }
   
                       );
   
                       //索引-->columns
   
                       Map> reflectionMap = new HashMap<>(16);
   
                       //默认读取第一个sheet
   
                       Sheet sheet = workbook.getSheetAt(0);
                   boolean firstRow = true;
                   for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {
                       Row row = sheet.getRow(i);
                       //首行  提取注解
                       if (firstRow) {
                           for (int j = row.getFirstCellNum(); j <= row.getLastCellNum(); j++) {
                               Cell cell = row.getCell(j);
                               String cellValue = getCellValue(cell);
                               if (classMap.containsKey(cellValue)) {
                                   reflectionMap.put(j, classMap.get(cellValue));
                               }
                           }
                           firstRow = false;
                       } else {
                           //忽略空白行
                           if (row == null) {
                               continue;
                           }
                           try {
                               T t = cls.newInstance();
                               //判断是否为空白行
                               boolean allBlank = true;
                               for (int j = row.getFirstCellNum(); j <= row.getLastCellNum(); j++) {
                                   if (reflectionMap.containsKey(j)) {
                                       Cell cell = row.getCell(j);
                                       String cellValue = getCellValue(cell);
                                       if (StringUtils.isNotBlank(cellValue)) {
                                           allBlank = false;
                                       }
                                       List<Field> fieldList = reflectionMap.get(j);
                                       fieldList.forEach(
                                               x -> {
                                                   try {
                                                       handleField(t, cellValue, x);
                                                   } catch (Exception e) {
                                                       log.error(String.format("reflect field:%s value:%s exception!", x.getName(), cellValue), e);
                                                   }
                                               }
                                       );
                                   }
                               }
                               if (!allBlank) {
                                   dataList.add(t);
                               } else {
                                   log.warn(String.format("row:%s is blank ignore!", i));
                               }
                           } catch (Exception e) {
                               log.error(String.format("parse row:%s exception!", i), e);
                           }
                       }
                   }
               }
           } catch (Exception e) {
               log.error(String.format("parse excel exception!"), e);
           } finally {
               if (workbook != null) {
                   try {
                       workbook.close();
                   } catch (Exception e) {
                       log.error(String.format("parse excel exception!"), e);
                   }
               }
           }
           return dataList;
       }
   private static &lt;T&gt; void handleField(T t, String value, Field field) throws Exception {
       Class&lt;?&gt; type = field.getType();
       if (type == null || type == void.class || StringUtils.isBlank(value)) {
           return;
       }
       if (type == Object.class) {
           field.set(t, value);
           //数字类型
       } else if (type.getSuperclass() == null || type.getSuperclass() == Number.class) {
           if (type == int.class || type == Integer.class) {
               field.set(t, NumberUtils.toInt(value));
           } else if (type == long.class || type == Long.class) {
               field.set(t, NumberUtils.toLong(value));
           } else if (type == byte.class || type == Byte.class) {
               field.set(t, NumberUtils.toByte(value));
           } else if (type == short.class || type == Short.class) {
               field.set(t, NumberUtils.toShort(value));
           } else if (type == double.class || type == Double.class) {
               field.set(t, NumberUtils.toDouble(value));
           } else if (type == float.class || type == Float.class) {
               field.set(t, NumberUtils.toFloat(value));
           } else if (type == char.class || type == Character.class) {
               field.set(t, CharUtils.toChar(value));
           } else if (type == boolean.class) {
               field.set(t, BooleanUtils.toBoolean(value));
           } else if (type == BigDecimal.class) {
               field.set(t, new BigDecimal(value));
           }
       } else if (type == Boolean.class) {
           field.set(t, BooleanUtils.toBoolean(value));
       } else if (type == Date.class) {
           //
           field.set(t, value);
       } else if (type == String.class) {
           field.set(t, value);
       } else {
           Constructor&lt;?&gt; constructor = type.getConstructor(String.class);
           field.set(t, constructor.newInstance(value));
       }
   }
   
   private static String getCellValue(Cell cell) {
       if (cell == null) {
           return "";
       }
       //更新，新版poi不建议使用以下方法,使用getCellTypeEnum代替getCellType
      /* if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
           if (DateUtil.isCellDateFormatted(cell)) {
               return HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();
           } else {
               return new BigDecimal(cell.getNumericCellValue()).toString();
           }
       } else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
           return StringUtils.trimToEmpty(cell.getStringCellValue());
       } else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) {
           return StringUtils.trimToEmpty(cell.getCellFormula());
       } else if (cell.getCellType() == Cell.CELL_TYPE_BLANK) {
           return "";
       } else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
           return String.valueOf(cell.getBooleanCellValue());
       } else if (cell.getCellType() == Cell.CELL_TYPE_ERROR) {
           return "ERROR";*/
       if (cell.getCellTypeEnum() == CellType.NUMERIC) {
           if (DateUtil.isCellDateFormatted(cell)) {
               return HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();
           } else {
               return new BigDecimal(cell.getNumericCellValue()).toString();
           }
       } else if (cell.getCellTypeEnum() == CellType.STRING) {
           return StringUtils.trimToEmpty(cell.getStringCellValue());
       } else if (cell.getCellTypeEnum() == CellType.FORMULA) {
           return StringUtils.trimToEmpty(cell.getCellFormula());
       } else if (cell.getCellTypeEnum() == CellType.BLANK) {
           return "";
       } else if (cell.getCellTypeEnum() == CellType.BOOLEAN) {
           return String.valueOf(cell.getBooleanCellValue());
       } else if (cell.getCellTypeEnum() == CellType.ERROR) {
           return "ERROR";
       } else {
           return cell.toString().trim();
       }
   
   }
   
   public static &lt;T&gt; void writeExcel(HttpServletResponse response, List&lt;T&gt; dataList, Class&lt;T&gt; cls){
       Field[] fields = cls.getDeclaredFields();
       List&lt;Field&gt; fieldList = Arrays.stream(fields)
               .filter(field -&gt; {
                   ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                   if (annotation != null &amp;&amp; annotation.col() &gt; 0) {
                       field.setAccessible(true);
                       return true;
                   }
                   return false;
               }).sorted(Comparator.comparing(field -&gt; {
                   int col = 0;
                   ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                   if (annotation != null) {
                       col = annotation.col();
                   }
                   return col;
               })).collect(Collectors.toList());
   
       Workbook wb = new XSSFWorkbook();
       Sheet sheet = wb.createSheet("Sheet1");
       AtomicInteger ai = new AtomicInteger();
       {
           Row row = sheet.createRow(ai.getAndIncrement());
           AtomicInteger aj = new AtomicInteger();
           //写入头部
           fieldList.forEach(field -&gt; {
               ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
               String columnName = "";
               if (annotation != null) {
                   columnName = annotation.value();
               }
               Cell cell = row.createCell(aj.getAndIncrement());
   
               CellStyle cellStyle = wb.createCellStyle();
               cellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex());
               cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
               cellStyle.setAlignment(HorizontalAlignment.CENTER);
   
               Font font = wb.createFont();
               font.setBold(false);
               cellStyle.setFont(font);
               cell.setCellStyle(cellStyle);
               cell.setCellValue(columnName);
           });
       }
       if (CollectionUtils.isNotEmpty(dataList)) {
           dataList.forEach(t -&gt; {
               Row row1 = sheet.createRow(ai.getAndIncrement());
               AtomicInteger aj = new AtomicInteger();
               fieldList.forEach(field -&gt; {
                   Class&lt;?&gt; type = field.getType();
                   Object value = "";
                   try {
                       value = field.get(t);
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
                   Cell cell = row1.createCell(aj.getAndIncrement());
                   if (value != null) {
                       if (type == Date.class) {
                           cell.setCellValue(value.toString());
                       } else {
                           cell.setCellValue(value.toString());
                       }
                       cell.setCellValue(value.toString());
                   }
               });
           });
       }
       //冻结窗格
       wb.getSheet("Sheet1").createFreezePane(0, 1, 0, 1);
       //浏览器下载excel
       buildExcelDocument("jocytest.xlsx",wb,response);
       //生成excel文件</code></pre>
   //        buildExcelFile(".\default.xlsx",wb);
   
           }
       /**
        * 浏览器下载excel
        * @param fileName
        * @param wb
        * @param response
        */
   private static  void  buildExcelDocument(String fileName, Workbook wb,HttpServletResponse response){
       try {
           response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
           response.setHeader("Content-Disposition", "attachment;filename="+URLEncoder.encode(fileName, "utf-8"));
           response.flushBuffer();
           wb.write(response.getOutputStream());
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
   
   /**
    * 生成excel文件
    * @param path 生成excel路径
    * @param wb
    */
   private static  void  buildExcelFile(String path, Workbook wb){
   
       File file = new File(path);
       if (file.exists()) {
           file.delete();
       }
       try {
           wb.write(new FileOutputStream(file));
       } catch (Exception e) {
           e.printStackTrace();
       }
   }</code></pre>
   }

import java.lang.annotation.*;

/**
 * 定义了实体类所需要的Bean
 */

@Target({ElementType.FIELD}) //该注解作用在域上
/**
 * 生命周期
 * 注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在，
 * 保存到class对象中，可以通过反射来获取
 */

@Retention(RetentionPolicy.RUNTIME)

@Documented
public @interface ExcelColumn {

    String value() default "";

    int col() default 0;
}


import lombok.Setter;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;

@Entity
@Table(name = "Excel")
@Getter
@Setter
public class TestExcel {
    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid",strategy = "uuid")
    private String id;
    @ExcelColumn(value = "excelId",col = 1)
    private String excelId;
    @ExcelColumn(value = "markId", col = 2)
    private String markId;

    @ExcelColumn(value = "toaluv", col = 3)
    private String toaluv;

    @ExcelColumn(value = "date", col = 4)
    private String date;

    @ExcelColumn(value = "clientVer", col = 5)
    private String clientVer;
}

public interface ExcelDao extends JpaRepository<TestExcel,String> {
}

Service(value = "excelService")
public class ExcelServiceImpl implements ExcelService {

    @Autowired
    ExcelDao excelDao;
    @Override
    public List<TestExcel> findAll() {
        return excelDao.findAll();
    }

    public void saveAll(List<TestExcel> excels){
        excelDao.saveAll(excels);
    }
}


import **.excelImportExport.entity.TestExcel;
import **.excelImportExport.service.ExcelService;
import **.excelImportExport.utils.ExcelUtils;
import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;

@RestController
@RequestMapping("/excel")
public class ExcelController  {

    @Autowired
    ExcelService excelService;

    /**
     * Excel导出功能
     * @param response
     * @throws IOException
     */
    @GetMapping(value = "/exportExcel")
    public void exportExcel(HttpServletResponse response)  throws IOException {

        List<TestExcel> resultList = excelService.findAll();

        long t1 = System.currentTimeMillis();
        ExcelUtils.writeExcel(response, resultList, TestExcel.class);
        long t2 = System.currentTimeMillis();
        System.out.println(String.format("write over! cost:%sms", (t2 - t1)));
    }

    /**
     * Excel导入功能
     * @param file
     * @throws IOException
     */

    @PostMapping(value = "/readExcel")
    public void readExcel(MultipartFile file) throws IOException {

       //测试时用此方法将File->MultipartFile，上传文件时直接调用readExcel方法即可
        MockMultipartFile mockMultipartFile    =
                new MockMultipartFile("jocy.xlsx", new FileInputStream(new File("/Users/Downloads/jocy.xlsx")));
        long t1 = System.currentTimeMillis();
        //List<TestExcel> list = ExcelUtils.readExcel("", TestExcel.class,file);
        List<TestExcel> list = ExcelUtils.readExcel("", TestExcel.class,mockMultipartFile);
        long t2 = System.currentTimeMillis();
        excelService.saveAll(list);
        System.out.println(String.format("read over! cost:%sms", (t2 - t1)));
        list.forEach(
                b -> System.out.println(JSON.toJSONString(b))
        );
    }
}