Java中Excel导入功能实现、excel导入公共方法_POI -

最新推荐文章于 2024-03-12 16:48:39 发布
最新推荐文章于 2024-03-12 16:48:39 发布
阅读量8k 收藏 6
点赞数
分类专栏： JavaEE 公司项目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jerome_s/article/details/38330635
版权

这是一个思路希望能帮助到大家：如果大家有更好的解决方法希望分享出来

公司导入是这样做的

每个到导入的地方

	@Override
	public List<DataImportMessage> materialDataImport2(byte[] fileBytes,
			String fileName) {
		//return DataImport(fileBytes, fileName, "inv_m");
	
		File file = FileUtils.getFileFromBytes(fileBytes, fileName);
		ExcelUtil excelUtil = null;
		try {
			excelUtil = new ExcelUtil(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			throw new CustomException("COM_016");
		} catch (IOException e) {
			throw new CustomException("COM_016");
		}
		StringBuffer insertSQLSB = new StringBuffer();
		String insertSQLFormat = "insert into scm_inventory(pk_inv,pk_invClass,invCode,invName,pk_sizeGroup,pk_aunit,invStd,pk_color,invYarn,invElement,invWidth,vdef1) values('%s','%s','%s','%s',%s,'%s','%s','%s','%s','%s',%s,'%s');";
		Iterator<Row> rows = excelUtil.getRows(0);
		int skipRows = 6;
		int count = 0;
		Map<String, String> invClsPkCache = new HashMap<String, String>();
		Map<String, String> unitPkCache = new HashMap<String, String>();
		Map<String, String> colorPkCache = new HashMap<String, String>(); 
		List<DataImportMessage> dms = new ArrayList<DataImportMessage>(); //用来存放出错的行信息
		Row headRow = null;
		while (rows.hasNext()) {
			count++;
			Row row = rows.next();
			if (count == 1) {
				if (row == null || row.getCell(1) == null    
						|| !"inv_m".equals(row.getCell(1).getStringCellValue())) {  //判断是不是材料导入模板
					file.delete();
					throw new CustomException("COM_017");          
				}
			}
			if (count == 2) {
				headRow = row;
			}
			if (count > skipRows) {        //从第7行开始进行遍历（模板中第7行才是要导入的数据）
				String invCode = null;
				if (row.getCell(2) == null) {    //判断第7行的第3个单元格是否存在
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(2).getStringCellValue(), "DI_001");  //"DI_001" 对应数据库 "第{0}行的[{1}]不能为空"
					dms.add(dm);
				} else {
					invCode = row.getCell(2).getStringCellValue();
					if (StringUtils.isEmpty(invCode)) {    //判断第7行的第3个单元格是否有值
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(2).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					} else {
						if (inventoryDao.existValue("code", invCode)) {  //判断是否存在此编码
							DataImportMessage dm = new DataImportMessage(count,
									headRow.getCell(2).getStringCellValue(),
									"DI_002");
							dms.add(dm);
						}
					}
				}

				String invPk = UuidUtility.compressedUuid();
				String invClsCode = null;
				String invClsPk = null;
				if (row.getCell(1) == null) {   //判断第7行的第2个单元格是否存在
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(1).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invClsCode = row.getCell(1).getStringCellValue();
					if (StringUtils.isEmpty(invClsCode)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(1).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					} else {
						if (invClsPkCache.containsKey(invClsCode)) {   //缓存，减少查询数据库次数
							invClsPk = invClsPkCache.get(invClsCode);
						} else {
							InventoryClass inventoryClass = inventoryClassService
									.getByCode(invClsCode);
							if (inventoryClass != null) {
								invClsPk = inventoryClass.getId();
								invClsPkCache.put(invClsCode, invClsPk);
							} else {                            //如果找不到物料分类
								DataImportMessage dm = new DataImportMessage(
										count, headRow.getCell(1)
												.getStringCellValue(), "DI_003");
								dms.add(dm);
							}
						}
					}
				}
				String invName = null;
				if (row.getCell(3) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow   //其他手输项只需要判断有没有单元格和值是否为空
							.getCell(3).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invName = row.getCell(3).getStringCellValue();
					if (StringUtils.isEmpty(invName)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(3).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					}
				}
				String invStd = null;
				if (row.getCell(4) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(4).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invStd = row.getCell(4).getStringCellValue();
					if (StringUtils.isEmpty(invStd)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(4).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					}
				}
				String invWidth = null;
				if (row.getCell(6) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(6).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invWidth = row.getCell(6).getStringCellValue();
					if (StringUtils.isEmpty(invWidth)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(6).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					}
				}
				String invYarn = null;
				if (row.getCell(7) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(7).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invYarn = row.getCell(7).getStringCellValue();
					if (StringUtils.isEmpty(invYarn)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(7).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					}
				}
				String invElement = null;
				if (row.getCell(8) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(8).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					invElement = row.getCell(8).getStringCellValue();
					if (StringUtils.isEmpty(invElement)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(8).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					}
				}
				String colorPk = null;
				String colorCode = null;
				if (row.getCell(5) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(5).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					colorCode = row.getCell(5).getStringCellValue();
					if (StringUtils.isEmpty(colorCode)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(5).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					} else {
						if (colorPkCache.containsKey(colorCode)) {
							colorPk = colorPkCache.get(colorCode);
						} else {
							Color color = colorService.getByCode(colorCode);
							if (color != null) {
								colorPk = color.getId();
								colorPkCache.put(colorCode, colorPk);
							} else {
								DataImportMessage dm = new DataImportMessage(
										count, headRow.getCell(5)
												.getStringCellValue(), "DI_003");
								dms.add(dm);
							}
						}
					}
				}

				String unitPk = null;
				String unitCode = null;
				if (row.getCell(9) == null) {
					DataImportMessage dm = new DataImportMessage(count, headRow
							.getCell(9).getStringCellValue(), "DI_001");
					dms.add(dm);
				} else {
					unitCode = row.getCell(9).getStringCellValue();
					if (StringUtils.isEmpty(unitCode)) {
						DataImportMessage dm = new DataImportMessage(count,
								headRow.getCell(9).getStringCellValue(),
								"DI_001");
						dms.add(dm);
					} else {
						if (unitPkCache.containsKey(unitCode)) {
							unitPk = unitPkCache.get(unitCode);
						} else {
							Aunit aunit = aunitService.getByCode(unitCode);
							if (aunit != null) {
								unitPk = aunit.getId();
								unitPkCache.put(unitCode, unitPk);
							} else {
								DataImportMessage dm = new DataImportMessage(
										count, headRow.getCell(9)
												.getStringCellValue(), "DI_003");
								dms.add(dm);
							}
						}
					}
				}
				String vdef1 = null;
				if (row.getCell(10) != null) {
					vdef1 = row.getCell(10).getStringCellValue();
				}
				insertSQLSB.append(String.format(insertSQLFormat, invPk,
						invClsPk, invCode, invName, "null", unitPk, invStd,
						colorPk, invYarn, invElement, invWidth, vdef1));  //使用format函数替换每个%s
				insertSQLSB.append("\n"); 
			}
		}
		if (dms.size() == 0) {
			inventoryDao.executeSql(insertSQLSB.toString(), null);
		}
		file.delete();
		return dms;
	}


对应模版的两个excel模版链接：http://pan.baidu.com/s/1gfFXRQN 密码：x3tp


我写的公共方法，因为公共要做到如的地方很多不可能每个地方分别写导入方法

定义模版  所有的导入模版都按照这个模版

public List<DataImportMessage> DataImport(byte[] fileBytes,
			String fileName, String templateCode) {
		// 读取Excel头部数据库信息存放到 ExcelDBInformation
		ExcelDBInformation excelDBInformation = new ExcelDBInformation();

		File file = FileUtils.getFileFromBytes(fileBytes, fileName);
		ExcelUtil excelUtil = null;
		try {
			excelUtil = new ExcelUtil(file);

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			throw new CustomException("COM_016"); 
		} catch (IOException e) {
			throw new CustomException("COM_016");
		}catch (Exception e) {
			throw new CustomException("COM_016");
		}
		//String insertSQL = "";
		StringBuffer insertSQLSB = new StringBuffer();
		String insertSQLFormat = "insert into %s(%s) values(%s);";
		Iterator<Row> rows = excelUtil.getRows(0); // 得到excel的内容
		// 1~11行固定的 数据库信息存放到 ExcelDBInformation
		int skipRows = 16; // excel从第17行开始读取插入数据
		int count = 0; // 标识读取到第几行
		int rank = 0;// 统计excel共有几列(第一列不算)

		List<DataImportMessage> dms = new ArrayList<DataImportMessage>(); // 数据格式化返回，显示返回信息
		Row headRow = null; // 第九行,字段中文名
		Map<Integer, String> map = null;
		//在循环插入数据之前，先将头部固定的信息放到ExcelDBInformation里面，excel设置这块不可更改
		while(rows.hasNext()){
			count++;
			Row row = rows.next();
			if (count == 1) {
				while (row.getCell(rank) != null) {
					rank++;
				}
				--rank;
			}
			if (count == 2) {
				if (row == null || row.getCell(1) == null || !templateCode // 判断是不是对应编码的模版
						.equals(row.getCell(1).getStringCellValue())) {
					file.delete();
					throw new CustomException("COM_017");
				}
			}
			if (count == 3) {//数据库名
				excelDBInformation.setDataTable(row.getCell(1)
						.getStringCellValue());
			}
			if(count == 4){//主键
				excelDBInformation.setPkName(row.getCell(1).getStringCellValue());
			}
			if (count > 4 && count < 12) {

				// 循环将信息放入 ExcelDBInformation的map中，没有信息放入null

				if (count == 5) {
					// 数据来源
					map = new HashMap<Integer, String>();
					for (int i = 1; i <= rank; i++) {
						map.put(i, row.getCell(i).getStringCellValue());
					}
					excelDBInformation.setDataSources(map);
				}
				if (count == 6) {
					// 数据来源字段
					map = new HashMap<Integer, String>();
					for (int i = 1; i <= rank; i++) {
						map.put(i, row.getCell(i).getStringCellValue());
					}
					excelDBInformation.setDataSourcesField(map);
				}
				if (count == 7) {
					// 字段名
					map = new HashMap<Integer, String>();
					for (int i = 1; i <= rank; i++) {
						map.put(i, row.getCell(i).getStringCellValue());
					}
					excelDBInformation.setFieldName(map);
				}
				if (count == 8) {
					// 批量导入数量
					excelDBInformation.setInsertQuantity((int)row.getCell(1).getNumericCellValue());
				}
				if (count == 9) {
					// 字段长度
					Map<Integer, Integer> map1 = new HashMap<Integer, Integer>();
					for (int i = 1; i <= rank; i++) {
						//row.getCell(i).setCellType(1);
						//map1.put(i,Integer.parseInt(row.getCell(i).getStringCellValue()));
						map1.put(i,(int)row.getCell(i).getNumericCellValue());
					}
					excelDBInformation.setFieldSize(map1);
				}
				if (count == 10) {
					// 是否可空
					map = new HashMap<Integer, String>();
					for (int i = 1; i <= rank; i++) {
						map.put(i, row.getCell(i).getStringCellValue());
					}
					excelDBInformation.setIsNull(map);
				}
				if (count == 11) {
					// 是否唯一
					map = new HashMap<Integer, String>();
					for (int i = 1; i <= rank; i++) {
						map.put(i, row.getCell(i).getStringCellValue());
					}
					excelDBInformation.setIsUnique(map);
				}
			}
			if (count == 12) {
				headRow = row;
				break;//跳出当前while循环
			}

	
		}
		// 得到需要查询外表的数量，然后分别创建缓存，插入数据多的时候如果编码在缓存里面，就不需要再去查询数据库了。key:code/value:pk
		// 根据“数据来源”有多少非空的 就创建几个，使用 “数据来源字段”+Cache 当cacheMap的key
		Map<String, Map<String, String>> cacheMap  =new HashMap<String, Map<String, String>>();
		String dataSourcesField = null;
		for (int i = 1; i <= rank; i++) {
			dataSourcesField = excelDBInformation.getDataSourcesField().get(i);
			if (!(dataSourcesField==null||"".equals(dataSourcesField))) {
				String str = dataSourcesField+"Cache";
				cacheMap.put(str,new HashMap<String, String>());
			}
		}

		while (rows.hasNext()) {
			count++;
			Row row = rows.next();
			
			if (count > skipRows) { // 从第17行开始读取要插入的数据

				// 将“英文字段名”循环输出，组成一组要插入的字段
				StringBuffer insertFieldNameSB = new StringBuffer(); 
				//主键先加进去
				insertFieldNameSB.append(excelDBInformation.getPkName());
				insertFieldNameSB.append(",");
				for (int i = 1; i <= rank; i++) {
					insertFieldNameSB.append(excelDBInformation.getFieldName().get(i));
					if (i != rank) {
						insertFieldNameSB.append(",");
					}
				}
				
				//循环读取要插入数据的值，并拼装成StringBuffer
				StringBuffer valueSB = new StringBuffer(); 
				//主键值先加进去
				valueSB.append("\'");
				valueSB.append(UuidUtility.compressedUuid());
				valueSB.append("\'");
				valueSB.append(",");
				for (int i = 1; i <= rank; i++) {
					String code = null;//单元格的编码
					String pk=null;//单元格编码对应的pk
					String dataSourcesField2 = null;//对应的缓存集合名字
					Map<String, String> cacheMap2 = null;//对应的缓存集合
					
					/*
					https://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/Cell.html#CELL_TYPE_NUMERIC
					static int	CELL_TYPE_BLANK
					Blank Cell type (3)
					static int	CELL_TYPE_BOOLEAN
					Boolean Cell type (4)
					static int	CELL_TYPE_ERROR
					Error Cell type (5)
					static int	CELL_TYPE_FORMULA
					Formula Cell type (2)
					static int	CELL_TYPE_NUMERIC
					Numeric Cell type (0)
					static int	CELL_TYPE_STRING
					String Cell type (1)*/
					
					//如果不是String类型统一设置为String
					if(row.getCell(i).getCellType()==0||
							row.getCell(i).getCellType()==2||
							row.getCell(i).getCellType()==3||
							row.getCell(i).getCellType()==4){
						row.getCell(i).setCellType(1);
					}
					//头部的数据库信息，不用判断，直接在excel模版设置不可更改
					if(row.getCell(i)==null){  //判断对应的单元格是否存在
						DataImportMessage dm = new DataImportMessage(count, headRow
								.getCell(2).getStringCellValue(), "DI_001");
						dms.add(dm);
					}else{
						if("N".equals(excelDBInformation.getIsNull().get(i))){//该单元格标识不可空
							if (StringUtils.isEmpty(row.getCell(i).getStringCellValue())) { //单元格没数据，提示信息
								DataImportMessage dm = new DataImportMessage(count,
										headRow.getCell(i).getStringCellValue(),
										"DI_001");
								dms.add(dm);
							}else if (row.getCell(i).getStringCellValue().length()>excelDBInformation.getFieldSize().get(i)){ 
								//判断单元格是否超出最大长度
								DataImportMessage dm = new DataImportMessage(count,
										headRow.getCell(i).getStringCellValue(),
										"DI_005");
								dms.add(dm);
							}
						}
						//单元格 不为空，并且唯一字段 唯一
						if("N".equals(excelDBInformation.getIsNull().get(i))&&"Y".equals(excelDBInformation.getIsUnique().get(i))){
							//查询对应的 唯一字段 是否存在
							String tempSQL = "select "+excelDBInformation.getFieldName().get(i)+" from "+excelDBInformation.getDataTable()+
									" where "+excelDBInformation.getFieldName().get(i)+" = '"+row.getCell(i).getStringCellValue()+"'";
								List findList=null;
								findList = QueryHelper.findBySql(tempSQL, null);
							if(!(findList==null||"".equals(findList)||findList.size()<1)){ //此字段的数值 已存在
								DataImportMessage dm = new DataImportMessage(count,
										headRow.getCell(i).getStringCellValue(),
										"DI_002");
								dms.add(dm);
							}
							
						}
						valueSB.append("\'");
						if (!(StringUtils.isEmpty(row.getCell(i).getStringCellValue()))) { //如果单元格是空的 就不需要查询对应的编码了
							
								if (!(excelDBInformation.getDataSourcesField().get(i)==null||"".equals(excelDBInformation.getDataSourcesField().get(i)))) {
									code=row.getCell(i).getStringCellValue();
									dataSourcesField2 =excelDBInformation.getDataSourcesField().get(i)+"Cache";
									cacheMap2 = cacheMap.get(dataSourcesField2);
									if(cacheMap2.containsKey(code)){
										pk = cacheMap2.get(code); //判断对应的缓存是否存在当前的编码
									}else {
										//如果字段为“pk_parent” 那么查询字段 使用当前数据表的主键，
										//因为我们命名规范，引用当前类主键都是使用“pk_parent”，所以可以这样做
										String pkName = excelDBInformation.getFieldName().get(i);
										if("pk_parent".equals(pkName)){
											pkName= excelDBInformation.getPkName();
										}
										String tempSQL = "select "+pkName+" from "+excelDBInformation.getDataSources().get(i)+
												" where "+excelDBInformation.getDataSourcesField().get(i)+" = '"+code+"'";
										List findList=null;
											findList = QueryHelper.findBySql(tempSQL, null);
										if(!(findList==null||"".equals(findList)||findList.size()<1)){
											//放入缓存
											Map<String, Object> mapReuslt = (Map<String, Object>) findList.get(0);
											pk = (String) mapReuslt.get(pkName);
											cacheMap2.put(code, pk);
										} else { //找不到对应的编码
											DataImportMessage dm = new DataImportMessage(
													count, headRow.getCell(i)
															.getStringCellValue(), "DI_003");
											dms.add(dm);
										}
									}
									valueSB.append(pk);
								}else{
									valueSB.append(row.getCell(i).getStringCellValue());
						}
							
						}
					}
					
					valueSB.append("\'");
					if (i != rank) {
						valueSB.append(",");
					}
				}	
				//将多条要插入的语句放在sb，然后一次性插入
				insertSQLSB.append(String.format(insertSQLFormat, excelDBInformation.getDataTable(),
						insertFieldNameSB.toString(), valueSB.toString()));  //使用format函数替换每个%s
				insertSQLSB.append("\n");
				
				//批量插入
				if (dms.size() == 0) {
				if((count-skipRows)%excelDBInformation.getInsertQuantity()==0){
						QueryHelper.executeSql(insertSQLSB.toString(), null); //一次性插入多条
						insertSQLSB.setLength(0);  //清空SB
					}
				}
			}
		}
		if (dms.size() == 0) {
			if(insertSQLSB.length()>0){
				QueryHelper.executeSql(insertSQLSB.toString(), null); //一次性插入多条
			}
		}
		file.delete();
		return dms;
	}

ExcelDBInformation

package cn.com.aperfect.auap.common.util;

import java.util.HashMap;
import java.util.Map;

/**
 * Excel公共模版头部的数据库信息
 * 
 * @author szd
 * 
 */
public class ExcelDBInformation {
	private String pkName;// 主键
	private Integer insertQuantity;//批量导入数量
	private String dataTable;// 数据表
	private Map<Integer, String> dataSources = new HashMap<Integer, String>();// 数据来源
	private Map<Integer, String> dataSourcesField = new HashMap<Integer, String>();// 数据来源字段
	private Map<Integer, String> fieldName = new HashMap<Integer, String>();// 字段名
	private Map<Integer, Integer> fieldSize = new HashMap<Integer, Integer>();// 字段长度
	private Map<Integer, String> isNull = new HashMap<Integer, String>();// 是否可空
	private Map<Integer, String> isUnique = new HashMap<Integer, String>(); //是否唯一


	public String getPkName() {
		return pkName;
	}

	public void setPkName(String pkName) {
		this.pkName = pkName;
	}

	public String getDataTable() {
		return dataTable;
	}

	public void setDataTable(String dataTable) {
		this.dataTable = dataTable;
	}

	public Map<Integer, String> getDataSources() {
		return dataSources;
	}

	public void setDataSources(Map<Integer, String> dataSources) {
		this.dataSources = dataSources;
	}

	public Map<Integer, String> getDataSourcesField() {
		return dataSourcesField;
	}

	public void setDataSourcesField(Map<Integer, String> dataSourcesField) {
		this.dataSourcesField = dataSourcesField;
	}

	public Map<Integer, String> getFieldName() {
		return fieldName;
	}

	public void setFieldName(Map<Integer, String> fieldName) {
		this.fieldName = fieldName;
	}


	public Map<Integer, String> getIsNull() {
		return isNull;
	}

	public void setIsNull(Map<Integer, String> isNull) {
		this.isNull = isNull;
	}

	public Integer getInsertQuantity() {
		return insertQuantity;
	}

	public void setInsertQuantity(Integer insertQuantity) {
		this.insertQuantity = insertQuantity;
	}

	public Map<Integer, String> getIsUnique() {
		return isUnique;
	}

	public void setIsUnique(Map<Integer, String> isUnique) {
		this.isUnique = isUnique;
	}

	public Map<Integer, Integer> getFieldSize() {
		return fieldSize;
	}

	public void setFieldSize(Map<Integer, Integer> fieldSize) {
		this.fieldSize = fieldSize;
	}

}


FileUtils

package cn.com.aperfect.auap.external.util;

import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FileUtils {
	/**
	 * 判断文件夹是否存在
	 * 
	 * @param pathname
	 *            文件夹路径
	 * @param mk
	 *            如果文件夹不存在是否创建文件夹
	 * @return 文件夹是否存在
	 */
	public static boolean directoryExists(String pathname, boolean mk) {
		File file = new File(pathname);
		if (file.exists() && file.isDirectory()) {
			if (mk) {
				file.mkdir();
			}
			return true;
		}
		return false;
	}

	/**
	 * 判断文件是否存在
	 * 
	 * @param pathname
	 *            文件路径
	 * @param mk
	 *            如果文件不存在是否创建文件
	 * @return 文件是否存在
	 */
	public static boolean fileExists(String pathname, boolean mk) {
		File file = new File(pathname);
		if (file.exists() && file.isFile()) {
			if (mk) {
				try {
					file.createNewFile();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return true;
		}
		return false;
	}

	/**
	 * 创建文件，如果目录不存在，也同时创建
	 * 
	 * @param pathname
	 * @return
	 */
	public static boolean createFile(String pathname) {
		// 获取文件路径的目录
		String dir = null;
		if (pathname.indexOf(".") != -1) {
			int index = pathname.lastIndexOf("\\");
			if (index == -1) {
				index = pathname.lastIndexOf("/");
			}
			dir = pathname.substring(0, index);
		}
		File file = new File(dir);
		if (!file.exists() && !file.isFile()) {
			// 目录不存在，创建目录
			file.mkdirs();
		}
		file = null;
		file = new File(pathname);
		if (!file.exists() && !file.isFile()) {
			// 文件不存在，创建文件
			try {
				return file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return false;
	}

	/**
	 * 
	 * @param pathname
	 *            文件路径
	 * @return 文件全部内容
	 */
	public static String readToString(String pathname) {
		String encoding = "UTF-8";
		File file = new File(pathname);
		Long filelength = file.length();
		byte[] filecontent = new byte[filelength.intValue()];
		try {
			FileInputStream in = new FileInputStream(file);
			in.read(filecontent);
			in.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			return new String(filecontent, encoding);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取文件后缀名
	 * 
	 * @param file
	 *            文件对象
	 * @return String 文件后缀名
	 */
	public static String getFileExtension(File file) {
		String fileName = file.getName();
		String extension = fileName.substring(fileName.lastIndexOf(".") + 1);
		return extension;
	}

	public static List<File> getListFile(String path, String fileNameRegex) {
		return getListFile(path, null, fileNameRegex);
	}

	/**
	 * 递归文件夹下的所有子文件
	 * 
	 * @param path
	 *            文件夹路径
	 * @param files
	 *            文件列表
	 * @param fileNameRegex
	 *            过滤文件名（正则表达式）
	 * @return List<File> 文件列表
	 */
	public static List<File> getListFile(String path, List<File> files,
			String fileNameRegex) {
		File file = new File(path);
		File[] array = file.listFiles();
		if (files == null) {
			files = new ArrayList<File>();
		}
		for (int i = 0; i < array.length; i++) {
			if (array[i].isFile()) {
				Pattern pattern = Pattern.compile(fileNameRegex);
				Matcher matcher = pattern.matcher(array[i].getName());
				if (matcher.find()) {
					files.add(array[i]);
				}
			} else if (array[i].isDirectory()) {
				getListFile(array[i].getPath(), files, fileNameRegex);
			}
		}
		return files;
	}

	public static boolean deleteFile(String path) {
		File file = new File(path);
		return file.delete();
	}

	/**
	 * 删除dir目录下的所有文件
	 * 
	 * @param dir
	 * @return
	 */
	public static Integer deleteAllFile(String dir) {
		// 获取目录下的所有文件
		File file = new File(dir);
		File[] array = file.listFiles();
		Integer deleteNum = 0; // 成功删除的文件数量
		boolean isDeleted = false;
		if (array == null || array.length == 0) {
			return 0;
		}
		// 删除文件
		for (File one : array) {
			isDeleted = one.delete();
			if (isDeleted) {
				deleteNum++;
			}
		}
		// System.out.println("deleteNum = " + deleteNum);
		return deleteNum;
	}

	public static void writeFile(String filepath, String context) {
		File writefile = new File(filepath);
		try {
			if (!writefile.exists()) {
				writefile.createNewFile();
			}
			BufferedWriter out = new BufferedWriter(new FileWriter(writefile));
			out.write(context);
			out.flush();
			out.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void createFile(String filePathAndName, String fileContent) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myFilePath = new File(filePath);
			if (!myFilePath.exists()) {
				myFilePath.createNewFile();
			}
			FileWriter resultFile = new FileWriter(myFilePath);
			PrintWriter myFile = new PrintWriter(resultFile);
			String strContent = fileContent;
			myFile.println(strContent);
			myFile.close();
			resultFile.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void createFile(String dir, String fileName,
			String fileContent, String encoding) {
		try {
			File dirFile = new File(dir);
			if (!dirFile.exists()) {
				dirFile.mkdirs();
			}

			String fullName = dir + fileName;
			File myFilePath = new File(fullName);
			if (!myFilePath.exists()) {
				myFilePath.createNewFile();
			}
			PrintWriter myFile = new PrintWriter(myFilePath, encoding);
			String strContent = fileContent;
			myFile.println(strContent);
			myFile.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 将2进制数据转换为文件
	 * 
	 * @param b
	 * @param outputFile
	 * @return
	 */
	public static File getFileFromBytes(byte[] b, String outputFile) {
		BufferedOutputStream stream = null;
		File file = null;
		try {
			file = new File(outputFile);
			FileOutputStream fstream = new FileOutputStream(file);
			stream = new BufferedOutputStream(fstream);
			stream.write(b);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (stream != null) {
				try {
					stream.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		}
		return file;
	}

	/**
	 * 获取文件扩展名
	 * 
	 * @param fileName
	 * @return
	 */
	public static String getFileType(String fileName) {
		return fileName.substring(fileName.lastIndexOf('.') + 1,
				fileName.length());
	}
}


ExcelUtil

package cn.com.aperfect.auap.common.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;

import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
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;

/**
 * Excel工具类
 * 
 * @author csh
 * 
 */
public class ExcelUtil {

	public Workbook workbook;

	public ExcelUtil(String fileName) throws FileNotFoundException {
		if (!FileUtilty.fileExists(fileName, false)) {
			throw new FileNotFoundException("Not Found " + fileName);
		}
		File file = new File(fileName);
		try {
			workbook = WorkbookFactory.create(file);
		} catch (InvalidFormatException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public ExcelUtil(File file) throws InvalidFormatException, IOException {
		workbook = WorkbookFactory.create(file);
	}

	public ExcelUtil(InputStream inputStream) throws FileNotFoundException {
		try {
			workbook = WorkbookFactory.create(inputStream);
		} catch (InvalidFormatException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public Sheet getSheet(int sheetIndex) {
		Sheet sheet = workbook.getSheetAt(sheetIndex);
		return sheet;
	}

	public Sheet getSheet(String sheetName) {
		Sheet sheet = workbook.getSheet(sheetName);
		return sheet;
	}

	public Iterator<Row> getRows(int sheetIndex) {
		return this.getSheet(sheetIndex).rowIterator();
	}

	public Iterator<Row> getRows(String sheetName) {
		return this.getSheet(sheetName).rowIterator();
	}
}




jerome_s
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ImportExcelUtil.java文件支持所有Excel文件解析导入的方法
04-15
本文件内含有支持所有Excel文件解析导入的方法
Java 策略模式与模板方法模式设计公用导入数据功能
rocky的编程随记
05-07 579
前言 在很多JavaWeb系统中，不同的业务模块都要求有Excel数据导入功能。由于不同的业务表的关系，对应Excel导入功能处理数据业务逻辑不一样，很多同学都是针对各自不同的业务表写不同的导入功能接口，导致多了一些例如下载Excel模板和导入Excel模板等重复性的工作。Java是面对对象的编程语言，在此，在下针对Excel数据导入的功能，剥离其共性与个性，封装了一个公用导入数据模块，让开发者根据专注于业务要点开发。 ...
easyExcel 导入、导出Excel 封装公共的方法
最新发布
qq_26408545的博客
03-12 737
*** 导出采购订单列表*/@Log(title = "采购订单", businessType = BusinessType.EXPORT)List listDatas = 获取数据的service方法nmwDate.setFileName("历史生产数据");
java用POI导出Excel，利用枚举建立公共方法
hgg923的专栏
09-06 2691
poi依赖： <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.17</version> ...
java中实现导出excel文件（封装方法，极简导出）（附excelutil工具类）
z710757293的博客
10-11 3863
导出excel规避导出文件失败与导出文件无法打开问题 1.首先在controller层需要获取 HttpServletResponse @ApiOperation(value = "导出", notes = "导出") @RequestMapping(value = "/exportInfo", method = RequestMethod.POST) public void exportOperLogInfo(@RequestBody InfoReq infoReq , HttpServl
java poi excel 导出_公共POI导出Excel方法--java
weixin_42384267的博客
02-12 255
packagecom.hwt.glmf.common;importjava.io.IOException;importjava.io.OutputStream;importjava.util.ArrayList;importjava.util.List;importjavax.servlet.http.HttpServletResponse;importorg.apache.poi.hssf.us...
java生成excel公共方法
wyazyf
09-16 307
java导出excel工具 类。支持插入图片。自动 计算列
JAVA操作execl
m0_59079063的博客
10-28 503
java - execl
【Java】excel表格导入公共类及使用
fei飞来了
12-09 499
公共类 import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.poi.hssf.usermodel.*; import org.apache.poi.ss.usermodel.*; import org.apache.poi.ss.util.Cell...
Java 中POI 导入EXCEL2003 和EXCEL2007的实现方法
08-29
主要介绍了Java 中POI 导入EXCEL2003 和EXCEL2007的实现方法的相关资料,希望通过本文大家能掌握理解这种方法，需要的朋友可以参考下
poi_java_excel.zip_java 导出excel_poi excel_poi导出再导入excel中文_导出exce
09-14
用poi读取导出excel，对中文乱码问题进行处理
java poi导入导出excel公共模块工具类-2018-09-05最新更新
09-05
本人工作中自己写的一个excel工具类，可以单独打包成jar,作为公共模块使用。 使用它可以直接不用关心poi的api。导入导出，轻轻松松。 使用方法请关注一下，cn.com.flaginfo.biz.excel.test 包下面的Test类。
JAVA中excel导入导出通用方法
07-18
Java中excel导入导出的通用方法。
Java实现导入导出Excel文件的方法（poi，jxl）
08-24
主要介绍了Java实现导入导出Excel文件的方法（poi，jxl）,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
java_poi实现excel导入导出
09-01
java_poi实现excel导入导出功能，有详细的注解
Java POI实现将导入Excel文件的示例代码
08-26
主要介绍了Java POI实现将导入Excel文件的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
分布式集群Session共享 简单多tomcat8+redis的session共享实现
热门推荐
jerome
09-25 3万+
什么是Session         用户使用网站的服务，基本上需要浏览器与Web服务器的多次交互。HTTP协议本身是无状态的，需要基于HTTP协议支持会话状态的机制。这样的机制应该可以使Web服务器从多次单独的HTTP请求中看到“会话”，也就是知道那些请求是来自哪个会话的。         具体实现方式为：在会话开始时，分配一个唯一的会话表示（SessionId），通过Coo
springmvc返回值、数据写到页面、表单提交、ajax、重定向
jerome
06-04 1万+
springmvc返回值、数据写到页面、表单提交、ajax、重定向
Java中导出到Excel实现_aspose.cells
jerome
09-03 1万+
参考http://183615215-qq-com.iteye.com/blog/1858208 包下载：http://pan.baidu.com/s/1o6ju0ZK,将lib的jar包导入到工程中   。。。   Spring mvc方面参考 http://blog.csdn.net/jerome_s/article/details/28308489 http://blog.cs
java中excel导入图片_java POI实现向Excel中插入图片
06-02
Java中使用Apache POI可以实现向Excel中插入图片。下面我将介绍一下具体实现步骤： 1. 首先需要导入POI相关的jar包。可以从官网上下载最新版本的POI，然后将poi-xxx.jar、poi-ooxml-xxx.jar、poi-ooxml-schemas-xxx...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值