2018-11-13 20:40:46 qq_16855077 阅读数 117
  • 车牌识别停车场管理系统(附SSM项目源代码)

          掌握基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场管理,停车费收费管理,按照临时车或包月车自动计算停车费,系统参数设置,修改用户密码及安全退出等功能,该系统采用Jsp技术,使用SSM框架,Mysql数据库,ajax技术及人工智能等相关技术实现。 项目开发技术:java,jsp,mysql,MyBatis,SpringMVC,jquery,ajax,json 项目运行环境:jdk1.7及以上版本,tomcat6.0及以上版本,mysql5.5及以上版本项目开发工具: 本项目开发工具是Eclipse,也支持myEclipse,Intellij Idea等其他版本开发工具 相关课程学习顺序 本校课程是培养JAVA软件工程师及JSP WEB网络应用程序开发,android工程师的全套课程,课程学习顺序如下:JAVA初级工程师:     1、计算机基础     2、HTML语言基础     3、C语言从入门到精通+贪吃蛇游戏     4、贪吃蛇游戏     5、SQL SERVER数据库基础     6、JAVA从入门到精通+推箱子游戏+QQ即时通讯软件     7、推箱子游戏;     8、仿QQ即时通讯软件;JAVA中级工程师:     9、SQLSERVER数据库高级     10、SQLSERVER从入门到精通(基础+高级)               11、JavaScript从入门到精通,     12、JSP从入门到精通+点餐系统,     13、JSP从入门到精通+在线视频学习教育平台,     14、JSP从入门到精通+大型电商平台;     15、XML从入门到精通,     16、数据结构(JAVA版),JAVA高级工程师:     17、Oracle数据库从入门到精通,     18、ajax+jquery从入门到精通,     19、EasyUI从入门到精通,SSH框架:     20、Struts2从入门到精通课程,     21、Hibernate从入门到精通课程,     22、Spring从入门到精通课程;     23、Echarts从入门到精通,     24、Excel基于POI的导入导出工作流框架:     25、Activiti流程框架从入门到精通     26、JBPM流程框架从入门到精通SSM框架:     27、MyBatis从入门到精通     28、Spring MVC从入门到精通面试题:     29、职业生涯规划及面试题集锦商业项目:     30、微信公众号在线支付系统     31、微信生活缴费在线支付系统     32、支付宝生活缴费在线支付系统     33、在线考试系统     34、手机订餐管理系统,     35、CRM客户关系管理系统     36、大型房地产CRM销售管理系统     37、CMPP2,CMPP3移动网关系统人工智能:     38、人脸识别在线考试系统     39、人脸识别系统项目实战     40、车牌识别系统项目实战     41、身份证识别系统项目实战     42、营业执照识别系统项目实战           43、名片识别管理系统

    1022 人正在学习 去看看 赖国荣

前提:

由于本人采取的是利用反射的方式,这样的好处,可以兼容,导出所有类型的数据,例如,订单,充值记录等等。

既然是公有的接口,肯定有一定的约束规范。

(1)导出的表头需要自己设置一个动态数组

(2) 头部的宽度需要自己设置,也可以自己写一个方法,根据字体的长度,形成一个头部的动态数组长度。

(3)返回的实体类,一定要遵循,跟头部一一对应的原则,例如:

导出的实体类,name要显示在excel的第一列,名字就得放在number这个字段的前面

1.pom.xml配置

<!-- poi -->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi</artifactId>
			<version>3.8</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>3.8</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-scratchpad</artifactId>
			<version>3.8</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml-schemas</artifactId>
			<version>3.8</version>
		</dependency>

2.前端代码

2.1jsp页面代码

 <div class="float-r">
		<a class="red_btn_big addOrEditFoodCategory" type="add" onclick="list.exportReCharge()">+ 导出充值记录</a>
</div>

2.2 js代码

	/**
		 * 导出充值交易信息
		 */
		exportReCharge : function() {
			var methodOfPayment = $('#methodOfPayment option:selected').val();
			var paymentStatus = $('#paymentStatus option:selected').val();
			var serviceType = $('#serviceType option:selected').val();
			var startTime = $('#date0').val();
			var endTime = $('#date1').val();
			var keywords = $('#keywords').val();
			layer.confirm('确定导出充值数据吗?', {
				icon : 3,
				title : '提示'
			}, function(index) {
				window.location.href = "export?search=" + keywords
						+ "&channels=" + methodOfPayment + "&state="
						+ paymentStatus + "&serviceType=" + serviceType
						+ "&startTime=" + startTime + "&endTime=" + endTime;
				layer.close(index);
			});
		}

2.3后台controller代码

@RequestMapping("export")
	public void exportCharge(HttpServletRequest request, HttpServletResponse response, OrderExportVo exportVo) {
		Principal principal = getLoginAdminInfo();
		if (null == principal) {
			logger.info("--------------获取登录用户身份信息为空!");
			return;
		}
		HashMap<String, Object> conditionMap = new HashMap<>();

		try {
			boolean superAdmin = false; // 是否为超级管理员
			if(principal.getOperatorId() != null && StringUtils.isBlank(principal.getTreeIds())){// 非超级管理员
				superAdmin = true;
			} 

			PayOrderInfo payOrderInfo = new PayOrderInfo();
			payOrderInfo.setState(exportVo.getState());
			payOrderInfo.setServiceType(exportVo.getServiceType());
			payOrderInfo.setChannels(exportVo.getChannels());
			
			conditionMap.put("payOrderInfo", payOrderInfo);
			conditionMap.put("superAdmin", superAdmin);
			conditionMap.put("operatorId", principal.getOperatorId());
			conditionMap.put("adminId", principal.getTreeIds());
			conditionMap.put("search", exportVo.getSearch());
			conditionMap.put("startTime", exportVo.getStartTime());
			conditionMap.put("endTime", exportVo.getEndTime());
			Collection<OrderVo> dataset = payOrderInfoMapper.getPayOrderList(conditionMap);
			
			
			for (OrderVo orderVo : dataset) {
				String channelsName = "";
				if(orderVo.getChannels() != null){
					channelsName = ChannelsType.getType(orderVo.getChannels()).getDesc();
				}
				orderVo.setChannelsName(channelsName);
				orderVo.setStateName(OrderState.getType(orderVo.getState()).getDesc());
				String serviceTypeName="";
				if(orderVo.getServiceType() != null){
					serviceTypeName = ServiceType.getType(orderVo.getServiceType()).getDesc();
				}
				orderVo.setServiceTypeName(serviceTypeName);
			}
			
			ExportExcelUtils<OrderVo> excelUtils = new ExportExcelUtils<>();
			SXSSFWorkbook exportExcel = null;
			String[] headers = { "用户名","手机号","充值金额","退款金额", "余额", "充值平台", "订单号", "支付时间", "支付状态", "支付类型", "操作者" };
			int[] widths = {68,90,80,80,80,85,189,140,68,68,68};
			exportExcel = excelUtils.exportExcel("充值", headers,widths, dataset, response.getOutputStream());
			String currentDate = TimeUtils.getCurrentTimeStr("yyyyMMddHHmmss");
			excelUtils.createSXSSFWorkbook(exportExcel, response, "充值记录" + currentDate + ".xlsx");
		} catch (IOException e) {
			logger.info("导出充值交易记录失败!", e.getMessage());
		}
	}

2.4 excel辅助类

package com.parwa.web.util;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
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.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
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.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 导出Excel工具 
 * @author wude
 *
 * @param <T>
 */
public class ExportExcelUtils<T> {
	private static final Logger logger = LoggerFactory.getLogger(ExportExcelUtils.class);

	public void exportExcel(String title, Collection<T> dataset, OutputStream out) {
		exportExcel(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
	}
	
	public void exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out) {
		exportExcel(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 生成excel
	 * @param title     sheet名称
	 * @param headers   表头
	 * @param width     宽
	 * @param dataset   当前list对象
	 * @param out 
	 * @return
	 */
	public SXSSFWorkbook exportExcel(String title, String[] headers,int[] width,Collection<T> dataset, OutputStream out) {
		SXSSFWorkbook exportExcel = exportBigDataExcel(title, headers,width,dataset, out, "yyyy-MM-dd HH:mm:ss");
		return exportExcel;
	}
	
	/**
	 * 创建excel文档
	 * @param wb
	 * @param response
	 * @param fileName   文件名称
	 * @throws IOException
	 */
    public  void createSXSSFWorkbook(Workbook wb,HttpServletResponse response,String fileName) throws IOException {
        ServletOutputStream out = null;
        try {
            // 设置响应头
            response.addHeader("Content-Disposition", "attachment;filename="
                    + new String(fileName.getBytes("GBK"), "ISO8859_1"));
            out = response.getOutputStream();
            wb.write(out);
        } catch (Exception e) {
        	logger.info("导出excel报错!",e.getMessage());
        } finally {
            if (out != null) {
                    out.close();
            }
        }
    }
	
	
	/**
	 * 利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
	 * @param title 表格标题名
	 * @param title 列宽度
	 * @param headers 表格属性列名数组
	 * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
	 * @param out 与输出设备关联的流对象,可以将EXCEL文档导出到本地文件或者网络中
	 * @param pattern 如果有时间数据,设定输出格式。默认为"yyy-MM-dd HH:mm:ss"
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public SXSSFWorkbook exportBigDataExcel(String title, String[] headers,int[] width,Collection<T> dataset, OutputStream out, String pattern) {
		/** 声明一个工作簿 **/
		SXSSFWorkbook workbook = new SXSSFWorkbook(100);   //100为内存缓存数据
		if (dataset == null || dataset.size() == 0) {
	            // 防止数据为空的情况下,excel无法打开
			workbook.createSheet();
	        return workbook;
	    }
		/** 声明一个表格 **/
		Sheet sheet = workbook.createSheet(title);
		/** 设置表格默认列宽度为15个字节 **/
		sheet.setDefaultColumnWidth((int) 16);
		sheet.autoSizeColumn(1);
		/** 生成样式,用于表格标题行 **/
		CellStyle style = workbook.createCellStyle();
		/** 设置样式 **/
		style.setFillForegroundColor(IndexedColors.LEMON_CHIFFON.index);
	    style.setFillPattern(CellStyle.SOLID_FOREGROUND);
	    style.setBorderBottom(CellStyle.BORDER_THIN);
	    style.setBorderLeft(CellStyle.BORDER_THIN);
	    style.setBorderRight(CellStyle.BORDER_THIN);
	    style.setBorderTop(CellStyle.BORDER_THIN);
	    style.setAlignment(CellStyle.ALIGN_CENTER);
	    /** 生成字体 **/
	    Font font = workbook.createFont();
	    font.setColor(IndexedColors.VIOLET.index);
	    font.setFontHeightInPoints((short) 13);
	    font.setBoldweight(Font.BOLDWEIGHT_BOLD);
	    /** 将字体应用到样式中 **/
	    style.setFont(font);
	    
	    /** 样式二,用于表格内容行 **/
	    CellStyle style2 = workbook.createCellStyle();
	    style2.setFillForegroundColor(IndexedColors.WHITE.index);
	    style2.setFillPattern(CellStyle.SOLID_FOREGROUND);
	    style2.setBorderBottom(CellStyle.BORDER_THIN);
	    style2.setBorderLeft(CellStyle.BORDER_THIN);
	    style2.setBorderRight(CellStyle.BORDER_THIN);
	    style2.setBorderTop(CellStyle.BORDER_THIN);
	    style2.setAlignment(CellStyle.ALIGN_CENTER); //水平布局:居中;
	    style2.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
      	/** 字体二 **/
	    Font font2 = workbook.createFont();
	    font.setFontHeightInPoints((short) 12);
	    font2.setBoldweight(Font.BOLDWEIGHT_NORMAL);
	    font2.setColor(IndexedColors.BLACK.index);
	    style2.setFont(font2);
	    /** 声明画图顶级管理器 **/
	    Drawing patriarch = sheet.createDrawingPatriarch();
	    
	    /** 设置表格标题行 **/
	    Row row = sheet.createRow(0);
	    for (int i = 0; i < headers.length; i++) {
	       Cell cell = row.createCell(i);
	       cell.setCellStyle(style);
	       XSSFRichTextString text = new XSSFRichTextString(headers[i]);
	       cell.setCellValue(text);
	       sheet.setColumnWidth(i, (int) (width[i] * 35.7));
	    }
	    
	    /** 以下是数据内容 **/
	    Iterator<T> it = dataset.iterator();
	    int index = 0;
	    while(it.hasNext() && it != null){
	    	index++;
	    	row = sheet.createRow(index);
	    	T t = (T) it.next();
	    	/** 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值 **/
	    	Field[] fields = t.getClass().getDeclaredFields();
	    	for(int i = 0;i < fields.length;i++){
	    		if(i == headers.length){
	    			break;
	    		}
	    		Cell cell = row.createCell(i);
	            
	            Field field = fields[i];
	            String fieldName = field.getName();
	            String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
	            
	            try {
	                Class tCls = t.getClass();
	                Method getMethod = tCls.getMethod(getMethodName, new Class[] {});
	                Object value = getMethod.invoke(t, new Object[] {});
	                /** 判断值的类型后进行强制类型转换 **/
	                String textValue = null;
	                if (value instanceof Boolean) {
	                	boolean bValue = (Boolean) value;
	                	textValue = "是";
	                	if (!bValue) {
	                		textValue ="否";
	                	}
	                } else if (value instanceof Date) {
	                	Date date = (Date) value;
	                	SimpleDateFormat sdf = new SimpleDateFormat(pattern);
	                    textValue = sdf.format(date);
	                } else if (value instanceof byte[]) {
	                	/** 有图片时,设置行高为60px **/
	                	row.setHeightInPoints(60);
	                	/** 设置图片所在列宽度为80px,注意这里单位的一个换算 **/
	                	sheet.setColumnWidth(i, (short) (35.7 * 80));
	                	byte[] bsValue = (byte[]) value;
	                	XSSFClientAnchor anchor = new XSSFClientAnchor(0, 0, 1023, 255, (short) 6, index, (short) 6, index);
	                 	anchor.setAnchorType(2);
	                	patriarch.createPicture(anchor, workbook.addPicture(bsValue, Workbook.PICTURE_TYPE_JPEG));
	                } else if(value instanceof Calendar){
	                	Calendar cale = Calendar.getInstance();  
	                	Date tasktime = cale.getTime();  
	                	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	                	textValue = df.format(tasktime);
	                } else{
	                	/** 其它数据类型都当作字符串简单处理 **/
	                	if(value != null){
	                		textValue = value.toString();
	                	}
	                }
	                /** 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成 **/
	                if(textValue!=null){
	                	Pattern p = Pattern.compile("^//d+(//.//d+)?$");  
	                	Matcher matcher = p.matcher(textValue);
	                	if(matcher.matches()){
	                		/** 是数字当作double处理 **/
	                		cell.setCellValue(Double.parseDouble(textValue));
	                   }else{
	                	   XSSFRichTextString richString = new XSSFRichTextString(textValue);
	                	   Font font3 = workbook.createFont();
	                	   font3.setColor(IndexedColors.BLACK.index);
	                	   richString.applyFont(font3);
	                	   cell.setCellValue(richString);
	                   }
	                }else{
	                	cell.setCellValue("");
	                }
	            } catch (Exception e) {
	            	e.printStackTrace();
	            	logger.info("导出excel报错!",e.getMessage());
	            } finally {
	                //清理资源
	            }
	            cell.setCellStyle(style2);
	    	}
	    }
		return workbook;
	}
	
	/**
	 * 利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
	 * @param title 表格标题名
	 * @param headers 表格属性列名数组
	 * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
	 * @param out 与输出设备关联的流对象,可以将EXCEL文档导出到本地文件或者网络中
	 * @param pattern 如果有时间数据,设定输出格式。默认为"yyy-MM-dd HH:mm:ss"
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public HSSFWorkbook exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
		/** 声明一个工作簿 **/
		HSSFWorkbook workbook = new HSSFWorkbook();
		/** 声明一个表格 **/
		HSSFSheet sheet = workbook.createSheet(title);
		/** 设置表格默认列宽度为15个字节 **/
		sheet.setDefaultColumnWidth((int) 16);
		sheet.autoSizeColumn(1);
		/** 生成样式,用于表格标题行 **/
		HSSFCellStyle style = workbook.createCellStyle();
		/** 设置样式 **/
		style.setFillForegroundColor(HSSFColor.LEMON_CHIFFON.index);
	    style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
	    style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	    style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	    style.setBorderRight(HSSFCellStyle.BORDER_THIN);
	    style.setBorderTop(HSSFCellStyle.BORDER_THIN);
	    style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
	    /** 生成字体 **/
	    HSSFFont font = workbook.createFont();
	    font.setColor(HSSFColor.VIOLET.index);
	    font.setFontHeightInPoints((short) 12);
	    font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
	    /** 将字体应用到样式中 **/
	    style.setFont(font);
	    
	    /** 样式二,用于表格内容行 **/
	    HSSFCellStyle style2 = workbook.createCellStyle();
	    style2.setFillForegroundColor(HSSFColor.WHITE.index);
	    style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
	    style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	    style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	    style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
	    style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
	    style2.setAlignment(HSSFCellStyle.ALIGN_LEFT);
	    style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
      	/** 字体二 **/
	    HSSFFont font2 = workbook.createFont();
	    font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
	    font2.setColor(HSSFColor.BLACK.index);
	    style2.setFont(font2);
	    /** 声明画图顶级管理器 **/
	    HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
	    
	    /** 设置表格标题行 **/
	    HSSFRow row = sheet.createRow(0);
	    for (int i = 0; i < headers.length; i++) {
	       HSSFCell cell = row.createCell(i);
	       cell.setCellStyle(style);
	       HSSFRichTextString text = new HSSFRichTextString(headers[i]);
	       cell.setCellValue(text);
	    }
	    
	    /** 以下是数据内容 **/
	    Iterator<T> it = dataset.iterator();
	    int index = 0;
	    while(it.hasNext() && it != null){
	    	index++;
	    	row = sheet.createRow(index);
	    	T t = (T) it.next();
	    	/** 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值 **/
	    	Field[] fields = t.getClass().getDeclaredFields();
	    	for(int i = 0;i < fields.length;i++){
	    		HSSFCell cell = row.createCell(i);
	            
	            Field field = fields[i];
	            String fieldName = field.getName();
	            String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
	            
	            try {
	                Class tCls = t.getClass();
	                Method getMethod = tCls.getMethod(getMethodName, new Class[] {});
	                Object value = getMethod.invoke(t, new Object[] {});
	                /** 判断值的类型后进行强制类型转换 **/
	                String textValue = null;
	                if (value instanceof Boolean) {
	                	boolean bValue = (Boolean) value;
	                	textValue = "是";
	                	if (!bValue) {
	                		textValue ="否";
	                	}
	                } else if (value instanceof Date) {
	                	Date date = (Date) value;
	                	SimpleDateFormat sdf = new SimpleDateFormat(pattern);
	                    textValue = sdf.format(date);
	                } else if (value instanceof byte[]) {
	                	/** 有图片时,设置行高为60px **/
	                	row.setHeightInPoints(60);
	                	/** 设置图片所在列宽度为80px,注意这里单位的一个换算 **/
	                	sheet.setColumnWidth(i, (short) (35.7 * 80));
	                	byte[] bsValue = (byte[]) value;
	                	HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 1023, 255, (short) 6, index, (short) 6, index);
	                 	anchor.setAnchorType(2);
	                	patriarch.createPicture(anchor, workbook.addPicture(bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
	                } else if(value instanceof Calendar){
	                	Calendar cale = Calendar.getInstance();  
	                	Date tasktime = cale.getTime();  
	                	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	                	textValue = df.format(tasktime);
	                } else{
	                	/** 其它数据类型都当作字符串简单处理 **/
	                	if(value != null){
	                		textValue = value.toString();
	                	}
	                }
	                /** 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成 **/
	                if(textValue!=null){
	                	Pattern p = Pattern.compile("^//d+(//.//d+)?$");  
	                	Matcher matcher = p.matcher(textValue);
	                	if(matcher.matches()){
	                		/** 是数字当作double处理 **/
	                		cell.setCellValue(Double.parseDouble(textValue));
	                   }else{
	                	   HSSFRichTextString richString = new HSSFRichTextString(textValue);
	                	   HSSFFont font3 = workbook.createFont();
	                	   font3.setColor(HSSFColor.BLACK.index);
	                	   richString.applyFont(font3);
	                	   cell.setCellValue(richString);
	                   }
	                }else{
	                	cell.setCellValue("");
	                }
	            } catch (SecurityException e) {
	                e.printStackTrace();
	            } catch (NoSuchMethodException e) {
	                e.printStackTrace();
	            } catch (IllegalArgumentException e) {
	                e.printStackTrace();
	            } catch (IllegalAccessException e) {
	                e.printStackTrace();
	            } catch (InvocationTargetException e) {
	                e.printStackTrace();
	            } finally {
	                //清理资源
	            }
	    	}
	    }
		return workbook;
	}
	
	
	public static void main(String[] args) {
		Timestamp time = TimeUtils.getCurrentTime();
		if(time instanceof Date){
			System.out.println("时间类型");
		}
	}
}

可能存在问题 

实体类

 因为set get是遵守驼峰规则的,按道理生成的get方法应该是getHMaxTemp,但是这里却不是,就是因为h后面接的是大写字母,如果是thMaxTemp,生成的get方法,就是getThMaxTemp,所以编码的时候,保持一个良好的习惯很重要,但是,项目用了一段时间,如果只是这个大小写的问题,就大改动,这样改动量也太大勒,这里我分享另外一种方法。

找到这个工具类的String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);,如上图所示换成下面的图片效果

需要增加一个辅助反射类

ReflectUtil.java


package com.cloudtech.web.util;
 
import java.lang.reflect.Field;
import java.util.ArrayList;

import com.cloudtech.web.entity.RuleCode;
 
public class ReflectUtil {
 
    /**
     * 使用反射设置变量值
     *
     * @param target 被调用对象
     * @param fieldName 被调用对象的字段,一般是成员变量或静态变量,不可是常量!
     * @param value 值
     * @param <T> value类型,泛型
     */
    public static <T> void setValue(Object target,String fieldName,T value) {
        try {
            Class c = target.getClass();
            Field f = c.getDeclaredField(fieldName);
            f.setAccessible(true);
            f.set(target, value);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 使用反射获取变量值
     *
     * @param target 被调用对象
     * @param fieldName 被调用对象的字段,一般是成员变量或静态变量,不可以是常量
     * @param <T> 返回类型,泛型
     * @return 值
     */
    public static <T> T getValue(Object target,String fieldName) {
        T value = null;
        try {
            Class c = target.getClass();
            Field f = c.getDeclaredField(fieldName);
            f.setAccessible(true);
            value = (T) f.get(target);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return value;
    }
    
    public static void main(String[] args) {
		RuleCode code = new RuleCode();
		code.setId(1234);
		//Object value = ReflectUtil.getValue(code, "id");
		System.out.println(code.getId());
    /*	String s ="avgSpd gt hThreeMaxSpd";
    	String replace = s.replace("gt", "");
    	String[] split = replace.split(" ");
    	System.out.println();*/
	}
}

 3.对比

建议用后面这种,毕竟可以兼容实体类字段命名不规范的问题

4.优化后excel辅助类

注意:使用的时候,使用反射方式,去掉多余的代码,使用SXSSFWorkbook,性能更优

package com.cloudtech.web.util;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
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.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
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.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 导出Excel工具
 * 
 * @author wude
 *
 * @param <T>
 */
public class ExportExcelUtils<T> {
	private static final Logger logger = LoggerFactory.getLogger(ExportExcelUtils.class);

	public void exportExcel(String title, Collection<T> dataset, OutputStream out) {
		exportExcel(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 生成excel
	 * 
	 * @param title
	 *            sheet名称
	 * @param headers
	 *            表头
	 * @param width
	 *            宽
	 * @param dataset
	 *            当前list对象
	 * @param out
	 * @return
	 */
	public SXSSFWorkbook exportExcel(String title, String[] headers, int[] width, Collection<T> dataset,
			OutputStream out) {
		SXSSFWorkbook exportExcel = exportBigDataExcel(title, headers, width, dataset, out, "yyyy-MM-dd HH:mm:ss");
		return exportExcel;
	}

	public SXSSFWorkbook exportMapExcel(String title, String[] headers, int[] width,
			LinkedHashMap<String, LinkedHashMap<String, Object>> dataset, OutputStream out) {
		SXSSFWorkbook exportExcel = exportBigMapDataExcel(title, headers, width, dataset, out, "yyyy-MM-dd HH:mm:ss");
		return exportExcel;
	}

	/**
	 * 创建excel文档
	 * 
	 * @param wb
	 * @param response
	 * @param fileName
	 *            文件名称
	 * @throws IOException
	 */
	public void createSXSSFWorkbook(Workbook wb, HttpServletResponse response, String fileName) throws IOException {
		ServletOutputStream out = null;
		try {
			// 设置响应头
			response.addHeader("Content-Disposition",
					"attachment;filename=" + new String(fileName.getBytes("GBK"), "ISO8859_1"));
			out = response.getOutputStream();
			wb.write(out);
		} catch (Exception e) {
			logger.info("导出excel报错!", e.getMessage());
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}

	/**
	 * 利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
	 * 
	 * @param title
	 *            表格标题名
	 * @param title
	 *            列宽度
	 * @param headers
	 *            表格属性列名数组
	 * @param dataset
	 *            需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。
	 *            此方法支持的javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
	 * @param out
	 *            与输出设备关联的流对象,可以将EXCEL文档导出到本地文件或者网络中
	 * @param pattern
	 *            如果有时间数据,设定输出格式。默认为"yyy-MM-dd HH:mm:ss"
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public SXSSFWorkbook exportBigDataExcel(String title, String[] headers, int[] width, Collection<T> dataset,
			OutputStream out, String pattern) {
		/** 声明一个工作簿 **/
		SXSSFWorkbook workbook = new SXSSFWorkbook(100); // 100为内存缓存数据
		if (dataset == null || dataset.size() == 0) {
			// 防止数据为空的情况下,excel无法打开
			workbook.createSheet();
			return workbook;
		}
		/** 声明一个表格 **/
		Sheet sheet = workbook.createSheet(title);
		/** 设置表格默认列宽度为15个字节 **/
		sheet.setDefaultColumnWidth((int) 16);
		sheet.autoSizeColumn(1);
		/** 生成样式,用于表格标题行 **/
		CellStyle style = workbook.createCellStyle();
		/** 设置样式 **/
		style.setFillForegroundColor(IndexedColors.LEMON_CHIFFON.index);
		style.setFillPattern(CellStyle.SOLID_FOREGROUND);
		style.setBorderBottom(CellStyle.BORDER_THIN);
		style.setBorderLeft(CellStyle.BORDER_THIN);
		style.setBorderRight(CellStyle.BORDER_THIN);
		style.setBorderTop(CellStyle.BORDER_THIN);
		style.setAlignment(CellStyle.ALIGN_CENTER);
		/** 生成字体 **/
		Font font = workbook.createFont();
		font.setColor(IndexedColors.VIOLET.index);
		font.setFontHeightInPoints((short) 13);
		font.setBoldweight(Font.BOLDWEIGHT_BOLD);
		/** 将字体应用到样式中 **/
		style.setFont(font);

		/** 样式二,用于表格内容行 **/
		CellStyle style2 = workbook.createCellStyle();
		style2.setFillForegroundColor(IndexedColors.WHITE.index);
		style2.setFillPattern(CellStyle.SOLID_FOREGROUND);
		style2.setBorderBottom(CellStyle.BORDER_THIN);
		style2.setBorderLeft(CellStyle.BORDER_THIN);
		style2.setBorderRight(CellStyle.BORDER_THIN);
		style2.setBorderTop(CellStyle.BORDER_THIN);
		style2.setAlignment(CellStyle.ALIGN_CENTER); // 水平布局:居中;
		style2.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
		/** 字体二 **/
		Font font2 = workbook.createFont();
		font.setFontHeightInPoints((short) 12);
		font2.setBoldweight(Font.BOLDWEIGHT_NORMAL);
		font2.setColor(IndexedColors.BLACK.index);
		style2.setFont(font2);
		/** 声明画图顶级管理器 **/
		Drawing patriarch = sheet.createDrawingPatriarch();

		/** 设置表格标题行 **/
		Row row = sheet.createRow(0);
		for (int i = 0; i < headers.length; i++) {
			Cell cell = row.createCell(i);
			cell.setCellStyle(style);
			XSSFRichTextString text = new XSSFRichTextString(headers[i]);
			cell.setCellValue(text);
			sheet.setColumnWidth(i, (int) (width[i] * 35.7));
		}

		/** 以下是数据内容 **/
		Iterator<T> it = dataset.iterator();
		int index = 0;
		while (it.hasNext() && it != null) {
			index++;
			row = sheet.createRow(index);
			T t = (T) it.next();
			/** 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值 **/
			Field[] fields = t.getClass().getDeclaredFields();
			for (int i = 0; i < fields.length; i++) {
				if (i == headers.length) {
					break;
				}
				Cell cell = row.createCell(i);

				Field field = fields[i];
				String fieldName = field.getName();

				try {
					Object value = ReflectUtil.getValue(t, fieldName);
					/** 判断值的类型后进行强制类型转换 **/
					String textValue = null;
					if (value == null) {
						cell.setCellValue("");
					} else {
						if (value instanceof Boolean) {
							boolean bValue = (Boolean) value;
							textValue = "是";
							if (!bValue) {
								textValue = "否";
							}
							cell.setCellValue(textValue);
						} else if (value instanceof Date) {
							Date date = (Date) value;
							SimpleDateFormat sdf = new SimpleDateFormat(pattern);
							textValue = sdf.format(date);
							cell.setCellValue(textValue);
						} else if (value instanceof Integer) {
							if (value != null) {
								int intValue = new BigDecimal(value.toString()).intValue();
								cell.setCellValue(intValue);
							}
						} else {
							/** 其它数据类型都当作字符串简单处理 **/
							if (value != null) {
								textValue = value.toString();
								cell.setCellValue(textValue);
							}
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
					logger.info("导出excel报错!", e.getMessage());
				} finally {
					// 清理资源
				}
				cell.setCellStyle(style2);
			}
		}
		return workbook;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public SXSSFWorkbook exportBigMapDataExcel(String title, String[] headers, int[] width,
			LinkedHashMap<String, LinkedHashMap<String, Object>> dataset, OutputStream out, String pattern) {
		/** 声明一个工作簿 **/
		SXSSFWorkbook workbook = new SXSSFWorkbook(100); // 100为内存缓存数据
		if (dataset == null || dataset.size() == 0) {
			// 防止数据为空的情况下,excel无法打开
			workbook.createSheet();
			return workbook;
		}
		/** 声明一个表格 **/
		Sheet sheet = workbook.createSheet(title);
		/** 设置表格默认列宽度为15个字节 **/
		sheet.setDefaultColumnWidth((int) 16);
		sheet.autoSizeColumn(1);
		/** 生成样式,用于表格标题行 **/
		CellStyle style = workbook.createCellStyle();
		/** 设置样式 **/
		style.setFillForegroundColor(IndexedColors.LEMON_CHIFFON.index);
		style.setFillPattern(CellStyle.SOLID_FOREGROUND);
		style.setBorderBottom(CellStyle.BORDER_THIN);
		style.setBorderLeft(CellStyle.BORDER_THIN);
		style.setBorderRight(CellStyle.BORDER_THIN);
		style.setBorderTop(CellStyle.BORDER_THIN);
		style.setAlignment(CellStyle.ALIGN_CENTER);
		/** 生成字体 **/
		Font font = workbook.createFont();
		font.setColor(IndexedColors.VIOLET.index);
		font.setFontHeightInPoints((short) 13);
		font.setBoldweight(Font.BOLDWEIGHT_BOLD);
		/** 将字体应用到样式中 **/
		style.setFont(font);

		/** 样式二,用于表格内容行 **/
		CellStyle style2 = workbook.createCellStyle();
		style2.setFillForegroundColor(IndexedColors.WHITE.index);
		style2.setFillPattern(CellStyle.SOLID_FOREGROUND);
		style2.setBorderBottom(CellStyle.BORDER_THIN);
		style2.setBorderLeft(CellStyle.BORDER_THIN);
		style2.setBorderRight(CellStyle.BORDER_THIN);
		style2.setBorderTop(CellStyle.BORDER_THIN);
		style2.setAlignment(CellStyle.ALIGN_CENTER); // 水平布局:居中;
		style2.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
		/** 字体二 **/
		Font font2 = workbook.createFont();
		font.setFontHeightInPoints((short) 12);
		font2.setBoldweight(Font.BOLDWEIGHT_NORMAL);
		font2.setColor(IndexedColors.BLACK.index);
		style2.setFont(font2);
		/** 声明画图顶级管理器 **/
		Drawing patriarch = sheet.createDrawingPatriarch();

		/** 设置表格标题行 **/
		Row row = sheet.createRow(0);
		for (int i = 0; i < headers.length; i++) {
			Cell cell = row.createCell(i);
			cell.setCellStyle(style);
			XSSFRichTextString text = new XSSFRichTextString(headers[i]);
			cell.setCellValue(text);
			sheet.setColumnWidth(i, (int) (width[i] * 35.7));
		}

		/** 以下是数据内容 **/
		int index = 0;
		for (Entry<String, LinkedHashMap<String, Object>> key : dataset.entrySet()) {
			index++;
			row = sheet.createRow(index);

			Cell cell = row.createCell(0);
			cell.setCellValue(key.getKey());
			cell.setCellStyle(style2);

			LinkedHashMap<String, Object> hourValues = key.getValue();
			int i = 1;
			for (Entry<String, Object> hourKey : hourValues.entrySet()) {
				cell = row.createCell(i);
				try {
					/** 判断值的类型后进行强制类型转换 **/
					String textValue = hourKey.getValue().toString();
					cell.setCellValue(textValue);
				} catch (Exception e) {
					e.printStackTrace();
					logger.info("导出excel报错!", e.getMessage());
				} finally {
					// 清理资源
				}
				cell.setCellStyle(style2);
				i++;
			}
		}
		/*
		 * Iterator<T> it = (Iterator<T>) dataset.keySet().iterator(); int index
		 * = 0; while (it.hasNext() && it != null) { index++; row =
		 * sheet.createRow(index); T t = (T) it.next();
		 *//** 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值 **/
		/*
		 * Field[] fields = t.getClass().getDeclaredFields(); for (int i = 0; i
		 * < fields.length; i++) { if (i == headers.length) { break; } Cell cell
		 * = row.createCell(i);
		 * 
		 * Field field = fields[i]; String fieldName = field.getName(); //
		 * String getMethodName = "get" + fieldName.substring(0, //
		 * 1).toUpperCase() + fieldName.substring(1);
		 * 
		 * try { Class tCls = t.getClass(); Object value =
		 * ReflectUtil.getValue(t, fieldName); // Method getMethod =
		 * tCls.getMethod(getMethodName, new // Class[] {}); // Object value =
		 * getMethod.invoke(t, new Object[] {});
		 *//** 判断值的类型后进行强制类型转换 **/
		/*
		 * String textValue = null; if (value instanceof Boolean) { boolean
		 * bValue = (Boolean) value; textValue = "是"; if (!bValue) { textValue =
		 * "否"; } } else if (value instanceof Date) { Date date = (Date) value;
		 * SimpleDateFormat sdf = new SimpleDateFormat(pattern); textValue =
		 * sdf.format(date); } else if (value instanceof byte[]) {
		 *//** 有图片时,设置行高为60px **/
		/*
		 * row.setHeightInPoints(60);
		 *//** 设置图片所在列宽度为80px,注意这里单位的一个换算 **/
		/*
		 * sheet.setColumnWidth(i, (short) (35.7 * 80)); byte[] bsValue =
		 * (byte[]) value; XSSFClientAnchor anchor = new XSSFClientAnchor(0, 0,
		 * 1023, 255, (short) 6, index, (short) 6, index);
		 * anchor.setAnchorType(2); patriarch.createPicture(anchor,
		 * workbook.addPicture(bsValue, Workbook.PICTURE_TYPE_JPEG)); } else if
		 * (value instanceof Calendar) { Calendar cale = Calendar.getInstance();
		 * Date tasktime = cale.getTime(); SimpleDateFormat df = new
		 * SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); textValue =
		 * df.format(tasktime); } else {
		 *//** 其它数据类型都当作字符串简单处理 **/
		/*
		 * if (value != null) { textValue = value.toString(); } }
		 *//** 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成 **/
		/*
		 * if (textValue != null) { Pattern p =
		 * Pattern.compile("^//d+(//.//d+)?$"); Matcher matcher =
		 * p.matcher(textValue); if (matcher.matches()) {
		 *//** 是数字当作double处理 **//*
								 * cell.setCellValue(Double.parseDouble(
								 * textValue)); } else { XSSFRichTextString
								 * richString = new
								 * XSSFRichTextString(textValue); Font font3 =
								 * workbook.createFont();
								 * font3.setColor(IndexedColors.BLACK.index);
								 * richString.applyFont(font3);
								 * cell.setCellValue(richString); } } else {
								 * cell.setCellValue(""); } } catch (Exception
								 * e) { e.printStackTrace();
								 * logger.info("导出excel报错!", e.getMessage()); }
								 * finally { // 清理资源 }
								 * cell.setCellStyle(style2); } }
								 */
		return workbook;
	}

	/**
	 * 利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
	 * 
	 * @param title
	 *            表格标题名
	 * @param headers
	 *            表格属性列名数组
	 * @param dataset
	 *            需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。
	 *            此方法支持的javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
	 * @param out
	 *            与输出设备关联的流对象,可以将EXCEL文档导出到本地文件或者网络中
	 * @param pattern
	 *            如果有时间数据,设定输出格式。默认为"yyy-MM-dd HH:mm:ss"
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public HSSFWorkbook exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out,
			String pattern) {
		/** 声明一个工作簿 **/
		HSSFWorkbook workbook = new HSSFWorkbook();
		/** 声明一个表格 **/
		HSSFSheet sheet = workbook.createSheet(title);
		/** 设置表格默认列宽度为15个字节 **/
		sheet.setDefaultColumnWidth((int) 16);
		sheet.autoSizeColumn(1);
		/** 生成样式,用于表格标题行 **/
		HSSFCellStyle style = workbook.createCellStyle();
		/** 设置样式 **/
		style.setFillForegroundColor(HSSFColor.LEMON_CHIFFON.index);
		style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
		style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
		style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
		style.setBorderRight(HSSFCellStyle.BORDER_THIN);
		style.setBorderTop(HSSFCellStyle.BORDER_THIN);
		style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		/** 生成字体 **/
		HSSFFont font = workbook.createFont();
		font.setColor(HSSFColor.VIOLET.index);
		font.setFontHeightInPoints((short) 12);
		font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
		/** 将字体应用到样式中 **/
		style.setFont(font);

		/** 样式二,用于表格内容行 **/
		HSSFCellStyle style2 = workbook.createCellStyle();
		style2.setFillForegroundColor(HSSFColor.WHITE.index);
		style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
		style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
		style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
		style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
		style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
		style2.setAlignment(HSSFCellStyle.ALIGN_LEFT);
		style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
		/** 字体二 **/
		HSSFFont font2 = workbook.createFont();
		font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
		font2.setColor(HSSFColor.BLACK.index);
		style2.setFont(font2);
		/** 声明画图顶级管理器 **/
		HSSFPatriarch patriarch = sheet.createDrawingPatriarch();

		/** 设置表格标题行 **/
		HSSFRow row = sheet.createRow(0);
		for (int i = 0; i < headers.length; i++) {
			HSSFCell cell = row.createCell(i);
			cell.setCellStyle(style);
			HSSFRichTextString text = new HSSFRichTextString(headers[i]);
			cell.setCellValue(text);
		}

		/** 以下是数据内容 **/
		Iterator<T> it = dataset.iterator();
		int index = 0;
		while (it.hasNext() && it != null) {
			index++;
			row = sheet.createRow(index);
			T t = (T) it.next();
			/** 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值 **/
			Field[] fields = t.getClass().getDeclaredFields();
			for (int i = 0; i < fields.length; i++) {
				HSSFCell cell = row.createCell(i);

				Field field = fields[i];
				String fieldName = field.getName();
				String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);

				try {
					Class tCls = t.getClass();
					Method getMethod = tCls.getMethod(getMethodName, new Class[] {});
					Object value = getMethod.invoke(t, new Object[] {});
					/** 判断值的类型后进行强制类型转换 **/
					String textValue = null;
					if (value instanceof Boolean) {
						boolean bValue = (Boolean) value;
						textValue = "是";
						if (!bValue) {
							textValue = "否";
						}
					} else if (value instanceof Date) {
						Date date = (Date) value;
						SimpleDateFormat sdf = new SimpleDateFormat(pattern);
						textValue = sdf.format(date);
					} else if (value instanceof byte[]) {
						/** 有图片时,设置行高为60px **/
						row.setHeightInPoints(60);
						/** 设置图片所在列宽度为80px,注意这里单位的一个换算 **/
						sheet.setColumnWidth(i, (short) (35.7 * 80));
						byte[] bsValue = (byte[]) value;
						HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 1023, 255, (short) 6, index, (short) 6,
								index);
						anchor.setAnchorType(2);
						patriarch.createPicture(anchor, workbook.addPicture(bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
					} else if (value instanceof Calendar) {
						Calendar cale = Calendar.getInstance();
						Date tasktime = cale.getTime();
						SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						textValue = df.format(tasktime);
					} else {
						/** 其它数据类型都当作字符串简单处理 **/
						if (value != null) {
							textValue = value.toString();
						}
					}
					/** 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成 **/
					if (textValue != null) {
						Pattern p = Pattern.compile("^//d+(//.//d+)?$");
						Matcher matcher = p.matcher(textValue);
						if (matcher.matches()) {
							/** 是数字当作double处理 **/
							cell.setCellValue(Double.parseDouble(textValue));
						} else {
							HSSFRichTextString richString = new HSSFRichTextString(textValue);
							HSSFFont font3 = workbook.createFont();
							font3.setColor(HSSFColor.BLACK.index);
							richString.applyFont(font3);
							cell.setCellValue(richString);
						}
					} else {
						cell.setCellValue("");
					}
				} catch (SecurityException e) {
					e.printStackTrace();
				} catch (NoSuchMethodException e) {
					e.printStackTrace();
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				} catch (InvocationTargetException e) {
					e.printStackTrace();
				} finally {
					// 清理资源
				}
			}
		}
		return workbook;
	}

	public static void main(String[] args) {
		Timestamp time = TimeUtils.getCurrentTime();
		if (time instanceof Date) {
			System.out.println("时间类型");
		}
	}

}

4.性能分析

列有69列,导出excel分析

优化前:

通过图片,我们可以发现sql的时间很长,当然跟我的列有关,69列

5w数据需要31.42s,而1w数据是6.5s,我们是不是可以做一些优化。列入拿1w作为切割,5w数据分为5次查询出来,再组装数据,是不是可以提升查询数据。所以,这里需要使用多线程。这样整个导出的时长就短了不少。

 

优化后:

通过数据分析,发现,性能方面有质的提高,而且缓存数大小,性能没有什么明显的提示,所以建议缓存数还是设置为100把 

 

缓存数:

设置为100后,超过100的部分会写入硬盘,而不是所有的都存放在内存中

性能优化部分: 

/** 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成 **/
					if (textValue != null) {
						Pattern p = Pattern.compile("^//d+(//.//d+)?$");
						Matcher matcher = p.matcher(textValue);
						if (matcher.matches()) {
							/** 是数字当作double处理 **/
							cell.setCellValue(Double.parseDouble(textValue));
						} else {
							XSSFRichTextString richString = new XSSFRichTextString(textValue);
							Font font3 = workbook.createFont();
							font3.setColor(IndexedColors.BLACK.index);
							richString.applyFont(font3);
							cell.setCellValue(richString);
						}
					} else {
						cell.setCellValue("");
					}

主要是正则方面的判断,消耗勒大量的数据,导致时间很长

2018-06-11 23:27:14 weixin_39220472 阅读数 2354
  • 车牌识别停车场管理系统(附SSM项目源代码)

          掌握基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场管理,停车费收费管理,按照临时车或包月车自动计算停车费,系统参数设置,修改用户密码及安全退出等功能,该系统采用Jsp技术,使用SSM框架,Mysql数据库,ajax技术及人工智能等相关技术实现。 项目开发技术:java,jsp,mysql,MyBatis,SpringMVC,jquery,ajax,json 项目运行环境:jdk1.7及以上版本,tomcat6.0及以上版本,mysql5.5及以上版本项目开发工具: 本项目开发工具是Eclipse,也支持myEclipse,Intellij Idea等其他版本开发工具 相关课程学习顺序 本校课程是培养JAVA软件工程师及JSP WEB网络应用程序开发,android工程师的全套课程,课程学习顺序如下:JAVA初级工程师:     1、计算机基础     2、HTML语言基础     3、C语言从入门到精通+贪吃蛇游戏     4、贪吃蛇游戏     5、SQL SERVER数据库基础     6、JAVA从入门到精通+推箱子游戏+QQ即时通讯软件     7、推箱子游戏;     8、仿QQ即时通讯软件;JAVA中级工程师:     9、SQLSERVER数据库高级     10、SQLSERVER从入门到精通(基础+高级)               11、JavaScript从入门到精通,     12、JSP从入门到精通+点餐系统,     13、JSP从入门到精通+在线视频学习教育平台,     14、JSP从入门到精通+大型电商平台;     15、XML从入门到精通,     16、数据结构(JAVA版),JAVA高级工程师:     17、Oracle数据库从入门到精通,     18、ajax+jquery从入门到精通,     19、EasyUI从入门到精通,SSH框架:     20、Struts2从入门到精通课程,     21、Hibernate从入门到精通课程,     22、Spring从入门到精通课程;     23、Echarts从入门到精通,     24、Excel基于POI的导入导出工作流框架:     25、Activiti流程框架从入门到精通     26、JBPM流程框架从入门到精通SSM框架:     27、MyBatis从入门到精通     28、Spring MVC从入门到精通面试题:     29、职业生涯规划及面试题集锦商业项目:     30、微信公众号在线支付系统     31、微信生活缴费在线支付系统     32、支付宝生活缴费在线支付系统     33、在线考试系统     34、手机订餐管理系统,     35、CRM客户关系管理系统     36、大型房地产CRM销售管理系统     37、CMPP2,CMPP3移动网关系统人工智能:     38、人脸识别在线考试系统     39、人脸识别系统项目实战     40、车牌识别系统项目实战     41、身份证识别系统项目实战     42、营业执照识别系统项目实战           43、名片识别管理系统

    1022 人正在学习 去看看 赖国荣

springmvc+pol把数据导出Excel表的步骤:

1.在pom.xml中先加poi的依赖包:

<!--导出excel需要的包-->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.14-beta1</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>3.14-beta1</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.14-beta1</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.2</version>
</dependency>

2.编码:

导入导出Excel工具类:ExcelUtil.Class

package net.stxy.one.utils;

import net.stxy.one.poi.ExcelBean;
import org.apache.http.client.utils.DateUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
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.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.*;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * Excel导入导出工具类
 * Created by ASUS on 2018/5/20
 *
 * @Authod Grey Wolf
 */
public class ExcelUtil {
    private final static String excel2003L =".xls";    //2003- 版本的excel
    private final static String excel2007U =".xlsx";   //2007+ 版本的excel
    /**
     * Excel导入
     */
    public static  List<List<Object>> getBankListByExcel(InputStream in, String fileName) throws Exception{
        List<List<Object>> list = null;
        //创建Excel工作薄
        Workbook work = getWorkbook(in,fileName);
        if(null == work){
            throw new Exception("创建Excel工作薄为空!");
        }
        Sheet sheet = null;
        Row row = null;
        Cell cell = null;
        list = new ArrayList<List<Object>>();
        //遍历Excel中所有的sheet
        for (int i = 0; i < work.getNumberOfSheets(); i++) {
            sheet = work.getSheetAt(i);
            if(sheet==null){continue;}
            //遍历当前sheet中的所有行
            //包涵头部,所以要小于等于最后一列数,这里也可以在初始值加上头部行数,以便跳过头部
            for (int j = sheet.getFirstRowNum(); j <= sheet.getLastRowNum(); j++) {
                //读取一行
                row = sheet.getRow(j);
                //去掉空行和表头
                if(row==null||row.getFirstCellNum()==j){continue;}
                //遍历所有的列
                List<Object> li = new ArrayList<Object>();
                for (int y = row.getFirstCellNum(); y < row.getLastCellNum(); y++) {
                    cell = row.getCell(y);
                    li.add(getCellValue(cell));
                }
                list.add(li);
            }
        }
        return list;
    }
    /**
     * 描述:根据文件后缀,自适应上传文件的版本
     */
    public static  Workbook getWorkbook(InputStream inStr,String fileName) throws Exception{
        Workbook wb = null;
        String fileType = fileName.substring(fileName.lastIndexOf("."));
        if(excel2003L.equals(fileType)){
            //2003-
            wb = new HSSFWorkbook(inStr);
        }else if(excel2007U.equals(fileType)){
            //2007+
            wb = new XSSFWorkbook(inStr);
        }else{
            throw new Exception("解析的文件格式有误!");
        }
        return wb;
    }
    /**
     * 描述:对表格中数值进行格式化
     */
    public static  Object getCellValue(Cell cell){
        Object value = null;
        //格式化字符类型的数字
        DecimalFormat df = new DecimalFormat("0");
        //日期格式化
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
        //格式化数字
        DecimalFormat df2 = new DecimalFormat("0.00");
        switch (cell.getCellType()) {
            case Cell.CELL_TYPE_STRING:
                value = cell.getRichStringCellValue().getString();
                break;
            case Cell.CELL_TYPE_NUMERIC:
                if("General".equals(cell.getCellStyle().getDataFormatString())){
                    value = df.format(cell.getNumericCellValue());
                }else if("m/d/yy".equals(cell.getCellStyle().getDataFormatString())){
                    value = sdf.format(cell.getDateCellValue());
                }else{
                    value = df2.format(cell.getNumericCellValue());
                }
                break;
            case Cell.CELL_TYPE_BOOLEAN:
                value = cell.getBooleanCellValue();
                break;
            case Cell.CELL_TYPE_BLANK:
                value = "";
                break;
            default:
                break;
        }
        return value;
    }
    /**
     * 导入Excel表结束
     * 导出Excel表开始
     * @param sheetName 工作簿名称
     * @param clazz  数据源model类型
     * @param objs   excel标题列以及对应model字段名
     * @param map  标题列行数以及cell字体样式
     */
    public static XSSFWorkbook createExcelFile(Class clazz, List objs, Map<Integer, List<ExcelBean>> map, String sheetName) throws
            IllegalArgumentException,IllegalAccessException,InvocationTargetException,
            ClassNotFoundException, IntrospectionException, ParseException {
        // 创建新的Excel工作簿
        XSSFWorkbook workbook = new XSSFWorkbook();
        // 在Excel工作簿中建一工作表,其名为缺省值, 也可以指定Sheet名称
        XSSFSheet sheet = workbook.createSheet(sheetName);
        // 以下为excel的字体样式以及excel的标题与内容的创建,下面会具体分析;
        //字体样式
        createFont(workbook);
        //创建标题(头)
        createTableHeader(sheet, map);
        //创建内容
        createTableRows(sheet, map, objs, clazz);
        return workbook;
    }
    private static XSSFCellStyle fontStyle;
    private static XSSFCellStyle fontStyle2;
    public static void createFont(XSSFWorkbook workbook) {
        // 表头
        fontStyle = workbook.createCellStyle();
        XSSFFont font1 = workbook.createFont();
        font1.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
        font1.setFontName("黑体");
        // 设置字体大小
        font1.setFontHeightInPoints((short) 14);
        fontStyle.setFont(font1);
        // 下边框
        fontStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
        // 左边框
        fontStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
        // 上边框
        fontStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
        // 右边框
        fontStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
        // 居中
        fontStyle.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        // 内容
        fontStyle2=workbook.createCellStyle();
        XSSFFont font2 = workbook.createFont();
        font2.setFontName("宋体");
        // 设置字体大小
        font2.setFontHeightInPoints((short) 10);
        fontStyle2.setFont(font2);
        // 下边框
        fontStyle2.setBorderBottom(XSSFCellStyle.BORDER_THIN);
        // 左边框
        fontStyle2.setBorderLeft(XSSFCellStyle.BORDER_THIN);
        // 上边框
        fontStyle2.setBorderTop(XSSFCellStyle.BORDER_THIN);
        // 右边框
        fontStyle2.setBorderRight(XSSFCellStyle.BORDER_THIN);
        // 居中
        fontStyle2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
    }
    /**
     * 根据ExcelMapping 生成列头(多行列头)
     *
     * @param sheet 工作簿
     * @param map 每行每个单元格对应的列头信息
     */
    public static final void createTableHeader(XSSFSheet sheet, Map<Integer, List<ExcelBean>> map) {
        //cell起始位置
        int startIndex=0;
        //cell终止位置
        int endIndex=0;
        for (Map.Entry<Integer, List<ExcelBean>> entry : map.entrySet()) {
            XSSFRow row = sheet.createRow(entry.getKey());
            List<ExcelBean> excels = entry.getValue();
            for (int x = 0; x < excels.size(); x++) {
                //合并单元格
                if(excels.get(x).getCols()>1){
                    if(x==0){
                        endIndex+=excels.get(x).getCols()-1;
                        CellRangeAddress range=new CellRangeAddress(0,0,startIndex,endIndex);
                        sheet.addMergedRegion(range);
                        startIndex+=excels.get(x).getCols();
                    }else{
                        endIndex+=excels.get(x).getCols();
                        CellRangeAddress range=new CellRangeAddress(0,0,startIndex,endIndex);
                        sheet.addMergedRegion(range);
                        startIndex+=excels.get(x).getCols();
                    }
                    XSSFCell cell = row.createCell(startIndex-excels.get(x).getCols());
                    // 设置内容
                    cell.setCellValue(excels.get(x).getHeadTextName());
                    if (excels.get(x).getCellStyle() != null) {
                        // 设置格式
                        cell.setCellStyle(excels.get(x).getCellStyle());
                    }
                    cell.setCellStyle(fontStyle);
                }else{
                    XSSFCell cell = row.createCell(x);
                    // 设置内容
                    cell.setCellValue(excels.get(x).getHeadTextName());
                    if (excels.get(x).getCellStyle() != null) {
                        // 设置格式
                        cell.setCellStyle(excels.get(x).getCellStyle());
                    }
                    cell.setCellStyle(fontStyle);
                }
            }
        }
    }
    public static void createTableRows(XSSFSheet sheet, Map<Integer, List<ExcelBean>> map, List objs, Class clazz)
            throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IntrospectionException,
            ClassNotFoundException, ParseException {
        int rowindex = map.size();
        int maxKey = 0;
        List<ExcelBean> ems = new ArrayList<>();
        for (Map.Entry<Integer, List<ExcelBean>> entry : map.entrySet()) {
            if (entry.getKey() > maxKey) {
                maxKey = entry.getKey();
            }
        }
        ems = map.get(maxKey);
        List<Integer> widths = new ArrayList<Integer>(ems.size());
        for (Object obj : objs) {
            XSSFRow row = sheet.createRow(rowindex);
            for (int i = 0; i < ems.size(); i++) {
                ExcelBean em = (ExcelBean) ems.get(i);
                // 获得get方法
                PropertyDescriptor pd = new PropertyDescriptor(em.getPropertyName(), clazz);
                Method getMethod = pd.getReadMethod();
                Object rtn = getMethod.invoke(obj);
                String value = "";
                // 如果是日期类型进行转换
                if (rtn != null) {
                    if (rtn instanceof Date) {
                        value = DateUtils.formatDate((Date)rtn,"yyyy-MM-dd");
                    } else if(rtn instanceof BigDecimal){
                        NumberFormat nf = new DecimalFormat("#,##0.00");
                        value=nf.format((BigDecimal)rtn).toString();
                    } else if((rtn instanceof Integer) && (Integer.valueOf(rtn.toString())<0 )){
                        value="--";
                    }else {
                        value = rtn.toString();
                    }
                }
                XSSFCell cell = row.createCell(i);
                cell.setCellValue(value);
                cell.setCellType(XSSFCell.CELL_TYPE_STRING);
                cell.setCellStyle(fontStyle2);
                // 获得最大列宽
                int width = value.getBytes().length * 300;
                // 还未设置,设置当前
                if (widths.size() <= i) {
                    widths.add(width);
                    continue;
                }
                // 比原来大,更新数据
                if (width > widths.get(i)) {
                    widths.set(i, width);
                }
            }
            rowindex++;
        }
        // 设置列宽
        for (int index = 0; index < widths.size(); index++) {
            Integer width = widths.get(index);
            width = width < 2500 ? 2500 : width + 300;
            width = width > 10000 ? 10000 + 300 : width + 300;
            sheet.setColumnWidth(index, width);
        }
    }
}

用到的bean:ExcelBean,ExcelClass

package net.stxy.one.poi;

import org.apache.poi.xssf.usermodel.XSSFCellStyle;

import java.io.Serializable;

/**
 * Excel表格
 * Created by ASUS on 2018/5/20
 *
 * @Authod Grey Wolf
 */
public class ExcelBean implements Serializable {
    //列头(标题)名
    private String headTextName;
    //对应字段名
    private String propertyName;
    //合并单元格数
    private Integer cols;
    //样式
    private XSSFCellStyle cellStyle;
    public ExcelBean(){
    }
    public ExcelBean(String headTextName, String propertyName){
        this.headTextName = headTextName;
        this.propertyName = propertyName;
    }
    public ExcelBean(String headTextName, String propertyName, Integer cols) {
        super();
        this.headTextName = headTextName;
        this.propertyName = propertyName;
        this.cols = cols;
    }

    public String getHeadTextName() {
        return headTextName;
    }

    public void setHeadTextName(String headTextName) {
        this.headTextName = headTextName;
    }

    public String getPropertyName() {
        return propertyName;
    }

    public void setPropertyName(String propertyName) {
        this.propertyName = propertyName;
    }

    public Integer getCols() {
        return cols;
    }

    public void setCols(Integer cols) {
        this.cols = cols;
    }

    public XSSFCellStyle getCellStyle() {
        return cellStyle;
    }

    public void setCellStyle(XSSFCellStyle cellStyle) {
        this.cellStyle = cellStyle;
    }
}
package net.stxy.one.poi;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Excel表格对应的表头信息处理类
 * Created by ASUS on 2018/6/11
 *
 * @Authod Grey Wolf
 */
public class ExcelClass {

    public  Map<Integer,List<ExcelBean>> contentExcel(){
        List<ExcelBean> excel=new ArrayList<>();
        Map<Integer,List<ExcelBean>> map=new LinkedHashMap<>();
        XSSFWorkbook xssfWorkbook=null;
        //设置标题栏
        excel.add(new ExcelBean("序号","id",0));
        excel.add(new ExcelBean("用户id","userid",0));
        excel.add(new ExcelBean("分享内容","content",0));
        excel.add(new ExcelBean("点赞数","nice",0));
        excel.add(new ExcelBean("创建时间","createtime",0));
        excel.add(new ExcelBean("图片1","pic1",0));
        excel.add(new ExcelBean("图片2","pic2",0));
        excel.add(new ExcelBean("图片3","pic3",0));
        map.put(0, excel);
        return map;
    }
}
接口服务层service:

package net.stxy.one.service;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.beans.IntrospectionException;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;

/**
 * Created by ASUS on 2018/5/20
 *
 * @Authod Grey Wolf
 */
public interface ExcelService {

    /**
     * 导出Excel表格
     * @param salaryDate
     * @return
     * @throws InvocationTargetException
     * @throws ClassNotFoundException
     * @throws IntrospectionException
     * @throws ParseException
     * @throws IllegalAccessException
     */
    XSSFWorkbook exportExcelInfo(String salaryDate) throws InvocationTargetException, ClassNotFoundException, IntrospectionException, ParseException, IllegalAccessException;
}

接口服务实现层serviceImpl:

package net.stxy.one.service.impl;

import net.stxy.one.mapper.ContentMapper;
import net.stxy.one.model.Content;
import net.stxy.one.poi.ExcelBean;
import net.stxy.one.poi.ExcelClass;
import net.stxy.one.service.ExcelService;
import net.stxy.one.utils.ExcelUtil;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.beans.IntrospectionException;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Excel实现类
 * Created by ASUS on 2018/5/20
 *
 * @Authod Grey Wolf
 */

@Service("excelService")
public class ExcelServiceImpl implements ExcelService {

    @Autowired
    private ContentMapper contentMapper;

    @Override
    public XSSFWorkbook exportExcelInfo(String salaryDate) throws InvocationTargetException, ClassNotFoundException, IntrospectionException, ParseException, IllegalAccessException {
        //根据条件查询数据,把数据装载到一个list中
        List<Content> list =contentMapper.selectAll();
        List<ExcelBean> excel=new ArrayList<>();
        Map<Integer,List<ExcelBean>> map=new ExcelClass().contentExcel();
        XSSFWorkbook xssfWorkbook=null;
        String sheetName = salaryDate + "分享内容";
        //调用ExcelUtil的方法
        xssfWorkbook = ExcelUtil.createExcelFile(Content.class, list, map, sheetName);
        return xssfWorkbook;
    }
}

控制层controller:

package net.stxy.one.controller;

import com.google.gson.JsonObject;
import net.stxy.one.model.Content;
import net.stxy.one.service.ExcelService;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.beans.IntrospectionException;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Excel控制器
 * Created by ASUS on 2018/5/20
 *
 * @Authod Grey Wolf
 */

@Controller
public class ExcelController {

    @Autowired
    private ExcelService excelService;


    @RequestMapping("/exports")
    public void export(HttpServletRequest request, HttpServletResponse response) throws ClassNotFoundException, IntrospectionException, IllegalAccessException, ParseException, InvocationTargetException {
        System.out.println("excel导出开始");
        String salaryDate="1";
        System.out.println("list:"+salaryDate);
        if(salaryDate!=""){
            response.reset(); //清除buffer缓存
            Map<String,Object> map=new HashMap<String,Object>();
            System.out.println("文件名:");
            // 指定下载的文件名
            response.setHeader("Content-Disposition", "attachment;filename="+salaryDate+".xlsx");
            response.setContentType("application/vnd.ms-excel;charset=UTF-8");
            response.setHeader("Pragma", "no-cache");
            response.setHeader("Cache-Control", "no-cache");
            response.setDateHeader("Expires", 0);
            XSSFWorkbook workbook=null;
            //导出Excel对象
            workbook = excelService.exportExcelInfo(salaryDate);
            OutputStream output;
            try {
                output = response.getOutputStream();
                BufferedOutputStream bufferedOutPut = new BufferedOutputStream(output);
                bufferedOutPut.flush();
                workbook.write(bufferedOutPut);
                bufferedOutPut.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
前端页面:


点击导出按钮:

<a class="layui-btn" href="<%=request.getContextPath()%>/exports">导出</a

显示效果:


打开Excel显示下载的数据:



我的座右铭:不会,我可以学;落后,我可以追赶;跌倒,我可以站起来;我一定行。

2017-07-27 13:47:36 mingshen3 阅读数 1367
  • 车牌识别停车场管理系统(附SSM项目源代码)

          掌握基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场管理,停车费收费管理,按照临时车或包月车自动计算停车费,系统参数设置,修改用户密码及安全退出等功能,该系统采用Jsp技术,使用SSM框架,Mysql数据库,ajax技术及人工智能等相关技术实现。 项目开发技术:java,jsp,mysql,MyBatis,SpringMVC,jquery,ajax,json 项目运行环境:jdk1.7及以上版本,tomcat6.0及以上版本,mysql5.5及以上版本项目开发工具: 本项目开发工具是Eclipse,也支持myEclipse,Intellij Idea等其他版本开发工具 相关课程学习顺序 本校课程是培养JAVA软件工程师及JSP WEB网络应用程序开发,android工程师的全套课程,课程学习顺序如下:JAVA初级工程师:     1、计算机基础     2、HTML语言基础     3、C语言从入门到精通+贪吃蛇游戏     4、贪吃蛇游戏     5、SQL SERVER数据库基础     6、JAVA从入门到精通+推箱子游戏+QQ即时通讯软件     7、推箱子游戏;     8、仿QQ即时通讯软件;JAVA中级工程师:     9、SQLSERVER数据库高级     10、SQLSERVER从入门到精通(基础+高级)               11、JavaScript从入门到精通,     12、JSP从入门到精通+点餐系统,     13、JSP从入门到精通+在线视频学习教育平台,     14、JSP从入门到精通+大型电商平台;     15、XML从入门到精通,     16、数据结构(JAVA版),JAVA高级工程师:     17、Oracle数据库从入门到精通,     18、ajax+jquery从入门到精通,     19、EasyUI从入门到精通,SSH框架:     20、Struts2从入门到精通课程,     21、Hibernate从入门到精通课程,     22、Spring从入门到精通课程;     23、Echarts从入门到精通,     24、Excel基于POI的导入导出工作流框架:     25、Activiti流程框架从入门到精通     26、JBPM流程框架从入门到精通SSM框架:     27、MyBatis从入门到精通     28、Spring MVC从入门到精通面试题:     29、职业生涯规划及面试题集锦商业项目:     30、微信公众号在线支付系统     31、微信生活缴费在线支付系统     32、支付宝生活缴费在线支付系统     33、在线考试系统     34、手机订餐管理系统,     35、CRM客户关系管理系统     36、大型房地产CRM销售管理系统     37、CMPP2,CMPP3移动网关系统人工智能:     38、人脸识别在线考试系统     39、人脸识别系统项目实战     40、车牌识别系统项目实战     41、身份证识别系统项目实战     42、营业执照识别系统项目实战           43、名片识别管理系统

    1022 人正在学习 去看看 赖国荣
通过传入实体类数组和指定导出列来即可,导出excel,读者可直接复制到项目直接使用,下面只是个简单的示例提供参考

一、导出excel工具类代码
  1. /**
  2. * 导出实体类
  3. * @param head 表头
  4. * @param exportColumn 导出字段
  5. * @param exportList 实体数组
  6. * @param clazz 实体类
  7. * @return
  8. * @throws Exception
  9. */
  10. public SXSSFWorkbook export(String[] head,String[] exportColumn,List exportList,Class clazz) throws Exception{
  11. XSSFWorkbook wb = new XSSFWorkbook ();
  12. SXSSFWorkbook swb=new SXSSFWorkbook(wb,1000);
  13. //swb.createSheet()
  14. //创建第一个sheet(页),命名为 new sheet
  15. SXSSFSheet sheet = null;
  16. sheet = (SXSSFSheet) swb.createSheet("myData");
  17. //创建head
  18. SXSSFRow heqadrow = sheet.createRow(0);
  19. int headlen = head.length;
  20. for(int i=0;i<headlen;i++) {
  21. heqadrow.createCell(i).setCellValue(head[i]);
  22. }
  23. //获取导出列
  24. List<String> columnNameList = new ArrayList<String>();
  25. if(exportColumn!=null&&exportColumn.length>0) {
  26. int columnNameLen = exportColumn.length;
  27. for(int i=0;i<columnNameLen;i++){
  28. columnNameList.add(exportColumn[i]);
  29. }
  30. } else {//通过反射获取所有列
  31. //暂未实现
  32. System.err.println("请指明导出列");
  33. }
  34. //导出列
  35. int exportListLen = exportList.size();
  36. List<Method> methodList = new ArrayList<Method>();
  37. int columnNameListLen = columnNameList.size();
  38. for(int i=0;i<columnNameListLen;i++){
  39. String methodName= "get".concat(captureName(columnNameList.get(i).toLowerCase()));
  40. Method method = clazz.getMethod(methodName);
  41. methodList.add(method);
  42. }
  43. for(int i=1;i<=exportListLen;i++){
  44. Object entity = exportList.get(i-1);
  45. SXSSFRow row = sheet.createRow(i);
  46. for(int j=0;j<columnNameListLen;j++) {
  47. Object value = methodList.get(j).invoke(entity);
  48. if(value!=null) {
  49. row.createCell(j).setCellValue(value.toString());
  50. }
  51. }
  52. }
  53. //写入文件
  54. /*FileOutputStream fos = new FileOutputStream("e:\\txt.xls");
  55. swb.write(fos);
  56. fos.flush();*/
  57. return swb;
  58. }
二、导出excel的controller下载部分
  1. SXSSFWorkbook wb = eu.export(head, exportColumn, easyJson.getRows(), TReportyszxqk.class);
  2. OutputStream output=response.getOutputStream(); //response为springMVC传入的httpservletResponse
  3. response.reset();
  4. response.setHeader("Content-disposition", "attachment; filename=details.xls");
  5. response.setContentType("application/msexcel");
  6. wb.write(output);
  7. output.close();
三、前端下载部分
1.html
  1. <form action="exportYszx" style="display:none" id="downForm" method="post">
  2. </form>
  1. <button id="btn_export"> 导出</button>
2.js
  1. $("#btn_export").click(function(){
  2. $("#downForm").empty();
  3. for(var key in searchData){
  4. var input = "<input name='"+key+"'value='"+searchData[key]+"'>";
  5. $("#downForm").append(input)
  6. }
  7. $("#downForm").submit();
  8. })


2019-05-15 17:07:22 WYA1993 阅读数 111
  • 车牌识别停车场管理系统(附SSM项目源代码)

          掌握基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场管理,停车费收费管理,按照临时车或包月车自动计算停车费,系统参数设置,修改用户密码及安全退出等功能,该系统采用Jsp技术,使用SSM框架,Mysql数据库,ajax技术及人工智能等相关技术实现。 项目开发技术:java,jsp,mysql,MyBatis,SpringMVC,jquery,ajax,json 项目运行环境:jdk1.7及以上版本,tomcat6.0及以上版本,mysql5.5及以上版本项目开发工具: 本项目开发工具是Eclipse,也支持myEclipse,Intellij Idea等其他版本开发工具 相关课程学习顺序 本校课程是培养JAVA软件工程师及JSP WEB网络应用程序开发,android工程师的全套课程,课程学习顺序如下:JAVA初级工程师:     1、计算机基础     2、HTML语言基础     3、C语言从入门到精通+贪吃蛇游戏     4、贪吃蛇游戏     5、SQL SERVER数据库基础     6、JAVA从入门到精通+推箱子游戏+QQ即时通讯软件     7、推箱子游戏;     8、仿QQ即时通讯软件;JAVA中级工程师:     9、SQLSERVER数据库高级     10、SQLSERVER从入门到精通(基础+高级)               11、JavaScript从入门到精通,     12、JSP从入门到精通+点餐系统,     13、JSP从入门到精通+在线视频学习教育平台,     14、JSP从入门到精通+大型电商平台;     15、XML从入门到精通,     16、数据结构(JAVA版),JAVA高级工程师:     17、Oracle数据库从入门到精通,     18、ajax+jquery从入门到精通,     19、EasyUI从入门到精通,SSH框架:     20、Struts2从入门到精通课程,     21、Hibernate从入门到精通课程,     22、Spring从入门到精通课程;     23、Echarts从入门到精通,     24、Excel基于POI的导入导出工作流框架:     25、Activiti流程框架从入门到精通     26、JBPM流程框架从入门到精通SSM框架:     27、MyBatis从入门到精通     28、Spring MVC从入门到精通面试题:     29、职业生涯规划及面试题集锦商业项目:     30、微信公众号在线支付系统     31、微信生活缴费在线支付系统     32、支付宝生活缴费在线支付系统     33、在线考试系统     34、手机订餐管理系统,     35、CRM客户关系管理系统     36、大型房地产CRM销售管理系统     37、CMPP2,CMPP3移动网关系统人工智能:     38、人脸识别在线考试系统     39、人脸识别系统项目实战     40、车牌识别系统项目实战     41、身份证识别系统项目实战     42、营业执照识别系统项目实战           43、名片识别管理系统

    1022 人正在学习 去看看 赖国荣

先上代码:

定义需要导出的实体类

@Data
public class Student implements Serializable {

    private Integer id;
    private String studentName;
    private Integer age;
    private LocalDate birth;
    private String desc;
    private Double weight;
    private Double height;

}

定义导出Excel的工具类

public class ExcelUtil {

    /**
     * 数据量过大时可通过此属性拆分多个sheet页
     */
    private static final int MAX_ROW_NUM = 5000;

    /**
     * 通过反射的方式导出Excel
     *
     * @param dataList
     * @param path
     * @param fields
     * @param <K>
     * @throws Exception
     */
    public static <K> void export(List<K> dataList, String path, Map<String, String> fields) throws Exception {
        if (dataList == null || dataList.size() == 0) {
            throw new Exception("dataList is empty");
        }
        if (fields == null || fields.isEmpty()) {
            throw new ExcelException("fields map is empty");
        }
//        int sheetSize = dataList.size() / MAX_ROW_NUM;
//        if (dataList.size() % MAX_ROW_NUM != 0) {
//            sheetSize += 1;
//        }
        XSSFWorkbook workbook = new XSSFWorkbook();
        String[] fieldNames = new String[fields.keySet().size()];
        String[] displayNames = new String[fields.keySet().size()];
        int i = 0;
        for (String fieldName : fields.keySet()) {
            fieldNames[i] = fieldName;
            displayNames[i] = fields.get(fieldName);
            i ++;
        }
        XSSFSheet sheet = workbook.createSheet();
        XSSFRow row = sheet.createRow(0);
        // 初始化列名
        for (int cellNum = 0; cellNum < displayNames.length; cellNum++) {
            row.createCell(cellNum).setCellValue(displayNames[cellNum]);
        }
        XSSFCell cell;
        K data;
        for (int j = 0; j < dataList.size(); j++) {
            row = sheet.createRow(j + 1);
            data = dataList.get(j);
            for (int cellNum = 0; cellNum < fieldNames.length; cellNum++) {
                cell = row.createCell(cellNum);
                // 通过反射的方式取值赋给单元格
                Field field = data.getClass().getDeclaredField(fieldNames[cellNum]);
                field.setAccessible(true);
                if (field.get(data) == null) {
                    cell.setCellValue("");
                } else if (field.getType() == String.class) {
                    cell.setCellValue((String) field.get(data));
                } else if (field.getType() == Integer.class) {
                    cell.setCellValue((Integer)field.get(data));
                } else if (field.getType() == Double.class) {
                    cell.setCellValue((Double)field.get(data));
                } else if (field.getType() == LocalDate.class) {
                    cell.setCellValue(((LocalDate)field.get(data)).format(DateTimeFormatter.ISO_DATE));
                }
            }
        }
        OutputStream out = null;
        try{
            out = new FileOutputStream(path);
            workbook.write(out);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }

}

定义测试类

@org.junit.Test
    public void test() throws Exception {
        Map<String, String> fields = new HashMap<>();
        fields.put("id", "编号");
        fields.put("studentName", "姓名");
        fields.put("age", "年龄");
        fields.put("birth", "生日");
        fields.put("desc", "简介");
        fields.put("weight", "体重");
        fields.put("height", "身高");

        List<Student> dataList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Student student = new Student();
            student.setId(i + 1);
            student.setStudentName("学生" + i);
            student.setAge(i + 20);
            student.setBirth(LocalDate.now());
            student.setHeight(175.67D);
            student.setWeight(120.66D);
            dataList.add(student);
        }
        String path = "D://student.xlsx";
        ExcelUtil.export(dataList, path, fields);
    }

查看效果

缺点:需要定义实体类

优点:使用反射的方式比较灵活,减少了很多获取值的硬编码

关于第一列标题的顺序也可以优化,目前就不做了,自己可以选择性优化一下。

另外如果数据量很大不要使用XSSFWorkBook ,建议使用SXSSFWorkBook。XSSFWorkBook对于内存的耗费特别严重,关于SXXFWorkBook的用法可以查看官方文档

 

 

2019-08-11 20:59:59 weixin_42054155 阅读数 176
  • 车牌识别停车场管理系统(附SSM项目源代码)

          掌握基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场管理,停车费收费管理,按照临时车或包月车自动计算停车费,系统参数设置,修改用户密码及安全退出等功能,该系统采用Jsp技术,使用SSM框架,Mysql数据库,ajax技术及人工智能等相关技术实现。 项目开发技术:java,jsp,mysql,MyBatis,SpringMVC,jquery,ajax,json 项目运行环境:jdk1.7及以上版本,tomcat6.0及以上版本,mysql5.5及以上版本项目开发工具: 本项目开发工具是Eclipse,也支持myEclipse,Intellij Idea等其他版本开发工具 相关课程学习顺序 本校课程是培养JAVA软件工程师及JSP WEB网络应用程序开发,android工程师的全套课程,课程学习顺序如下:JAVA初级工程师:     1、计算机基础     2、HTML语言基础     3、C语言从入门到精通+贪吃蛇游戏     4、贪吃蛇游戏     5、SQL SERVER数据库基础     6、JAVA从入门到精通+推箱子游戏+QQ即时通讯软件     7、推箱子游戏;     8、仿QQ即时通讯软件;JAVA中级工程师:     9、SQLSERVER数据库高级     10、SQLSERVER从入门到精通(基础+高级)               11、JavaScript从入门到精通,     12、JSP从入门到精通+点餐系统,     13、JSP从入门到精通+在线视频学习教育平台,     14、JSP从入门到精通+大型电商平台;     15、XML从入门到精通,     16、数据结构(JAVA版),JAVA高级工程师:     17、Oracle数据库从入门到精通,     18、ajax+jquery从入门到精通,     19、EasyUI从入门到精通,SSH框架:     20、Struts2从入门到精通课程,     21、Hibernate从入门到精通课程,     22、Spring从入门到精通课程;     23、Echarts从入门到精通,     24、Excel基于POI的导入导出工作流框架:     25、Activiti流程框架从入门到精通     26、JBPM流程框架从入门到精通SSM框架:     27、MyBatis从入门到精通     28、Spring MVC从入门到精通面试题:     29、职业生涯规划及面试题集锦商业项目:     30、微信公众号在线支付系统     31、微信生活缴费在线支付系统     32、支付宝生活缴费在线支付系统     33、在线考试系统     34、手机订餐管理系统,     35、CRM客户关系管理系统     36、大型房地产CRM销售管理系统     37、CMPP2,CMPP3移动网关系统人工智能:     38、人脸识别在线考试系统     39、人脸识别系统项目实战     40、车牌识别系统项目实战     41、身份证识别系统项目实战     42、营业执照识别系统项目实战           43、名片识别管理系统

    1022 人正在学习 去看看 赖国荣

背景:需要导出大量数据到Excel中,但是又因为普通的导出数据工具不太好用,并且很容易OOM,那么可以使用这个方法来解决:下面给出2个方法,一个是简洁数据文件,不带样式和标题的导出工具类,一个是导出的数据文件带有标题和一些简易样式 并且到百万级别数据速度非常快,如果字段不多,30秒左右即可

需要加入的poi依赖:

   <dependency>
       <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.10-FINAL</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.10-FINAL</version>
    </dependency>

1. 简洁易用的导出数据工具类:(不带样式)

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.common.usermodel.Hyperlink;
import org.apache.poi.hpsf.SummaryInformation;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.*;

import java.io.*;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/**
*  不带样式的Excel输出基本数据的工具类
*/
public class ExcelUtil {



	public static final String DEFAULT_DATE_PATTERN = "yyyy年MM月dd日";// 默认日期格式,如果传递的是Date类型,则会格式化为这个
	public static final int DEFAULT_COLUMN_WIDTH = 17;// 默认列宽


	/**
	 * 导出Excel(.xlsx)格式
	 * @param titleList 表格头信息集合
	 * @param dataArray 数据数组
	 * @param os 文件输出流
	 */
	public static void exportExcel(ArrayList<LinkedHashMap> titleList, JSONArray dataArray, OutputStream os) {
		String datePattern = DEFAULT_DATE_PATTERN;
		int minBytes = DEFAULT_COLUMN_WIDTH;

		/**
		 * 声明一个工作薄
		 */
		SXSSFWorkbook workbook = new SXSSFWorkbook(100000);// 大于1000行时会把之前的行写入硬盘
		workbook.setCompressTempFiles(true);
		
		String title1 = (String) titleList.get(0).get("title1");
		String title2 = (String) titleList.get(0).get("title2");
		LinkedHashMap<String, String> headMap = titleList.get(1);

		/**
		 * 生成一个(带名称)表格
		 */
		if(StringUtils.isNotBlank(title1)) {
			SXSSFSheet sheet = (SXSSFSheet) workbook.createSheet(title1);
			sheet.createFreezePane(0, 3, 0, 3);// (单独)冻结前三行
		}
		SXSSFSheet sheet = (SXSSFSheet) workbook.createSheet();

		/**
		 * 生成head相关信息+设置每列宽度
		 */
		int[] colWidthArr = new int[headMap.size()];// 列宽数组
		String[] headKeyArr = new String[headMap.size()];// headKey数组
		String[] headValArr = new String[headMap.size()];// headVal数组
		int i = 0;
		for (Map.Entry<String, String> entry : headMap.entrySet()) {
			headKeyArr[i] = entry.getKey();
			headValArr[i] = entry.getValue();

			int bytes = headKeyArr[i].getBytes().length;
			colWidthArr[i] = bytes < minBytes ? minBytes : bytes;
			sheet.setColumnWidth(i, colWidthArr[i] * 256);// 设置列宽
			i++;
		}


		/**
		 * 遍历数据集合,产生Excel行数据
		 */
		int rowIndex = 0;
		for (Object obj : dataArray) {
			// 生成title+head信息
			if (rowIndex == 0) {
				SXSSFRow headerRow = (SXSSFRow) sheet.createRow(0);// head行
				for (int j = 0; j < headValArr.length; j++) {
					headerRow.createCell(j).setCellValue(headValArr[j]);
//					headerRow.getCell(j).setCellStyle(headerStyle);
				}
				rowIndex++;
			}

			JSONObject jo = (JSONObject) JSONObject.toJSON(obj);
			// 生成数据
			SXSSFRow dataRow = (SXSSFRow) sheet.createRow(rowIndex);// 创建行
			for (int k = 0; k < headKeyArr.length; k++) {
				SXSSFCell cell = (SXSSFCell) dataRow.createCell(k);// 创建单元格
				Object o = jo.get(headKeyArr[k]);
				String cellValue = "";

				if (o == null) {
					cellValue = "";
				} else if (o instanceof Date) {
					cellValue = new SimpleDateFormat(datePattern).format(o);
				} else if (o instanceof Float || o instanceof Double) {
					cellValue = new BigDecimal(o.toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString();
				} else {
					cellValue = o.toString();
				}

				cell.setCellValue(cellValue);
			}
			rowIndex++;
		}

		try {
			workbook.write(os);
			os.flush();// 刷新此输出流并强制将所有缓冲的输出字节写出
			IOUtils.closeQuietly(os);
			workbook.dispose();// 释放workbook所占用的所有windows资源
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

调用示例:

public void exportData(String dir) {
		    // 从数据库中查询list数据
		    List<Object[]> list = tempRepository.queryData();

			String fileName = "EXAMPLE_FILE" + ".xlsx";
			
			// 将list集合数据转换为JsonArray类型
			JSONArray dataArray = new JSONArray();
			for (Object[] obj : list) {
				if (obj != null) {
					ExportModel fc = new ExportModel();
					fc.setId((String) obj[0]);
					fc.setName((String) obj[1]);
					fc.setMobile((String) obj[2]);
					Date date = (Date)obj[3];
					fc.setCreateDate(date != null? df.format(date):"");
					dataArray.add(fc);
				}
			}


			ArrayList<LinkedHashMap> titleList = new ArrayList<LinkedHashMap>();
			// 1.titleMap存放了该excel的头信息
			LinkedHashMap<String, String> titleMap = new LinkedHashMap<String, String>();
			// 2.headMap存放了该excel的列项
			LinkedHashMap<String, String> headMap = new LinkedHashMap<String, String>();
			headMap.put("id", "ID");
			headMap.put("name", "name");
			headMap.put("mobile", "MOBILE");
			headMap.put("create_date", "create_date");

			titleList.add(titleMap);
			titleList.add(headMap);

			File file = new File(dir);
			if (!file.exists()) file.mkdirs();// 创建该文件夹目录
			OutputStream os = null;
			try {
				log.info("正在导出xlsx...");
				long start = System.currentTimeMillis();
				// .xlsx格式
				os = new FileOutputStream(file.getAbsolutePath() + File.separator + fileName);
				ExcelUtil.exportExcel(titleList, dataArray, os);
				log.info("导出完成...共" + list.size() + "条数据,用时" + (System.currentTimeMillis() - start) + "毫秒");
				log.info("文件路径:" + file.getAbsolutePath() + File.separator + start + ".xlsx");
			} catch (Exception e) {
				log.error("创建文件异常:", e);
			} finally {
				IOUtils.closeQuietly(os);
			}
	}

2. 简洁易用的导出数据工具类:(带样式)

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.common.usermodel.Hyperlink;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.*;

import java.io.*;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 带有样式的Excel导出工具类
 * @time 2019/8/8 10:05 AM
 */
public class ExcelUtil {



	public static final String DEFAULT_DATE_PATTERN = "yyyy年MM月dd日";// 默认日期格式,如果传递的是Date类型,则会格式化为这个
	public static final int DEFAULT_COLUMN_WIDTH = 17;// 默认列宽


	/**
	 * 导出Excel(.xlsx)格式
	 * @param titleList 表格头信息集合
	 * @param dataArray 数据数组
	 * @param os 文件输出流
	 */
	public static void exportExcel(ArrayList<LinkedHashMap> titleList, JSONArray dataArray, OutputStream os) {
		String datePattern = DEFAULT_DATE_PATTERN;
		int minBytes = DEFAULT_COLUMN_WIDTH;

		/**
		 * 声明一个工作薄
		 */
		SXSSFWorkbook workbook = new SXSSFWorkbook(100000);// 大于100000行时会把之前的行写入硬盘
		workbook.setCompressTempFiles(true);

		// 表头1样式
		CellStyle title1Style = workbook.createCellStyle();
		title1Style.setAlignment(HSSFCellStyle.ALIGN_CENTER);// 水平居中
		title1Style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);// 垂直居中
		Font titleFont = workbook.createFont();// 字体
		titleFont.setFontHeightInPoints((short) 20);
		titleFont.setBoldweight((short) 700);
		title1Style.setFont(titleFont);

		// 表头2样式
		CellStyle title2Style = workbook.createCellStyle();
		title2Style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		title2Style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
		title2Style.setBorderTop(HSSFCellStyle.BORDER_THIN);// 上边框
		title2Style.setBorderRight(HSSFCellStyle.BORDER_THIN);// 右
		title2Style.setBorderBottom(HSSFCellStyle.BORDER_THIN);// 下
		title2Style.setBorderLeft(HSSFCellStyle.BORDER_THIN);// 左
		Font title2Font = workbook.createFont();
		title2Font.setUnderline((byte) 1);
		title2Font.setColor(HSSFColor.BLUE.index);
		title2Style.setFont(title2Font);

		// head样式
		CellStyle headerStyle = workbook.createCellStyle();
		headerStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		headerStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
		headerStyle.setFillForegroundColor(HSSFColor.LIGHT_GREEN.index);// 设置颜色
		headerStyle.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);// 前景色纯色填充
		headerStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
		headerStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
		headerStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
		headerStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
		Font headerFont = workbook.createFont();
		headerFont.setFontHeightInPoints((short) 12);
		headerFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
		headerStyle.setFont(headerFont);

		// 单元格样式
		CellStyle cellStyle = workbook.createCellStyle();
		cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
		cellStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
		cellStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
		cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
		cellStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
		Font cellFont = workbook.createFont();
		cellFont.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
		cellStyle.setFont(cellFont);


		String title1 = (String) titleList.get(0).get("title1");
		String title2 = (String) titleList.get(0).get("title2");
		LinkedHashMap<String, String> headMap = titleList.get(1);

		/**
		 * 生成一个(带名称)表格
		 */
		SXSSFSheet sheet = null;
		if(StringUtils.isNotBlank(title1)) {
			sheet = (SXSSFSheet) workbook.createSheet(title1);
			sheet.createFreezePane(0, 3, 0, 3);// (单独)冻结前三行
		} else {
			sheet = (SXSSFSheet) workbook.createSheet();
		}

		/**
		 * 生成head相关信息+设置每列宽度
		 */
		int[] colWidthArr = new int[headMap.size()];// 列宽数组
		String[] headKeyArr = new String[headMap.size()];// headKey数组
		String[] headValArr = new String[headMap.size()];// headVal数组
		int i = 0;
		for (Map.Entry<String, String> entry : headMap.entrySet()) {
			headKeyArr[i] = entry.getKey();
			headValArr[i] = entry.getValue();

			int bytes = headKeyArr[i].getBytes().length;
			colWidthArr[i] = bytes < minBytes ? minBytes : bytes;
			sheet.setColumnWidth(i, colWidthArr[i] * 256);// 设置列宽
			i++;
		}


		/**
		 * 遍历数据集合,产生Excel行数据
		 */
		int rowIndex = 0;
		for (Object obj : dataArray) {
			// 生成title+head信息
			if (rowIndex == 0) {
				SXSSFRow title1Row = (SXSSFRow) sheet.createRow(0);// title1行
				title1Row.createCell(0).setCellValue(title1);
				title1Row.getCell(0).setCellStyle(title1Style);
				sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, headMap.size() - 1));// 合并单元格

				if(StringUtils.isNotBlank(title2)) {
					SXSSFRow title2Row = (SXSSFRow) sheet.createRow(1);// title2行
					title2Row.createCell(0).setCellValue(title2);
					CreationHelper createHelper = workbook.getCreationHelper();
					XSSFHyperlink  hyperLink = (XSSFHyperlink) createHelper.createHyperlink(Hyperlink.LINK_URL);
					hyperLink.setAddress(title2);
					title2Row.getCell(0).setHyperlink(hyperLink);// 添加超链接

					title2Row.getCell(0).setCellStyle(title2Style);
					sheet.addMergedRegion(new CellRangeAddress(1, 1, 0, headMap.size() - 1));// 合并单元格

				}


				SXSSFRow headerRow = (SXSSFRow) sheet.createRow(2);// head行
				for (int j = 0; j < headValArr.length; j++) {
					headerRow.createCell(j).setCellValue(headValArr[j]);
					headerRow.getCell(j).setCellStyle(headerStyle);
				}
				rowIndex = 3;
			}

			JSONObject jo = (JSONObject) JSONObject.toJSON(obj);
			// 生成数据
			SXSSFRow dataRow = (SXSSFRow) sheet.createRow(rowIndex);// 创建行
			for (int k = 0; k < headKeyArr.length; k++) {
				SXSSFCell cell = (SXSSFCell) dataRow.createCell(k);// 创建单元格
				Object o = jo.get(headKeyArr[k]);
				String cellValue = "";

				if (o == null) {
					cellValue = "";
				} else if (o instanceof Date) {
					cellValue = new SimpleDateFormat(datePattern).format(o);
				} else if (o instanceof Float || o instanceof Double) {
					cellValue = new BigDecimal(o.toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString();
				} else {
					cellValue = o.toString();
				}

				cell.setCellValue(cellValue);
				cell.setCellStyle(cellStyle);
			}
			rowIndex++;
		}

		try {
			workbook.write(os);
			os.flush();// 刷新此输出流并强制将所有缓冲的输出字节写出
			IOUtils.closeQuietly(os);
			workbook.dispose();// 释放workbook所占用的所有windows资源
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

调用示例:

public void exportData(String dir) {
	// 查询数据
	List<Object[]> list = tempRepository.queryData();
	
	String fileName = "EXAMPLE_FILE" + ".xlsx";
	
	// 将list集合转换为JsonnArray
	JSONArray dataArray = new JSONArray();
	for (Object[] obj : list) {
		if (obj != null) {
			ExportModel fc = new ExportModel();
			fc.setId((String) obj[0]);
			fc.setName((String) obj[1]);
			fc.setMobile((String) obj[2]);
			Date date = (Date)obj[3];
			fc.setCreateDate(date != null? df.format(date):"");
			dataArray.add(fc);
		}
	}


	ArrayList<LinkedHashMap> titleList = new ArrayList<LinkedHashMap>();
	// 1.titleMap存放了该excel的头信息
	LinkedHashMap<String, String> titleMap = new LinkedHashMap<String, String>();
	titleMap.put("title1", "大标题");
	titleMap.put("title2", "小标题");
	// 2.headMap存放了该excel的列项
	LinkedHashMap<String, String> headMap = new LinkedHashMap<String, String>();
	headMap.put("id", "id");
	headMap.put("name", "name");
	headMap.put("mobile", "mobile");
	headMap.put("create_date", "create_date");

	titleList.add(titleMap);
	titleList.add(headMap);

	File file = new File(dir);
	if (!file.exists()) file.mkdirs();// 创建该文件夹目录
	OutputStream os = null;
	try {
		log.info("正在导出xlsx...");
		long start = System.currentTimeMillis();
		// .xlsx格式
		os = new FileOutputStream(file.getAbsolutePath() + File.separator + fileName);
		ExcelUtil.exportExcel(titleList, dataArray, os);
		log.info("导出完成...共" + list.size() + "条数据,用时" + (System.currentTimeMillis() - start) + "毫秒");
		log.info("文件路径:" + file.getAbsolutePath() + File.separator + start + ".xlsx");
	} catch (Exception e) {
		log.error("创建文件异常:", e);
	} finally {
		IOUtils.closeQuietly(os);
	}
}			
没有更多推荐了,返回首页