用java实现从文本文件批量导入数据至数据库

合集下载

java批量向oracle插入数据

java批量向oracle插入数据

java批量向oracle插⼊数据 由于项⽬需要,需要将⼀个6M的txt中的数据插⼊到oracle数据表中。

txt中的数据是每⾏⼀个词。

经过统计,词总数是505040。

为了看起来⽅便,我将我的所有⽅法写在类⼊⼝中,数据库的信息我会⽤test代替,代码如下。

public static void main(String[] args) throws IOException, Exception {// TODO Auto-generated method stubConnection conn = null;Class.forName("oracle.jdbc.driver.OracleDriver");conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:test","test", "test");conn.setAutoCommit(false);PreparedStatement pst = conn.prepareStatement("insert into yq_seq_word values(seq_yq_seq_word.nextval,?)");InputStreamReader isr = new InputStreamReader(new FileInputStream(new File("C:/Users/Press-Lab/Desktop/test.txt")), "utf-8");BufferedReader read = new BufferedReader(isr);String s = null;int i = 1;long start = System.currentTimeMillis();while ((s = read.readLine()) != null) {// 当数据满100条批量插⼊if (i % 100 == 0) {// 语句执⾏完毕,提交本事务pst.executeBatch();// 此处的事务回滚是必须的,⽹上很多代码没有处理,会导致插⼊数据不完整。

把数据从txt文件导入到Oracle数据库的实现方法

把数据从txt文件导入到Oracle数据库的实现方法

把数据从txt文件导入到Oracle数据库的实现方法
1、环境配置准备
在导入txt文件到Oracle数据库之前,我们需要配置环境,方可方
便后续的操作:
(1)安装Oracle数据库,并配置好数据库用户及其权限;
(2)安装Oracle的工具sqlldr,这是一个数据导入工具;
(3)在操作系统中,创建一个目录,用于存放sqlldr需要使用的控
制文件,以及要导入数据库的txt文件;
(4)编写好sqlldr需要的控制文件,控制文件可以定义数据的格式,以及要插入到数据库的表结构等;
(5)将要被导入的txt文件存放到上面定义的目录中;
2、编写sqlldr控制文件
sqlldr提供了一种类SQL语句的控制文件,这些控制文件用于描述
如何将txt文件中的数据导入到Oracle数据库中,主要包括以下几方面
的内容:
(1)数据的编码;
(2)要被导入的表名;
(3)每个要被导入的字段的定义,包括其类型、长度等;
(4)数据的分隔符,比如以空格分隔或者以tab分隔等;
(5)进行数据校验,比如检查给定字段的数据是否是满足要求的类型等;
(6)如果数据中有时间字段,可以定义时间的格式;
(7)数据导入失败的记录日志路径;
(8)定义要被导入的字段的映射关系,比如txt文件中的列名与表中的字段没有一一对应;。

如何用Java实现把excel表中的数据导入到mysql数据库已有的表中

如何用Java实现把excel表中的数据导入到mysql数据库已有的表中

如何用Java实现把excel表中的数据导入到mysql数据库已有的表中?悬赏分:15 |解决时间:2010-12-23 13:53 |提问者:quce227如何用Java实现把excel表中的数据导入到mysql数据库已有的表中?数据库中表的字段已定好~~问题补充:主要是excel中的字段和数据库表中的字段匹配然后批量导入(插入),能否给一个实例最佳答案java 读excel 还是比较方便简单的,原理就是,先用java 读取excel,然后,一行行的写入数据库,字段的话,你自己程序里面写就行了,给你个例子:从Excel读取数据,生成新的Excel,以及修改Excelpackage common.util;import jxl.*;import jxl.format.UnderlineStyle;import jxl.write.*;import jxl.write.Number;import jxl.write.Boolean;import java.io.*;/*** Created by IntelliJ IDEA.* User: xl* Date: 2005-7-17* Time: 9:33:22* To change this template use File | Settings | File Templates.*/public class ExcelHandle{public ExcelHandle(){}/*** 读取Excel** @param filePath*/public static void readExcel(String filePath){try{InputStream is = new FileInputStream(filePath);Workbook rwb = Workbook.getWorkbook(is);//Sheet st = rwb.getSheet("0")这里有两种方法获取sheet表,1为名字,而为下标,从0开始Sheet st = rwb.getSheet("original");Cell c00 = st.getCell(0,0);//通用的获取cell值的方式,返回字符串String strc00 = c00.getContents();//获得cell具体类型值的方式if(c00.getType() == BEL){LabelCell labelc00 = (LabelCell)c00;strc00 = labelc00.getString();}//输出System.out.println(strc00);//关闭rwb.close();}catch(Exception e){e.printStackTrace();}}/*** 输出Excel** @param os*/public static void writeExcel(OutputStream os){try{/*** 只能通过API提供的工厂方法来创建Workbook,而不能使用WritableWorkbook的构造函数,* 因为类WritableWorkbook的构造函数为protected类型* method(1)直接从目标文件中读取WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile));* method(2)如下实例所示将WritableWorkbook直接写入到输出流*/WritableWorkbook wwb = Workbook.createWorkbook(os);//创建Excel工作表指定名称和位置WritableSheet ws = wwb.createSheet("Test Sheet 1",0);//**************往工作表中添加数据*****************//1.添加Label对象Label label = new Label(0,0,"this is a label test");ws.addCell(label);//添加带有字型Formatting对象WritableFont wf = newWritableFont(WritableFont.TIMES,18,WritableFont.BOLD,true);WritableCellFormat wcf = new WritableCellFormat(wf);Label labelcf = new Label(1,0,"this is a label test",wcf);ws.addCell(labelcf);//添加带有字体颜色的Formatting对象WritableFont wfc = newWritableFont(WritableFont.ARIAL,10,WritableFont.NO_BOLD,false, UnderlineStyle.NO_UNDERLINE,jxl.format.Colour.RED);WritableCellFormat wcfFC = new WritableCellFormat(wfc);Label labelCF = new Label(1,0,"This is a Label Cell",wcfFC);ws.addCell(labelCF);//2.添加Number对象Number labelN = new Number(0,1,3.1415926);ws.addCell(labelN);//添加带有formatting的Number对象NumberFormat nf = new NumberFormat("#.##");WritableCellFormat wcfN = new WritableCellFormat(nf);Number labelNF = new jxl.write.Number(1,1,3.1415926,wcfN);ws.addCell(labelNF);//3.添加Boolean对象Boolean labelB = new jxl.write.Boolean(0,2,false);ws.addCell(labelB);//4.添加DateTime对象jxl.write.DateTime labelDT = new jxl.write.DateTime(0,3,new java.util.Date());ws.addCell(labelDT);//添加带有formatting的DateFormat对象DateFormat df = new DateFormat("dd MM yyyy hh:mm:ss");WritableCellFormat wcfDF = new WritableCellFormat(df);DateTime labelDTF = new DateTime(1,3,newjava.util.Date(),wcfDF);ws.addCell(labelDTF);//添加图片对象,jxl只支持png格式图片File image = new File("f:\\2.png");WritableImage wimage = new WritableImage(0,1,2,2,image);ws.addImage(wimage);//写入工作表wwb.write();wwb.close();}catch(Exception e){e.printStackTrace();}}/*** 拷贝后,进行修改,其中file1为被copy对象,file2为修改后创建的对象* 尽单元格原有的格式化修饰是不能去掉的,我们还是可以将新的单元格修饰加上去,* 以使单元格的内容以不同的形式表现* @param file1* @param file2*/public static void modifyExcel(File file1,File file2){try{Workbook rwb = Workbook.getWorkbook(file1);WritableWorkbook wwb =Workbook.createWorkbook(file2,rwb);//copyWritableSheet ws = wwb.getSheet(0);WritableCell wc = ws.getWritableCell(0,0);//判断单元格的类型,做出相应的转换if(wc.getType == BEL){Label label = (Label)wc;label.setString("The value has been modified");}wwb.write();wwb.close();rwb.close();}catch(Exception e){e.printStackTrace();}}//测试public static void main(String[] args){try{//读ExcelExcelHandle.readExcel("f:/testRead.xls");//输出ExcelFile fileWrite = new File("f:/testWrite.xls");fileWrite.createNewFile();OutputStream os = new FileOutputStream(fileWrite);ExcelHandle.writeExcel(os);//修改ExcelExcelHandle.modifyExcel(new file(""),new File(""));}catch(Exception e){e.printStackTrace();}}}2.在jsp中做相关测试,创建一个writeExcel.jsp<%response.reset();//清除Bufferresponse.setContentType("application/vnd.ms-excel");File fileWrite = new File("f:/testWrite.xls");fileWrite.createNewFile();new FileOutputStream(fileWrite);ExcelHandle.writeExcel(new FileOutputStream(fileWrite));%>在IE中浏览writeExcel.jsp就可以动态生成Excel文档了,其中response.setContentType("application/vnd.ms- excel");语句必须要,才能确保不乱码,在jsp中输入<%@page contentType="application/vnd.ms-excel;charset=GBK"%>不行。

java写txt文件的大数据方法

java写txt文件的大数据方法

一、概述随着信息技术的不断发展和应用,数据处理和管理方面的需求也日益增加。

在大数据处理和管理方面,Java作为一种流行且功能强大的编程语言,为开发人员提供了丰富的工具和库。

本文将介绍如何使用Java编程语言来处理和管理大数据,并重点讨论如何写入txt文件的大数据方法。

二、大数据处理的挑战传统的数据处理方法通常无法满足大数据处理的需求,例如内存的限制、并发处理的问题等。

针对大数据处理的挑战,Java提供了多种机制和工具,例如多线程、文件流、缓冲区等。

这些工具和机制可以帮助开发人员更有效地处理大数据。

三、Java写入txt文件的基本方法在Java中,写入txt文件的基本方法通常涉及到以下几个步骤:1. 创建文件对象:首先需要创建一个文件对象来表示要写入的文件。

可以使用Java中的File类来创建文件对象。

2. 创建文件输出流:接下来需要创建一个文件输出流来将数据写入到文件中。

可以使用Java中的FileOutputStream类来创建文件输出流。

3. 写入数据:一旦创建了文件输出流,就可以调用其write()方法来写入数据。

可以使用缓冲输出流来提高写入效率。

四、Java写入大数据到txt文件的方法在处理大数据时,直接使用FileOutputStream的write()方法来写入数据可能会遇到内存溢出的问题。

为了有效地处理大数据,可以考虑以下几种方法:1. 使用缓冲区:可以通过使用缓冲输出流来提高写入大数据的效率。

缓冲输出流可以将数据暂时存储在缓冲区中,然后一次性写入到文件中,避免频繁的文件I/O操作。

2. 使用多线程:可以考虑使用多线程来并发地写入大数据。

通过将数据分割成多个小块,并分配给不同的线程来处理,可以提高写入数据的速度。

3. 使用内存映射文件:Java提供了内存映射文件的机制,可以将文件映射到内存中,然后直接对内存进行操作,从而避免频繁的文件I/O 操作。

五、示例代码以下是一个使用Java写入大数据到txt文件的示例代码:```javaimport java.io.BufferedWriter;import java.io.File;import java.io.FileWriter;import java.io.IOException;public class WriteBigDataToFile {public static void m本人n(String[] args) {File file = new File("bigdata.txt");try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))){for (int i = 0; i < xxx; i++) {writer.write(String.valueOf(i));writer.newLine();}} catch (IOException e) {e.printStackTrace();}}}```六、总结在处理大数据时,选择合适的方法和工具非常重要。

把数据从txt文件导入到数据库的实现方法

把数据从txt文件导入到数据库的实现方法

把数据从txt文件导入到数据库的实现方法将数据从txt文件导入到数据库可以通过以下步骤实现:1. 创建数据库表结构:首先需要创建一个与txt文件数据相对应的数据库表结构。

表的列应该与txt文件中的数据字段对应。

可以使用数据库管理工具(如MySQL Workbench)或编程语言中的数据库操作库(如Python的MySQLdb)来创建表结构。

2. 打开txt文件:使用编程语言中的文件操作函数(如Python的open(函数)打开txt文件,并读取其中的数据。

根据txt文件的格式,可以使用逐行读取或一次性读取整个文件的方式来获取数据。

3. 解析数据:对于每一行数据,需要将其解析成各个字段的值。

可以使用字符串操作函数(如split(函数)将一行数据拆分成多个字段值。

如果txt文件中的数据是有结构的,可以使用正则表达式来匹配和提取字段值。

4. 建立数据库连接:使用编程语言中的数据库操作库连接到目标数据库。

根据数据库类型,可以使用不同的库(如Python的MySQLdb库、psycopg2库用于PostgreSQL等)来建立连接。

5.插入数据:将解析得到的数据插入到数据库表中。

使用数据库操作库提供的插入语句(如SQL语句)将数据插入到数据库表中。

可以使用批量插入的方式来提高插入性能,即将多个数据记录一次性插入到数据库中。

6. 关闭文件和数据库连接:在数据导入完成后,关闭txt文件和数据库连接,释放资源。

7. 错误处理:在数据导入的过程中,可能会出现一些错误,如文件不存在、数据格式错误等。

需要进行错误处理,确保数据导入的完整性和正确性。

可以使用异常处理机制(如Python的try-except语句)来捕获和处理错误。

8. 日志记录:为了追踪数据导入的过程和结果,可以添加日志记录功能。

可以使用编程语言中的日志库(如Python的logging库)来记录日志,包括导入开始时间、结束时间、导入的记录数等信息。

总结:将数据从txt文件导入到数据库需要完成文件读取、数据解析、数据库连接、数据插入等步骤。

Java实现大批量数据导入导出(100W以上) -(二)导出

Java实现大批量数据导入导出(100W以上) -(二)导出

Java实现⼤批量数据导⼊导出(100W以上) -(⼆)导出使⽤POI或JXLS导出⼤数据量(百万级)Excel报表常常⾯临两个问题:1. 服务器内存溢出;2. ⼀次从数据库查询出这么⼤数据,查询缓慢。

当然也可以分页查询出数据,分别⽣成多个Excel打包下载,但这种⽣成还是很缓慢。

⼤数据量导⼊请参考:那么如何解决呢?我们可以借助XML格式利⽤模板替换,分页查询出数据从磁盘写⼊XML,最终会以Excel多sheet形式⽣成。

亲测2400万⾏数据,⽣成Excel⽂件4.5G,总耗时1.5分钟。

我利⽤StringTemplate模板解析技术对XML模板进⾏填充。

当然也可以使⽤FreeMarker, Velocity等Java模板技术实现。

⾸先引⼊StringTemplate所需Jar包:使⽤技术为 stringTemplatepom.xml:1 <dependency>2<groupId>antlr</groupId>3<artifactId>antlr</artifactId>4<version>2.7.7</version>5</dependency>67<dependency>8<groupId>org.antlr</groupId>9<artifactId>stringtemplate</artifactId>10<version>3.2.1</version>11</dependency>⾸先准备导出Excel模板,然后打开-》另存为-》选择格式为XML,然后⽤⽂本打开XML,提取XML头模板(head.st可通⽤),数据体模板(boday.st):head.st可通⽤:1<?xml version="1.0"?>2<?mso-application progid="Excel.Sheet"?>3<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"4 xmlns:o="urn:schemas-microsoft-com:office:office"5 xmlns:x="urn:schemas-microsoft-com:office:excel"6 xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"7 xmlns:html="/TR/REC-html40">8<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">9<Created>1996-12-17T01:32:42Z</Created>10<LastSaved>2013-08-02T09:21:24Z</LastSaved>11<Version>11.9999</Version>12</DocumentProperties>13<OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office">14<RemovePersonalInformation/>15</OfficeDocumentSettings>16<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">17<WindowHeight>4530</WindowHeight>18<WindowWidth>8505</WindowWidth>19<WindowTopX>480</WindowTopX>20<WindowTopY>120</WindowTopY>21<AcceptLabelsInFormulas/>22<ProtectStructure>False</ProtectStructure>23<ProtectWindows>False</ProtectWindows>24</ExcelWorkbook>25<Styles>26<Style ss:ID="Default" ss:Name="Normal">27<Alignment ss:Vertical="Bottom"/>28<Borders/>29<Font ss:FontName="宋体" x:CharSet="134" ss:Size="12"/>30<Interior/>31<NumberFormat/>32<Protection/>33</Style>34</Styles>boday.st:1 $worksheet:{2<Worksheet ss:Name="$it.sheet$">3<Table ss:ExpandedColumnCount="$it.columnNum$" ss:ExpandedRowCount="$it.rowNum$" x:FullColumns="1"4 x:FullRows="1" ss:DefaultColumnWidth="54" ss:DefaultRowHeight="14.25">5 $it.rows:{6<Row>7<Cell><Data ss:Type="String">$1$</Data></Cell>8<Cell><Data ss:Type="String">$2$</Data></Cell>9<Cell><Data ss:Type="String">$3$</Data></Cell>10</Row>11 }$12</Table>13</Worksheet>14 }$⽣成⼤数据量Excel类:ExcelGenerator:1package test.exportexcel;23import org.antlr.stringtemplate.StringTemplate;4import org.antlr.stringtemplate.StringTemplateGroup;5import test.exportexcel.bean.Row;6import test.exportexcel.bean.Worksheet;78import java.io.*;9import java.util.ArrayList;10import java.util.List;11import java.util.Random;1213/**14 * 类功能描述:generator big data Excel15 *16 * @author WangXueXing create at 19-4-13 下午10:2317 * @version 1.0.018*/19public class ExcelGenerator {20public static void main(String[] args) throws FileNotFoundException{21 ExcelGenerator template = new ExcelGenerator();22 template.output2();23 }2425/**26 * ⽣成数据量⼤的时候,该⽅法会出现内存溢出27 * @throws FileNotFoundException28*/29public void output1() throws FileNotFoundException{30 StringTemplateGroup stGroup = new StringTemplateGroup("stringTemplate");31 StringTemplate st4 = stGroup.getInstanceOf("test/exportexcel/template/test");32 List<Worksheet> worksheets = new ArrayList<>();3334 File file = new File("/home/barry/data/output.xls");35 PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(file)));3637for(int i=0;i<30;i++){38 Worksheet worksheet = new Worksheet();39 worksheet.setSheet("第"+(i+1)+"页");40 List<Row> rows = new ArrayList<>();41for(int j=0;j<6000;j++){42 Row row = new Row();43 row.setName1("zhangzehao");44 row.setName2(""+j);45 row.setName3(i+" "+j);46 rows.add(row);47 }48 worksheet.setRows(rows);49 worksheets.add(worksheet);50 }5152 st4.setAttribute("worksheets", worksheets);53 writer.write(st4.toString());54 writer.flush();55 writer.close();56 System.out.println("⽣成excel完成");57 }5859/**60 * 该⽅法不管⽣成多⼤的数据量,都不会出现内存溢出,只是时间的长短61 * 经测试,⽣成2400万数据,2分钟内,4.5G⼤的⽂件,打开⼤⽂件就看内存是否⾜够⼤了62 * 数据量⼩的时候,推荐⽤JXLS的模板技术⽣成excel⽂件,谁⽤谁知道,⼤数据量可以结合该⽅法使⽤63 * @throws FileNotFoundException64*/65public void output2() throws FileNotFoundException{66long startTimne = System.currentTimeMillis();67 StringTemplateGroup stGroup = new StringTemplateGroup("stringTemplate");6869//写⼊excel⽂件头部信息70 StringTemplate head = stGroup.getInstanceOf("test/exportexcel/template/head");71 File file = new File("/home/barry/data/output.xls");72 PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(file)));73 writer.print(head.toString());74 writer.flush();7576int sheets = 400;77//excel单表最⼤⾏数是6553578int maxRowNum = 60000;7980//写⼊excel⽂件数据信息81for(int i=0;i<sheets;i++){82 StringTemplate body = stGroup.getInstanceOf("test/exportexcel/template/body");83 Worksheet worksheet = new Worksheet();84 worksheet.setSheet(" "+(i+1)+" ");85 worksheet.setColumnNum(3);86 worksheet.setRowNum(maxRowNum);87 List<Row> rows = new ArrayList<>();88for(int j=0;j<maxRowNum;j++){89 Row row = new Row();90 row.setName1(""+new Random().nextInt(100000));91 row.setName2(""+j);92 row.setName3(i+""+j);93 rows.add(row);94 }95 worksheet.setRows(rows);96 body.setAttribute("worksheet", worksheet);97 writer.print(body.toString());98 writer.flush();99 rows.clear();100 rows = null;101 worksheet = null;102 body = null;103 Runtime.getRuntime().gc();104 System.out.println("正在⽣成excel⽂件的 sheet"+(i+1));105 }106107//写⼊excel⽂件尾部108 writer.print("</Workbook>");109 writer.flush();110 writer.close();111 System.out.println("⽣成excel⽂件完成");112long endTime = System.currentTimeMillis();113 System.out.println("⽤时="+((endTime-startTimne)/1000)+"秒");114 }115 }定义JavaBean:WorkSheet.java:1package test.exportexcel.bean;23import java.util.List;45/**6 * 类功能描述:Excel sheet Bean7 *8 * @author WangXueXing create at 19-4-13 下午10:219 * @version 1.0.010*/11public class Worksheet {12private String sheet;13private int columnNum;14private int rowNum;15private List<Row> rows;1617public String getSheet() {18return sheet;19 }20public void setSheet(String sheet) {21this.sheet = sheet;22 }2324public List<Row> getRows() {25return rows;26 }27public void setRows(List<Row> rows) {28this.rows = rows;29 }3031public int getColumnNum() {32return columnNum;33 }34public void setColumnNum(int columnNum) {35this.columnNum = columnNum;36 }3738public int getRowNum() {39return rowNum;40 }41public void setRowNum(int rowNum) {42this.rowNum = rowNum;43 }44 }Row.java:1package test.exportexcel.bean;23/**4 * 类功能描述:Excel row bean5 *6 * @author WangXueXing create at 19-4-13 下午10:227 * @version 1.0.08*/9public class Row {10private String name1;11private String name2;12private String name3;1314public String getName1() {15return name1;16 }17public void setName1(String name1) {1 = name1;19 }2021public String getName2() {22return name2;23 }24public void setName2(String name2) {2 = name2;26 }2728public String getName3() {29return name3;30 }31public void setName3(String name3) {3 = name3;33 }34 }另附实现源码: 此外,⼤数据量并并且Excel列较多时,会出现内存溢出。

Java多线程批量数据导入的方法详解

Java多线程批量数据导入的方法详解

Java多线程批量数据导⼊的⽅法详解前⾔:当遇到⼤量数据导⼊时,为了提⾼处理的速度,可以选择使⽤多线程来批量处理这些处理。

常见的场景有:⼤⽂件导⼊数据库(这个⽂件不⼀定是标准的CSV可导⼊⽂件或者需要在内存中经过⼀定的处理)数据同步(从第三⽅接⼝拉取数据处理后写⼊⾃⼰的数据库)以上的场景有⼀个共性,这类数据导⼊的场景简单来说就是将数据从⼀个数据源移动到另外⼀个数据源,⽽其中必定可以分为两步数据读取:从数据源读取数据到内存数据写⼊:将内存中的数据写⼊到另外⼀个数据源,可能存在数据处理⽽且根据读取的速度⼀般会⽐数据写⼊的速度快很多,即读取快,写⼊慢。

设计思路由于场景的特点是读取快,写⼊慢,如果是使⽤多线程处理,建议是数据写⼊部分改造为多线程。

⽽数据读取可以改造成批量读取数据。

简单来说就是两个要点:批量读取数据多线程写⼊数据⽰例多线程批量处理最简单的⽅案是使⽤线程池来进⾏处理,下⾯会通过⼀个模拟批量读取和写⼊的服务,以及对这个服务的多线程写⼊调⽤作为⽰例,展⽰如何多线程批量数据导⼊。

模拟服务import java.util.concurrent.atomic.AtomicLong;/*** 数据批量写⼊⽤的模拟服务** @author RJH* create at 2019-04-01*/public class MockService {/*** 可读取总数*/private long canReadTotal;/*** 写⼊总数*/private AtomicLong writeTotal=new AtomicLong(0);/*** 写⼊休眠时间(单位:毫秒)*/private final long sleepTime;/*** 构造⽅法** @param canReadTotal* @param sleepTime*/public MockService(long canReadTotal, long sleepTime) {this.canReadTotal = canReadTotal;this.sleepTime = sleepTime;}/*** 批量读取数据接⼝** @param num* @return*/public synchronized long readData(int num) {long readNum;if (canReadTotal >= num) {canReadTotal -= num;readNum = num;} else {readNum = canReadTotal;canReadTotal = 0;}//System.out.println("read data size:" + readNum);return readNum;}/*** 写⼊数据接⼝*/public void writeData() {try {// 休眠⼀定时间模拟写⼊速度慢Thread.sleep(sleepTime);} catch (InterruptedException e) {e.printStackTrace();}// 写⼊总数⾃增System.out.println("thread:" + Thread.currentThread() + " write data:" + writeTotal.incrementAndGet()); }/*** 获取写⼊的总数** @return*/public long getWriteTotal() {return writeTotal.get();}}批量数据处理器import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/*** 基于线程池的多线程批量写⼊处理器* @author RJH* create at 2019-04-01*/public class SimpleBatchHandler {private ExecutorService executorService;private MockService service;/*** 每次批量读取的数据量*/private int batch;/*** 线程个数*/private int threadNum;public SimpleBatchHandler(MockService service, int batch,int threadNum) {this.service = service;this.batch = batch;//使⽤固定数⽬的线程池this.executorService = Executors.newFixedThreadPool(threadNum);}/*** 开始处理*/public void startHandle() {// 开始处理的时间long startTime = System.currentTimeMillis();System.out.println("start handle time:" + startTime);long readData;while ((readData = service.readData(batch)) != 0) {// 批量读取数据,知道读取不到数据才停⽌for (long i = 0; i < readData; i++) {executorService.execute(() -> service.writeData());}}// 关闭线程池executorService.shutdown();while (!executorService.isTerminated()) {//等待线程池中的线程执⾏完}// 结束时间long endTime = System.currentTimeMillis();System.out.println("end handle time:" + endTime);// 总耗时System.out.println("total handle time:" + (endTime - startTime) + "ms");// 写⼊总数System.out.println("total write num:" + service.getWriteTotal());}}测试类/*** SimpleBatchHandler的测试类* @author RJH* create at 2019-04-01*/public class SimpleBatchHandlerTest {public static void main(String[] args) {// 总数long total=100000;// 休眠时间long sleepTime=100;// 每次拉取的数量int batch=100;// 线程个数int threadNum=16;MockService mockService=new MockService(total,sleepTime);SimpleBatchHandler handler=new SimpleBatchHandler(mockService,batch,threadNum);handler.startHandle();}}运⾏结果start handle time:1554298681755thread:Thread[pool-1-thread-2,5,main] write data:1thread:Thread[pool-1-thread-1,5,main] write data:2...省略部分输出thread:Thread[pool-1-thread-4,5,main] write data:100000end handle time:1554299330202total handle time:648447mstotal write num:100000分析在单线程情况下的执⾏时间应该为total*sleepTime,即10000000ms,⽽改造为多线程后执⾏时间为648447ms。

java从文件中读取数据并存入对象中的方法

java从文件中读取数据并存入对象中的方法

一、概述在软件开发中,经常会遇到需要从文件中读取数据并存入对象中的情况,尤其是在使用Java语言进行编程时。

掌握Java从文件中读取数据并存入对象中的方法对于开发者来说是非常重要的。

本文将介绍Java中实现该功能的常用方法,并结合实例详细讲解。

二、使用Java读取文件的方法1. 使用File类和Scanner类读取文件Java中可以使用File类和Scanner类来读取文件中的数据。

首先通过File类创建文件对象,然后通过Scanner类来读取文件中的内容。

以下是一个简单的示例代码:```javaimport java.io.File;import java.io.FileNotFoundException;import java.util.Scanner;public class ReadFromFile {public static void m本人n(String[] args) {try {File file = new File("data.txt");Scanner scanner = new Scanner(file);while (scanner.hasNextLine()) {String data = scanner.nextLine();System.out.println(data);}scanner.close();} catch (FileNotFoundException e) {System.out.println("File not found");e.printStackTrace();}}}```2. 使用BufferedReader类读取文件除了Scanner类,还可以使用BufferedReader类来读取文件中的数据。

与Scanner类不同,BufferedReader类提供了更高效的读取方式。

以下是一个使用BufferedReader类读取文件的示例代码:```javaimport java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;public class ReadFromFile {public static void m本人n(String[] args) {try {BufferedReader reader = new BufferedReader(new FileReader("data.txt"));String line = reader.readLine();while (line != null) {System.out.println(line);line = reader.readLine();}reader.close();} catch (IOException e) {System.out.println("IO Exception");e.printStackTrace();}}}```以上是使用Java读取文件的基本方法,开发者可以根据实际需求选择合适的方式来读取文件中的数据。

kettle 批量导入文本数据到mysql、oracle数据库(整改1)

kettle 批量导入文本数据到mysql、oracle数据库(整改1)

kettle 批量导入文本数据到mysql、oracle数据库1Kettle 工具Kettle是开源的ETL工具,纯java编写,可以在Windows、Li nux、Unix上运行,数据抽取高效稳定。

Kettle 中文名称叫水壶,该项目的主程序员MATT 希望把各种数据放到一个壶里,然后以一种指定的格式流出。

Kettle中有两种脚本文件,transformation和job,transformati on完成针对数据的基础转换,job则完成整个工作流的控制。

2背景工作中有时会有一种需求,将几百个文件导入的数据库中,这时如果一个一个去导入工作量非常大,而且容易出错不好控制。

使用k ettle 可以非常容易的解决。

2.1转换文件如果有批量文件导入的可以下载本文件获取编辑好的转换。

3使用说明3.1打开下载好的转换文件3.2修改文本文件输入第一步:打开编辑界面第二步:通过通配符选择文件第三步:测验是否可以正常读到文件名第四步:内容设置说明:根据实际填写第五步:字段设置3.3修改插入/ 更新第一步:打开编辑界面第二步:选择数据库连接及需要导入的表第三步:配置数据如果存在是更新还是跳过说明:如果文本字段Field_005 和数据库表server_no 相等,对字段server_no,statis_date 字段不进行更新。

4符:新建数据库连接Mysql jdbc连接为例:第一步:工具-向导-创建数据库连接向导第二步:填写数据库连接名称-选择数据库类型-选择数据库访问类型-NEXT(下一步)第三步:服务器主机名(ip)-数据库端口-数据库名- NEXT(下一步)第四步:输入数据库用户名密码-点击测试-成功后点击Finish。

java excel导入20万条

java excel导入20万条

java excel导入20万条
在Java中导入20万条Excel数据可以通过以下几种方式来实现:
1. 使用Apache POI库,Apache POI是一个用于读写Microsoft Office文件的开源Java库。

你可以使用Apache POI来读取Excel文件并将数据导入到Java中。

你需要使用XSSFWorkbook和XSSFSheet类来读取Excel文件中的数据。

然后,你可以将读取到的数据存储在Java对象中,或者直接将数据插入到数据库中。

2. 使用JDBC连接Excel文件,你可以使用JDBC(Java Database Connectivity)来连接Excel文件,并通过Java代码将数据导入到数据库中。

首先,你需要使用ODBC(Open Database Connectivity)驱动程序来连接Excel文件,然后使用JDBC来执行插入操作。

3. 使用第三方库,除了Apache POI之外,还有一些其他的第三方库可以用来处理Excel文件,比如JExcelApi、JExcel等。

你可以选择适合你需求的库来实现数据导入操作。

无论你选择哪种方式,都需要注意以下几点:
内存管理,在导入大量数据时,需要注意内存的使用,避免内存溢出的问题。

优化性能,对于大量数据的导入,需要考虑性能优化,比如批量插入、使用索引等方式来提高导入速度。

异常处理,需要处理可能出现的异常情况,比如文件不存在、格式错误等。

总之,导入20万条Excel数据是一个比较大的任务,需要仔细考虑数据量、性能和异常处理等方面的问题,选择合适的方式来实现数据导入操作。

JAVA类实现导出各种数据库INSERT语句

JAVA类实现导出各种数据库INSERT语句

JAVA类实现导出各种数据库INSERT语句以下是一个简单的Java类实现将数据导出为不同数据库的INSERT语句的示例:```javaimport java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;import java.sql.*;import java.util.ArrayList;import java.util.List;public class DatabaseExporter//数据库连接信息private String url;private String username;private String password;//导出的目标文件路径private String exportFilePath;public DatabaseExporter(String url, String username, String password, String exportFilePath)this.url = url;ername = username;this.password = password;this.exportFilePath = exportFilePath;}public void exportDataToInsertStatements(String tableName) Connection conn = null;Statement stmt = null;ResultSet rs = null;BufferedWriter writer = null;try//连接到数据库conn = DriverManager.getConnection(url, username, password); stmt = conn.createStatement(;//查询表中的数据rs = stmt.executeQuery("SELECT * FROM " + tableName);//获取查询结果集的元数据ResultSetMetaData rsmd = rs.getMetaData(;int columnCount = rsmd.getColumnCount(;//创建导出文件的输出流writer = new BufferedWriter(new FileWriter(exportFilePath));while (rs.next()String insertStatement = "INSERT INTO " + tableName + " VALUES (";for (int i = 1; i <= columnCount; i++)Object columnValue = rs.getObject(i);//根据列的类型进行处理if (columnValue == null)insertStatement += "NULL";} else if (columnValue instanceof String , columnValue instanceof Date)insertStatement += "'" + columnValue.toString( + "'";} elseinsertStatement += columnValue.toString(;}//判断是否是最后一列if (i < columnCount)insertStatement += ", ";}insertStatement += ");\n";writer.write(insertStatement);}writer.flush(;System.out.println("导出成功!");} catch (SQLException , IOException e) e.printStackTrace(;} finallytryif (writer != null)writer.close(;}if (rs != null)rs.close(;}if (stmt != null)stmt.close(;if (conn != null)conn.close(;}} catch (SQLException , IOException e)e.printStackTrace(;}}}public static void main(String[] args)//创建数据库导出器实例DatabaseExporter exporter = newDatabaseExporter("jdbc:mysql://localhost:3306/dbname", "username", "password", "exported_data.sql");//指定要导出的表名称String tableName = "table1";//调用方法导出数据exporter.exportDataToInsertStatements(tableName);}上述示例中的`exportDataToInsertStatements`方法用于导出指定表名称中的数据为INSERT语句,并将结果写入一个指定路径的文件中。

JAVA中文件写入的6种方法

JAVA中文件写入的6种方法

JAVA中文件写入的6种方法在Java中,我们可以使用不同的方法将数据写入文件。

下面介绍了6种常见的文件写入方法。

方法一:使用FileOutputStream类FileOutputStream类用于写入数据到文件中。

它是OutputStream类的一个派生类,并提供了用于写入字节的各种方法。

```javatryFileOutputStream fos = new FileOutputStream("file.txt");byte[] data = "Hello, World!".getBytes(;fos.write(data);fos.close(;} catch (IOException e)e.printStackTrace(;```方法二:使用BufferedWriter类BufferedWriter类提供了一个高效的方式将文本写入文件。

它继承自Writer类,可用于写入字符和字符串。

```javatryBufferedWriter bw = new BufferedWriter(newFileWriter("file.txt"));bw.write("Hello, World!");bw.close(;} catch (IOException e)e.printStackTrace(;```方法三:使用PrintWriter类PrintWriter类是Writer类的子类,可以用于写入字符和字符串到文件中。

```javatryPrintWriter pw = new PrintWriter("file.txt");pw.println("Hello, World!");pw.close(;} catch (IOException e)e.printStackTrace(;```方法四:使用FileWriter类FileWriter类用于写入字符或字符串到文件。

用Java在macOS电脑中进行数据的导入和导出

用Java在macOS电脑中进行数据的导入和导出

用Java在macOS电脑中进行数据的导入和导出在日常工作中,我们经常需要处理各种数据,包括导入和导出数据。

而对于使用macOS操作系统的开发人员来说,如何利用Java语言进行数据的导入和导出是一个常见的需求。

本文将介绍如何在macOS 电脑中使用Java编程语言进行数据的导入和导出操作。

1. 准备工作在开始之前,我们需要确保已经安装了Java开发环境(JDK)以及适当的集成开发环境(IDE),比如Eclipse或IntelliJ IDEA。

同时,我们还需要准备好要处理的数据文件,可以是Excel表格、CSV文件或其他格式的数据文件。

2. 数据导入2.1 从Excel表格导入数据在macOS电脑中使用Java导入Excel表格数据通常需要借助第三方库,比如Apache POI。

首先,在项目中引入Apache POI相关的依赖,然后编写代码读取Excel文件中的数据并进行处理。

示例代码star:编程语言:javaFileInputStream fis = new FileInputStream("data.xlsx");XSSFWorkbook workbook = new XSSFWorkbook(fis);XSSFSheet sheet = workbook.getSheetAt(0);// 读取数据for (Row row : sheet) {for (Cell cell : row) {// 处理单元格数据}}workbook.close();示例代码end2.2 从CSV文件导入数据如果要从CSV文件中导入数据,可以使用Java自带的CSV解析库OpenCSV。

首先引入OpenCSV相关的依赖,然后编写代码读取CSV文件中的数据。

示例代码star:编程语言:javaCSVReader reader = new CSVReader(newFileReader("data.csv"));String[] nextLine;while ((nextLine = reader.readNext()) != null) {// 处理每一行数据}reader.close();示例代码end3. 数据导出3.1 导出数据到Excel表格要将数据导出到Excel表格,同样可以使用Apache POI库。

快速导入大数据库的方法

快速导入大数据库的方法

快速导入大数据库的方法
导入大数据库的方法有多种,以下是一些常见的方法:
1. 批量插入:这是最常见的方法,可以通过构建一个SQL语句,将多条记录一次性插入到数据库中。

2. 使用存储过程:可以将多个操作封装成一个过程,提高数据导入的效率。

3. 使用数据导入工具:例如使用Excel或其他格式的文件导入到数据库中,这可以帮助用户快速地完成数据导入。

4. 使用LOAD DATA语句:例如在MySQL中,可以使用LOAD DATA命令快速导入大规模数据。

这个命令可以从文本文件中导入数据到数据库中,能够比单独执行INSERT命令更快。

请注意,上述方法的选择取决于数据库类型、数据量大小、网络状况以及系统资源等多种因素。

在实际操作中,建议根据具体情况选择最合适的方法。

java中高效获取txt所有文本内容的方法

java中高效获取txt所有文本内容的方法

java中高效获取txt所有文本内容的方法Java中高效获取txt所有文本内容的方法在Java编程中,我们经常需要读取文件的内容并进行处理。

在某些情况下,我们需要读取一个txt文件的所有文本内容,并且希望能够以高效的方式实现。

本文将介绍一种高效获取txt所有文本内容的方法,并逐步回答中括号内的问题。

第一步:使用Java的File类首先,我们需要使用Java的File类来表示我们要读取的txt文件。

File类提供了很多与文件相关的常用方法,比如判断文件是否存在、获取文件路径等。

javaFile file = new File("file.txt");在上面的代码中,我们创建了一个名为file的File对象,表示文件名为file.txt的文本文件。

你可以将file.txt替换为你要读取的txt文件名。

问题1:如何创建File类对象?答:通过在File类的构造函数中传入文件名(包括路径)来创建File对象。

问题2:如何表示要读取的txt文件的路径?答:可以使用相对路径或绝对路径来表示要读取的txt文件的路径。

相对路径是相对于当前Java程序的工作目录的路径,而绝对路径是该txt文件在文件系统中的完整路径。

第二步:使用Java的BufferedReader类接下来,我们需要使用Java的BufferedReader类来读取txt文件的内容。

BufferedReader类提供了按行读取文本内容的方法,非常适合读取txt 文件。

javatry {BufferedReader reader = new BufferedReader(new FileReader(file));String line;while ((line = reader.readLine()) != null) {处理文本内容}reader.close();} catch (IOException e) {e.printStackTrace();}在上面的代码中,我们首先创建一个BufferedReader对象reader,它使用FileReader对象来读取文件内容。

esjava批量insert_elasticsearch使用javaapi批量插入数据

esjava批量insert_elasticsearch使用javaapi批量插入数据

esjava批量insert_elasticsearch使用javaapi批量插入数据Elasticsearch是一个开源的分布式和分析引擎,它提供了Java API 来操作数据。

在Java中使用Elasticsearch的API进行批量插入数据可以使用esjava插件来实现。

首先,我们需要在Java项目的pom.xml文件中添加esjava的依赖:```xml<dependency><groupId>org.elasticsearch</groupId><artifactId>elasticsearch</artifactId><version>${elasticsearch.version}</version></dependency>```然后,我们需要创建一个Elasticsearch的客户端对象,来连接到Elasticsearch集群并执行操作:```javaimport org.elasticsearch.action.index.IndexRequest;import org.elasticsearch.action.bulk.BulkRequest;import org.elasticsearch.action.bulk.BulkResponse;import org.elasticsearch.client.RequestOptions;import org.elasticsearch.client.RestClient;import org.elasticsearch.client.RestHighLevelClient;import java.io.IOException;public class BulkInsertExampleprivate static final String INDEX_NAME = "my_index";public static void main(String[] args)try (RestHighLevelClient client = new RestHighLevelClient RestClient.builder("localhost:9200")BulkRequest bulkRequest = new BulkRequest(;//构造批量插入请求for (int i = 0; i < 1000; i++)String json = "{\"title\":\"Document " + i + "\"}";IndexRequest indexRequest = new IndexRequest(INDEX_NAME) .source(json, XContentType.JSON);bulkRequest.add(indexRequest);}//执行批量插入请求BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);//处理插入结果if (bulkResponse.hasFailures()//处理插入失败的情况System.out.println("Some documents failed to be inserted:");bulkResponse.forEach(response ->if (response.isFailed()System.out.println(response.getFailureMessage();}});} else//处理插入成功的情况System.out.println("All documents were successfully inserted.");}} catch (IOException e)e.printStackTrace(;}}```在上面的例子中,我们首先创建了一个`RestHighLevelClient`对象,用来连接到Elasticsearch集群。

java日志批量写入数据库的方法

java日志批量写入数据库的方法

java日志批量写入数据库的方法在Java中将日志批量写入数据库有多种方法,下面是一种简单的实现。

1.创建数据库表```sqlCREATE TABLE logid INT PRIMARY KEY AUTO_INCREMENT,message VARCHAR(255) NOT NULL,level VARCHAR(50) NOT NULL,```2.构建日志对象```javapublic class Logprivate String message;private String level;// 构造方法、getter和setter方法```3.批量写入日志接下来,我们可以使用JDBC来连接数据库并进行批量插入。

在写入日志之前,我们可以先将日志对象保存到一个集合中,然后批量插入到数据库中。

以下是一个示例代码:```javaimport java.sql.*;import java.util.List;public class LogDaoprivate static final String DB_URL ="jdbc:mysql://localhost:3306/test";private static final String DB_USER = "root";private static final String DB_PASSWORD = "password";public static void batchInsert(List<Log> logs)try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD))try (PreparedStatement stmt = conn.prepareStatement(sql))for (Log log : logs)stmt.setString(1, log.getMessage();stmt.setString(2, log.getLevel();stmt.setTimestamp(3, log.getTimestamp();stmt.addBatch(;}stmt.executeBatch(;} catch (SQLException ex)conn.rollback(;ex.printStackTrace(;}} catch (SQLException ex)ex.printStackTrace(;}}```上述代码中,我们使用JDBC连接到MySQL数据库,并将日志对象作为参数插入到log表中。

java 使用jxl技术excel文件进行导入和导出实验用到的知识与技术

java 使用jxl技术excel文件进行导入和导出实验用到的知识与技术

java 使用jxl技术excel文件进行导入和导出实验用到的知识与技术Java是一种流行的编程语言,而JXL技术是一种用于处理Excel文件的Java库。

在本文中,我们将一步一步地介绍如何使用JXL技术导入和导出Excel文件。

我们将从JXL技术的概述开始,然后讨论如何导入Excel文件,接着是如何导出Excel文件。

JXL技术是一个基于Java的开源库,用于读取、写入和操作Microsoft Excel文件。

它提供了一组API,可以方便地处理Excel文件中的单元格、行和列。

不仅可以读取现有的Excel文件,还可以创建新的Excel文件并在其中写入数据。

JXL技术支持Excel的各种版本,包括xls和xlsx格式。

接下来,我们将讨论如何导入Excel文件。

首先,我们需要在项目中引入JXL库的依赖。

在Maven项目中,我们可以将以下依赖添加到pom.xml 文件中:xml<dependency><groupId>net.sourceforge.jexcelapi</groupId><artifactId>jxl</artifactId><version>2.6.12</version></dependency>一旦我们引入了JXL依赖,我们就可以使用它的API来导入Excel文件。

首先,我们需要创建一个Workbook对象,它代表整个Excel文件。

我们可以使用Workbook类的静态方法getWorkbook()来打开一个现有的Excel文件,例如:javaWorkbook workbook = Workbook.getWorkbook(newFile("path/to/excel.xls"));在Workbook对象上,我们可以执行各种操作,例如获取特定的工作表、读取单元格的值等。

批量导入文本数据操作方法

批量导入文本数据操作方法

批量导入文本数据操作方法
批量导入文本数据可以通过以下几种方法进行操作:
1. 手动导入:可以通过文件管理器或命令行界面手动选择要导入的文本文件,然后逐个文件导入数据。

这种方法适用于少量文本文件的情况。

2. 使用数据导入工具:如果需要导入大量的文本文件,可以使用数据导入工具或脚本来自动化导入过程。

这些工具可以读取指定的目录中的所有文本文件,并将其逐个导入数据库或其他数据存储系统。

3. 使用编程语言进行导入:如果需要对导入的文本数据进行处理或转换,可以使用编程语言如Python、Java或R来完成导入操作。

通过编写代码,可以使用文件读取功能和数据库连接工具来读取文本文件并将数据导入到数据库中。

需要注意的是,批量导入文本数据操作的具体步骤和方法会根据使用的工具、数据库或编程语言而有所不同。

因此,根据具体的需求和环境,选择合适的方法来进行批量导入文本数据操作。

java保存数组到数据库的方法

java保存数组到数据库的方法

在Java编程中,我们经常需要将数组中的数据保存到数据库中。

这篇文章将介绍一些常见的方法和技巧,来帮助你在Java中实现这一功能。

一、使用JDBC保存数组数据到数据库1. JDBC(Java Database Connectivity)是Java用于与数据库进行连接和操作的一套API。

我们可以使用JDBC来将数组中的数据保存到数据库中。

2. 我们需要在Java程序中引入JDBC相关的包,然后通过JDBC连接数据库、创建SQL语句,并执行插入操作。

3. 对于数组,我们通常需要使用循环来逐个将数组中的数据插入到数据库中。

这里需要注意的是,不同的数据库可能对于插入数据的方式有一些差异,需要根据具体的数据库类型来编写相应的SQL语句。

4. 在使用JDBC操作数据库的过程中,我们需要注意异常处理和资源释放,以确保程序的稳定性和性能。

二、使用ORM框架保存数组数据到数据库1. 除了直接使用JDBC操作数据库外,我们还可以通过ORM (Object-Relational Mapping)框架来简化数据库操作。

ORM框架可以将Java对象与数据库表进行映射,从而实现对象的持久化。

2. 使用ORM框架保存数组数据到数据库,通常需要首先定义好对应的实体类,并在实体类中设置数组属性。

3. 我们需要配置ORM框架的映射规则,以及数据库连接等相关信息。

4. 我们可以通过ORM框架提供的API来操作数据库,将数组中的数据保存到数据库中。

ORM框架会帮助我们生成对应的SQL语句,并执行数据库操作。

5. 在使用ORM框架时,我们需要注意配置文件的编写、映射关系的设置以及性能优化等方面。

三、使用Spring Data JPA保存数组数据到数据库1. Spring Data JPA是Spring框架中的一个子项目,它提供了一种简化数据库访问的方式。

通过Spring Data JPA,我们可以很方便地将数组数据保存到数据库中。

2. 我们需要在Spring项目中引入Spring Data JPA相关的依赖,然后配置好数据源和实体类。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class InsertDB {
private static final String user = "sa";
try {
Class.forName(driver).newInstance();
con = DriverManager.getConnection(url, user, pwd);
if (con != null) {
line_record = raf.readLine();
}
System.out.println("共有合法的记录" + count + "条");
} catch (Exception e) {
stm = con.createStatement();
int i = stm.executeUpdate(sql);
if (i > 0) {
flag = true;
System.out.println(flag + "插入数据成功!");
e.printStackTrace();
}
return con;
}
public boolean insertDB(String FltNum, String FltLine, String FltDate,
)
我们将向表t_FltPsgInfo中插入1000条记录。
新建一个文本文件,每一行代表一条记录,如:
HU7804,广州-北京,2007-07-18,谢丽珍,3,1,C,3A,服务保障信息:未用餐随行人员…
其中以“,”作为字段的分隔标志,我们在解析这个文本文件时将根据“,”来拆分字段值。
try {
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2》数据采集类DataGather.java
package test;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
public class DataGather {
private static final String driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
public static Connection getCon() {
Connection con = null;
private static final String pwd = "sa";
private static final String url = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=hhfly";
public static final int fieldAllCount = 9;
private int count;
private String FltNum;
private String FltLine;
private String FltDate;
private static final String path = "src/resource/test";
public static final String openFileStyle = "r";
public static final String fieldLimitChar = ",";
try {
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
if (stm != null)
//拆分记录
try {
stm.close();
} catch (Exception e) {
e.printStackTrace();
}
if (con != null)
private String PsgInfo;
/*
* 功能:解析文本文件
*/
public void loadFile() {
try {
RandomAccessFile raf = new RandomAccessFile(path, openFileStyle);
}
} catch (Exception e) {
flag = false;
e.printStackTrace();
} finally {
close(null, stm, con);
PsgCab VARCHAR(1), -- 几等舱, F/Y 舱位按字母顺序排列
PsgSeatNo VARCHAR(5),-- 座位号 2A,22F,根据这个得到一排有多少个座位,共有多少排座位信息
PsgInfo VARCHAR(2048) -- 详细信息,可能很长
}
return flag;
}
//关闭相关连接
public void close(ResultSet rs, Statement stm, Connection con) {
if (rs != null)
1、将数据按一定规律录入到一个文本文件,每一行代表一条记录。
下面是数据库建表SQL:
CREATE TABLE t_FltPsgInfo -- 航班乘客信息
(
FltNum VARCHAR(10), -- 航班号
FltLine VARCHAR(30), -- 航线
e.printStackTrace();
}
}
/*
* 功能:具体解析每一条记录,这里可以增加很多对记录的解析判断条件,如是否为字母、
* 数字、email等。
*/
private void parseRecord(String line_record) throws Exception {
FltDate VARCHAR(10), -- 日期
PsgName VARCHAR(30), -- 姓名
PsgType VARCHAR(30), -- 乘客类型,数字表示,目前是1-13
PsgSex VARCHAR(1), -- 0 男 1 女
按照上面的格式,将要插入的数据输入到文本文件中,注意,是每一行代表一条记录,或者你已有从数据库导出的文本文件,那你就只需找到文件的规律,稍作调整就行了。
2、编写Java源码
1》数据库操作类InsertDB.java
Hale Waihona Puke package test;
import java.sql.Connection;
用java实现从文本文件批量导入数据至数据库
2011-07-08 16:13:03| 分类: 数据库 | 标签:java sql |字号 订阅
今天同事让我准备一个项目的测试数据,要向一个表中插入上千条记录,并且保证每条记录内容不同,如果用手工一条一条插入肯定是不可能,也不会有哪个SB去做这样的事,我最开始想到了用循环,但要求插入的记录内容不能相同,用循环实现比较麻烦,于是我想到了将记录从文本文件导入至数据库(其实SQLServer可利用sql语句实现导入xls或txt文件,在这就不具体说明了),写个简单的具有解析文本文件并将解析结果插入数据库的类,实现批量插入记录的功能。
+ "','" + PsgSex + "','" + PsgCab + "','" + PsgSeatNo + "','"
+ PsgInfo + "')";
try {
con = getCon();
private String PsgName;
private String PsgType;
private String PsgSex;
private String PsgCab;
private String PsgSeatNo;
System.out.println("你已连接到数据库:" + con.getCatalog());
}
} catch (Exception e) {
System.out.println("连接数据库失败!");
String line_record = raf.readLine();
while (line_record != null) {
// 解析每一条记录
parseRecord(line_record);
Statement stm = null;
boolean flag = false;
String sql = "insert into t_FltPsgInfo values('" + FltNum + "','"
相关文档
最新文档