`
liukai
  • 浏览: 706404 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

Spring3MVC and POI

ExcelSpringApacheITeyeJDBC 
阅读更多
本教程我们将通过Apache的 POI进行excel的导出和写入:
即把数据库的数据导出excel格式,
读取excel表报中的数据并写入数据库.

我们将会使用mysql进行数据的操作.

POI是什么?

引用
Apache POI是Apache软件基金会的开放源码函式库，POI提供API给Java程式对Microsoft Office格式档案读和写的功能。 .NET的开发人员则可以利用NPOI (POI for .NET) 来存取 POI 的功能。


也可以访问Apache POI 官方网站

目前最新版本为3.8b2,此教程我们将采用3.7版本.

对于POI的基本用法可以观看官方的quick-guide

下面是我们的应用程序文件夹结构:



然后是pom.xml里添加的jar包:



注意:poi的jar包一定要导入poi-ooxml
通过依赖顺便能导入poi.
如果直接导入poi后面的WebbookFactory将找不到jar包.

在数据库spring3db中创建一个表 computer 
CREATE TABLE `computer` (
  `ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `BRAND` VARCHAR(255) DEFAULT NULL,
  `CPU` VARCHAR(255) DEFAULT NULL,
  `GPU` VARCHAR(255) DEFAULT NULL,
  `MEMORY` VARCHAR(255) DEFAULT NULL,
  `PRICE` DOUBLE DEFAULT NULL,
  PRIMARY KEY (`ID`)
) ENGINE=INNODB AUTO_INCREMENT=67 DEFAULT CHARSET=utf8


也可以直接把附件代码中src/main/resource/data下面的spring3db.sql导入数据库中.
导入后的数据库如下所示




首先添加Spring MVC所必须的配置.

web.xml 

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
	xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

	<welcome-file>index.jsp</welcome-file>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
		/WEB-INF/application-dataSource.xml
		/WEB-INF/applicationContext.xml
		</param-value>
	</context-param>

	<servlet>
		<servlet-name>spring</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>spring</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>


</web-app>


在web.xml中我们定义servlet:spring.
按照惯例,我们必须声明一个spring-servle.xml

spring-servle.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!-- 定义一个视图解析器 -->
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver"
		p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />

	<!-- Spring分段文件上传所必须的 ,用于检查请求中是否包含multipart
	see: http://www.html.org.cn/books/springReference/ch13s08.html
	-->
	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver" p:maxUploadSize="5000000"
	 />
		
</beans>


这个XML配置声明一个视图解析器.在控制器中会根据JSP名映射到/ WEB-INF/jsp中相应的位置.
spring-servle.xml中的multipartResolver是Spring分段文件上传所必须的 ,用于检查请求中是否包含multipart.
更多的详情对分段文件上传（multipart file upload）的支持

要进行数据库操作,一定需要一个数据库连接的配置.

jdbc.properties 
# database properties
#spring3db is databaseName.
app.jdbc.driverClassName=com.mysql.jdbc.Driver
app.jdbc.url=jdbc:mysql://localhost/spring3db
app.jdbc.username=root
app.jdbc.password=root



application-dataSource.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

	<description>dataSource配置</description>

	<!-- 指定数据库配置文件地址. -->
	<context:property-placeholder location="classpath*:/jdbc.properties"/>
	
	 <!-- 启用注释管理事务注释风格. -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

	<!--声明一个数据源.c3p0-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close"
		p:driverClass="${app.jdbc.driverClassName}"
		p:jdbcUrl="${app.jdbc.url}"
		p:user="${app.jdbc.username}"
		p:password="${app.jdbc.password}"
		p:acquireIncrement="5"
		p:idleConnectionTestPeriod="60"
		p:maxPoolSize="100"
		p:maxStatements="50"
		p:minPoolSize="10" 
		p:maxIdleTime="25000"
	/>
	
	<!--声明一个事务管理器. -->
	<bean id="transactionManager"
	class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
	p:dataSource-ref="dataSource" />
	

</beans>


该文件主要配置了:
1.启用了事务管理
2.声明了一个数据源

然后创建一个applicationContext.xml.

applicationContext.xml. 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	   		http://www.springframework.org/schema/context
	   		http://www.springframework.org/schema/context/spring-context-3.0.xsd
			http://www.springframework.org/schema/mvc 
			http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

	<!-- 激活spring的注解. -->
	<context:annotation-config />

	<!-- 扫描注解组件并且自动的注入spring beans中. 
	例如,他会扫描@Controller 和@Service下的文件.所以确保此base-package设置正确. -->
	<context:component-scan base-package="org.liukai.tutorial" />

	<!-- 配置注解驱动的Spring MVC Controller 的编程模型.注:此标签只在 Servlet MVC工作! -->
	<mvc:annotation-driven />
	
</beans>


至此,基本的配置文件就完成了.

然后我们定义一个Computer对象

Computer.java 
package org.liukai.tutorial.domain;

import java.io.Serializable;

public class Computer implements Serializable {

	private static final long serialVersionUID = 7955753961332480136L;

	private Long id;
	private String brand;
	private String cpu;
	private String gpu;
	private String memory;
	private Double price;

	//getter&setter

}



接下来就是POI来操作excel了.

需要注意的是POI里每个不同的模块代表了对不同格式档案的操作.如下:

 
引用
 
    HSSF － 提供读写Microsoft Excel XLS格式档案的功能。
    XSSF － 提供读写Microsoft Excel OOXML XLSX格式档案的功能。
    HWPF － 提供读写Microsoft Word DOC格式档案的功能。
    HSLF － 提供读写Microsoft PowerPoint格式档案的功能。
    HDGF － 提供读Microsoft Visio格式档案的功能。
    HPBF － 提供读Microsoft Publisher格式档案的功能。
    HSMF － 提供读Microsoft Outlook格式档案的功能。


在本教程中我们是实现对excel的操作.所以包含了HSSF和XLSX(开头在pom导入中强调了需要
导入ooxml的jar包,也包含了XSSF)

对导出的excel进行自定义格式:

Layouter.java 
package org.liukai.tutorial.poi;


import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.util.CellRangeAddress;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.liukai.tutorial.utils.DateUtils;

/**
 * 更多单元格请查看http://justdoblogger.com/blog/200911/setfillforegroundcolor.html
 * 
 * @author liukai
 * 
 */
@SuppressWarnings("deprecation")
public class Layouter {

	/**
	 * 创建报表
	 */
	public static void buildReport(HSSFSheet worksheet, int startRowIndex,
			int startColIndex) {
		// 设置列的宽度
		worksheet.setColumnWidth(0, 5000);
		worksheet.setColumnWidth(1, 5000);
		worksheet.setColumnWidth(2, 5000);
		worksheet.setColumnWidth(3, 5000);
		worksheet.setColumnWidth(4, 5000);
		worksheet.setColumnWidth(5, 5000);

		buildTitle(worksheet, startRowIndex, startColIndex);

		buildHeaders(worksheet, startRowIndex, startColIndex);

	}

	/**
	 * 创建报表标题和日期
	 */
	private static void buildTitle(HSSFSheet worksheet, int startRowIndex,
			int startColIndex) {
		// 设置报表标题字体
		Font fontTitle = worksheet.getWorkbook().createFont();
		fontTitle.setBoldweight(Font.BOLDWEIGHT_BOLD);
		fontTitle.setFontHeight((short) 280);

		// 标题单元格样式
		HSSFCellStyle cellStyleTitle = worksheet.getWorkbook()
				.createCellStyle();
		cellStyleTitle.setAlignment(CellStyle.ALIGN_CENTER);
		cellStyleTitle.setWrapText(true);
		cellStyleTitle.setFont(fontTitle);

		// 报表标题
		HSSFRow rowTitle = worksheet.createRow((short) startRowIndex);
		rowTitle.setHeight((short) 500);
		HSSFCell cellTitle = rowTitle.createCell(startColIndex);
		cellTitle.setCellValue("Computer Report!");
		cellTitle.setCellStyle(cellStyleTitle);

		// 合并区域内的报告标题
		worksheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 5));

		// date header
		HSSFRow dateTitle = worksheet.createRow((short) startRowIndex + 1);
		HSSFCell cellDate = dateTitle.createCell(startColIndex);
		cellDate.setCellValue("这个报表创建于: " + DateUtils.getNowTime());
	}

	/**
	 * 创建表头
	 */
	private static void buildHeaders(HSSFSheet worksheet, int startRowIndex,
			int startColIndex) {
		// Header字体
		Font font = worksheet.getWorkbook().createFont();
		font.setBoldweight(Font.BOLDWEIGHT_BOLD);

		// 单元格样式
		HSSFCellStyle headerCellStyle = worksheet.getWorkbook()
				.createCellStyle();
		headerCellStyle.setFillBackgroundColor(HSSFColor.GREY_25_PERCENT.index);
		headerCellStyle.setFillPattern(CellStyle.FINE_DOTS);
		headerCellStyle.setAlignment(CellStyle.ALIGN_CENTER);
		headerCellStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
		headerCellStyle.setWrapText(true);
		headerCellStyle.setFont(font);
		headerCellStyle.setBorderBottom(CellStyle.BORDER_THIN);

		// 创建字段标题
		HSSFRow rowHeader = worksheet.createRow((short) startRowIndex + 2);
		rowHeader.setHeight((short) 500);

		HSSFCell cell1 = rowHeader.createCell(startColIndex + 0);
		cell1.setCellValue("Id");
		cell1.setCellStyle(headerCellStyle);

		HSSFCell cell2 = rowHeader.createCell(startColIndex + 1);
		cell2.setCellValue("Brand");
		cell2.setCellStyle(headerCellStyle);

		HSSFCell cell3 = rowHeader.createCell(startColIndex + 2);
		cell3.setCellValue("CPU");
		cell3.setCellStyle(headerCellStyle);

		HSSFCell cell4 = rowHeader.createCell(startColIndex + 3);
		cell4.setCellValue("GPU");
		cell4.setCellStyle(headerCellStyle);

		HSSFCell cell5 = rowHeader.createCell(startColIndex + 4);
		cell5.setCellValue("Memory");
		cell5.setCellStyle(headerCellStyle);

		HSSFCell cell6 = rowHeader.createCell(startColIndex + 5);
		cell6.setCellValue("Price");
		cell6.setCellStyle(headerCellStyle);

	}

}


可以通过POI单元格顔色设定了解更多的信息.

然后我们是填充数据的一个类:

FillComputerManager.java 

package org.liukai.tutorial.poi;

import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.ss.usermodel.CellStyle;
import org.liukai.tutorial.domain.Computer;

public class FillComputerManager {

	public static void fillReport(HSSFSheet worksheet, int startRowIndex,
			int startColIndex, List<Computer> datasource) {

		// Row offset
		startRowIndex += 2;

		// Create cell style for the body
		HSSFCellStyle bodyCellStyle = worksheet.getWorkbook().createCellStyle();
		bodyCellStyle.setAlignment(CellStyle.ALIGN_CENTER);
		bodyCellStyle.setWrapText(false); //是否自动换行.

		// Create body
		for (int i=startRowIndex; i+startRowIndex-2< datasource.size()+2; i++) {
			// Create a new row
			HSSFRow row = worksheet.createRow((short) i+1);

			// Retrieve the id value
			HSSFCell cell1 = row.createCell(startColIndex+0);
			cell1.setCellValue(datasource.get(i-2).getId());
			cell1.setCellStyle(bodyCellStyle);

			// Retrieve the brand value
			HSSFCell cell2 = row.createCell(startColIndex+1);
			cell2.setCellValue(datasource.get(i-2).getBrand());
			cell2.setCellStyle(bodyCellStyle);

			// Retrieve the model value
			HSSFCell cell3 = row.createCell(startColIndex+2);
			cell3.setCellValue(datasource.get(i-2).getCpu());
			cell3.setCellStyle(bodyCellStyle);

			// Retrieve the maximum power value
			HSSFCell cell4 = row.createCell(startColIndex+3);
			cell4.setCellValue(datasource.get(i-2).getGpu());
			cell4.setCellStyle(bodyCellStyle);

			// Retrieve the price value
			HSSFCell cell5 = row.createCell(startColIndex+4);
			cell5.setCellValue(datasource.get(i-2).getMemory());
			cell5.setCellStyle(bodyCellStyle);
		
			// Retrieve the efficiency value
			HSSFCell cell6 = row.createCell(startColIndex+5);
			cell6.setCellValue(datasource.get(i-2).getPrice());
			cell6.setCellStyle(bodyCellStyle);
		}
	}
}


报表写入类

Writer.java 
package org.liukai.tutorial.poi;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFSheet;

public class Writer {
	
	private static Logger logger = Logger.getLogger("service");

	public static void write(HttpServletResponse response, HSSFSheet worksheet) {

		logger.debug("Writing report to the stream");
		try {
			// Retrieve the output stream
			ServletOutputStream outputStream = response.getOutputStream();
			// Write to the output stream
			worksheet.getWorkbook().write(outputStream);
			// 清除缓存
			outputStream.flush();

		} catch (Exception e) {
			logger.error("报表输入失败!");
		}
	}

}

这样对导出表报的格式基本设置完成.

接着我们完成一个对数据库进行操作的类.
PoiDao.java 

package org.liukai.tutorial.dao;

import java.util.List;

import javax.annotation.Resource;
import javax.sql.DataSource;

import org.liukai.tutorial.domain.Computer;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("poiDao")
public class PoiDao {

	private SimpleJdbcTemplate jdbcTemplate;

	@Resource(name = "dataSource")
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new SimpleJdbcTemplate(dataSource);
	}

	public List<Computer> getComputer() {
		String sql = "SELECT * FROM computer";
		return jdbcTemplate.query(sql, new BeanPropertyRowMapper<Computer>(
				Computer.class));

	}

	public int[] insertComputer(List<Computer> list) {
		String sql = "INSERT INTO computer (BRAND,CPU,GPU,MEMORY,PRICE)VALUES(:brand,:cpu,:gpu,:memory,:price)";
		SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(list
				.toArray());
		return jdbcTemplate.batchUpdate(sql, batch);

	}

}

该类我们实现了两个方法:查询所有的Computer对象并装入一个list的类 : getComputer
批量插入的类:insertComputer
前者用于报表的导出,后者用于报表的插入.

业务层中我们还是需要实现两个业务:导出和导入excel文件.

PoiService.java 
package org.liukai.tutorial.service;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.liukai.tutorial.dao.PoiDao;
import org.liukai.tutorial.domain.Computer;
import org.liukai.tutorial.poi.FillComputerManager;
import org.liukai.tutorial.poi.Layouter;
import org.liukai.tutorial.poi.Writer;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("poiService")
@Transactional
public class PoiService {

	@Resource(name = "poiDao")
	private PoiDao dao;
	private static Logger logger = Logger.getLogger("service");

	public void exportXLS(HttpServletResponse response) {

		// 1.创建一个 workbook
		HSSFWorkbook workbook = new HSSFWorkbook();

		// 2.创建一个 worksheet
		HSSFSheet worksheet = workbook.createSheet("Computer");

		// 3.定义起始行和列
		int startRowIndex = 0;
		int startColIndex = 0;

		// 4.创建title,data,headers
		Layouter.buildReport(worksheet, startRowIndex, startColIndex);

		// 5.填充数据
		FillComputerManager.fillReport(worksheet, startRowIndex, startColIndex,
				getDatasource());

		// 6.设置reponse参数
		String fileName = "ComputersReport.xls";
		response.setHeader("Content-Disposition", "inline; filename="
				+ fileName);
		// 确保发送的当前文本格式
		response.setContentType("application/vnd.ms-excel");

		// 7. 输出流
		Writer.write(response, worksheet);

	}

	/**
	 * 读取报表
	 */
	public List<Computer> readReport(InputStream inp) {

		List<Computer> computerList = new ArrayList<Computer>();

		try {
			String cellStr = null;

			Workbook wb = WorkbookFactory.create(inp);

			Sheet sheet = wb.getSheetAt(0);// 取得第一个sheets

			//从第四行开始读取数据
			for (int i = 3; i <= sheet.getLastRowNum(); i++) {

				Computer computer = new Computer();
				Computer addComputer = new Computer();

				Row row = sheet.getRow(i); // 获取行(row)对象

				if (row == null) {
					// row为空的话,不处理
					continue;
				}

				for (int j = 0; j < row.getLastCellNum(); j++) {

					Cell cell = row.getCell(j); // 获得单元格(cell)对象

					// 转换接收的单元格
					cellStr = ConvertCellStr(cell, cellStr);

					// 将单元格的数据添加至一个对象
					addComputer = addingComputer(j, computer, cellStr);

				}
				// 将添加数据后的对象填充至list中
				computerList.add(addComputer);
			}

		} catch (InvalidFormatException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inp != null) {
				try {
					inp.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			} else {
				logger.info("没有数据流!");
			}
		}
		return computerList;

	}

	/**
	 * 从数据库获得所有的Computer信息.
	 */
	private List<Computer> getDatasource() {
		return dao.getComputer();
	}

	/**
	 * 读取报表的数据后批量插入
	 */
	public int[] insertComputer(List<Computer> list) {
		return dao.insertComputer(list);

	}

	/**
	 * 获得单元格的数据添加至computer
	 * 
	 * @param j
	 *            列数
	 * @param computer
	 *            添加对象
	 * @param cellStr
	 *            单元格数据
	 * @return
	 */
	private Computer addingComputer(int j, Computer computer, String cellStr) {
		switch (j) {
		case 0:
			computer.setId(null);
			break;
		case 1:
			computer.setBrand(cellStr);
			break;
		case 2:
			computer.setCpu(cellStr);
			break;
		case 3:
			computer.setGpu(cellStr);
			break;
		case 4:
			computer.setMemory(cellStr);
			break;
		case 5:
			computer.setPrice(new Double(cellStr).doubleValue());
			break;
		}

		return computer;
	}

	/**
	 * 把单元格内的类型转换至String类型
	 */
	private String ConvertCellStr(Cell cell, String cellStr) {

		switch (cell.getCellType()) {

		case Cell.CELL_TYPE_STRING:
			// 读取String
			cellStr = cell.getStringCellValue().toString();
			break;

		case Cell.CELL_TYPE_BOOLEAN:
			// 得到Boolean对象的方法
			cellStr = String.valueOf(cell.getBooleanCellValue());
			break;

		case Cell.CELL_TYPE_NUMERIC:

			// 先看是否是日期格式
			if (DateUtil.isCellDateFormatted(cell)) {

				// 读取日期格式
				cellStr = cell.getDateCellValue().toString();

			} else {

				// 读取数字
				cellStr = String.valueOf(cell.getNumericCellValue());
			}
			break;

		case Cell.CELL_TYPE_FORMULA:
			// 读取公式
			cellStr = cell.getCellFormula().toString();
			break;
		}
		return cellStr;
	}

}


此业务层实现了两个方法:
exportXLS:用于读取数据库并导出报表.
readReport:用于读取报表并插入数据库中.

untils包里的DateUtils.java只有一个类,用于格式化日期.

DateUtils.java 
package org.liukai.tutorial.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtils {

	/**
	 * 获得yyyy-MM-dd格式的当前日期
	 */
	public static String getNowTime() {
		Date date = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
		return dateFormat.format(date);
	}

}


最后就是我们的controller层了
PoiController.java 

package org.liukai.tutorial.controller;

import java.io.IOException;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.liukai.tutorial.domain.Computer;
import org.liukai.tutorial.service.PoiService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

@Controller
@RequestMapping("/report")
public class PoiController {

	private static Logger logger = Logger.getLogger("controller");

	@Resource(name = "poiService")
	private PoiService service;

	/**
	 * 跳转到主页.
	 */
	@RequestMapping(value = "", method = RequestMethod.GET)
	public String getIndex() {
		logger.info("index!");
		return "report";
	}

	/**
	 * 导出excel报表
	 */
	@RequestMapping(value = "/export", method = RequestMethod.GET)
	public void getXLS(HttpServletResponse response) {
		service.exportXLS(response);
	}

	/**
	 * 读取excel报表
	 */
	@RequestMapping(value = "/read", method = RequestMethod.POST)
	public String getReadReport(@RequestParam MultipartFile file)
			throws IOException {
		List<Computer> list = service.readReport(file.getInputStream());
		service.insertComputer(list);
		return "addedReport";

	}
}


到此,后台的代码基本完成了.
下面还有3个JSP页面.

index.jsp 
<% response.sendRedirect("/report"); %>


report.jsp 

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Report</title>
</head>
<body>
	<c:url var="exportUrl" value="/report/export" />
	<c:url var="readUrl" value="/report/read" />
	
	
	<h3><a href="${exportUrl }">Export Report</a></h3>
	<br />
	<form  id="readReportForm" action="${readUrl }" method="post" enctype="multipart/form-data"  >
			<label for="file">File</label>
			<input id="file" type="file" name="file" />
			<p><button type="submit">Read</button></p>	
		</form>
	
</body>
</html>


addedReport.jsp 
<?xml version="1.0" encoding="UTF-8" ?>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Insert title here</title>
</head>
<body>
<h1>导入成功!</h1>

<a href="/spring3-poi/report">返回</a>
</body>
</html>


启动项目后输入:
http://localhost:8080/spring3-poi/report



点击Export Report我们会得到一个excel文件.
打开后



如此我们通过读取数据库得到了一个excel的文件.

点击"浏览",选择需要导入的excel报表.
注:强烈建议选择我们刚导出的excel报表.因为选择其他的报表格式不同,肯定会报错.
本教程只是演示基本的POI操作.如果要用于生产环境中,请根据自己的状况进行改动和重构.

成功后会显示



这个时候查询数据库,就会发现有2个相同的数据.说明我们导入成功.



总结
本教程中,我们成功的通过使用POI来进行了excel操作
大家可以根据本教程自定义excel的格式,输出的字段.

需要注意的是两点:
1.导入jar包一定要包含poi-ooxml.
2.别忘记关闭InputStream

BTW:附件为本次教程源码.你可以下载后直接在tomcat或其他web服务器启动.也可以自行添加
maven插件启动.
  • 大小: 21.3 KB
  • 大小: 12.9 KB
  • 大小: 3.7 KB
  • 大小: 11.1 KB
  • 大小: 11.3 KB
  • 大小: 4.2 KB
  • 大小: 14.6 KB
分享到：
| SVN提交代码到googlecode时报405错误的解 ...
评论
3 楼 xubinggggg 2014-06-12  
请问我用myeclipse打开maven项目 Maven Dependencies 里没看到jar包啊
2 楼 lindakun 2011-12-13  
你的文章实在是写得太好了~学习了！
1 楼 yin_bp 2011-05-05  
可不可以利用国产的bbossgroups中的bboss mvc框架实现一下你文章中指定的功能，顺便提些建议哦，共同完善一下哦，谢谢了
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring3 MVC + POI 实现 Excel与MySQL 的导入导出

    本主题聚焦于如何利用Spring3 MVC框架结合Apache POI库来实现在Java环境中Excel与MySQL数据库之间的数据导入与导出。 Spring3 MVC是Spring框架的一个组件，专门用于构建Web应用程序，它提供了模型-视图-控制器（MVC...

    spring3.2.5 MVC Poi3.9操作excel批量导入

    使用Spring MVC和Apache POI，我们可以构建一个高效、可扩展的系统，实现从Excel文件批量导入数据到数据库，并能将数据库中的数据导出为Excel文件。这样，数据分析师可以轻松地进行数据预处理和分析。 在Maven2的...

    spring mvc easyui-POI导出excel封装源码

    在IT行业中，Spring MVC、EasyUI和POI是常见的开发工具和技术，它们分别在不同的领域发挥着重要作用。这里我们将深入探讨这些技术，并结合标题和描述，重点讲述如何使用Spring MVC和EasyUI结合POI库来实现Excel数据...

    spring3.0 MVC Poi操作excel批量导入数据库和导出数据

    在本主题中，我们将讨论如何利用Spring 3.0 MVC和Apache POI库来处理Excel文件，实现批量导入数据库和导出数据的功能。 Apache POI是一个强大的开源库，专门用于读写Microsoft Office格式的文件，特别是Excel（....

    Spring3.0MVC 实用教程（高淇）

    通过策略接口，Spring MVC 具有高度可配置性，支持多种视图技术，如 JSP、Velocity、Tiles、iText 和 POI。 Spring MVC 的主要组成部分包括控制器、模型对象、分派器和处理程序对象，这些组件的职责明确，易于定制...

    Spring MVC+Spring+Mybatis+poi+xml全部jar包

    结合这三个框架和POI库，开发者可以构建一个完整的后端系统，处理HTTP请求，通过Spring MVC进行业务逻辑控制，利用Spring管理依赖，通过Mybatis执行数据库操作，同时使用POI处理Excel数据，如报表生成或数据导入导出...

    spring框架的MVC

    通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（JSP）技术、Velocity、Tiles、iText 和POI。Spring MVC 框架并不知道使用的视图，所以不会强迫您只使用 JSP 技术。Spring ...

    poi导入导出及spring

    - **整合到Spring MVC项目中:** 在Web层使用Spring MVC来接收前端上传的Excel文件，然后利用POI进行解析和处理。 - **Spring事务管理:** 在执行复杂的Excel数据处理逻辑时，可以利用Spring的事务管理功能确保数据的...

    Spring_MVC详解学习

    首先，Spring框架提供了一套构建Web应用程序的全功能MVC模块，该模块支持多种视图技术，包括但不限于JSP、Velocity、Tiles、iText和POI。Spring MVC的灵活性表现在它不会强迫使用特定的视图技术，开发者可以根据实际...

    spring mvc 框架示例

    通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（JSP）技术、Velocity、Tiles、iText 和POI。Spring MVC 框架并不知道使用的视图，所以不会强迫您只使用 JSP 技术。Spring ...

    spring mvc excel common view

    源码分析可以帮助我们理解如何在Spring MVC环境中集成Excel导出功能，而工具可能指的是Apache POI或其他辅助开发的工具，如IDE插件。 总的来说，Spring MVC Excel common view涉及到的知识点包括： 1. Spring MVC...

    Spring_MVC详解学习.pdf

    Spring MVC是高度可配置的，并且支持多种视图技术，包括但不限于JavaServer Pages（JSP）、Velocity、Tiles、iText和Apache POI。由于Spring MVC的视图层解耦于模型层，开发者可以自由选择最适合当前需求的视图技术...

    Spring、mvc、mybatis、easyui实例

    8. **数据导出Excel**：使用Apache POI库，配合Spring MVC的ResponseEntity，实现将查询结果导出为Excel文件的功能。 9. **测试与优化**：运行项目，进行功能测试，根据实际需求进行性能优化和用户体验调整。 通过...

    Spring MVC 学习笔记 十二 PDF/Excel格式输出

    对于PDF和Excel格式的输出，Spring MVC可以通过Apache POI库来处理Excel，使用Flying Saucer或iText库来生成PDF。这些库能够将HTML内容转换为所需的格式，方便导出和下载。 总的来说，Spring MVC是Spring框架的重要...

    spring MVC 导出excel

    Spring MVC 提供了丰富的工具和库，如Apache POI，来支持这样的需求。 Apache POI 是一个开源项目，它允许开发者创建、修改和显示Microsoft Office格式的文件，包括Excel（.xlsx 和 .xls）文件。在Spring MVC项目中...

    SpringMvc+POI 处理Excel的导入操作

    2. **SpringMVC**：基于Spring框架的一个MVC架构实现，用于构建Web应用程序。 3. **MultipartRequest**：SpringMVC提供的用于处理多部分请求的对象，常用于文件上传场景。 #### 四、核心代码解析 本节将详细解析...

    Easyui.+.Spring.Mvc导出Excel

    为了实现以上功能，开发人员需要对Java、Spring MVC、Easyui和Apache POI有深入的理解。在调试和优化过程中，性能问题也需要考虑，比如大数据量导出时如何避免内存溢出，以及如何通过流式处理提高导出效率。同时，...

    Jxls+Spring MVC实现Excel导出

    Jxls是一个强大的Java库，它扩展了Apache POI，使得在Excel模板上进行编程变得简单，而Spring MVC是Spring框架的一部分，用于构建基于MVC模式的Web应用。 首先，我们需要了解Jxls的基本用法。Jxls提供了一种模板...

Magicbox
Global site tag (gtag.js) - Google Analytics