hzs0502030128
- 浏览: 23797 次
- 性别:
- 来自: 广州
-
最新评论
-
Wuaner：
<div class="quote_t ...
导出数据到Excel表中--用Apache的POI实现简单封装 -
ilove2009：
<div class="quote_t ...
导出数据到Excel表中--用Apache的POI实现简单封装 -
qtalen：
<div class="quote_t ...
导出数据到Excel表中--用Apache的POI实现简单封装 -
qtalen：
<p>LZ好，你这个挺好用的，不过 ...
导出数据到Excel表中--用Apache的POI实现简单封装 -
studyoo：
是POI不是PIO。
导出数据到Excel表中--用Apache的POI实现简单封装
使用Apache的POI 实现对数据导出到EXCEL表中进行了一个简单的封装，可以通过XML配置文件配置你想导出的信息，以下是这个小工具的代码：
DataImportAndExportTool.java 代码：
MethodTool.java 代码：
现在做一个测试：
下面是一个hibernate 实体映射类
只要在classPath下建一个文件：
里面配置你想导出的字段
Medicine.xml
就可以导出数据了：
以下是导出数据到EXCEL的应用；
这样就可以一个Excel表了
DataImportAndExportTool.java 代码：
package nhu.drugstore.uitl;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class DataImportAndExportTool
{
private class Entiy
{
String name;
String text;
String type;
}
private static DataImportAndExportTool tool=new DataImportAndExportTool();
/**
* 空的构造方法
*/
private DataImportAndExportTool()
{
//do nothing
}
/**
*
* 以一个数组方式创建一个标题行
* @param row
* @param title
*/
private void createTitleRow(HSSFWorkbook workbook,HSSFRow row,String[] title)
{
int length=title.length;
HSSFCellStyle style=workbook.createCellStyle();
HSSFFont font=workbook.createFont();
font.setColor(HSSFColor.BLUE.index);
font.setFontHeightInPoints((short)14);
font.setBoldweight((short)24);
style.setFont(font);
style.setFillBackgroundColor(HSSFColor.YELLOW.index);
for(int i=0;i<length;i++)
{
HSSFCell cell=row.createCell(i);
cell.setCellValue(title);
cell.setCellStyle(style);
}
}
/**
* 解析XML文件
* @param className
* @return
* @throws ParserConfigurationException
* @throws IOException
* @throws SAXException
*/
private List<Entiy> parseXML(String className) throws Exception
{
List<Entiy> list=new ArrayList<Entiy>();
Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(this.getClass().getClassLoader().getResourceAsStream("/"+className+".xml"));
NodeList nodeList=doc.getElementsByTagName("property");
Element element;
for(int i=0;i<nodeList.getLength();i++)
{
element=(Element)nodeList.item(i);
Entiy e=new Entiy();
e.name=element.getAttribute("name");
e.text=element.getAttribute("text");
e.type=element.getAttribute("type");
list.add(e);
}
return list;
}
/**
* 创建工作表的标题行
* @param workbook
* @param row
* @param list
*/
private void createTitleRow(HSSFWorkbook workbook,HSSFRow row,List<Entiy> list)
{
HSSFCellStyle style=workbook.createCellStyle();
HSSFFont font=workbook.createFont();
font.setColor(HSSFColor.BLUE.index);
font.setFontHeightInPoints((short)14);
font.setBoldweight((short)24);
style.setFont(font);
style.setFillBackgroundColor(HSSFColor.YELLOW.index);
int i=0;
for(Entiy e:list)
{
HSSFCell cell=row.createCell(i++);
cell.setCellValue(e.text);
cell.setCellStyle(style);
}
}
/**
* 从一个列表中创建出一个工作空间
* @param list
* @param sheetName
* @return
* @throws Exception
*/
public static HSSFWorkbook ExportToExcel(List list,String sheetName) throws Exception
{
Class c=list.get(0).getClass();
String className=c.getSimpleName();
//解析XML文件中的信息到一个列表中
List<Entiy> entiyList=tool.parseXML(className);
//创建一个空工作空间
HSSFWorkbook workbook=new HSSFWorkbook();
//创建一个表
HSSFSheet sheet=workbook.createSheet(sheetName);
//创建标题行
HSSFRow titleRow=sheet.createRow(0);
tool.createTitleRow(workbook, titleRow,entiyList);
/*
* 创建表中的信息
*/
int rowNum=1;
for(int i=0;i<list.size();i++)
{
HSSFRow row=sheet.createRow(rowNum++);
int colNum=0;
for(Entiy e:entiyList)
{
if(e.type.endsWith("String"))
{
row.createCell(colNum++).setCellValue((String)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else if("int".equals(e.type)||"java.lang.Integer".equals(e.type))
{
row.createCell(colNum++).setCellValue((Integer)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else if("double".equals(e.type)||"java.lang.Double".equals(e.type))
{
row.createCell(colNum++).setCellValue((Double)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else if(e.type.endsWith("Date"))
{
row.createCell(colNum++).setCellValue((Date)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else if(e.type.endsWith("Calendar"))
{
row.createCell(colNum++).setCellValue((Calendar)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else if("boolean".equals(e.type)||"java.lang.Boolean".equals(e.type))
{
row.createCell(colNum++).setCellValue((Double)MethodTool.excuteMethod(list.get(i),MethodTool.returnGetMethodName(e.name)));
}
else
{
throw new Exception("数据类型错误");
}
}
}
return workbook;
}
}
MethodTool.java 代码：
package nhu.drugstore.uitl;
import java.lang.reflect.Method;
/**
* 这是一个用于方法反射的工具类
* 这将运用JDK的反射机制
* @author strive
*
*/
public class MethodTool
{
/**
* 反转一个有返回值的无参方法
* @param object
* @param methodName
* @return
* @throws Exception
*/
public static Object excuteMethod(Object object,String methodName) throws Exception
{
Class c=object.getClass();
Method m=c.getMethod(methodName);
return m.invoke(object);
}
/**
* 反转一个没有返回值的有一个参数的方法
* @param object
* @param methodName
* @param parameter
* @throws Exception
*/
public static void excuteMethod(Object object,String methodName,Object parameter) throws Exception
{
Class c=object.getClass();
Method m=c.getDeclaredMethod(methodName, parameter.getClass());
m.invoke(object,parameter);
}
/**
* 执行一个参数为boolean类型的方法
* @param object
* @param methodName
* @param parameter
* @throws Exception
*/
public static void excuteBoolMethod(Object object,String methodName,boolean parameter) throws Exception
{
Class c=object.getClass();
Method m=c.getDeclaredMethod(methodName,boolean.class);
m.invoke(object,parameter);
}
/**
* 获得一个属性的set方法名
* @param property
* @return
*/
public static String returnSetMethodName(String property)
{
return "set"+Character.toUpperCase(property.charAt(0))+property.substring(1);
}
/**
* 获得一个属性的get方法名
* @param property
* @return
*/
public static String returnGetMethodName(String property)
{
return "get"+Character.toUpperCase(property.charAt(0))+property.substring(1);
}
}
现在做一个测试：
下面是一个hibernate 实体映射类
/
package nhu.drugstore.bean;
/**
* this is a class description a model of Medicine
* only some geter and seter method
* @author strive
* @hibernate.class
*/
public class Medicine
{
/**
* 主键
* @hibernate.id generator-class="native"
*/
private int id;
/**
* 药品名称
* @hibernate.property
* unique="true"
*/
private String name;
/**
* 放药药框
* @hibernate.property
*/
private String ark;
/**
* 条形码
* @hibernate.property
*
*/
private String barCode;
/**
* 功效描述
* @hibernate.property
*/
private String efficacy;
/**
* 进货价格
* @hibernate.property
*/
private double buyPrice;
/**
* 出售价格
* @hibernate.property
*/
private double sellPrice;
/**
* 库存量
* @hibernate.property
*/
private double stockpile;
/**
* 库存不足提示数量
* @hibernate.property
*/
private double cueNumber;
/**
* 打折百分比
* @hibernate.property
*/
private double rebate;
/**
* 提成百分比
* @hibernate.property
*/
private double rakeOff;
/**
* 拼音简查码
* @hibernate.property
*/
private String spellShort;
/**
* 数字简查码
* @hibernate.property
*/
private String numberShort;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getArk()
{
return ark;
}
public void setArk(String ark)
{
this.ark = ark;
}
public String getBarCode()
{
return barCode;
}
public void setBarCode(String barCode)
{
this.barCode = barCode;
}
public String getEfficacy()
{
return efficacy;
}
public void setEfficacy(String efficacy)
{
this.efficacy = efficacy;
}
public double getBuyPrice()
{
return buyPrice;
}
public void setBuyPrice(double buyPrice)
{
this.buyPrice = buyPrice;
}
public double getSellPrice()
{
return sellPrice;
}
public void setSellPrice(double sellPrice)
{
this.sellPrice = sellPrice;
}
public double getStockpile()
{
return stockpile;
}
public void setStockpile(double stockpile)
{
this.stockpile = stockpile;
}
public double getCueNumber()
{
return cueNumber;
}
public void setCueNumber(double cueNumber)
{
this.cueNumber = cueNumber;
}
public double getRebate()
{
return rebate;
}
public void setRebate(double rebate)
{
this.rebate = rebate;
}
public double getRakeOff()
{
return rakeOff;
}
public void setRakeOff(double rakeOff)
{
this.rakeOff = rakeOff;
}
public String getSpellShort()
{
return spellShort;
}
public void setSpellShort(String spellShort)
{
this.spellShort = spellShort;
}
public String getNumberShort()
{
return numberShort;
}
public void setNumberShort(String numberShort)
{
this.numberShort = numberShort;
}
}
只要在classPath下建一个文件：
里面配置你想导出的字段
Medicine.xml
<?xml version="1.0" encoding="UTF-8"?> <bean class="nhu.drugstore.bean.Medicine"> <property name="name" text="药品名称" type="String"/> <property name="ark" text="放药药框" type="String"/> <property name="barCode" text="条形码" type="String"/> <property name="buyPrice" text="进货价格" type="double"/> <property name="stockpile" text="库存量" type="double"/> <property name="sellPrice" text="出售价格" type="double"/> <property name="rebate" text="打折百分比" type="double"/> <property name="efficacy" text="功效描述" type="String"/> </bean>
就可以导出数据了：
以下是导出数据到EXCEL的应用；
File outputFile=new File("C:/");
OutputStream fOut = new PrintStream(outputFile);
// 把相应的Excel 工作簿存盘
DataImportAndExportTool.ExportToExcel(medicineDao.getAllMedicine(),"药材信息表").write(fOut);
fOut.flush();
// 操作结束，关闭文件
fOut.close();
这样就可以一个Excel表了
分享到：
评论
5 楼
Wuaner
2010-07-14
<div class="quote_title">ilove2009 写道</div>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
</div>
<br>就是不知道这么大量的使用反射会不会性能有问题</div>
<p><br>1、把配置写到java里，要是需求改变，是不是重新编译代码</p>
<p>2、to LZ：如果用户对数据格式有要求，不如日期有yyyyMMdd或者yyyy-MM-dd不同需要，好像不能满足。</p>
</div>
<p> </p>
<p> </p>
<p>使用注解的方式确实得重新编译，这点比不上使用xml的方式啊；</p>
<p>日期的格式，为方法多加个日期格式的参数，呵呵。</p>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
</div>
<br>就是不知道这么大量的使用反射会不会性能有问题</div>
<p><br>1、把配置写到java里，要是需求改变，是不是重新编译代码</p>
<p>2、to LZ：如果用户对数据格式有要求，不如日期有yyyyMMdd或者yyyy-MM-dd不同需要，好像不能满足。</p>
</div>
<p> </p>
<p> </p>
<p>使用注解的方式确实得重新编译，这点比不上使用xml的方式啊；</p>
<p>日期的格式，为方法多加个日期格式的参数，呵呵。</p>
4 楼
ilove2009
2010-01-04
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
</div>
<br>就是不知道这么大量的使用反射会不会性能有问题</div>
<p><br>1、把配置写到java里，要是需求改变，是不是重新编译代码</p>
<p>2、to LZ：如果用户对数据格式有要求，不如日期有yyyyMMdd或者yyyy-MM-dd不同需要，好像不能满足。</p>
<div class="quote_div">
<div class="quote_title">qtalen 写道</div>
<div class="quote_div">
<p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
</div>
<br>就是不知道这么大量的使用反射会不会性能有问题</div>
<p><br>1、把配置写到java里，要是需求改变，是不是重新编译代码</p>
<p>2、to LZ：如果用户对数据格式有要求，不如日期有yyyyMMdd或者yyyy-MM-dd不同需要，好像不能满足。</p>
3 楼
qtalen
2010-01-04
<div class="quote_title">qtalen 写道</div><div class="quote_div"><p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p></div><br/>就是不知道这么大量的使用反射会不会性能有问题
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p></div><br/>就是不知道这么大量的使用反射会不会性能有问题
2 楼
qtalen
2009-12-30
<p>LZ好，你这个挺好用的，不过我在项目搞了一些改造：</p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
<p>首先加了一个annotation:</p>
<pre name="code" class="java">@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Cell {
/**
* 该字段对应的表格头
*/
public String title();
}</pre>
<p> 接着在ExportTool里增加一个方法来解析annotation:</p>
<pre name="code" class="java">/**
* 解析出元数据信息，初始化excel导出
*
* @param className
* @return
* @throws ClassNotFoundException
*/
private List<Entity> parseAnnotation(Class clazz)
throws ClassNotFoundException {
List<Entity> entities = new ArrayList<Entity>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Entity e = new Entity();
boolean hasAnnotation = field.isAnnotationPresent(Cell.class);
if (hasAnnotation) {
Cell annotation = field.getAnnotation(Cell.class);
e.title = annotation.title();
e.type = field.getType().getName();
e.name = field.getName();
entities.add(e);
}
}
return entities;
}</pre>
<p> 其他的变动不大，对于需要导出的值对象，用annotation标注一下就可以了：</p>
<pre name="code" class="java">public class Student {
@Cell(title = "学号")
private long serialNumber;
@Cell(title = "姓名")
private String name;
@Cell(title = "性别")
private String sexual;
@Cell(title = "分数")
private Long score;
…
}
</pre>
<p> </p>
<p> </p>
<p> </p>
1 楼
studyoo
2009-09-21
是POI不是PIO。
发表评论
相关推荐
在IT行业中，Apache POI是一个广泛使用的库，主要用于读取和写入Microsoft Office格式的文件，尤其是Excel。本文将深入探讨如何使用POI库来实现Excel文件的导出，以及如何将图片URL转换为图片文件并与其他文件一起...
总之，利用 Apache POI 实现多表头的 Excel 导出，需要理解 POI API，合理组织数据结构，以及灵活运用单元格合并和样式设置。结合提供的代码文件，你可以进一步研究和学习如何在实际项目中应用这些技术。
在"基于poi的excel导入导出封装"这个主题中，我们将深入探讨如何使用Apache POI库来实现Excel文件的导入和导出功能。 **一、Apache POI基本概念** 1. **工作簿（Workbook）**: 在Apache POI中，工作簿是Excel文件...
在本示例中，"poi导出excel demo"指的是使用Apache POI库创建和导出Excel文件的演示。这个项目可能包含了一个或多个Java源代码文件，展示了如何使用POI API来生成Excel工作簿、工作表、单元格等内容。 Apache POI ...
在本文中，我们将深入探讨如何使用Apache POI库实现Excel的导入和导出功能，这对于处理大量数据和自动化办公流程非常有用。 首先，让我们了解一下Apache POI的核心组件HSSF（Horrible Spreadsheet Format）和XSSF...
本教程将深入探讨如何利用POI在Java环境中实现数据的Excel导出功能，包括在控制台程序、Java Web应用以及框架中的应用。 ### POI基本概念 1. **工作簿（Workbook）**: 在POI中，工作簿代表整个Excel文件。你可以...
在你提供的信息中，“基于poi封装的word-excel-Pdf导出的xdoc设计”是一个使用Apache POI进行文件处理的项目，它包含了将数据导出到Word、Excel和PDF格式的功能。 1. **Apache POI**: Apache POI 是一套用于处理...
本文将深入探讨如何使用Apache POI来创建和导出具有复杂表头的Excel文件，包括合并行和合并列的功能。首先，我们需要理解Apache POI的基本概念和API。 Apache POI提供了一个编程接口，允许Java开发者处理Microsoft ...
虽然Apache POI本身并不直接支持Excel到PDF的转换，但Easy POI通过引入第三方库如 Flying Saucer 或 Apache FOP 实现了这一功能。首先，你需要将Excel文件读取为一个工作簿对象，然后利用PDF生成器，将每个工作表...
标题提到的"java中excel导出工具poi接口封装"是指开发者为了简化业务代码，提高代码复用性和易用性，对Apache POI的API进行了二次封装。这种封装通常会创建一个或多个高级接口，隐藏了底层复杂的细节，让调用者能更...
模板管理中有一个导出模板功能，可以将模板导出到Excel表格中。模板下可以嵌套的是指标或模板，但是模板的最底层必定是指标。然而，在导出过程中存在三个问题： 1. 模板/指标定位位置的问题 2. 编码过程中，出现Row...
在EasyUIPoI中，导出Excel的过程被封装成了一套简单的API。首先，你需要创建一个模板文件，定义好Excel的结构和样式，例如单元格的合并、字体、颜色等。模板文件可以使用Microsoft Excel来创建，保存为`.xlsx`格式，...
本文将深入讲解如何使用Apache POI创建一个简单的Excel导出工具类。 1. **安装与引入Apache POI** 在开始之前，你需要在项目中添加Apache POI的依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ...
Java 实现数据导出到Excel是一项常见的任务，尤其在企业级应用中，如基于SSH（Struts、Spring、Hibernate）框架的系统。本教程将详细讲解如何使用Java来创建一个Excel 2003格式的工作簿，以满足数据导出的需求。 ...
标题“poi导出excel通用类”指的是使用Apache POI库创建一个可以用于导出Excel文件的Java类。Apache POI是开源项目，提供了一组API，使得开发者可以在Java应用程序中读写Microsoft Office格式的文件，包括Excel。在...
在提供的“java-excel导入导出”压缩包中，可能包含了示例代码、说明文档以及测试数据，可以帮助初学者快速理解和使用Java POI进行Excel操作。通过学习和实践这些示例，你可以掌握Java POI库的基本用法，并能灵活...
通过上述步骤，你可以使用Apache POI结合Struts 2实现从Java Web应用中导出Excel报表的功能。这个过程涉及到了Java编程、面向对象设计、Web框架和文件处理等多个技术领域，对于Java开发者来说是一项非常实用的技能。
在IT行业中，将数据导出为...总结来说，Struts2框架结合Apache POI库，使得在Java web应用中实现数据导出至Excel的功能变得简单高效。这种能力对于提升用户体验，特别是处理大量数据时的查看和分析，具有很大的价值。
然后，我们创建一个Sheet对象，代表Excel中的一个工作表。 2. **构建复杂表头** 复杂表头可能包括多行或多列合并，甚至嵌套的表头。这可以通过调用`sheet.addMergedRegion`方法来实现单元格的合并。对于嵌套表头，...
Easy-Poi是一款优秀的Java库，它简化了与Excel文件交互的过程，使得在Java项目中进行Excel的导入导出变得简单易行。本文将深入探讨如何使用Easy-Poi进行Excel操作，并基于提供的jar包及示例代码进行实践解析。 首先...