`
inewzone
  • 浏览: 9484 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

java操作excel实现从数据库导入导出（二）

javaxlsjava操作文件java操作exceljava操作properties 
阅读更多
  上一篇文章主要针对的是java操作excel的描述，但是具体很没有真正的完善，仍然需要与数据库打交道。先简单介绍这个功能的具体实现吧，主要先从properties读取你实现配置好的数据表，根据你自己定义的规范在数据库里面建模，然后下一步从excel里面读取具体的内容存入到自己的一个容器里面，最后描述生成多个insert语句插入到数据库里面去 

//定义读文件接口
package xls.io;

import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;

public interface Reader {
	
	public boolean hasNext() throws CoreException;

	public Record next() throws CoreException;

	public void close() throws CoreException;

	public Schema getSchema();
}




//接口的实现类
package xls.io;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

import xls.core.Cell;
import xls.core.Column;
import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;
import xls.core.Type;
import xls.util.ConnUtils;
import xls.util.IoUtils;

public class SQLReader implements Reader {

	private Schema schema;
	private ResultSet rs;
	private ResultSetMetaData metadata;
	private int rowCount;
	private Record record;

	public SQLReader(Schema schema, ResultSet rs) {
		this.schema = schema;
		this.rs = rs;
		this.rowCount = 0;
	}

	public boolean hasNext() throws CoreException {
		try {
			while (rowCount < schema.getStartRow()) {
				System.err.println("[Skip Record] row=" + rowCount);
				if (!rs.next()) {
					return false;
				}
				++rowCount;
			}
			if (rowCount > schema.getEndtRow()) {
				return false;
			}
			return rs.next();
		} catch (SQLException sqlex) {
			throw new CoreException(sqlex);
		}
	}

	public Record next() throws CoreException {
		if (record == null) {
			record = new Record(schema, rowCount);
		} else {
			record.setRowIndex(rowCount);
			record.clearCells();
		}
		try {
			if (metadata == null) {
				metadata = rs.getMetaData();
			}
			int colTotal = metadata.getColumnCount();
			Type srcType = null;
			Type dstType = null;
			Column column = null;

			Cell cellObject = null;

			for (int i = 1; i <= colTotal && (i <= schema.getColumnCount()); ++i) {
				column = schema.getColumn(i - 1);
				if (column.isNull()) {
					record.addCell(Cell.NULL_CELL);
				} else {
					srcType = column.getInType();
					dstType = column.getType();
					if (srcType == null) {
						srcType = dstType;
					}
					if (column.useDefault()) {
						cellObject = new Cell(schema, rowCount, i - 1,
								column.getDefaultValue());
					} else {
						cellObject = new Cell(schema, rowCount, i - 1,
								IoUtils.readCell(rs, i, srcType, dstType));
					}
					record.addCell(cellObject);

				}
			}
		} catch (SQLException sqlex) {
			throw new CoreException(sqlex);
		}

		++rowCount;
		System.err.println("[Read]{" + record + "}");
		return record;
	}

	public void close() throws CoreException {
	}

	public Schema getSchema() {
		return schema;
	}

	public static void main(String args[]) throws Exception {
		//POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(".\\conf\\in.xls"));
		//HSSFWorkbook hssfworkbook = new HSSFWorkbook(fs);
		//HSSFSheet sheet = hssfworkbook.getSheetAt(0);
		Schema schema = new Schema();
		schema.open();
		Connection conn = ConnUtils.getConnection(schema.getStoreConfig());
		Statement stmt = conn.createStatement();
		ResultSet rs = stmt
				.executeQuery("select vc_billmonth,vc_clientId,vc_clientName from study");
		SQLReader reader = new SQLReader(schema, rs);
		while (reader.hasNext()) {
			reader.next();
		}
		conn.close();
	}
}




package xls.io;

import java.io.FileInputStream;
import java.util.Iterator;

import org.apache.poi.hssf.usermodel.HSSFCell;
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.poifs.filesystem.POIFSFileSystem;

import xls.core.Cell;
import xls.core.Column;
import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;
import xls.core.Type;
import xls.util.IoUtils;

public class XlsReader implements Reader {

	private Iterator<?> rowIterator;
	private int rowCount;
	private Record record;
	private Schema schema;

	public XlsReader(Schema schema, HSSFSheet sheet) {
		this.schema = schema;
		this.rowIterator = sheet.rowIterator();
		this.rowCount = 0;
	}

	public boolean hasNext() throws CoreException {
		while (rowCount < schema.getStartRow()) {
			System.err.println("[Skip Record] row=" + rowCount);
			if (!rowIterator.hasNext()) {
				return false;
			}
			rowIterator.next();
			++rowCount;
		}
		if (rowCount > schema.getEndtRow()) {
			return false;
		}
		
		return rowIterator.hasNext();
	}

	public Record next() throws CoreException {
		int cellCount = 0;
		try {
			HSSFRow row = (HSSFRow) rowIterator.next();
			Iterator<?> cells = row.cellIterator();
			HSSFCell cell = null;

			if (record == null) {
				record = new Record(schema, rowCount);
			} else {
				record.setRowIndex(rowCount);
				record.clearCells();
			}

			Cell cellObject = null;

			Type srcType = null;
			Type dstType = null;
			Column column = null;

			while (cells.hasNext() && (cellCount < schema.getColumnCount())) {
				cell = row.getCell((short) cellCount);
				cells.next();

				if (cell == null) {
					column = schema.getColumn(cellCount);
					srcType = column.getInType();
					dstType = column.getType();

					if (srcType == null) {
						srcType = dstType;
					}
					if (column.useDefault()) {
						cellObject = new Cell(schema, rowCount, cellCount,
								column.getDefaultValue());
					} else {
						cellObject = new Cell(schema, rowCount, cellCount, null);
					}

					record.addCell(cellObject);
				} else {
					column = schema.getColumn(cell.getCellNum());

					if (column.isNull()) {
						record.addCell(Cell.NULL_CELL);
					} else {
						srcType = column.getInType();
						dstType = column.getType();

						if (srcType == null) {
							srcType = dstType;
						}
						if (column.useDefault()) {
							cellObject = new Cell(schema, rowCount, cellCount,
									column.getDefaultValue());
						} else {
							cellObject = new Cell(schema, rowCount, cellCount,
									IoUtils.readCell(cell, srcType, dstType));
						}
						record.addCell(cellObject);
					}
				}
				++cellCount;
			}

			int columnCount = schema.getColumnCount();
			if (cellCount < columnCount) {
				for (int i = cellCount; i < columnCount; ++i) {
					column = schema.getColumn(cellCount);
					srcType = column.getInType();
					dstType = column.getType();
					cellObject = new Cell(schema, rowCount, i, null);
					record.addCell(cellObject);
				}
			}
			++rowCount;
		} catch (Exception ex) {
			System.err.println("[XlsReader read] { row=" + rowCount
					+ ",column=" + cellCount + " }");
			throw new CoreException(ex);
		}
		return record;
	}

	public void close() throws CoreException {
	}

	public Schema getSchema() {
		return (this.schema);
	}

	public static void main(String args[]) throws Exception {
		POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
				"D://project/excelUtil/conf_file/out.xls"));
		HSSFWorkbook hssfworkbook = new HSSFWorkbook(fs);
		HSSFSheet sheet = hssfworkbook.getSheetAt(0);
		Schema schema = new Schema();
		schema.open();
		XlsReader reader = new XlsReader(schema, sheet);
		while (reader.hasNext()) {
			System.out.println(reader.next());
		}
	}
}





//定义一个写的接口
package xls.io;

import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;

public interface Writer {

	public void write(Record record) throws CoreException;

	public void close() throws CoreException;

	public Schema getSchema();
}



package xls.io;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import xls.core.Cell;
import xls.core.Column;
import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;
import xls.util.IoUtils;

public class SQLWriter implements Writer {

	private Schema schema;
	private Connection conn;
	private PreparedStatement stmt;

	public SQLWriter(Schema schema, Connection conn) {
		this.schema = schema;
		this.conn = conn;
	}

	public void write(Record record) throws CoreException {
		try {
			if (stmt == null) {
				stmt = conn.prepareStatement(generateSQL(record));
			}
			PreparedStatement pstmt = (PreparedStatement) stmt;
			setParameter(pstmt, record);
			pstmt.execute();
		} catch (SQLException sqlex) {
			System.err.println("[SQLWriter write]{" + record + "}");
			throw new CoreException(sqlex);
		}
	}

	public void close() throws CoreException {
		try {
			if (stmt != null) {
				PreparedStatement pstmt = (PreparedStatement) stmt;
				pstmt.close();
			}
		} catch (SQLException sqlex) {
			throw new CoreException(sqlex);
		}
	}

	public Schema getSchema() {
		return schema;
	}

	private String generateSQL(Record record) {
		int colTotal = schema.getColumnCount();
		StringBuffer columns = new StringBuffer();
		StringBuffer values = new StringBuffer();
		Column column = null;
		String colName = null;
		for (int i = 0; i < colTotal; ++i) {
			column = schema.getColumn(i);
			if (!column.isNull()) {
				colName = column.getName();
				columns.append(colName + ",");
				values.append("?,");
			}
		}
		String col = columns.toString();
		String val = values.toString();

		int chopIndex = col.lastIndexOf(",");
		if (chopIndex > 0) {
			col = col.substring(0, chopIndex);
		}

		chopIndex = val.lastIndexOf(",");
		if (chopIndex > 0) {
			val = val.substring(0, chopIndex);
		}
		return "insert into " + schema.getTableName() + "(" + col + ") values("
				+ val + ")";
	}

	private void setParameter(PreparedStatement pstmt, Record record)
			throws SQLException, CoreException {
		
		int cellSize = record.getCellCount();
		int paramIndex = 1;

		for (int i = 0; i < cellSize; ++i) {
			Cell cell = record.getCell(i);
			if (!cell.isNull()) {
				IoUtils.writeCell(pstmt, cell, paramIndex);
				++paramIndex;
			}
		}
	}
	public static void main(String args[]){
		
	}
}



package xls.io;

import java.io.OutputStream;

import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import xls.core.Cell;
import xls.core.Column;
import xls.core.CoreException;
import xls.core.Record;
import xls.core.Schema;
import xls.util.IoUtils;

public class XlsWriter {

	private Schema schema;
	private OutputStream fout;
	HSSFWorkbook workBook;
	HSSFSheet sheet;

	int rowCount;

	public XlsWriter(Schema schema_, OutputStream fout_) {
		this.schema = schema_;
		this.fout = fout_;
		this.workBook = new HSSFWorkbook();
		this.sheet = workBook.createSheet();
		this.rowCount = 0;
	}

	public void write(Record record) throws CoreException {
		HSSFRow row = sheet.createRow(rowCount);
		int sizeCell = record.getCellCount();
		Cell cellObject = null;
		int cellIndex = 0;
		for (int i = 0; i < sizeCell; ++i) {
			cellObject = record.getCell(i);
			if (!cellObject.isNull()) {
				IoUtils.writeCell(workBook, row, cellIndex, cellObject);
				++cellIndex;
			}
		}
		++rowCount;
		System.err.println("[Write]{" + record + "}");
	}

	public void close() throws CoreException {
		try {
			workBook.write(fout);
		} catch (Exception ex) {
			throw new CoreException(ex);
		}
	}

	public void writeTitle() throws CoreException {
		HSSFRow row = sheet.createRow(rowCount);
		int sizeColumn = schema.getColumnCount();
		Column column = null;
		int titleIndex = 0;
		for (int i = 0; i < sizeColumn; ++i) {
			column = schema.getColumn(i);
			if (!column.isNull()) {
				IoUtils.writeTitle(row, titleIndex, column.getName());
				++titleIndex;
			}
		}
		++rowCount;
	}

	public Schema getSchema() {
		return schema;
	}
}

这个针对文件操作实现读写流
分享到：
| java操作excel实现从数据库导入导出（一）
评论
发表评论

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

相关推荐

    Java实现excel文档数据导入数据库、导出excel

    总结，Java通过Apache POI库处理Excel文档，结合JDBC进行数据库操作，实现了数据的导入导出。在实际应用中，可能还需要处理异常、优化性能，以及考虑并发和多线程等问题。理解并掌握这些技术，可以极大地提高Java...

    excel表导入数据库 数据库导出excel（idea平台）

    在这个主题中，我们将深入探讨如何使用Java技术栈，特别是基于IDEA开发环境，来实现在JSP和Servlet中进行Excel与数据库之间的数据导入和导出。 首先，我们需要了解Java中用于处理Excel文件的库，如Apache POI。...

    Java实现Excel导入导出数据库的方法示例

    Java实现Excel导入导出数据库的方法示例主要介绍了Java实现Excel导入导出数据库的方法，结合实例形式分析了java针对Excel的读写及数据库操作相关实现技巧。该示例中，主要讲解了如何将Excel文件导入到数据库中，并...

    JAVA实现数据库数据导入导出到Excel（POI)所需jar包

    在Java开发中，有时我们需要将数据库中的数据导出到Excel文件，或者从Excel文件导入数据到数据库。Apache POI是一个流行的API，专为处理Microsoft Office格式的文件，如Excel（.xlsx, .xls）。本教程将详细介绍如何...

    asp将EXCEL导入导出数据库原程序

    这个"asp将EXCEL导入导出数据库原程序"提供了一个解决方案，能够方便地将Excel中的数据存入MSSQL数据库，同时也能将数据库中的数据导出到Excel文件。 首先，我们需要了解如何使用ASP连接MSSQL数据库。通常，这涉及...

    java实现Excel数据导入到数据库

    本篇文章将深入探讨如何使用Java实现这两个功能，主要涉及的技术栈包括Apache POI库用于操作Excel，以及JDBC（Java Database Connectivity）用于与MySQL数据库进行交互。 首先，我们需要了解Apache POI库。这是一个...

    最新java实现Excel导入导出

    用Java实现的Excel的导入导出，简洁明了，高质量代码。

    java实现mysql数据库的表导出到excel文件

    本文将详细讲解如何使用Java实现从MySQL数据库的表导出到Excel文件的过程，以及涉及到的关键技术和工具。 首先，我们需要了解的是Java与数据库交互的基础——JDBC（Java Database Connectivity）。JDBC是Java API，...

    java解析Excel文件并把数据存入数据库和导出数据为excel文件SpringBoot代码示例

    2、java读取数据库数据，并导出为excel文件。 3、README.md中有详细的操作步骤示例。 使用说明： 1. 先使用postman导入：other/excel相关.postman_collection.json 2. 导入sql到数据库：other/excel.sql 3. idea导入...

    spring boot+mybatis plus+easy poi实现数据库导出成excel和excel导入到数据库.zip

    在本项目中，"spring boot+mybatis plus+easy poi实现数据库导出成excel和excel导入到数据库"，开发者利用了Spring Boot、MyBatis Plus和EasyPoi库来实现了一个功能强大的数据交互系统，允许用户将数据库中的数据...

    SpringBootMybatis+poi+Thymeleaf实现excel文件数据导入到数据库以及从数据库将数据导出成excel.zip

    总的来说，这个项目展示了如何在Java环境中，结合Spring Boot的便利性，利用MyBatis进行数据库操作，借助Apache POI处理Excel文件，以及Thymeleaf生成动态页面，实现数据的导入导出功能。这是一个综合性的Java Web...

    Java操作Excel之Poi模板导入导出

    在"Java操作Excel之Poi模板导入导出"这个主题中，我们将深入探讨如何使用POI库来处理Excel模板，并进行数据的导入和导出。 首先，了解Excel模板的基本概念。模板通常包含预定义的样式、格式和计算，开发人员可以...

    POI实现Excel导入导出并附带加载进度条

    总之，这个项目是一个完整的Java解决方案，用于处理Excel文件的导入导出，同时具备用户友好的进度条显示。它利用了Apache POI的强大功能，结合maven的依赖管理，以及可能的GUI组件，提供了高效且直观的数据操作体验...

    使用poi从数据库导出excel表的示例

    总结起来，"使用poi从数据库导出excel表的示例"是一个结合了Struts1 MVC框架和Apache POI库的Java编程任务，它涉及数据库连接、SQL查询、Excel文件生成以及Web应用响应。这个过程不仅有助于数据的高效管理和分享，也...

    Java--Excel根据数据库导入，导出

    本主题主要关注如何使用Java将数据库中的数据导出到Excel，以及如何从Excel文件导入数据到数据库。以下是一些关键知识点的详细说明： 1. **Java与Excel的交互**：Java中处理Excel文件最常用的库是Apache POI，它...

    java编写的数据库导入和导出工具

    本项目"java编写的数据库导入和导出工具"旨在简化这个过程，支持对SQL Server和MySQL数据库进行数据的便捷操作。下面我们将详细探讨相关的Java编程知识点、数据库操作以及可能涉及的库和框架。 1. **Java编程基础**...

    使用Springboot实现excel的导入导出

    在Spring Boot中实现Excel的导入导出可以通过POI库来实现，POI是一个开源的Java库，用于处理Microsoft Office格式文件，包括Excel。一个简单的示例，演示如何在Spring Boot项目中使用POI来实现Excel的导入导出功能。...

    java实现Excel数据导入到mysql数据库.zip

    总结来说，这个项目涵盖了Java编程、文件操作（尤其是Excel处理）、数据库连接与操作（通过JDBC和SQL）以及数据导入导出策略等多个IT核心技能。对于学习和提升这些技能，这个项目提供了一个很好的实践平台。

    java excel导入导出数据库表内容

    只需传入数据库连接信息、Excel文件路径和相关的SQL语句，就能轻松实现数据的导入导出。 为了优化性能，可以考虑使用缓存技术（如HikariCP）提高数据库连接管理效率，或者使用线程池并发处理Excel数据，尤其是在...

    excel和数据库之间数据的导入导出

    在IT领域，Excel和数据库之间的数据导入导出是一项常见的任务，尤其在数据分析、报表制作以及信息管理中。Excel是一款强大的电子表格工具，而SQL Server则是一种功能强大的关系型数据库管理系统。两者之间的数据交互...

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