POI之自定义注解生成文档-yellowcong

到处数据如果是成条的，而且是批量处理的情况下，我们可以通过对数据模型使用注解，来解决这种问题。

环境搭建

<!-- excel -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.17</version>
</dependency>

<!-- word -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-scratchpad</artifactId>
<version>3.17</version>
</dependency>

<!-- xlsx -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.17</version>
</dependency>
<!-- xlsx  依赖这个包 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml-schemas</artifactId>
<version>3.17</version>
</dependency>

实现思路

在数据模型对象下，添加一个注解类，说明抽出的字段在excel中所对应的表头，然后通过工具类，通过反射，获取每个字段所对应的标题，同时设定每个字段对应的数据

POI自定义注解类(HFFSAlias.java)

HFFSAlias.java

这个注解类是基于file字段的，用于说明字段在xls中的中文名称

package com.yellowcong.utils;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* 通过注解来操作别名,判断的是字段上的别名
* 通过这个注解类和我们的PoiUtils 可以很好的解决文档导出的问题
*
* @author yellowcong
* @date 2016年1月7日
*/
@Target({ java.lang.annotation.ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface HFFSAlias{
//设定别名,通过value 这个函数，就不需要写参数了
//@HFFSAlias("xx") 就可以了
public String value() default "";
}

模型类对象(User.java)

这个模型对象，使用的是Hibernate的框架，通过Hibernate做ORM框架，我们只需要调用自定义的

HFFSAlias.java

这个annotation，就可以设定标题了

package com.yellowcong.model;

import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

import org.hibernate.annotations.Index;
import org.hibernate.validator.constraints.Email;

import com.yellowcong.utils.HFFSAlias;

/**
* yellowcong 的新网站，以后也会一直建立下去
*
* @author yellowcong
*
*
* QQ
* 新浪微博借口
* 微信接口  数据推送
* github 接口
*
*
* 用户登录的 email
* 用户登录的手机号
* 用户的名称
* 必须是唯一的
*
*
* 网名和头像随机生成，如果用户不填写的情况下
*
*
* 手机和email登录
* 三方登录
*
*/
@Entity
@Table(name="ycg_user")
public class User {
@HFFSAlias("编号")
private int id;
//用户名称
@HFFSAlias("用户名称")
private String username;
//别名
//别名不能存在邮箱@ 不然会导致问题，我们需要做js验证
@HFFSAlias("别名")
private String nickname;
//密码
//  @HFFSAlias("密码")
private String password;
//创建日期
@HFFSAlias("创建日期")
private Date createDate;
//用户头像
@HFFSAlias("用户头像")
private String imgUrl;
//用户的邮箱地址
@HFFSAlias("邮箱")
private String email;
//电话
@HFFSAlias("电话号")
private String phone;
//是否邮箱激活
// 0 表示未激活
// 1 表示激活
@HFFSAlias("是否激活")
private int isActive;

public User() {
super();
// TODO Auto-generated constructor stub
}

//用于验证用户是否登录
public User(int id) {
super();
this.id = id;
}

@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Index(name="username")
@Column(name="username",length=16)
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}

//我们不需要设定我们的nickname 为唯一的
@Index(name="nickname")
@Column(name="nickname",length=16,unique=false)
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
@Column(length=32)
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}

@Column(name="create_date")
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}

@Column(name="img_url")
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}

@Email
@Column(unique=true,length=64)
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}

@Column(name="phone",length=11,unique=true)
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
@Column(name="is_active",length=1)
public int getIsActive() {
return isActive;
}
public void setIsActive(int isActive) {
this.isActive = isActive;
}

}

工具类

工具类中，主要可供使用的是将获取的

List<?>

数据转化为Excel文档，同时也可以 将转化的Excel文档转化为

List<?>

,这几个方法都有一个特点，他们是有表头，而且还有一点缺点，对于时间类型需要指定，不然有问题，同时逆向工程中，读取的表的数据 少一行

package com.yellowcong.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;

/**
* 报表工具包,用来操作报表中的数据
* @author yellowcong
* @date 2016年1月6日
* 依赖 poi-2.5.1.jar
* beanutil
*
* 重要的方法
* 创建xls文件
*
* 基于annotation
* 类对象需要使用@HHFSAlias 注解 给字段设定别名
* createHSSFByAnnotation(List<?>)
*
* 自己配置好映射关系，然后传 List<?>对象
* createHSSF(LinkedHashMap<String, String>, List<?>)
*
* 逆向生成 java对象
* 类对象需要使用@HHFSAlias 注解 给字段设定别名
* reverseHSSFByAnnotation(File, Class<?>)
*
* 对于文档直接使用，使用String[]来配置我们的 映射关系，boolena 设定是否有表头
* reverseHSSF(File, String[], Class<?>, boolean)
*
* 对于有表头的可以使用这个，也可以使用上一个，上一个的效率高一点
* reverseHSSF(File, Map<String, String>, Class<?>)
*/
public class PoiUtils {
private PoiUtils(){}

/**
* 将HSSFWorkbook 对象转化为 文件
* @param wb  HSSFWorkbook 对象
* @param file 文件
*/
public static void copyHSSFToFile(HSSFWorkbook wb,File file){
FileOutputStream  out = null;
try {
out = new FileOutputStream(file);
} catch (Exception e) {
// TODO: handle exception
}finally{

try {
if(wb != null){
wb.write(out);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if(out != null){
out.close();
}
} catch (Exception e2) {
// TODO: handle exception
}
}
}
}

/**
* 获取一个不带有输入流的HSSFWorkbook 对象
* @return
*/
public static HSSFWorkbook getHSSFWorkbook(){
return getHSSFWorkbook(null);
}
/**
* 获取我们的一个HSSFWorkbook
* @return
*/
public static HSSFWorkbook getHSSFWorkbook(File file){
HSSFWorkbook workbook= null;
try {
if(file != null){
workbook  = new HSSFWorkbook(new FileInputStream(file));
}else{
workbook = new HSSFWorkbook();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return workbook;
}
//判断数据
/**
* 通过 结合注解，来生成我们的poi文档操作
* 通过注解调用的时候,我们的类中必须要有注解写出，如果没有就创建不了
* 需要结合@HFFSAlias 这个类
* @param data 我们的数据集合
* @return
*/
public static HSSFWorkbook createHSSFByAnnotation(List<?> data) {
LinkedHashMap<String, String> title = null;
//获取到我们的title数据
if(data != null && data.size() >0){
title = new LinkedHashMap<String, String>();
/*Field [] fields = data.get(0).getClass().getDeclaredFields();
for(Field field:fields){
HFFSAlias alias = field.getAnnotation(HFFSAlias.class);
if(alias != null){
title.put(field.getName(), alias.value());
}
}*/
title = PoiUtils.getAnnotationAlias(data.get(0).getClass());
//然后调用已经存在的方法来生成表
return PoiUtils.createHSSF(title, data);
}
return null;
}
/**
* 逆向生成，我们需要的数据，将xls中的数据转化为字符串数据
* @param clazz 映射的类对象
* @param file xls文件对象
* @return
*/
public static List<?> reverseHSSFByAnnotation(File file,Class<?> clazz ){
//获取field中的信息
return PoiUtils.reverseHSSF(file, PoiUtils.getAnnotationAlias(clazz), clazz);
}

/**
* 通过clazz 来获取到里面的title数据
* @param clazz
* @return
*/
public static LinkedHashMap<String,String> getAnnotationAlias(Class<?> clazz){
Field []  fields = clazz.getDeclaredFields();
LinkedHashMap<String,String> title = new LinkedHashMap<String, String>();
for(Field field:fields){
HFFSAlias alias = field.getAnnotation(HFFSAlias.class);
if(alias != null){
title.put(field.getName(), alias.value());
}
}
return title;
}
/**
* 没有行标题的数据,需要通过这种方法来确定数据
* 这个方法使用起来 比通过Map 更加的简便
* @param file  逆向工程的xls文件爱你
* @param title  这个 需要设定 映射关系,而且顺序不能错
* @param clazz   映射的类对象
* @param hasHead  是否包含表头，有表头的数据就 需要从1 开始
* @return
*/
public static List<?> reverseHSSF(File file,String[] title,Class<?> clazz ,boolean hasHead){
try {
//创建work
HSSFWorkbook work = PoiUtils.getHSSFWorkbook(file);
//获取第一页
HSSFSheet sheet = work.getSheetAt(0);
//row是从0开始的,获取列和行的数目
HSSFRow row =  sheet.getRow(0);
List list =null;
List<String> dateFields = null;
int rownum = sheet.getLastRowNum();
int cellnum = row.getLastCellNum();
//          System.out.println(rownum);
String [] ids = title;

if(rownum >0 && cellnum >0){
list = new ArrayList();
dateFields = PoiUtils.getDataTimeFiled(clazz);
//遍历别的数据，、第一行数据 是需要的
int start = 0;
if(hasHead){
start = 1;
}
for(int i=start;i<rownum;i++){
row = sheet.getRow(i);
//实例化对象
Object obj = clazz.newInstance();
//设定属性
for(int j=0;j<cellnum;j++){
HSSFCell cell = row.getCell((short)j);
String result ="";
//当时数字类型的数据，不可以转化
if(cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
result = cell.getNumericCellValue()+"";
}else{
result =cell.getStringCellValue();
}

//日期类型的数据不好注入，需要判断，和设定数据的类型
if(dateFields.contains(ids[j])){
BeanUtils.setProperty(obj, ids[j], new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(result));
}else{
BeanUtils.setProperty(obj, ids[j], result);
}
}
list.add(obj);
}
}
return list;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 通过配置的方法来生成逆向工程
* 给定文件，将对象转化为类
* 设定中，sheeet 就一页
* @param file  xls文件名称
* @param title 标题,表头关系
* @param clazz 类对象
* @return
*/
public static List<?> reverseHSSF(File file,Map<String,String> title,Class<?> clazz ){
try {
//创建work
HSSFWorkbook work = PoiUtils.getHSSFWorkbook(file);
//获取第一页
HSSFSheet sheet = work.getSheetAt(0);
//row是从0开始的,获取列和行的数目
HSSFRow row =  sheet.getRow(0);
List list =null;
List<String> dateFields = null;
int rownum = sheet.getLastRowNum();
int cellnum = row.getLastCellNum();
//          System.out.println(rownum);
String [] ids = new String[cellnum];

if(rownum >0 && cellnum >0){
title = PoiUtils.reverseMap(title);
list = new ArrayList();
dateFields = PoiUtils.getDataTimeFiled(clazz);
//这个可以 提取为 获取第一行数据的信息
//获取地一行，标题行  获取标题对应信息
for(int j=0;j<cellnum;j++){
HSSFCell cell = row.getCell((short)j);
String result = "";
//当时数字类型的数据，不可以转化
if(cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
//                  ids[j]= title.containsValue(value);
result = cell.getNumericCellValue()+"";
}else{
result = cell.getStringCellValue();
}
//获取的数据进行注入操作

//需要反转map集合
if(title != null && result != null){
if(!title.containsKey(result)){
throw new RuntimeException("内容不匹配");
}
ids[j] = title.get(result);
}
}

//遍历别的数据
for(int i=1;i<rownum;i++){
row = sheet.getRow(i);
//实例化对象
Object obj = clazz.newInstance();
//设定属性
for(int j=0;j<cellnum;j++){
HSSFCell cell = row.getCell((short)j);
String result ="";
//当时数字类型的数据，不可以转化
if(cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
result = cell.getNumericCellValue()+"";
}else{
result =cell.getStringCellValue();
}

//日期类型的数据不好注入，需要判断，和设定数据的类型
if(dateFields.contains(ids[j])){
BeanUtils.setProperty(obj, ids[j], new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(result));
}else{
BeanUtils.setProperty(obj, ids[j], result);
}
}
list.add(obj);
}
}
return list;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

/**
* 通过给定类，来获取到日期类型的字段
* 解决日期类型 注入不进去的问题
* @param clazz
* @return
*/
public static List<String> getDataTimeFiled(Class<?> clazz){
Field [] fields = clazz.getDeclaredFields();
List<String> fieldNames = new ArrayList<String>();
for(Field  field :fields){
if(field.getType().getSimpleName().equals("Date")){
fieldNames.add(field.getName());
}
}
return  fieldNames;
}
/**
* 创建我们的HSSFwork 通过配置别名属性
* @param tiles 文档的title         Map<属性名称, 别名>
* @param date List<?> 是一个集合的数据
* @return
*/
public static HSSFWorkbook createHSSF(LinkedHashMap<String, String> title,List<?> data) {
try {
//一个汉字的宽度是 500
//英文260
HSSFWorkbook workbook = new HSSFWorkbook();
HSSFSheet sheet = workbook.createSheet();

//获取字符的长度
//      sheet.setColumnGroupCollapsed(columnNumber, collapsed);
//          sheet.setColumnWidth(column, width);
//写title中的数据
if(title!= null && title.size() >0){
//创建样式
HSSFCellStyle style = PoiUtils.getHeadStyle(workbook);
int index = 0;
HSSFRow row = sheet.createRow(0);
//获取宽度
Map<String, Short> columns = PoiUtils.getColumnWidth(title, data);
//获取数据
for(Map.Entry<String, String> entry:title.entrySet()){
String val = entry.getValue();
HSSFCell cell = row.createCell((short)index);
//设置单元格的类型
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
//设置编码格式
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
//设定样式
cell.setCellStyle(style);
cell.setCellValue(val);
sheet.setColumnWidth((short)index, columns.get(entry.getKey()));
index++;
}

//创建样式
style = PoiUtils.getBodyStyle(workbook);
//设定数据
if(data != null && data.size() >0){
//获取我们的 data中的数据
//内容从第二行开始
int rownum =1;
for(Object obj:data){
row = sheet.createRow(rownum);
//列从第一行开始
int colnum = 0;
for(Map.Entry<String, String> entry:title.entrySet()){
String key = entry.getKey();
//获取装的对象数据
String val = BeanUtils.getProperty(obj, key);
if(val == null || "".equals(val.trim())){
val = "-";
}
HSSFCell cell  = row.createCell((short)colnum);
//设置单元格的类型
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
//设置编码格式
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
//设定样式
cell.setCellStyle(style);
cell.setCellValue(val);
//增加列
colnum ++;
}
rownum ++;
}
}
}

return workbook;
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

/**
* 计算每个数据列的最适合的宽度
* 通过数据来获取到我们的数据的宽度
* @param title 数据标题
* @param data 数据几何
* @return
*/
public static Map<String, Short> getColumnWidth(Map<String, String> title,List<?> data){
try {
//存储我们的每个属性的宽度
//Map<属性明，宽度>
Map<String,Short> map = new HashMap<String, Short>();

if(title!= null && title.size() >0){
//计算我们的第一行的宽度
for(Map.Entry<String, String> entry:title.entrySet()){
int max = PoiUtils.countColumnLength(entry.getValue());

//计算下面的所有 同一字段的长度
for(Object obj:data){
String val = BeanUtils.getProperty(obj, entry.getKey());
int temp = PoiUtils.countColumnLength(val);
max = max >temp?max:temp;
}
//设定字段的值
map.put(entry.getKey(), (short)max);
}
}
return map;
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

/**
*
* 根据字符的数量，来计算列的宽度
* 不同的数据他的数据长度是不一样的，所以我们需要计算总体的长度
* @param str 字符串
* @return int 计算出列宽
*
*/
private static int countColumnLength(String str){
int len =0;
if(str != null && !"".equals(str.trim())){
//一个汉字的宽度是 500
//英文260
char [] chars = str.toCharArray();
//z
int chines = 0;
int other =0;
for(char val:chars){
if(PoiUtils.isChineseChar(val)){
chines ++;
}else{
other++;
}
}
//获取到了数据然后计算长度
len = chines*500+other*260+1000;
}
return len;
}
/**
* 创建样式
* @return
*/
public static HSSFCellStyle getHeadStyle(HSSFWorkbook workbook){
HSSFCellStyle  style = workbook.createCellStyle();
//居中显示
style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
style.setFont(PoiUtils.getSongRed10(workbook));
return style;
}

/**
* 创建样式
* @return
*/
public static HSSFCellStyle getBodyStyle(HSSFWorkbook workbook){
HSSFCellStyle  style = workbook.createCellStyle();
style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
style.setFont(PoiUtils.getSong10(workbook));
return style;
}

/**
* 创建字体
* @param fontFamly 字体
* @param size 大小 字号 14  13
* @param color  HSSFColor.BLACK.index 这个HSSFColor中 的数据
* @param isBold 是否加粗 操作
* @return
*/
//字号 是14号 -->对应的short 280宽度 是 14好字体
public static HSSFFont creatFont(HSSFWorkbook workbook,String fontFamly,Integer size,Short color,boolean isBold){
HSSFFont font = workbook.createFont();
//字号 是14号 -->对应的short 宽度 是 14好字体
font.setFontHeight((short)((size== null  || size ==0 )?280:size*20));
font.setBoldweight(isBold?HSSFFont.BOLDWEIGHT_BOLD:HSSFFont.BOLDWEIGHT_NORMAL);
//将字体颜色变红色
//      short colors = HSSFColor.RED.index;
font.setColor(color== null?HSSFColor.BLACK.index:color);
return font;
}

/**
* 判断我们的数据 中，是否有中文字符
* @param str
* @return
*/
public static boolean isChineseChar(char str){
boolean flag = false;
Pattern pattern = Pattern.compile("[\u4e00-\u9fa5]");
if(pattern.matcher(str+"").find()){
flag = true;
}
return flag;
}

/**
* 得到宋体10 号 黑色
* 默认字体的大小就是10 号
* @return
*/
public static HSSFFont getSong10(HSSFWorkbook workbook){
return creatFont(workbook,"宋体", 10, null,false);
}

/**
* 得到宋体10 号  红色加粗
* @return
*/
public static HSSFFont getSongRed10(HSSFWorkbook workbook){
return creatFont(workbook,"宋体", 10, HSSFColor.RED.index,true);
}

/**
* 将Map
* @param map
* @return
*/
public static Map<String,String> reverseMap(Map<String,String> map){
Map<String,String> newMap = null;
//将便利的结果重新装填一下
if(map != null  && map.size() >0){
newMap = new LinkedHashMap<String, String>();
for(Map.Entry<String, String> entry:map.entrySet()){
newMap.put(entry.getValue(), entry.getKey());
}
}
return newMap;
}
}

测试类

主要测试了，自己手动编写表头和自动配置生成表头两种方法，同时还测试了Excel转List数据

package com.yellowcong.test;

import java.io.File;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yellowcong.model.Pager;
import com.yellowcong.model.SystemContext;
import com.yellowcong.model.User;
import com.yellowcong.service.UserService;
import com.yellowcong.utils.HFFSAlias;
import com.yellowcong.utils.PoiUtils;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:ApplicationContext.xml")
public class UserServiceTest {

private UserService userService;

@Resource(name="userService")
public void setUserService(UserService userService) {
this.userService = userService;
}

@Test
public void testList(){
List<User> users= userService.listByPager().getData();
//可以做成annotation的
Map<String,String> map = new HashMap<String, String>();
map.put("id", "编号");
map.put("username", "用户名");
map.put("nickname", "别名");
map.put("password", "密码");
map.put("createDate", "创建日期");
map.put("imgUrl", "头像路径");
map.put("email", "邮箱");
map.put("phone", "电话");
map.put("isActive", "是否激活");

HSSFWorkbook work = PoiUtils.createHSSF(map, users);
PoiUtils.copyHSSFToFile(work, new File("D:/users.xls"));
}

@Test
public void testList2Anotation(){
List<User> users= userService.listByPager().getData();
HSSFWorkbook work = PoiUtils.createHSSFByAnnotation(users);
PoiUtils.copyHSSFToFile(work, new File("D:/users.xls"));
}

}

测试结果