devbox
编程探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

EasyExcel ----- 实现数据库数据 导出为Excel表和Excel表导入数据功能

作者：编程探险家 | 2024-02-05 15:31:08

赞

踩

EasyExcel ----- 实现数据库数据 导出为Excel表和Excel表导入数据功能

一、EasyExcel简介

        Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。easyexcel重写了poi对07版Excel的解析，能够原本一个3M的excel用POI sax依然需要100M左右内存降低到KB级别，并且再大的excel不会出现内存溢出，03版依赖POI的sax模式。在上层做了模型转换的封装，让使用者更加简单方便。

       EasyExcel阿里官方文档：https://github.com/alibaba/easyexcel

二、EasyExcel的简单使用

1、搭建EasyExcel项目环境

1.1、添加EasyExcel所需依赖

  1. <properties>
  2.     <poi.version>3.17</poi.version>
  3.     <spring.version>5.1.5.RELEASE</spring.version>
  4. </properties>
  5.  
  6. <dependencies>
  7.     <!-- ******************** EasyExcel依赖包 开始 ******************** -->
  8.     <!-- xls格式 excel依赖包 -->
  9.     <dependency>
  10.         <groupId>org.apache.poi</groupId>
  11.         <artifactId>poi</artifactId>
  12.         <version>${poi.version}</version>
  13.     </dependency>
  14.     
  15.     <!--xlsx格式 excel依赖包-->
  16.     <dependency>
  17.         <groupId>org.apache.poi</groupId>
  18.         <artifactId>poi-ooxml</artifactId>
  19.         <version>${poi.version}</version>
  20.     </dependency>
  21.        
  22.     <!-- EasyExcel依赖包 -->
  23.     <dependency>
  24.         <groupId>com.alibaba</groupId>
  25.         <artifactId>easyexcel</artifactId>
  26.         <version>1.1.2-beta5</version>
  27.      </dependency>
  28.      <!-- ******************** EasyExcel依赖包 结束 ******************** -->
  29.      
  30.      <!-- MySql驱动 -->
  31.      <dependency>
  32.          <groupId>mysql</groupId>
  33.          <artifactId>mysql-connector-java</artifactId>
  34.          <version>5.1.47</version>
  35.      </dependency>
  36.  
  37.      <!-- Druid连接池 -->
  38.      <dependency>
  39.          <groupId>com.alibaba</groupId>
  40.          <artifactId>druid</artifactId>
  41.          <version>1.1.10</version>
  42.      </dependency>
  43.      
  44.      <!-- Mybatis -->
  45.      <dependency>
  46.          <groupId>org.mybatis</groupId>
  47.          <artifactId>mybatis</artifactId>
  48.          <version>3.4.6</version>
  49.      </dependency>
  50.      <dependency>
  51.          <groupId>org.mybatis</groupId>
  52.          <artifactId>mybatis-spring</artifactId>
  53.          <version>1.3.2</version>
  54.      </dependency>
  55.  
  56.      <!-- Lombok -->
  57.      <dependency>
  58.          <groupId>org.projectlombok</groupId>
  59.          <artifactId>lombok</artifactId>
  60.          <version>1.16.20</version>
  61.          <scope>provided</scope>
  62.      </dependency>
  63.      
  64.      <!-- javax.servlet-api -->
  65.      <dependency>
  66.          <groupId>javax.servlet</groupId>
  67.          <artifactId>javax.servlet-api</artifactId>
  68.          <version>3.1.0</version>
  69.          <scope>provided</scope>
  70.      </dependency>
  71.  
  72.      <!-- Spring -->
  73.      <dependency>
  74.          <groupId>org.springframework</groupId>
  75.          <artifactId>spring-context</artifactId>
  76.          <version>${spring.version}</version>
  77.      </dependency>
  78.      <dependency>
  79.          <groupId>org.springframework</groupId>
  80.          <artifactId>spring-beans</artifactId>
  81.          <version>${spring.version}</version>
  82.      </dependency>
  83.      <dependency>
  84.          <groupId>org.springframework</groupId>
  85.          <artifactId>spring-webmvc</artifactId>
  86.          <version>${spring.version}</version>
  87.      </dependency>
  88.      <dependency>
  89.          <groupId>org.springframework</groupId>
  90.          <artifactId>spring-jdbc</artifactId>
  91.          <version>${spring.version}</version>
  92.      </dependency>
  93.      <dependency>
  94.          <groupId>org.springframework</groupId>
  95.          <artifactId>spring-aspects</artifactId>
  96.          <version>${spring.version}</version>
  97.      </dependency>
  98.      <dependency>
  99.          <groupId>org.springframework</groupId>
  100.          <artifactId>spring-jms</artifactId>
  101.          <version>${spring.version}</version>
  102.      </dependency>
  103.      <dependency>
  104.          <groupId>org.springframework</groupId>
  105.          <artifactId>spring-context-support</artifactId>
  106.          <version>${spring.version}</version>
  107.      </dependency>
  108.      
  109.      <!-- junit单元测试 -->
  110.      <dependency>
  111.          <groupId>junit</groupId>
  112.          <artifactId>junit</artifactId>
  113.          <version>4.11</version>
  114.          <scope>test</scope>
  115.      </dependency>
  116.  
  117. </dependencies>
  118.  
  119.       
  120.      <!-- 打包资源文件 -->
  121.      <build>
  122.         <resources>
  123.             <resource>
  124.                 <directory>src/main/java</directory>
  125.                 <includes>
  126.                     <include>**/*.properties</include>
  127.                     <include>**/*.xml</include>
  128.                 </includes>
  129.             </resource>
  130.         </resources>
  131.     </build>
  132.

1.2、设计并创建对应的user数据库表

  1. CREATE TABLE `user` (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,
  3.   `name` varchar(11) DEFAULT NULL,
  4.   `sex` varchar(3) DEFAULT NULL,
  5.   `age` int(4) DEFAULT NULL,
  6.   `birthday` date DEFAULT NULL,
  7.   PRIMARY KEY (`id`)
  8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

1.3、在resources资源目录下，创建一个properties目录，并创建和编写jdbc.properties配置文件，设置jdbc连接数据库的四个参数

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/easy_excel?rewriteBatchedStatements=true&allowMultiQueries=true&useUnicode=true&characterEncoding=utf-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
  3. jdbc.username=root
  4. jdbc.password=123456
  5.  
  6. ---------------------------mysql 连接数据库参数设置介绍
  7.  
  8. //设置JDBC驱动批量执行SQL
  9. rewriteBatchedStatements=true 
  10.  
  11. //设置允许JDBC连接能够一次执行多条增删改查操作,假如没配这个参数的话，所有批量操作都会报错。
  12. allowMultiQueries=true       
  13.  
  14. //指定字符的编码、解码格式
  15. useUnicode=true&characterEncoding=utf-8  
  16.  
  17. //在使用数据库连接池的情况下,最好设置如下两个参数
  18. autoReconnect=true  //当数据库连接异常中断时，自动重新连接
  19. failOverReadOnly=false   //自动重连成功后，连接是否设置为只读
  20.  
  21. //设置关闭SSL连接
  22. useSSL=false

1.4、在resources资源目录下，创建一个spring目录，并创建和编写applicationContext-spring.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xmlns:tx="http://www.springframework.org/schema/tx"
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
  9. 	   http://www.springframework.org/schema/context
  10. 	   http://www.springframework.org/schema/context/spring-context-4.2.xsd
  11. 	   http://www.springframework.org/schema/tx
  12. 	   http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
  13.        http://www.springframework.org/schema/aop
  14.        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
  15.  
  16.     <!-- 配置包扫描器，扫描注解的类 -->
  17.     <context:component-scan base-package="com.easyexcel.service"/>
  18.  
  19.     <!-- 加载配置文件 -->
  20.     <context:property-placeholder location="classpath:properties/jdbc.properties" />
  21.     <!-- 数据库连接池 -->
  22.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
  23.         <property name="url" value="${jdbc.url}" />
  24.         <property name="username" value="${jdbc.username}" />
  25.         <property name="password" value="${jdbc.password}" />
  26.         <property name="driverClassName" value="${jdbc.driver}" />
  27.         <property name="maxActive" value="10" />
  28.         <property name="minIdle" value="5" />
  29.     </bean>
  30.  
  31.     <!-- 让spring管理sqlsessionfactory 使用mybatis和spring整合包中的 -->
  32.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  33.         <!-- 数据库连接池 -->
  34.         <property name="dataSource" ref="dataSource" />
  35.     </bean>
  36.  
  37.     <!-- MapperScannerConfigurer 自动扫描将Mapper接口生成代理注入到spring -->
  38.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  39.         <!--basePackage指定要扫描的包，在此包之下的映射器都会被搜索到。可指定多个包，包与包之间用逗号或分号分隔-->
  40.         <property name="basePackage" value="com.easyexcel.mapper" />
  41.     </bean>
  42.  
  43.     <!-- 事务管理器 -->
  44.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  45.         <!-- 数据源 -->
  46.         <property name="dataSource" ref="dataSource" />
  47.     </bean>
  48.  
  49.     <!-- 通知 -->
  50.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  51.         <tx:attributes>
  52.             <!-- 传播行为 -->
  53.             <tx:method name="save*" propagation="REQUIRED" />
  54.             <tx:method name="insert*" propagation="REQUIRED" />
  55.             <tx:method name="add*" propagation="REQUIRED" />
  56.             <tx:method name="create*" propagation="REQUIRED" />
  57.             <tx:method name="delete*" propagation="REQUIRED" />
  58.             <tx:method name="update*" propagation="REQUIRED" />
  59.             <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
  60.             <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
  61.             <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
  62.         </tx:attributes>
  63.     </tx:advice>
  64.     <!-- 切面 -->
  65.     <aop:config>
  66.         <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.easyexcel.service.*.*(..))" />
  67.     </aop:config>
  68.  
  69. </beans>

2、使用EasyExcel导入、导出带有表头注解的Java实体类模型的Excel

2.1、编写与数据库表对应的带有表头注解的实体类模型 (需要继承BaseRowModel类)

  1. package com.easyexcel.pojo;
  2.  
  3. import com.alibaba.excel.annotation.ExcelProperty;
  4. import com.alibaba.excel.metadata.BaseRowModel;
  5. import lombok.Getter;
  6. import lombok.NoArgsConstructor;
  7. import lombok.Setter;
  8. import lombok.ToString;
  9.  
  10. import java.io.Serializable;
  11. import java.util.Date;
  12.  
  13. @Getter
  14. @Setter
  15. @ToString
  16. @NoArgsConstructor
  17. public class User extends BaseRowModel implements Serializable {
  18.  
  19.     /**
  20.      * @ExcelProperty(value = "表头名称",index = 0,format = "yyyy-MM-dd")
  21.      * value是表头数据，默认会写在excel的表头位置
  22.      * index代表第几列，从0开始
  23.      * format表示时间日期输出到Excel表中的格式
  24.      */
  25.     @ExcelProperty(value="主键id",index=0)
  26.     private Integer id;
  27.     @ExcelProperty(value="姓名",index=1)
  28.     private String name;
  29.     @ExcelProperty(value="性别",index=2)
  30.     private String sex;
  31.     @ExcelProperty(value="年龄",index=3)
  32.     private Integer age;
  33.     @ExcelProperty(value="生日",index=4,format="yyyy-MM-dd")
  34.     private Date birthday;
  35.  
  36.     private static final long serialVersionUID = 1L;
  37.  
  38. }

2.2、编写与数据库交互的UserMapper接口

  1. package com.easyexcel.mapper;
  2.  
  3. import com.easyexcel.pojo.User;
  4. import org.apache.ibatis.annotations.Param;
  5.  
  6. import java.util.List;
  7.  
  8. public interface UserMapper {
  9.  
  10.     /**
  11.      * 查询所有用户信息
  12.      * @return List<User>
  13.      */
  14.     List<User> selectAllOfUser();
  15.  
  16.     /**
  17.      * 批量插入所有用户信息
  18.      * @param users 用户信息集合
  19.      * @return int
  20.      */
  21.     int insertAllOfUser(@Param("users") List<User> users);
  22.  
  23. }

2.3、编写与UserMapper接口对应的UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.easyexcel.mapper.UserMapper" >
  4.   <resultMap id="BaseResultMap" type="com.easyexcel.pojo.User" >
  5.     <id column="id" property="id" jdbcType="INTEGER" />
  6.     <result column="name" property="name" jdbcType="VARCHAR" />
  7.     <result column="sex" property="sex" jdbcType="VARCHAR" />
  8.     <result column="age" property="age" jdbcType="INTEGER" />
  9.     <result column="birthday" property="birthday" jdbcType="DATE" />
  10.   </resultMap>
  11.  
  12.   <sql id="Base_Column_List" >
  13.     id, name, sex, age, birthday
  14.   </sql>
  15.  
  16.   <select id="selectAllOfUser" resultMap="BaseResultMap">
  17.     select
  18.     <include refid="Base_Column_List" />
  19.     from user
  20.   </select>
  21.  
  22.   <insert id="insertAllOfUser" parameterType="com.easyexcel.pojo.User" >
  23.     insert into user 
  24.     (<include refid="Base_Column_List" />)
  25.     values
  26.     <foreach collection="users" item="user" separator=",">
  27.       (#{user.id},#{user.name},#{user.sex},#{user.age},#{user.birthday})
  28.     </foreach>
  29.   </insert>
  30.   
  31. </mapper>

2.4、编写UserService接口

  1. package com.easyexcel.service;
  2.  
  3. import com.easyexcel.pojo.User;
  4. import java.util.List;
  5.  
  6. public interface UserService {
  7.  
  8.     /**
  9.      * 查询所有用户信息
  10.      *
  11.      * @return List<User> User实体类对象集合
  12.      */
  13.     List<User> selectAllOfUser();
  14.  
  15.     /**
  16.      * 批量插入所有用户信息
  17.      *
  18.      * @param users 用户信息集合
  19.      * @return int 影响行数
  20.      */
  21.     int insertAllOfUser(List<User> users);
  22.  
  23. }

2.5、编写UserService接口的实现类UserServiceImpl

  1. package com.easyexcel.service.impl;
  2.  
  3. import com.easyexcel.mapper.UserMapper;
  4. import com.easyexcel.pojo.User;
  5. import com.easyexcel.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8.  
  9. import java.util.List;
  10.  
  11.  
  12. @Service
  13. public class UserServiceImpl implements UserService {
  14.  
  15.     @Autowired
  16.     private UserMapper userMapper;
  17.  
  18.     @Override
  19.     public List<User> selectAllOfUser() {
  20.         return userMapper.selectAllOfUser();
  21.     }
  22.  
  23.     @Override
  24.     public int insertAllOfUser(List<User> users) {
  25.         return userMapper.insertAllOfUser(users);
  26.     }
  27. }

2.6、编写ExcelException异常处理器

  1. package com.easyexcel.exception;
  2.  
  3. public class ExcelException extends RuntimeException{
  4.  
  5.     public ExcelException(String message){
  6.         super(message);
  7.     }
  8. }

2.7、编写ExcelListener监听类

  1. package com.easyexcel.listener;
  2.  
  3. import com.alibaba.excel.context.AnalysisContext;
  4. import com.alibaba.excel.event.AnalysisEventListener;
  5.  
  6. import java.util.ArrayList;
  7. import java.util.List;
  8.  
  9.  
  10. public class ExcelListener extends AnalysisEventListener{
  11.  
  12.     /**
  13.      *  自定义用于暂时存储data。
  14.      *  可以通过实例获取该值
  15.      */
  16.     private List<Object> datas = new ArrayList<Object>();
  17.  
  18.     @Override
  19.     public void invoke(Object object, AnalysisContext analysisContext) {
  20.  
  21.         System.out.println("当前行："+ analysisContext.getCurrentRowNum());
  22.         System.out.println(object);
  23.         //数据存储到list，供批量处理，或后续自己业务逻辑处理。
  24.         datas.add(object);
  25.         //根据自己业务做处理
  26.         doSomething(object);
  27.  
  28.     }
  29.  
  30.     @Override
  31.     public void doAfterAllAnalysed(AnalysisContext analysisContext) {
  32.          //解析结束销毁不用的资源
  33.         // datas.clear();
  34.     }
  35.  
  36.     public List<Object> getDatas() {
  37.         return datas;
  38.     }
  39.  
  40.     public void setDatas(List<Object> datas) {
  41.         this.datas = datas;
  42.     }
  43.  
  44.     private void doSomething(Object object){
  45.         //入库调用接口
  46.     }
  47. }

2.8、编写ExcelUtils工具类，可以直接调用该工具类的方法完成 Excel 的导入或者导出

  1. package com.easyexcel.utils;
  2.  
  3. import com.alibaba.excel.EasyExcelFactory;
  4. import com.alibaba.excel.ExcelReader;
  5. import com.alibaba.excel.ExcelWriter;
  6. import com.alibaba.excel.metadata.BaseRowModel;
  7. import com.alibaba.excel.metadata.Sheet;
  8. import com.easyexcel.exception.ExcelException;
  9. import com.easyexcel.listener.ExcelListener;
  10. import org.springframework.web.multipart.MultipartFile;
  11.  
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.*;
  14. import java.text.SimpleDateFormat;
  15. import java.util.Date;
  16. import java.util.List;
  17.  
  18.  
  19. public class ExcelUtils {
  20.  
  21.     //--------------------------------------------导入Excel--------------------------------------------
  22.  
  23.     /**
  24.      * 读取带有表头注解的Java实体类模型
  25.      * 读取多个sheet 的Excel
  26.      *
  27.      * @param inputStream 字节输入流
  28.      * @param clazz 类的字节码文件对象
  29.      * @return List<?> 实体对象集合
  30.      */
  31.     public static List<?> readExcel(InputStream inputStream, Class clazz){
  32.  
  33.         BufferedInputStream bufferedInputStream = null;
  34.         ExcelListener excelListener = null;
  35.  
  36.         try {
  37.             //包装成缓冲字节输入流
  38.             bufferedInputStream = new BufferedInputStream(inputStream);
  39.             //解析Excel表格的每行数据
  40.             excelListener = new ExcelListener();
  41.             //读取Excel表格数据
  42.             ExcelReader excelReader = EasyExcelFactory.getReader(bufferedInputStream,excelListener);
  43.             //循环读取多个Sheet
  44.             for(Sheet sheet : excelReader.getSheets()){
  45.                   sheet.setClazz(clazz);
  46.                   excelReader.read(sheet);
  47.             }
  48.  
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         } finally {
  52.             //关闭缓冲字节输入流，释放资源
  53.             if(bufferedInputStream != null){
  54.                 try {
  55.                     bufferedInputStream.close();
  56.                 } catch (IOException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.             }
  60.         }
  61.  
  62.         return excelListener.getDatas();
  63.  
  64.     }
  65.  
  66.  
  67.     /**
  68.      * 读取带有表头注解的Java实体类模型
  69.      * 读取单个指定sheet 的Excel
  70.      *
  71.      * @param inputStream 字节输入流
  72.      * @param clazz 类的字节码文件对象
  73.      * @param sheetNo sheet的序号 默认从1开始
  74.      * @return List<?> 实体对象集合
  75.      */
  76.     public static List<?> readExcel(InputStream inputStream, Class clazz, int sheetNo){
  77.        return readExcel(inputStream,clazz,sheetNo,1);
  78.     }
  79.  
  80.  
  81.     /**
  82.      * 读取带有表头注解的Java实体类模型
  83.      * 读取单个指定sheet和headLineNum 的Excel
  84.      *
  85.      * @param inputStream 字节输入流
  86.      * @param clazz 类的字节码文件对象
  87.      * @param sheetNo sheet的序号 默认从1开始
  88.      * @param headLineNum 实体对象集合 默认从1开始
  89.      * @return List<?> 实体对象集合
  90.      */
  91.     public static List<?> readExcel(InputStream inputStream, Class clazz, int sheetNo, int headLineNum){
  92.  
  93.         BufferedInputStream bufferedInputStream = null;
  94.         ExcelListener excelListener = null;
  95.  
  96.         try {
  97.             //包装成缓冲字节输入流
  98.             bufferedInputStream = new BufferedInputStream(inputStream);
  99.             //解析Excel表格的每行数据
  100.             excelListener = new ExcelListener();
  101.             //读取Excel表格数据
  102.             ExcelReader excelReader = EasyExcelFactory.getReader(bufferedInputStream,excelListener);
  103.             excelReader.read(new Sheet(sheetNo,headLineNum,clazz));
  104.         } catch (Exception e) {
  105.             e.printStackTrace();
  106.         } finally {
  107.             //关闭缓冲字节输入流，释放资源
  108.             if(bufferedInputStream != null){
  109.                 try {
  110.                     bufferedInputStream.close();
  111.                 } catch (IOException e) {
  112.                     e.printStackTrace();
  113.                 }
  114.             }
  115.         }
  116.  
  117.         return excelListener.getDatas();
  118.     }
  119.  
  120.  
  121.     
  122.     
  123.     
  124.     //--------------------------------------------导出Excel--------------------------------------------
  125.  
  126.     /**
  127.      * 判断上传的Excel文件是否符合格式要求
  128.      *
  129.      * @param excel 上传的Excel文件
  130.      * @return boolean true表示符合文件格式要求，false表示不符合文件格式要求
  131.      */
  132.     public static boolean  determineExcelIsFormatted(MultipartFile excel){
  133.  
  134.         //获取文件名
  135.         String fileName = excel.getOriginalFilename();
  136.         //判断文件名是否符合文件格式
  137.         boolean flag = (fileName == null || (!fileName.toLowerCase().endsWith(".xls") && !fileName.toLowerCase().endsWith(".xlsx")));
  138.  
  139.         if(flag){
  140.             return false;
  141.         }
  142.  
  143.         return true;
  144.     }
  145.     
  146.  
  147.     /**
  148.      * 设置文件响应信息，并返回字节输出流
  149.      *
  150.      * @param fileName 文件名
  151.      * @param response HttpServletResponse响应
  152.      * @return OutputStream 字节输出流
  153.      */
  154.     public static OutputStream setResponse(String fileName, HttpServletResponse response){
  155.  
  156.         try {
  157.             //设置文件名
  158.             fileName = new String((fileName +" "+ new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
  159.                     .getBytes(),"UTF-8");
  160.             //设置文件ContentType类型
  161.             response.setContentType("multipart/form-data");
  162.             //设置服务器响应数据的编码
  163.             response.setCharacterEncoding("utf-8");
  164.             //设置文件头
  165.             response.setHeader("Content-disposition", "attachment;filename="+fileName+".xlsx");
  166.             return response.getOutputStream();
  167.         } catch (IOException e) {
  168.            throw new ExcelException("创建文件失败！");
  169.         }
  170.  
  171.     }
  172.  
  173.     /**
  174.      * 导出带有表头注解的Java实体类模型
  175.      * 导出单个sheet 的Excel，带表头
  176.      *
  177.      * @param outputStream 字节输出流
  178.      * @param clazz 类的字节码文件对象
  179.      * @param data 实体对象集合
  180.      */
  181.     public static void writeExcel(OutputStream outputStream, Class clazz, List<? extends BaseRowModel> data){
  182.          writeExcel(outputStream,clazz,"User表格",data);
  183.     }
  184.  
  185.  
  186.     /**
  187.      * 导出带有表头注解的Java实体类模型
  188.      * 导出单个sheet 的Excel，带表头，可自定义sheet表格名称
  189.      *
  190.      * @param outputStream 字节输出流
  191.      * @param clazz 类的字节码文件对象
  192.      * @param sheetName sheet表格名称
  193.      * @param data 实体对象集合
  194.      */
  195.     public static void writeExcel(OutputStream outputStream, Class clazz, String sheetName, List<? extends BaseRowModel> data){
  196.  
  197.         BufferedOutputStream bufferedOutputStream = null;
  198.  
  199.         try {
  200.             //包装成缓冲字节输入流
  201.             bufferedOutputStream = new BufferedOutputStream(outputStream);
  202.             //包装成缓冲字节输入流
  203.             ExcelWriter writer = EasyExcelFactory.getWriter(outputStream);
  204.             //创建sheet表格，并设置表格名称
  205.             Sheet sheet = new Sheet(1, 0, clazz);
  206.             sheet.setSheetName(sheetName);
  207.             //设置自适应宽度
  208.             sheet.setAutoWidth(Boolean.TRUE);
  209.             //把数据写入表格
  210.             writer.write(data,sheet);
  211.             writer.finish();
  212.         } catch (Exception e) {
  213.             e.printStackTrace();
  214.         } finally {
  215.             //关闭缓冲字节输出流，释放资源
  216.             if(bufferedOutputStream != null){
  217.                 try {
  218.                     bufferedOutputStream.close();
  219.                 } catch (IOException e) {
  220.                     e.printStackTrace();
  221.                 }
  222.             }
  223.         }
  224.     }
  225.     
  226. }

2.9、准备Excel表格数据 (因为数据库表字段id，我设置为 int自增类型，所以主键id这一列我们不设置值)

主键id姓名性别年龄生日
曾华男421977-09-01
匡明男441975-10-02
王丽女431976-01-23
李军男431976-02-20
王芳女441975-02-10
陆君男451974-06-03
李诚男611958-12-02
张旭男501969-03-12
王萍女471972-05-05
刘冰女421977-08-14

2.10、编写带有表头注解的Java实体类模型的测试用例

  1. package com.easyexcel.test;
  2.  
  3. import com.easyexcel.pojo.User;
  4. import com.easyexcel.service.UserService;
  5. import com.easyexcel.utils.ExcelUtils;
  6. import org.junit.Before;
  7. import org.junit.Test;
  8. import org.springframework.context.support.ClassPathXmlApplicationContext;
  9.  
  10. import java.io.*;
  11. import java.util.List;
  12.  
  13. public class EasyExcelTest {
  14.  
  15.     private UserService userService;
  16.  
  17.     @Before
  18.     public void init() {
  19.  
  20.         //读取applicationContext-spring.xml配置文件
  21.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-spring.xml");
  22.         //获取Spring容器中已初始化的UserServiceImpl实例对象
  23.         userService = (UserService) context.getBean("userServiceImpl");
  24.     }
  25.  
  26.  
  27.     /**
  28.      * 读取带有表头注解的Java实体类模型
  29.      * 读取单个指定sheet 的Excel，并导入到数据库中
  30.      */
  31.     @Test
  32.     public void readExcel() {
  33.  
  34.         InputStream fileInputStream = null;
  35.         try {
  36.             //读取user.xlsx表格，获得文件输入流
  37.             fileInputStream = new FileInputStream("G:/user.xlsx");
  38.             //获得User实体类对象集合
  39.             List<User> users = (List<User>) ExcelUtils.readExcel(fileInputStream, User.class, 1);
  40.             //批量插入到数据库user表中
  41.             userService.insertAllOfUser(users);
  42.  
  43.         } catch (FileNotFoundException e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             //关闭文件输入流，释放资源
  47.             if (fileInputStream != null) {
  48.                 try {
  49.                     fileInputStream.close();
  50.                 } catch (IOException e) {
  51.                     e.printStackTrace();
  52.                 }
  53.             }
  54.         }
  55.     }
  56.  
  57.  
  58.     /**
  59.      * 导出带有表头注解的Java实体类模型
  60.      * 导出单个sheet 的Excel，带表头
  61.      */
  62.     @Test
  63.     public void writeExcel() {
  64.  
  65.         FileOutputStream fileOutputStream = null;
  66.         try {
  67.             //获取文件输出流
  68.             fileOutputStream = new FileOutputStream("G:/create_user.xlsx");
  69.             //获得User实体类对象集合
  70.             List<User> users = userService.selectAllOfUser();
  71.             //把数据写入到指定的Excel表格中
  72.             ExcelUtils.writeExcel(fileOutputStream, User.class, users);
  73.  
  74.         } catch (FileNotFoundException e) {
  75.             e.printStackTrace();
  76.         } finally {
  77.  
  78.             if (fileOutputStream != null) {
  79.                 try {
  80.                     fileOutputStream.close();
  81.                 } catch (IOException e) {
  82.                     e.printStackTrace();
  83.                 }
  84.             }
  85.         }
  86.     }
  87.  
  88. }

2.11、测试结果如下图所示

导入结果图：

导出结果图：

2.12、如果想通过Java实体类模型生成如下多层级表头

Java实体类模型写法如下：

  1. public class MultiLineHeadExcelModel extends BaseRowModel {
  2.  
  3.     @ExcelProperty(value = {"表头1","表头1","表头31"},index = 0)
  4.     private String p1;
  5.  
  6.     @ExcelProperty(value = {"表头1","表头1","表头32"},index = 1)
  7.     private String p2;
  8.  
  9.     @ExcelProperty(value = {"表头3","表头3","表头3"},index = 2)
  10.     private int p3;
  11.  
  12.     @ExcelProperty(value = {"表头4","表头4","表头4"},index = 3)
  13.     private long p4;
  14.  
  15.     @ExcelProperty(value = {"表头5","表头51","表头52"},index = 4)
  16.     private String p5;
  17.  
  18.     @ExcelProperty(value = {"表头6","表头61","表头611"},index = 5)
  19.     private String p6;
  20.  
  21.     @ExcelProperty(value = {"表头6","表头61","表头612"},index = 6)
  22.     private String p7;
  23.  
  24.     @ExcelProperty(value = {"表头6","表头62","表头621"},index = 7)
  25.     private String p8;
  26.  
  27.     @ExcelProperty(value = {"表头6","表头62","表头622"},index = 8)
  28.     private String p9;
  29. }

2.13、Controller层 编写Excel文件导入、模板导出 和 数据导出方法

  1. package com.easyexcel.controller;
  2.  
  3. import com.easyexcel.Exception.ExcelException;
  4. import com.easyexcel.pojo.User;
  5. import com.easyexcel.service.UserService;
  6. import com.easyexcel.utils.ExcelUtils;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Controller;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestParam;
  11. import org.springframework.web.multipart.MultipartFile;
  12.  
  13. import javax.servlet.http.HttpServletResponse;
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.io.OutputStream;
  17. import java.util.List;
  18.  
  19. @Controller
  20. public class ExcelController {
  21.  
  22.     @Autowired
  23.     private UserService userService;
  24.  
  25.     /**
  26.      * 导入带有表头注解的Java实体类模型
  27.      * 导入单个Excel表
  28.      * 
  29.      * @param excel 上传的Excel文件
  30.      */
  31.     @RequestMapping(value="/uploadExcel")
  32.     public void uploadExcel(@RequestParam(value="file") MultipartFile excel){
  33.  
  34.         InputStream inputStream = null;
  35.  
  36.         try {
  37.             //判断文件后缀是否以.xls 或者 .xlsx 结尾
  38.             boolean flag = ExcelUtils.determineExcelIsFormatted(excel);
  39.             if (!flag){
  40.                 throw new ExcelException("文件格式有误");
  41.             }
  42.  
  43.             //获取文件输入流
  44.             inputStream = excel.getInputStream();
  45.             //获得User实体类对象集合
  46.             List<User> users = (List<User>) ExcelUtils.readExcel(inputStream, User.class, 1);
  47.             //批量插入到数据库user表中
  48.             userService.insertAllOfUser(users);
  49.  
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             //关闭字节输入流，释放资源
  54.             if (inputStream != null) {
  55.                 try {
  56.                     inputStream.close();
  57.                 } catch (IOException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.         }
  62.     }
  63.  
  64.     
  65.     /**
  66.      * 导出带有表头注解的Java实体类模型
  67.      * 导出模板，用于填写导入数据
  68.      * 
  69.      * @param response HttpServletResponse响应
  70.      */
  71.     @RequestMapping(value="/downLoadExcelTemplate")
  72.     public void downLoadExcelTemplate(HttpServletResponse response){
  73.         //设置Excel表的名称
  74.         String fileName = "User导入模板";
  75.         //设置文件响应信息，并获得字节输出流
  76.         OutputStream outputStream = ExcelUtils.setResponse(fileName, response);
  77.         //把数据写入到Excel表格中
  78.         ExcelUtils.writeExcel(outputStream,User.class,null);
  79.  
  80.         //关闭字节输入流，释放资源
  81.         if(outputStream != null){
  82.             try {
  83.                 outputStream.close();
  84.             } catch (IOException e) {
  85.                 e.printStackTrace();
  86.             }
  87.         }
  88.  
  89.     }
  90.  
  91.     
  92.     /**
  93.      * 导出Excel数据表文件
  94.      * 
  95.      * @param response HttpServletResponse响应
  96.      */
  97.     @RequestMapping(value="/downLoadExcel")
  98.     public void downLoadExcel(HttpServletResponse response){
  99.  
  100.         //设置Excel表的名称
  101.         String fileName = "User信息详情";
  102.         //获得User实体类对象集合
  103.         List<User> users = userService.selectAllOfUser();
  104.         //设置文件响应信息，并获得字节输出流
  105.         OutputStream outputStream = ExcelUtils.setResponse(fileName, response);
  106.         //把数据写入到Excel表格中
  107.         ExcelUtils.writeExcel(outputStream,User.class,users);
  108.  
  109.         //关闭字节输入流，释放资源
  110.         if(outputStream != null){
  111.             try {
  112.                 outputStream.close();
  113.             } catch (IOException e) {
  114.                 e.printStackTrace();
  115.             }
  116.         }
  117.     }
  118.  
  119. }

3、使用EasyExcel导入、导出带有表头的无注解模型映射关系的数据模型的Excel

3.1、在ExcelUtils工具类中添加如下方法 (由于导入可以直接调用带有表头注解的Java实体类模型的导入方法，这里就不在陈述)

  1.     /**
  2.      * 导出带有表头的无注解模型映射关系的数据模型
  3.      * 导出单个sheet 的Excel，带表头
  4.      *
  5.      * @param outputStream 字节输出流
  6.      * @param data         实体对象集合
  7.      * @param head         表头
  8.      */
  9.     public static void writeExcelWithOutJavaModel(OutputStream outputStream, List<List<Object>> data, List<List<String>> head) {
  10.         writeExcelWithOutJavaModel(outputStream, "Data表格", data, head);
  11.     }
  12.  
  13.  
  14.     /**
  15.      * 导出带有表头的无注解模型映射关系的数据模型
  16.      * 导出单个sheet 的Excel，带表头，可自定义sheet表格名称
  17.      *
  18.      * @param outputStream 字节输出流
  19.      * @param sheetName    sheet表格名称
  20.      * @param data         实体对象集合
  21.      */
  22.     public static void writeExcelWithOutJavaModel(OutputStream outputStream, String sheetName, List<List<Object>> data, List<List<String>> head) {
  23.  
  24.         BufferedOutputStream bufferedOutputStream = null;
  25.  
  26.         try {
  27.             //包装成缓冲字节输入流
  28.             bufferedOutputStream = new BufferedOutputStream(outputStream);
  29.             //包装成缓冲字节输入流
  30.             ExcelWriter writer = EasyExcelFactory.getWriter(outputStream);
  31.             //创建sheet表格，并设置表格名称
  32.             Sheet sheet = new Sheet(1, 0);
  33.             sheet.setSheetName(sheetName);
  34.             //设置自适应宽度
  35.             sheet.setAutoWidth(Boolean.TRUE);
  36.  
  37.             //无注解模型映射关系的数据模型，动态添加表头
  38.             Table table = new Table(1);
  39.             table.setHead(head);
  40.  
  41.             //把数据写入表格,如果数据类型是List<List<String>>，请使用writer.write0(data, sheet)进行数据写入
  42.             writer.write1(data, sheet, table);
  43.             writer.finish();
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             //关闭缓冲字节输出流，释放资源
  48.             if (bufferedOutputStream != null) {
  49.                 try {
  50.                     bufferedOutputStream.close();
  51.                 } catch (IOException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.         }
  56.     }

3.2、编写带有表头的无注解模型映射关系的数据模型的测试用例

  1. package com.easyexcel.test;
  2.  
  3. import com.easyexcel.utils.ExcelUtils;
  4. import org.junit.Test;
  5.  
  6. import java.io.*;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9.  
  10. public class EasyExcelTest {
  11.  
  12.     /**
  13.      * 读取带有表头的无注解模型映射关系的数据模型
  14.      * 单个指定sheet 的Excel，并导入到数据库中
  15.      */
  16.     @Test
  17.     public void readExcelWithOutJavaModel() {
  18.  
  19.         InputStream fileInputStream = null;
  20.         try {
  21.             //读取data.xlsx表格，获得文件输入流
  22.             fileInputStream = new FileInputStream("G:/data.xlsx");
  23.             //获得dataList集合对象，注意：无注解模型映射关系的数据模型在读取Excel时，其Class参数传null就行
  24.             List<List<Object>> dataList = (List<List<Object>>) ExcelUtils.readExcel(fileInputStream, null, 1);
  25.             //循环打印获取到的dataList集合对象
  26.             for (List<Object> list : dataList) {
  27.                 System.out.println(list);
  28.             }
  29.  
  30.         } catch (FileNotFoundException e) {
  31.             e.printStackTrace();
  32.         } finally {
  33.             //关闭文件输入流，释放资源
  34.             if (fileInputStream != null) {
  35.                 try {
  36.                     fileInputStream.close();
  37.                 } catch (IOException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.         }
  42.     }
  43.  
  44.  
  45.     /**
  46.      * 导出带有表头的无注解模型映射关系的数据模型
  47.      * 单个sheet 的Excel，带表头
  48.      */
  49.     @Test
  50.     public void writeExcelWithOutJavaModel() {
  51.  
  52.         FileOutputStream fileOutputStream = null;
  53.         try {
  54.             //获取文件输出流
  55.             fileOutputStream = new FileOutputStream("G:/create_data.xlsx");
  56.             //动态创建数据，注意创建的数据类型是List<List<Object>>
  57.             List<List<Object>> rows = new ArrayList<>();
  58.             for (int i = 0; i < 10; i++) {
  59.                 List<Object> row = new ArrayList<>();
  60.                 row.add("2015435040" + i);
  61.                 row.add("李四--" + i);
  62.                 row.add(Integer.valueOf(10 + i));
  63.                 row.add("男");
  64.                 row.add("博客：浅末年华");
  65.                 rows.add(row);
  66.             }
  67.  
  68.             //无注解模型映射关系的数据模型，动态创建表头数据
  69.             List<List<String>> head = createTestListStringHead();
  70.  
  71.             //把数据写入到指定的Excel表格中
  72.             ExcelUtils.writeExcelWithOutJavaModel(fileOutputStream, rows, head);
  73.  
  74.         } catch (FileNotFoundException e) {
  75.             e.printStackTrace();
  76.         } finally {
  77.  
  78.             if (fileOutputStream != null) {
  79.                 try {
  80.                     fileOutputStream.close();
  81.                 } catch (IOException e) {
  82.                     e.printStackTrace();
  83.                 }
  84.             }
  85.         }
  86.     }
  87.  
  88.  
  89.     /**
  90.      * 无注解模型映射关系的数据模型，动态创建表头数据
  91.      *
  92.      * @return List<List<String>> 表头
  93.      */
  94.     public static List<List<String>> createTestListStringHead() {
  95.         //无注解模型映射关系的数据模型，动态创建表头数据
  96.         List<List<String>> head = new ArrayList<List<String>>();
  97.         List<String> headCoulumn1 = new ArrayList<String>();
  98.         List<String> headCoulumn2 = new ArrayList<String>();
  99.         List<String> headCoulumn3 = new ArrayList<String>();
  100.         List<String> headCoulumn4 = new ArrayList<String>();
  101.         List<String> headCoulumn5 = new ArrayList<String>();
  102.  
  103.         headCoulumn1.add("第一列");headCoulumn1.add("第一列");headCoulumn1.add("第一列");
  104.         headCoulumn2.add("第一列");headCoulumn2.add("第一列");headCoulumn2.add("第一列");
  105.         headCoulumn3.add("第二列");headCoulumn3.add("第二列");headCoulumn3.add("第二列");
  106.         headCoulumn4.add("第三列1");headCoulumn4.add("第三列2");headCoulumn4.add("第三列2");
  107.         headCoulumn5.add("第四列");headCoulumn5.add("第四列1");headCoulumn5.add("第四列2");
  108.  
  109.         head.add(headCoulumn1);
  110.         head.add(headCoulumn2);
  111.         head.add(headCoulumn3);
  112.         head.add(headCoulumn4);
  113.         head.add(headCoulumn5);
  114.         return head;
  115.     }
  116.  
  117. }

4、EasyExcel自定义导出带有表头注解的Java实体类模型的表头以及内容样式的Excel

方式一：通过调用Table类中的 setTableStyle(TableStyle tableStyle) 来设置表头以及内容样式

4.1、在ExcelUtils工具类中添加如下方法

  1.     /**
  2.      * 导出带有表头注解的Java实体类模型
  3.      * 导出单个sheet 的Excel，带表头，可自定义sheet表格名称 和 Excel表格样式
  4.      *
  5.      * @param outputStream 字节输出流
  6.      * @param clazz        类的字节码文件对象
  7.      * @param sheetName    sheet表格名称
  8.      * @param data         实体对象集合
  9.      * @param tableStyle   Excel表格样式
  10.      */
  11.     public static void writeExcelWithStyle(OutputStream outputStream, Class clazz, String sheetName, List<? extends BaseRowModel> data, TableStyle tableStyle) {
  12.  
  13.         BufferedOutputStream bufferedOutputStream = null;
  14.  
  15.         try {
  16.             //包装成缓冲字节输入流
  17.             bufferedOutputStream = new BufferedOutputStream(outputStream);
  18.             //包装成缓冲字节输入流
  19.             ExcelWriter writer = EasyExcelFactory.getWriter(outputStream);
  20.             //创建sheet表格，并设置表格名称
  21.             Sheet sheet = new Sheet(1, 0, clazz);
  22.             sheet.setSheetName(sheetName);
  23.             //设置自适应宽度
  24.             sheet.setAutoWidth(Boolean.TRUE);
  25.  
  26.             //设置Excel表格样式
  27.             Table table = new Table(0);
  28.             table.setTableStyle(tableStyle);
  29.             table.setClazz(clazz);
  30.  
  31.             //把数据写入表格
  32.             writer.write(data, sheet, table);
  33.             writer.finish();
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         } finally {
  37.             //关闭缓冲字节输出流，释放资源
  38.             if (bufferedOutputStream != null) {
  39.                 try {
  40.                     bufferedOutputStream.close();
  41.                 } catch (IOException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.         }
  46.     }

4.2、编写导出带有表头注解的Java实体类模型的测试用例

  1. package com.easyexcel.test;
  2.  
  3. import com.alibaba.excel.metadata.Font;
  4. import com.alibaba.excel.metadata.TableStyle;
  5. import com.easyexcel.pojo.User;
  6. import com.easyexcel.service.UserService;
  7. import com.easyexcel.utils.ExcelUtils;
  8. import org.apache.poi.ss.usermodel.IndexedColors;
  9. import org.junit.Before;
  10. import org.junit.Test;
  11. import org.springframework.context.support.ClassPathXmlApplicationContext;
  12.  
  13. import java.io.*;
  14. import java.util.List;
  15.  
  16. public class EasyExcelTest {
  17.  
  18.     private UserService userService;
  19.  
  20.     @Before
  21.     public void init() {
  22.  
  23.         //读取applicationContext-spring.xml配置文件
  24.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-spring.xml");
  25.         //获取Spring容器中已初始化的UserServiceImpl实例对象
  26.         userService = (UserService) context.getBean("userServiceImpl");
  27.     }
  28.  
  29.     /**
  30.      * 导出带有表头注解的Java实体类模型
  31.      * 导出单个sheet 的Excel，带表头和表格样式
  32.      */
  33.     @Test
  34.     public void writeExcelWithStyle() {
  35.  
  36.         FileOutputStream fileOutputStream = null;
  37.         try {
  38.             //获取文件输出流
  39.             fileOutputStream = new FileOutputStream("G:/create_user.xlsx");
  40.             //获得User实体类对象集合
  41.             List<User> users = userService.selectAllOfUser();
  42.             //自定义表格样式
  43.             TableStyle tableStyle = createTableStyle();
  44.             //把数据写入到指定的Excel表格中
  45.             ExcelUtils.writeExcelWithStyle(fileOutputStream, User.class, "User表格",users,tableStyle);
  46.  
  47.         } catch (FileNotFoundException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.  
  51.             if (fileOutputStream != null) {
  52.                 try {
  53.                     fileOutputStream.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.         }
  59.     }
  60.  
  61.  
  62.     /**
  63.      * 自定义表格样式
  64.      */
  65.     public static TableStyle createTableStyle() {
  66.         TableStyle tableStyle = new TableStyle();
  67.         // 设置表头样式
  68.         Font headFont = new Font();
  69.         // 字体是否加粗
  70.         headFont.setBold(true);
  71.         // 字体大小
  72.         headFont.setFontHeightInPoints((short)12);
  73.         // 字体
  74.         headFont.setFontName("楷体");
  75.         tableStyle.setTableHeadFont(headFont);
  76.         // 背景色
  77.         tableStyle.setTableHeadBackGroundColor(IndexedColors.BLUE);
  78.  
  79.  
  80.         // 设置表格内容样式
  81.         Font contentFont = new Font();
  82.         contentFont.setBold(true);
  83.         contentFont.setFontHeightInPoints((short)12);
  84.         contentFont.setFontName("黑体");
  85.         tableStyle.setTableContentFont(contentFont);
  86.         tableStyle.setTableContentBackGroundColor(IndexedColors.GREEN);
  87.         return tableStyle;
  88.     }
  89.     
  90. }

4.3、测试导出Excel结果如下图所示

方式二：通过实现WriterHandler接口来实现自定义表头以及内容样式，WriterHandler接口中定义了如下三个方法：

void sheet(int sheetNo, Sheet sheet)：在创建每个sheet后，自定义业务逻辑处理

void row(int rowNum, Row row)：在创建每个row后，自定义业务逻辑处理

void cell(int cellNum, Cell cell)：在创建每个cell后，自定义业务逻辑处理

4.1、编写自定义样式处理类ExcelStyleHandler，实现WriterHandler接口

  1. package com.easyexcel.handler;
  2.  
  3. import com.alibaba.excel.event.WriteHandler;
  4. import org.apache.poi.ss.usermodel.*;
  5.  
  6. public class ExcelStyleHandler implements WriteHandler {
  7.  
  8.     @Override
  9.     public void sheet(int sheetNo, Sheet sheet) {
  10.  
  11.     }
  12.  
  13.     @Override
  14.     public void row(int rowNum, Row row) {
  15.  
  16.     }
  17.  
  18.     @Override
  19.     public void cell(int cellNum, Cell cell) {
  20.  
  21.         //这里可以获得Workbook是因为Sheet类有这个接口，但是其他地方没有对应的Sheet,所以要获得的话，需要用到反射了
  22.         Workbook workbook = cell.getSheet().getWorkbook();
  23.         CellStyle cellStyle = workbook.createCellStyle();
  24.         Font font = workbook.createFont();
  25.         //设置边框为细边框
  26.         borderStyle(cellStyle,BorderStyle.THIN);
  27.         //设置水平、垂直居中对齐
  28.         alignmentStyle(cellStyle,HorizontalAlignment.CENTER,VerticalAlignment.CENTER);
  29.  
  30.         //设置标题行(表头)样式
  31.         if(0 == cell.getRowIndex()){
  32.             //设置字体样式
  33.             fontStyle(cellStyle, font,IndexedColors.AQUA,true,14,"黑体");
  34.             //设置设置单元格填充样式 和 颜色
  35.             colorStyle(cellStyle,FillPatternType.SOLID_FOREGROUND,IndexedColors.LEMON_CHIFFON);
  36.         }
  37.  
  38.         //设置表格内容样式
  39.         if (cell.getRowIndex() > 0) {
  40.             //设置字体样式
  41.             fontStyle(cellStyle, font,IndexedColors.AQUA,true,14,"楷体");
  42.             //设置设置单元格填充样式 和 颜色
  43.             colorStyle(cellStyle,FillPatternType.SOLID_FOREGROUND,IndexedColors.TURQUOISE);
  44.         }
  45.  
  46.         cell.getRow().getCell(cellNum).setCellStyle(cellStyle);
  47.     }
  48.  
  49.  
  50.     /**
  51.      * 设置四周边框
  52.      *
  53.      * @param cellStyle 单元格样式实体对象
  54.      */
  55.     private void borderStyle(CellStyle cellStyle,BorderStyle borderStyle) {
  56.  
  57.         //设置上、下、左、右边框为细边框
  58.         cellStyle.setBorderTop(borderStyle);
  59.         cellStyle.setBorderBottom(borderStyle);
  60.         cellStyle.setBorderLeft(borderStyle);
  61.         cellStyle.setBorderRight(borderStyle);
  62.  
  63.     }
  64.  
  65.  
  66.     /**
  67.      * 设置水平和垂直对齐格式
  68.      *
  69.      * @param horizontalAlignment
  70.      * @param verticalAlignment
  71.      */
  72.     private void alignmentStyle(CellStyle cellStyle, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment) {
  73.  
  74.         // 水平居中对齐
  75.         cellStyle.setAlignment(horizontalAlignment);
  76.         // 垂直居中对齐
  77.         cellStyle.setVerticalAlignment(verticalAlignment);
  78.     }
  79.  
  80.  
  81.     /**
  82.      * 设置字体样式
  83.      *
  84.      * @param cellStyle 单元格样式实体对象
  85.      * @param font      字体实体对象
  86.      */
  87.     private void fontStyle(CellStyle cellStyle, Font font,IndexedColors indexedColors,boolean isBold,int fontHeight,String fontName) {
  88.  
  89.         //设置字体颜色
  90.         font.setColor(indexedColors.getIndex());
  91.         //设置字体是否加粗
  92.         font.setBold(isBold);
  93.         //设置字体大小
  94.         font.setFontHeightInPoints((short) fontHeight);
  95.         //设置字体
  96.         font.setFontName(fontName);
  97.  
  98.         cellStyle.setFont(font);
  99.  
  100.     }
  101.  
  102.  
  103.     /**
  104.      * 设置单元格填充样式 和 颜色
  105.      *
  106.      * @param cellStyle 单元格样式实体对象
  107.      * @param fillPatternType 字体实体对象
  108.      * @param indexedColors 字体实体对象
  109.      */
  110.     private void colorStyle(CellStyle cellStyle, FillPatternType fillPatternType, IndexedColors indexedColors) {
  111.  
  112.         //设置前景填充样式
  113.         cellStyle.setFillPattern(fillPatternType);
  114.         //前景填充色
  115.         cellStyle.setFillForegroundColor(indexedColors.getIndex());
  116.     }
  117.  
  118. }

4.2、在ExcelUtils工具类中添加如下方法

  1.     /**
  2.      * 导出带有表头注解的Java实体类模型
  3.      * 导出单个sheet 的Excel，带表头，可自定义sheet表格名称 和 Excel表格样式
  4.      *
  5.      * @param outputStream 字节输出流
  6.      * @param clazz        类的字节码文件对象
  7.      * @param sheetName    sheet表格名称
  8.      * @param data         实体对象集合
  9.      * @param handler      Excel表格样式
  10.      */
  11.     public static void writeExcelWithStyle(OutputStream outputStream, Class clazz, String sheetName, List<? extends BaseRowModel> data, WriteHandler handler) {
  12.  
  13.         BufferedOutputStream bufferedOutputStream = null;
  14.  
  15.         try {
  16.             //包装成缓冲字节输入流
  17.             bufferedOutputStream = new BufferedOutputStream(outputStream);
  18.             //包装成缓冲字节输入流
  19.             ExcelWriter writer = EasyExcelFactory.getWriterWithTempAndHandler(null, outputStream, ExcelTypeEnum.XLSX, true, handler);
  20.             //创建sheet表格，并设置表格名称
  21.             Sheet sheet = new Sheet(1, 0, clazz);
  22.             sheet.setSheetName(sheetName);
  23.             //设置自适应宽度
  24.             sheet.setAutoWidth(Boolean.TRUE);
  25.             //把数据写入表格
  26.             writer.write(data, sheet);
  27.             writer.finish();
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             //关闭缓冲字节输出流，释放资源
  32.             if (bufferedOutputStream != null) {
  33.                 try {
  34.                     bufferedOutputStream.close();
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         }
  40.     }

4.3、编写导出带有表头注解的Java实体类模型的Excel表格样式的测试用例

  1. package com.easyexcel.test;
  2.  
  3. import com.easyexcel.handler.ExcelStyleHandler;
  4. import com.easyexcel.pojo.User;
  5. import com.easyexcel.service.UserService;
  6. import com.easyexcel.utils.ExcelUtils;
  7. import org.junit.Before;
  8. import org.junit.Test;
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;
  10.  
  11. import java.io.FileNotFoundException;
  12. import java.io.FileOutputStream;
  13. import java.io.IOException;
  14. import java.util.List;
  15.  
  16. public class EasyExcelTest {
  17.  
  18.     private UserService userService;
  19.  
  20.     @Before
  21.     public void init() {
  22.  
  23.         //读取applicationContext-spring.xml配置文件
  24.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-spring.xml");
  25.         //获取Spring容器中已初始化的UserServiceImpl实例对象
  26.         userService = (UserService) context.getBean("userServiceImpl");
  27.     }
  28.  
  29.  
  30.     /**
  31.      * 导出带有表头注解的Java实体类模型
  32.      * 导出单个sheet 的Excel，带表头和表格样式
  33.      */
  34.     @Test
  35.     public void writeExcelWithStyle() {
  36.  
  37.         FileOutputStream fileOutputStream = null;
  38.         try {
  39.             //获取文件输出流
  40.             fileOutputStream = new FileOutputStream("G:/create_user.xlsx");
  41.             //获得User实体类对象集合
  42.             List<User> users = userService.selectAllOfUser();
  43.             //自定义表格样式
  44.             ExcelStyleHandler handler = new ExcelStyleHandler();
  45.             //把数据写入到指定的Excel表格中
  46.             ExcelUtils.writeExcelWithStyle(fileOutputStream, User.class, "User表格",users,handler);
  47.  
  48.         } catch (FileNotFoundException e) {
  49.             e.printStackTrace();
  50.         } finally {
  51.  
  52.             if (fileOutputStream != null) {
  53.                 try {
  54.                     fileOutputStream.close();
  55.                 } catch (IOException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.         }
  60.     }
  61.     
  62. }

4.4、测试导出Excel结果如下图所示

5、EasyExcel自定义导出带有表头的无注解模型映射关系的数据模型的表头以及内容样式Excel

5.1、在ExcelUtils工具类中添加如下方法

  1.     /**
  2.      * 导出带有表头的无注解模型映射关系的数据模型
  3.      * 导出单个sheet 的Excel，带表头，可自定义sheet表格名称 和 Excel表格样式
  4.      *
  5.      * @param outputStream 字节输出流
  6.      * @param sheetName    sheet表格名称
  7.      * @param data         实体对象集合
  8.      * @param tableStyle   实体对象集合
  9.      */
  10.     public static void writeExcelWithOutJavaModelOfStyle(OutputStream outputStream, String sheetName, List<List<Object>> data, List<List<String>> head, TableStyle tableStyle) {
  11.  
  12.         BufferedOutputStream bufferedOutputStream = null;
  13.  
  14.         try {
  15.             //包装成缓冲字节输入流
  16.             bufferedOutputStream = new BufferedOutputStream(outputStream);
  17.             //包装成缓冲字节输入流
  18.             ExcelWriter writer = EasyExcelFactory.getWriter(outputStream);
  19.             //创建sheet表格，并设置表格名称
  20.             Sheet sheet = new Sheet(1, 0);
  21.             sheet.setSheetName(sheetName);
  22.             //设置自适应宽度
  23.             sheet.setAutoWidth(Boolean.TRUE);
  24.  
  25.             //无注解模型映射关系的数据模型，动态添加表头
  26.             Table table = new Table(1);
  27.             table.setHead(head);
  28.             //设置Excel表格样式
  29.             table.setTableStyle(tableStyle);
  30.  
  31.             //把数据写入表格,如果数据类型是List<List<String>>，请使用writer.write0(data, sheet)进行数据写入
  32.             writer.write1(data, sheet, table);
  33.             writer.finish();
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         } finally {
  37.             //关闭缓冲字节输出流，释放资源
  38.             if (bufferedOutputStream != null) {
  39.                 try {
  40.                     bufferedOutputStream.close();
  41.                 } catch (IOException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.         }
  46.     }

5.2、编写带有表头的无注解模型映射关系的数据模型的Excel表格样式的测试用例

  1. package com.easyexcel.test;
  2.  
  3. import com.alibaba.excel.metadata.TableStyle;
  4. import com.easyexcel.utils.ExcelUtils;
  5. import org.apache.poi.ss.usermodel.IndexedColors;
  6. import org.junit.Test;
  7.  
  8. import java.io.*;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11.  
  12. public class EasyExcelTest {
  13.  
  14.     /**
  15.      * 导出带有表头的无注解模型映射关系的数据模型
  16.      * 单个sheet 的Excel，带表头
  17.      */
  18.     @Test
  19.     public void writeExcelWithOutJavaModel() {
  20.  
  21.         FileOutputStream fileOutputStream = null;
  22.         try {
  23.             //获取文件输出流
  24.             fileOutputStream = new FileOutputStream("G:/create_data.xlsx");
  25.             //动态创建数据，注意创建的数据类型是List<List<Object>>
  26.             List<List<Object>> rows = new ArrayList<>();
  27.             for (int i = 0; i < 10; i++) {
  28.                 List<Object> row = new ArrayList<>();
  29.                 row.add("2015435040" + i);
  30.                 row.add("李四--" + i);
  31.                 row.add(Integer.valueOf(10 + i));
  32.                 row.add("男");
  33.                 row.add("博客：浅末年华");
  34.                 rows.add(row);
  35.             }
  36.  
  37.             //无注解模型映射关系的数据模型，动态创建表头数据
  38.             List<List<String>> head = createTestListStringHead();
  39.             //自定义表格样式
  40.             TableStyle tableStyle = createTableStyle();
  41.  
  42.             //把数据写入到指定的Excel表格中
  43.             ExcelUtils.writeExcelWithOutJavaModelOfStyle(fileOutputStream, "Data表格", rows, head, tableStyle);
  44.  
  45.         } catch (FileNotFoundException e) {
  46.             e.printStackTrace();
  47.         } finally {
  48.  
  49.             if (fileOutputStream != null) {
  50.                 try {
  51.                     fileOutputStream.close();
  52.                 } catch (IOException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             }
  56.         }
  57.     }
  58.  
  59.  
  60.     /**
  61.      * 无注解模型映射关系的数据模型，动态创建表头数据
  62.      *
  63.      * @return List<List < String>> 表头
  64.      */
  65.     public static List<List<String>> createTestListStringHead() {
  66.         //无注解模型映射关系的数据模型，动态创建表头数据
  67.         List<List<String>> head = new ArrayList<List<String>>();
  68.         List<String> headCoulumn1 = new ArrayList<String>();
  69.         List<String> headCoulumn2 = new ArrayList<String>();
  70.         List<String> headCoulumn3 = new ArrayList<String>();
  71.         List<String> headCoulumn4 = new ArrayList<String>();
  72.         List<String> headCoulumn5 = new ArrayList<String>();
  73.  
  74.         headCoulumn1.add("第一列");headCoulumn1.add("第一列");headCoulumn1.add("第一列");
  75.         headCoulumn2.add("第一列");headCoulumn2.add("第一列");headCoulumn2.add("第一列");
  76.         headCoulumn3.add("第二列");headCoulumn3.add("第二列");headCoulumn3.add("第二列");
  77.         headCoulumn4.add("第三列1");headCoulumn4.add("第三列2");headCoulumn4.add("第三列2");
  78.         headCoulumn5.add("第四列");headCoulumn5.add("第四列1");headCoulumn5.add("第四列2");
  79.  
  80.         head.add(headCoulumn1);
  81.         head.add(headCoulumn2);
  82.         head.add(headCoulumn3);
  83.         head.add(headCoulumn4);
  84.         head.add(headCoulumn5);
  85.         return head;
  86.     }
  87.  
  88.  
  89.     /**
  90.      * 自定义表格样式
  91.      */
  92.     public static com.alibaba.excel.metadata.TableStyle createTableStyle() {
  93.         com.alibaba.excel.metadata.TableStyle tableStyle = new com.alibaba.excel.metadata.TableStyle();
  94.         // 设置表头样式
  95.         com.alibaba.excel.metadata.Font headFont = new com.alibaba.excel.metadata.Font();
  96.         // 字体是否加粗
  97.         headFont.setBold(true);
  98.         // 字体大小
  99.         headFont.setFontHeightInPoints((short) 12);
  100.         // 字体
  101.         headFont.setFontName("楷体");
  102.         tableStyle.setTableHeadFont(headFont);
  103.         // 背景色
  104.         tableStyle.setTableHeadBackGroundColor(IndexedColors.BLUE);
  105.  
  106.  
  107.         // 设置表格内容样式
  108.         com.alibaba.excel.metadata.Font contentFont = new com.alibaba.excel.metadata.Font();
  109.         contentFont.setBold(true);
  110.         contentFont.setFontHeightInPoints((short) 12);
  111.         contentFont.setFontName("黑体");
  112.         tableStyle.setTableContentFont(contentFont);
  113.         tableStyle.setTableContentBackGroundColor(IndexedColors.GREEN);
  114.         return tableStyle;
  115.     }
  116.  
  117. }

6、使用EasyExcel合并单元格，通过调用ExcelWriter类中的 merge(int firstRow, int lastRow, int firstCol, int lastCol) 来合并单元格

merge方法的四个参数：

     firstRow：开始合并的行数 、lastRow：结束合并的行数、firstCol：开始合并的列数、astCol：结束合并的列数

需要注意的是：行数 和 列数的下标是从0开始的，同时对应的 last 的值必须大于 first 的值

  1. package com.easyexcel.test;
  2.  
  3. import com.alibaba.excel.EasyExcelFactory;
  4. import com.alibaba.excel.ExcelWriter;
  5. import com.alibaba.excel.metadata.Sheet;
  6. import com.alibaba.excel.metadata.Table;
  7. import org.junit.Test;
  8.  
  9. import java.io.FileNotFoundException;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14.  
  15. public class EasyExcelTest {
  16.  
  17.     /**
  18.      * 导出带有表头的无注解模型映射关系的数据模型
  19.      * 单个sheet 的Excel，带表头并合并单元格
  20.      */
  21.     @Test
  22.     public void writeExcelWithOutJavaModel() {
  23.  
  24.         FileOutputStream fileOutputStream = null;
  25.         try {
  26.             //获取文件输出流
  27.             fileOutputStream = new FileOutputStream("G:/create_data.xlsx");
  28.             //动态创建数据，注意创建的数据类型是List<List<Object>>
  29.             List<List<Object>> rows = new ArrayList<>();
  30.             for (int i = 0; i < 10; i++) {
  31.                 List<Object> row = new ArrayList<>();
  32.                 row.add("2015435040" + i);
  33.                 row.add("李四--" + i);
  34.                 row.add(Integer.valueOf(10 + i));
  35.                 row.add("男");
  36.                 row.add("博客：浅末年华");
  37.                 rows.add(row);
  38.             }
  39.  
  40.             //无注解模型映射关系的数据模型，动态创建表头数据
  41.             List<List<String>> head = createTestListStringHead();
  42.             //包装成缓冲字节输入流
  43.             ExcelWriter writer = EasyExcelFactory.getWriter(fileOutputStream);
  44.             //创建sheet表格，并设置表格名称
  45.             Sheet sheet = new Sheet(1, 0);
  46.             sheet.setSheetName("合并单元格");
  47.             //设置自适应宽度
  48.             sheet.setAutoWidth(Boolean.TRUE);
  49.  
  50.             //无注解模型映射关系的数据模型，动态添加表头
  51.             Table table = new Table(1);
  52.             table.setHead(head);
  53.             //把数据写入表格,如果数据类型是List<List<String>>，请使用writer.write0(data, sheet)进行数据写入
  54.             writer.write1(rows, sheet, table);
  55.             //合并单元格,表示把第四行到第六行、第一列到第二列进行合并
  56.             writer.merge(3,5,0,1);
  57.             writer.finish();
  58.  
  59.         } catch (FileNotFoundException e) {
  60.             e.printStackTrace();
  61.         } finally {
  62.  
  63.             if (fileOutputStream != null) {
  64.                 try {
  65.                     fileOutputStream.close();
  66.                 } catch (IOException e) {
  67.                     e.printStackTrace();
  68.                 }
  69.             }
  70.         }
  71.     }
  72.  
  73.  
  74.     /**
  75.      * 无注解模型映射关系的数据模型，动态创建表头数据
  76.      *
  77.      * @return List<List<String>> 表头
  78.      */
  79.     public static List<List<String>> createTestListStringHead() {
  80.         //无注解模型映射关系的数据模型，动态创建表头数据
  81.         List<List<String>> head = new ArrayList<List<String>>();
  82.         List<String> headCoulumn1 = new ArrayList<String>();
  83.         List<String> headCoulumn2 = new ArrayList<String>();
  84.         List<String> headCoulumn3 = new ArrayList<String>();
  85.         List<String> headCoulumn4 = new ArrayList<String>();
  86.         List<String> headCoulumn5 = new ArrayList<String>();
  87.  
  88.         headCoulumn1.add("第一列");headCoulumn1.add("第一列");headCoulumn1.add("第一列");
  89.         headCoulumn2.add("第一列");headCoulumn2.add("第一列");headCoulumn2.add("第一列");
  90.         headCoulumn3.add("第二列");headCoulumn3.add("第二列");headCoulumn3.add("第二列");
  91.         headCoulumn4.add("第三列1");headCoulumn4.add("第三列2");headCoulumn4.add("第三列2");
  92.         headCoulumn5.add("第四列");headCoulumn5.add("第四列1");headCoulumn5.add("第四列2");
  93.  
  94.         head.add(headCoulumn1);
  95.         head.add(headCoulumn2);
  96.         head.add(headCoulumn3);
  97.         head.add(headCoulumn4);
  98.         head.add(headCoulumn5);
  99.         return head;
  100.     }
  101.  
  102. }

6.1、测试导出Excel结果如下图所示

7、使用EasyExcel实现一个Excel写入多个Sheet表格

  1. package com.easyexcel.test;
  2.  
  3. import com.alibaba.excel.EasyExcelFactory;
  4. import com.alibaba.excel.ExcelWriter;
  5. import com.alibaba.excel.metadata.Font;
  6. import com.alibaba.excel.metadata.Sheet;
  7. import com.alibaba.excel.metadata.TableStyle;
  8. import com.easyexcel.pojo.User;
  9. import com.easyexcel.service.UserService;
  10. import org.apache.poi.ss.usermodel.IndexedColors;
  11. import org.junit.Before;
  12. import org.junit.Test;
  13. import org.springframework.context.support.ClassPathXmlApplicationContext;
  14.  
  15. import java.io.FileNotFoundException;
  16. import java.io.FileOutputStream;
  17. import java.io.IOException;
  18. import java.util.ArrayList;
  19. import java.util.List;
  20.  
  21. public class EasyExcelTest {
  22.  
  23.     private UserService userService;
  24.  
  25.     @Before
  26.     public void init() {
  27.  
  28.         //读取applicationContext-spring.xml配置文件
  29.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-spring.xml");
  30.         //获取Spring容器中已初始化的UserServiceImpl实例对象
  31.         userService = (UserService) context.getBean("userServiceImpl");
  32.     }
  33.  
  34.  
  35.     /**
  36.      * 导出带有表头注解的Java实体类模型
  37.      * 导出单个sheet 的Excel，带表头和表格样式
  38.      */
  39.     @Test
  40.     public void writeExcelWithStyle() {
  41.  
  42.         FileOutputStream fileOutputStream = null;
  43.         try {
  44.             //获取文件输出流
  45.             fileOutputStream = new FileOutputStream("G:/create_data.xlsx");
  46.             ExcelWriter writer = EasyExcelFactory.getWriter(fileOutputStream);
  47.             //动态创建数据
  48.             List<List<Object>> list = createDynamicModelList();
  49.             //获得User实体类对象集合
  50.             List<User> users = userService.selectAllOfUser();
  51.  
  52.             //写第一个sheet, sheet1 数据是List<List<Object>> 无注解模型映射关系的数据模型，无表头
  53.             Sheet sheet1 = new Sheet(1, 0);
  54.             sheet1.setSheetName("第一个sheet");
  55.             sheet1.setAutoWidth(Boolean.TRUE);
  56.             sheet1.setStartRow(-1);
  57.             writer.write1(list, sheet1);
  58.  
  59.             //写第二个sheet，sheet2 数据是List<User> 有表头注解的Java实体类模型
  60.             Sheet sheet2 = new Sheet(2, 0, User.class);
  61.             sheet2.setSheetName("第二个sheet");
  62.             sheet2.setAutoWidth(Boolean.TRUE);
  63.             writer.write(users, sheet2);
  64.  
  65.             //写第三个sheet，sheet3 数据是List<List<Object>> 带有表头以及内容样式
  66.             List<List<String>> head = createTestListStringHead();
  67.             //自定义表格样式
  68.             TableStyle tableStyle = createTableStyle();
  69.             Sheet sheet3 = new Sheet(3, 0, null, "第三个sheet", head);
  70.             sheet3.setAutoWidth(Boolean.TRUE);
  71.             sheet3.setTableStyle(tableStyle);
  72.             writer.write1(list, sheet3);
  73.  
  74.             writer.finish();
  75.  
  76.         } catch (FileNotFoundException e) {
  77.             e.printStackTrace();
  78.         } finally {
  79.  
  80.             if (fileOutputStream != null) {
  81.                 try {
  82.                     fileOutputStream.close();
  83.                 } catch (IOException e) {
  84.                     e.printStackTrace();
  85.                 }
  86.             }
  87.         }
  88.     }
  89.  
  90.  
  91.     /**
  92.      * 动态创建数据
  93.      */
  94.     public List<List<Object>> createDynamicModelList() {
  95.         //动态创建数据，注意创建的数据类型是List<List<Object>>
  96.         List<List<Object>> rows = new ArrayList<>();
  97.         for (int i = 0; i < 10; i++) {
  98.             List<Object> row = new ArrayList<>();
  99.             row.add("2015435040" + i);
  100.             row.add("李四--" + i);
  101.             row.add(Integer.valueOf(10 + i));
  102.             row.add("男");
  103.             row.add("博客：浅末年华");
  104.             rows.add(row);
  105.         }
  106.         return rows;
  107.     }
  108.  
  109.  
  110.     /**
  111.      * 自定义表格样式
  112.      */
  113.     public static TableStyle createTableStyle() {
  114.         TableStyle tableStyle = new TableStyle();
  115.         // 设置表头样式
  116.         Font headFont = new Font();
  117.         // 字体是否加粗
  118.         headFont.setBold(true);
  119.         // 字体大小
  120.         headFont.setFontHeightInPoints((short) 12);
  121.         // 字体
  122.         headFont.setFontName("楷体");
  123.         tableStyle.setTableHeadFont(headFont);
  124.         // 背景色
  125.         tableStyle.setTableHeadBackGroundColor(IndexedColors.BLUE);
  126.  
  127.  
  128.         // 设置表格内容样式
  129.         Font contentFont = new Font();
  130.         contentFont.setBold(true);
  131.         contentFont.setFontHeightInPoints((short) 12);
  132.         contentFont.setFontName("黑体");
  133.         tableStyle.setTableContentFont(contentFont);
  134.         tableStyle.setTableContentBackGroundColor(IndexedColors.GREEN);
  135.         return tableStyle;
  136.     }
  137.  
  138.  
  139.     /**
  140.      * 无注解模型映射关系的数据模型，动态创建表头数据
  141.      *
  142.      * @return List<List<String>> 表头
  143.      */
  144.     public static List<List<String>> createTestListStringHead() {
  145.         //无注解模型映射关系的数据模型，动态创建表头数据
  146.         List<List<String>> head = new ArrayList<List<String>>();
  147.         List<String> headCoulumn1 = new ArrayList<String>();
  148.         List<String> headCoulumn2 = new ArrayList<String>();
  149.         List<String> headCoulumn3 = new ArrayList<String>();
  150.         List<String> headCoulumn4 = new ArrayList<String>();
  151.         List<String> headCoulumn5 = new ArrayList<String>();
  152.  
  153.         headCoulumn1.add("第一列");headCoulumn1.add("第一列");headCoulumn1.add("第一列");
  154.         headCoulumn2.add("第一列");headCoulumn2.add("第一列");headCoulumn2.add("第一列");
  155.         headCoulumn3.add("第二列");headCoulumn3.add("第二列");headCoulumn3.add("第二列");
  156.         headCoulumn4.add("第三列1");headCoulumn4.add("第三列2");headCoulumn4.add("第三列2");
  157.         headCoulumn5.add("第四列");headCoulumn5.add("第四列1");headCoulumn5.add("第四列2");
  158.  
  159.         head.add(headCoulumn1);
  160.         head.add(headCoulumn2);
  161.         head.add(headCoulumn3);
  162.         head.add(headCoulumn4);
  163.         head.add(headCoulumn5);
  164.         return head;
  165.     }
  166.  
  167. }

7.1、测试导出Excel结果如下图所示

8、使用EasyExcel实现Excel中一个Sheet表格写入多个Table表格

  1. package com.easyexcel.test;
  2.  
  3. import com.alibaba.excel.EasyExcelFactory;
  4. import com.alibaba.excel.ExcelWriter;
  5. import com.alibaba.excel.metadata.Font;
  6. import com.alibaba.excel.metadata.Sheet;
  7. import com.alibaba.excel.metadata.Table;
  8. import com.alibaba.excel.metadata.TableStyle;
  9. import com.easyexcel.pojo.User;
  10. import com.easyexcel.service.UserService;
  11. import org.apache.poi.ss.usermodel.IndexedColors;
  12. import org.junit.Before;
  13. import org.junit.Test;
  14. import org.springframework.context.support.ClassPathXmlApplicationContext;
  15.  
  16. import java.io.FileNotFoundException;
  17. import java.io.FileOutputStream;
  18. import java.io.IOException;
  19. import java.util.ArrayList;
  20. import java.util.List;
  21.  
  22. public class EasyExcelTest {
  23.  
  24.     private UserService userService;
  25.  
  26.     @Before
  27.     public void init() {
  28.  
  29.         //读取applicationContext-spring.xml配置文件
  30.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-spring.xml");
  31.         //获取Spring容器中已初始化的UserServiceImpl实例对象
  32.         userService = (UserService) context.getBean("userServiceImpl");
  33.     }
  34.  
  35.  
  36.     /**
  37.      * 导出带有表头注解的Java实体类模型
  38.      * 导出单个sheet 的Excel，带表头和表格样式
  39.      */
  40.     @Test
  41.     public void writeExcelWithStyle() {
  42.  
  43.         FileOutputStream fileOutputStream = null;
  44.         try {
  45.             //获取文件输出流
  46.             fileOutputStream = new FileOutputStream("G:/create_data.xlsx");
  47.             ExcelWriter writer = EasyExcelFactory.getWriter(fileOutputStream);
  48.             //动态创建数据
  49.             List<List<Object>> list = createDynamicModelList();
  50.             //获得User实体类对象集合
  51.             List<User> users = userService.selectAllOfUser();
  52.  
  53.             //创建Sheet
  54.             Sheet sheet = new Sheet(1, 0);
  55.             sheet.setSheetName("第一个sheet");
  56.             sheet.setAutoWidth(Boolean.TRUE);
  57.             sheet.setStartRow(-1);
  58.  
  59.             //写第一个table, table1 数据是List<List<Object>> 无注解模型映射关系的数据模型，无表头
  60.             Table table1 = new Table(1);
  61.             writer.write1(list,sheet,table1);
  62.  
  63.             //写第二个table，table2 数据是List<User> 有表头注解的Java实体类模型
  64.             Table table2 = new Table(2);
  65.             table2.setClazz(User.class);
  66.             writer.write(users, sheet,table2);
  67.  
  68.             //写第三个table，table3 数据是List<List<Object>> 带有表头以及内容样式
  69.             List<List<String>> head = createTestListStringHead();
  70.             //自定义表格样式
  71.             TableStyle tableStyle = createTableStyle();
  72.             Table table3 = new Table(3);
  73.             table3.setHead(head);
  74.             table3.setTableStyle(tableStyle);
  75.             writer.write1(list, sheet, table3);
  76.  
  77.             writer.finish();
  78.  
  79.         } catch (FileNotFoundException e) {
  80.             e.printStackTrace();
  81.         } finally {
  82.  
  83.             if (fileOutputStream != null) {
  84.                 try {
  85.                     fileOutputStream.close();
  86.                 } catch (IOException e) {
  87.                     e.printStackTrace();
  88.                 }
  89.             }
  90.         }
  91.     }
  92.  
  93.  
  94.     /**
  95.      * 动态创建数据
  96.      */
  97.     public List<List<Object>> createDynamicModelList() {
  98.         //动态创建数据，注意创建的数据类型是List<List<Object>>
  99.         List<List<Object>> rows = new ArrayList<>();
  100.         for (int i = 0; i < 10; i++) {
  101.             List<Object> row = new ArrayList<>();
  102.             row.add("2015435040" + i);
  103.             row.add("李四--" + i);
  104.             row.add(Integer.valueOf(10 + i));
  105.             row.add("男");
  106.             row.add("博客：浅末年华");
  107.             rows.add(row);
  108.         }
  109.         return rows;
  110.     }
  111.  
  112.  
  113.     /**
  114.      * 自定义表格样式
  115.      */
  116.     public static TableStyle createTableStyle() {
  117.         TableStyle tableStyle = new TableStyle();
  118.         // 设置表头样式
  119.         Font headFont = new Font();
  120.         // 字体是否加粗
  121.         headFont.setBold(true);
  122.         // 字体大小
  123.         headFont.setFontHeightInPoints((short) 12);
  124.         // 字体
  125.         headFont.setFontName("楷体");
  126.         tableStyle.setTableHeadFont(headFont);
  127.         // 背景色
  128.         tableStyle.setTableHeadBackGroundColor(IndexedColors.BLUE);
  129.  
  130.  
  131.         // 设置表格内容样式
  132.         Font contentFont = new Font();
  133.         contentFont.setBold(true);
  134.         contentFont.setFontHeightInPoints((short) 12);
  135.         contentFont.setFontName("黑体");
  136.         tableStyle.setTableContentFont(contentFont);
  137.         tableStyle.setTableContentBackGroundColor(IndexedColors.GREEN);
  138.         return tableStyle;
  139.     }
  140.  
  141.  
  142.     /**
  143.      * 无注解模型映射关系的数据模型，动态创建表头数据
  144.      *
  145.      * @return List<List<String>> 表头
  146.      */
  147.     public static List<List<String>> createTestListStringHead() {
  148.         //无注解模型映射关系的数据模型，动态创建表头数据
  149.         List<List<String>> head = new ArrayList<List<String>>();
  150.         List<String> headCoulumn1 = new ArrayList<String>();
  151.         List<String> headCoulumn2 = new ArrayList<String>();
  152.         List<String> headCoulumn3 = new ArrayList<String>();
  153.         List<String> headCoulumn4 = new ArrayList<String>();
  154.         List<String> headCoulumn5 = new ArrayList<String>();
  155.  
  156.         headCoulumn1.add("第一列");headCoulumn1.add("第一列");headCoulumn1.add("第一列");
  157.         headCoulumn2.add("第一列");headCoulumn2.add("第一列");headCoulumn2.add("第一列");
  158.         headCoulumn3.add("第二列");headCoulumn3.add("第二列");headCoulumn3.add("第二列");
  159.         headCoulumn4.add("第三列1");headCoulumn4.add("第三列2");headCoulumn4.add("第三列2");
  160.         headCoulumn5.add("第四列");headCoulumn5.add("第四列1");headCoulumn5.add("第四列2");
  161.  
  162.         head.add(headCoulumn1);
  163.         head.add(headCoulumn2);
  164.         head.add(headCoulumn3);
  165.         head.add(headCoulumn4);
  166.         head.add(headCoulumn5);
  167.         return head;
  168.     }
  169.  
  170. }

8.1、测试导出Excel结果如下图所示

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/编程探险家/article/detail/61071
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号