easyexcel实现简单的上传下载

需要导入的pom：

        <!--        easyexcel-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.0.5</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.71</version>
        </dependency>

<!--        easyexcel-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.0.5</version>
        </dependency>

controller：

    /**
     * 导出数据
     */
    @RequestMapping("/export")
    public void export(HttpServletResponse response) throws IOException {
        response.setHeader("Content-Disposition",
                "attachment;fileName=" + URLEncoder.encode("地址.xlsx", "UTF-8"));
        ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).build();
        WriteSheet sheet = EasyExcel.writerSheet(0).head(tAddressCity.class).build();
        List<addressDto> list = addressService.filefindAll();
        excelWriter.write(list, sheet);
        excelWriter.finish();
    }

    /**
     * 下载模板
     */
    @RequestMapping("/downloadModel")
    public void downloadModel(HttpServletResponse response) throws IOException {
        response.reset();
        response.setContentType("application/octet-stream");
        response.setCharacterEncoding("utf-8");
        response.setHeader("Content-Disposition",
                "attachment;fileName=" + URLEncoder.encode("模板.xlsx", "UTF-8"));
        ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).build();
        WriteSheet sheet = EasyExcel.writerSheet(0).head(tAddressCity.class).build();
        excelWriter.write(Collections.emptyList(), sheet);
        excelWriter.finish();
    }

    /**
     * @param serviceFile excel文件
     * @return 注意请求参数是 file
     * @throws IOException 异常
     */
    @PostMapping(value = "/upload")
    @ResponseBody
    public String uploadEasyExcel(@RequestParam(value = "file") MultipartFile serviceFile) throws IOException {
        ExcelReader excelReader = null;
        @Cleanup InputStream in = null;
        try {
            in = serviceFile.getInputStream();
            //注意这里需要解析的数据 User3.class
            excelReader = EasyExcel.read(in, tAddressCity.class, new ExcelListener()).build();
            ReadSheet readSheet = EasyExcel.readSheet(0).build();
            excelReader.read(readSheet);
        } catch (IOException ex) {
            log.error("import excel to db fail", ex);
        }
         finally {
             in.close();
             // 这里一定别忘记关闭，读的时候会创建临时文件，到时磁盘会崩 @Cleanup注解更加简洁一些哈
             if (excelReader != null) {
                 excelReader.finish();
             }
         }
        return "解析成功,并入库";
    }

监听器：

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.yjxxt.crm.bean.tAddressCity;
import com.yjxxt.crm.dao.AddressDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;

/**
 * ExcelListener:Excel监听器
 * @author liuyang
 */
@Slf4j
public class ExcelListener extends AnalysisEventListener {
    @Autowired
    AddressDao addressDao;
    private static final int BATCH_COUNT = 1000;
    private List<Object> objectList = new ArrayList(10);
    @Override
    public void invoke(Object o, AnalysisContext analysisContext) {
        log.info("解析到一条数据:{}", JSON.toJSONString(o));
        //数据存储到list，
        objectList.add(o);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (objectList.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            objectList.clear();
        }
    }
    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
//        saveData();
        log.info("所有数据解析完成(此时可以做点其他事情)！");
    }

    /**
     * 入库
     */
    private void saveData() {
        for (Object o : objectList) {
            addressDao.insert((tAddressCity) o);
        }
        log.info("{}条数据，开始存储数据库！", objectList.size());
        //这个方法自己实现  能完成保存数据入库即可
        log.info("模拟数据库保存数据:" + objectList);
    }

    public List<Object> getObjectList() {
        return objectList;
    }

    public void setObjectList(List<Object> objectList) {
        this.objectList = objectList;
    }

另外版本：

    @ApiOperation(value = "导入单个sheet数据")
    @PostMapping("/importSheet")
    public void importSheet(@RequestParam("multipartFile") MultipartFile multipartFile) {
        try {
            InputStream inputStream = multipartFile.getInputStream();
            //异步读取所有sheet数据,可在sheet方法参数中指定sheet索引,sheet名称
            EasyExcel.read(inputStream, User.class, new UserDataListener(userService)).sheet().doRead();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @ApiOperation(value = "导入多个sheet数据")
    @PostMapping("/importSheets")
    public void importSheets(@RequestParam("multipartFile") MultipartFile multipartFile) {
        ExcelReader excelReader = null;
        try {
            InputStream inputStream = multipartFile.getInputStream();
            excelReader = EasyExcel.read(inputStream).build();
            ReadSheet readSheet1 =
                    //构建ExcelReader对象
                    EasyExcel.readSheet(0).head(User.class).registerReadListener(new UserDataListener(userService)).build();
            ReadSheet readSheet2 =
                    //构建ExcelReader对象
                    EasyExcel.readSheet(1).head(Achievement.class).registerReadListener(new AchievementDataListener(achievementService)).build();
            //这里注意 一定要把sheet1 sheet2 一起传进去
            excelReader.read(readSheet1, readSheet2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (excelReader != null) {
                // 这里千万别忘记关闭，读的时候会创建临时文件，到时磁盘会崩的
                excelReader.finish();
            }
        }
    }

    @ApiOperation(value = "导出数据", produces = "application/octet-stream")
    @PostMapping("/simpleWrite")
    public void simpleWrite(HttpServletResponse response) {
        userService.simpleWrite(response);
    }

    @ApiOperation(value = "分页导出数据", produces = "application/octet-stream")
    @PostMapping("/pageWrite")
    public void pageWrite(HttpServletResponse response) {
        userService.pageWrite(response);
    }

    @ApiOperation(value = "分页导出多sheet数据", produces = "application/octet-stream")
    @PostMapping("/pageWriteSheets")
    public void pageWriteSheets(HttpServletResponse response) {
        userService.pageWriteSheets(response);
    }

    @ApiOperation(value = "分页导出多sheet数据发送邮件")
    @PostMapping("/writeSendMail")
    public void writeSendMail(HttpServletResponse response) throws IOException {
        userService.writeSendMail(response);
    }
}

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.easyexcel.dao.User;
import com.easyexcel.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * 模板的读取类
 */
public class UserDataListener extends AnalysisEventListener<User> {
    private static final Logger LOGGER = LoggerFactory.getLogger(UserDataListener.class);
    /**
     * 每隔3000条存储数据库,然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 3000;
    List<User> list = new ArrayList<>();

    private UserService userService;


    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param userService
     */
    public UserDataListener(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void invoke(User data, AnalysisContext context) {
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
        list.add(data);
        if (list.size() >= BATCH_COUNT) {
            saveData();
            list.clear();
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        saveData();
        LOGGER.info("所有数据解析完成！");
    }

    /**
     * 加上存储数据库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        userService.insertBatch(list);
        LOGGER.info("存储数据库成功！");
    }
}