|||
版本1
46.源码46,部件程序,修改式导出到office文件,包括word、excel、pdf文件数据导出部件。
/**
* 程序文件名:dataTransfer6.java
* 作者:程学先
* 功能:修改式导出到office文件,包括word、excel、pdf文件。
* 原目的文件内容保留,当前表数据导出到指定文件中,如果关键字值和已有数据相同则更改已有数据
* 否则添加到原文件尾部,如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容,符合本程序中“类型对照表"设置的对应关系。
* 完成日期:2013年1月22日
* 被调用语句:dataTransfer6.means(parameter)
* 必须提供的参数:数据“表名”、“导出文件名”。
* 可选择参数:“字段号表”、“要求按钮号表”、
* 要求字段号表:所操作数据可以是表的全部字段,也可以只涉及部分字段。如果选择全部字段,初始值设为"";
* 否则写入所有将涉及的字段在表中的顺序号,号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个,序号及按钮名:1修改式导出到word文件、2修改式导出到excel文件、
* 3修改式导出到PDF文件、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到Office文件要求下载以下文件并设置构建路径:
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果导出到PDF文件。不支持大数据类型,每字段宽度不超过50字符。
* 导入部件只能对由dataTransfer4.java生成的PDF文件进行修改式导入。
* 如果导出到WORD文件,文件名必须带路径全称,否则会存放到我的文档中。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.poi.hssf.usermodel.HSSFCell;
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.hwpf.extractor.WordExtractor;
import org.apache.poi.ss.usermodel.Sheet;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
public class dataTransfer6 extends JFrame {
static dataTransfer6 frame = new dataTransfer6(); // 创建窗体
private static JTable table; //创建表格
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
static int 列数; //数据表列数
static int 列数1;
static String [][] 列名; //数据表列名
static String [] 列名1;
static int[] 对应目的表序号; //存放当前记录各字段数据宽度的数组
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[] 表格数据1;
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
static String 关键字;
static String[] 关键字名,关键字名1;
static int[] 关键字序号,关键字序号1;
private static Connection cont4; // 连接数据库
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static String[] 列名0; // 数据表列名
private static String 列名表=""; //包括全部列名的字符串
private static int 列数0;
private static String 连接条件;
static String s1="",s2="",s3="";
static String s4=" ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
{"java" ,"string","string","string" ,"int" ,"int" ,"string","string" ,"string","string","boolean","byte" ,"short" ,"long" ,"float" ,"int" ,"double","float" ,"float" ,"byte[]"},
{"sqlserver","char" ,"nchar" ,"nvarchar" ,"int" ,"float" ,"datetime" ,"datetime","text","ntext" ,"bit" ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
{"vfp" ,"c" ,"c" ,"c" ,"i" ,"n" ,"d" ,"t" ,"m" ,"m" ,"l" ,"i" ,"i" ,"i" ,"n" ,"i" ,"n" ,"b" ,"y" ,"g" },
{"access" ,"text" ,"text" ,"text" ,"integer","integer" ,"date" ,"date" ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float" ,"integer","float" ,"float" ,"float" ,"general"},
{"oracle" ,"char" ,"char" ,"char" ,"number" ,"number" ,"date" ,"date" ,"long" ,"long" ,"char" ,"raw" ,"number" ,"number" ,"number" ,"number" ,"number" ,"number","number","blob"},
{"mysql" ,"char" ,"char" ,"varchar" ,"int" ,"float" ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float" ,"integer","double" ,"float" ,"float" ,"blob"}
};
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame = new dataTransfer6(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0; //记录条数
s1="";s2="";s3="";
x1=10;x2=13;x3='"';x4=',';
类型对照表[0][0]="java";类型对照表[0][1]="string";
类型对照表[0][2]="string";类型对照表[0][3]="string";
类型对照表[0][4]="int";类型对照表[0][5]="int";
类型对照表[0][6]="string";类型对照表[0][7]="string";
类型对照表[0][8]="string";类型对照表[0][9]="string";
类型对照表[0][10]="boolean";类型对照表[0][11]="byte";
类型对照表[0][12]="short";类型对照表[0][13]="long";
类型对照表[0][14]="float";类型对照表[0][15]="int";
类型对照表[0][16]="double";类型对照表[0][17]="float";
类型对照表[0][18]="float";类型对照表[0][19]="byte[]";
类型对照表[1][0]="sqlserver";类型对照表[1][1]="char";
类型对照表[1][2]="nchar";类型对照表[1][3]="nvarchar";
类型对照表[1][4]="int";类型对照表[1][5]="float";
类型对照表[1][6]="datetime";类型对照表[1][7]="datetime";
类型对照表[1][8]="text";类型对照表[1][9]="ntext";
类型对照表[1][10]="bit";类型对照表[1][11]="tinyint";
类型对照表[1][12]="smallint";类型对照表[1][13]="bigint";
类型对照表[1][14]="numeric";类型对照表[1][15]="integer";
类型对照表[1][16]="double";类型对照表[1][17]="money";
类型对照表[1][18]="real";类型对照表[1][19]="image";
类型对照表[2][0]="vfp";类型对照表[2][1]="c";
类型对照表[2][2]="c";类型对照表[2][3]="c";
类型对照表[2][4]="i";类型对照表[2][5]="n";
类型对照表[2][6]="d";类型对照表[2][7]="t";
类型对照表[2][8]="m";类型对照表[2][9]="m";
类型对照表[2][10]="l";类型对照表[2][11]="i";
类型对照表[2][12]="i";类型对照表[2][13]="i";
类型对照表[2][14]="n";类型对照表[2][15]="i";
类型对照表[2][16]="n";类型对照表[2][17]="b";
类型对照表[2][18]="y";类型对照表[2][19]="g";
类型对照表[3][0]="access";类型对照表[3][1]="text";
类型对照表[3][2]="text";类型对照表[3][3]="text";
类型对照表[3][4]="integer";类型对照表[3][5]="integer";
类型对照表[3][6]="date";类型对照表[3][7]="date";
类型对照表[3][8]="memo";类型对照表[3][9]="memo";
类型对照表[3][10]="logical";类型对照表[3][11]="integer";
类型对照表[3][12]="integer";类型对照表[3][13]="integer";
类型对照表[3][14]="float";类型对照表[3][15]="integer";
类型对照表[3][16]="float";类型对照表[3][17]="float";
类型对照表[3][18]="float";类型对照表[3][19]="general";
类型对照表[4][0]="oracle";类型对照表[4][1]="char";
类型对照表[4][2]="char";类型对照表[4][3]="char";
类型对照表[4][4]="number";类型对照表[4][5]="number";
类型对照表[4][6]="date";类型对照表[4][7]="date";
类型对照表[4][8]="long";类型对照表[4][9]="long";
类型对照表[4][10]="char";类型对照表[4][11]="raw";
类型对照表[4][12]="number";类型对照表[4][13]="number";
类型对照表[4][14]="number";类型对照表[4][15]="number";
类型对照表[4][16]="number";类型对照表[4][17]="number";
类型对照表[4][18]="number";类型对照表[4][19]="blob";
类型对照表[5][0]="mysql";类型对照表[5][1]="char";
类型对照表[5][2]="char";类型对照表[5][3]="varchar";
类型对照表[5][4]="int";类型对照表[5][5]="float";
类型对照表[5][6]="date";类型对照表[5][7]="datetime";
类型对照表[5][8]="text";类型对照表[5][9]="text";
类型对照表[5][10]="tinyint";类型对照表[5][11]="tinyint";
类型对照表[5][12]="smallint";类型对照表[5][13]="bigint";
类型对照表[5][14]="float";类型对照表[5][15]="integer";
类型对照表[5][16]="double";类型对照表[5][17]="float";
类型对照表[5][18]="float";类型对照表[5][19]="blob";
连接条件="";
File file = new File(".\\com\\iText-5.0.5.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\jacob.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\poi-3.8-20120326.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\PDFBox-0.7.3.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
表名=parameter[4] ; // 数据表名
字段号表=parameter[8];
导出文件名=parameter[18];
导出表名=parameter[2];
String [] 按钮集01={"导出到word","导出到excel","导出到PDF","退出"};
按钮集=new String[按钮集01.length];
按钮数=0;
for (int i0=0;i0<按钮集01.length;i0++)
按钮集[i0]= 按钮集01[i0];
if (parameter[11].length()>0){
要求按钮号表=parameter[11] ;// 需要显示的按钮的顺序号
//将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表=要求按钮号表.replaceAll(";",";");
要求按钮号表=要求按钮号表.replaceAll("。",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
if (要求按钮号表.indexOf(";")>0){ //如果有按钮更名要求
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (s601[i01].indexOf(";")>0){
String s602[]=s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))]=s602[1];
要求按钮号表=要求按钮号表+","+s602[0];//只留号,去更名
按钮数++;
}
else {
要求按钮号表=要求按钮号表+","+s601[i01];//只留号,原无更名
按钮数++;
}
}
} //如果没有按钮更名要求,要求按钮号长度又大于0,保持原有摸样
else {
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (i01==0) 要求按钮号表=s601[i01];
else 要求按钮号表=要求按钮号表+","+s601[i01];
按钮数++;
}
}
}
else {
要求按钮号表=""; //没输入要求按钮号,定全部按钮号
for (int i1=0;i1<按钮集.length;i1++){
if (i1==0) 要求按钮号表=要求按钮号表+i1;
else 要求按钮号表=要求按钮号表+","+i1;
按钮数++;
}
}
要求按钮号表=","+要求按钮号表+",";
窗口宽=main1.窗口宽; 窗口高=main1.窗口高;
int m1,m2;
try{
if (parameter[17].length()==0) {
m1=0;m2=0;
}
else {
m1=Integer.parseInt(parameter[17]) ;//宽度参数
m2=Integer.parseInt(parameter[18]) ;
}
if (m1>0){
if (m2<80){
m1=m1*10;
m2=m2*10;
}
窗口宽=m1 ;
窗口高=m2 ;
}
}catch(Exception e2){}
关键字=parameter[6];
String 字段名表=parameter[19].trim();
if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equals(",")))
字段名表=字段名表.substring(0,字段名表.length()-1);
String 表名表=parameter[0];
String [] l3=字段名表.split(",");
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
String[] l1;
if (字段号表.length()>0){
l1=字段号表.split(",");
int [] l2=new int[l1.length];
for (int i=0;i<l1.length;i++){
l2[i]=Integer.valueOf(l1[i]);
}
列数=l1.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[l2[i]];
列名[1][i]=列名[0][i];
}
}
else {
列数=l3.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[i];
列名[1][i]=列名[0][i];
}
}
s1="";
for (int i=0;i<列数;i++)
s1=s1+列名[0][i]+",";
s1=s1.substring(0,s1.length()-1);
try
{
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+s1+" from "+表名;
数据表查询结构002();
if (连接条件.length()>0) s1=s1+" where "+连接条件;
ResultSet rs=sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数];
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数];
for (int i=0;i<列数;i++) {
列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i]=列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i]<列名[0][i].length()) 列数据宽度[i]=列名[0][i].length();
if (列数据宽度[i]<列名[1][i].length()) 列数据宽度[i]=列名[1][i].length();
if (列数据宽度[i]>50) 列数据宽度[i]=50;
}
关键字名=关键字.split(",");
关键字名1=new String[关键字名.length];
关键字序号=new int[关键字名.length];
关键字序号1=new int[关键字名.length];
表格列名=new String[列数];
表列数据类型=new String[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
}
记录条数=0; //记录条数
rs.last();
记录条数=rs.getRow();
表格数据=new String[记录条数][列数];
rs.absolute(1);
c=0; //行号
b=0; //列号
while(c<记录条数) {
rs.absolute(c+1);
while(b<列数){
表格数据[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close(); //关闭查询结果集
sta4.close(); //关闭连接
con1.close();
}
catch(SQLException e)
{
JOptionPane.showMessageDialog( null, "读取数据出错!");
}
if (字典表名.length()>0){
try
{
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名; // 查取全表数据
rs = sta4.executeQuery(s1);
String s4="";
String s5="";
b=1;
while (rs.absolute(b)) {
b++;
s4=rs.getString(1).trim(); //字段名
s5=rs.getString(2).trim();
for (int j=0;j<列数;j++){
if (列名[0][j].trim().equalsIgnoreCase(s4.trim())){
列名[1][j]=s5;
break;
}
}
}
rs.close(); //关闭查询结果集
con1.close();
sta4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!");
}
}
for (int i=0;i<列数;i++) {
for (int j=0;j<关键字名.length;j++)
if (关键字名[j].trim().equalsIgnoreCase(列名[0][i].trim())){
关键字名1[j]=列名[1][i];
关键字序号[j]=i;
}
}
frame.setTitle("数据修改式导出到office文件部件。根据关键字查出关键字相同记录用当前表中数据替代。 作者:程学先");
frame.setBounds(10, 10, 窗口宽, 窗口高);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(10, 10,窗口宽,窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
scrollPane.setBounds(0,0,窗口宽-20,窗口高-100); //定义滚动面板大小位置
panel.add(scrollPane);
model = new DefaultTableModel(表格数据,列名[1]); // 创建表格模型
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for(int i=0;i<列数;i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i]*14);
tc.setMaxWidth(列数据宽度[i]*14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
按钮宽=(窗口宽-60)/按钮数;
int 按钮左边距=30;
JButton 到word = new JButton(按钮集[0]);
到word.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.doc","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".doc")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".doc";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".doc";
}
}
try {
FileInputStream in=new FileInputStream(new File(导出文件名));
WordExtractor extractor=null;
extractor=new WordExtractor(in);
String 内容=extractor.getText();
int m1=0;;
String[] 记录=new String[列数];
int k=0;
int k2=0,k5=0;
记录[k]="";
for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){ //找到一个回车
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+记录[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){ //表中所有记录
s2="";
for (int k4=0;k4<关键字名.length;k4++){
s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
}
if (s3.trim().equalsIgnoreCase(s2.trim())) { //找到关键字相同记录
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(记录);
记录条数++;
}
k5=0;
记录[0]="";
k=0;
m1=1;
if ((i<内容.length()-2)&&(内容.charAt(i+2)=='\r')) break;
}
else if (内容.charAt(i)=='\n'){}
else if ((byte)(内容.charAt(i))==9){
k++;
m1=0;
if (k<列数) 记录[k]="";
}
else if (k<列数){
记录[k]=记录[k]+内容.charAt(i); //记录[k]+
}
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据出错,可能是原文件中数据结构与数据表不同,不能作修改式导出!");
}
try{
ActiveXComponent word = new ActiveXComponent("Word.Application");
Dispatch documents = word.getProperty("Documents").toDispatch();
try { //用覆盖方式或添加方式加入表格
Dispatch doc = Dispatch.call(documents, "Add").toDispatch();
Dispatch selection = Dispatch.get(word,"Selection").toDispatch();
Dispatch.call(selection, "HomeKey");
Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
Dispatch range = Dispatch.get(selection, "Range").toDispatch();
Dispatch newTable = Dispatch.call(tables, "Add", range,
new Variant(记录条数), new Variant(列数)).toDispatch();
for(int i1=0;i1<model.getRowCount();i1++){
for(int j=0;j<列数;j++){
Dispatch table = Dispatch.call(tables, "Item", new Variant(1))
.toDispatch();
Dispatch cell = Dispatch.call(table, "Cell", new Variant(i1+1),
new Variant(j+1)).toDispatch();
Dispatch.call(cell, "Select");
s1=""+model.getValueAt(i1,j);
Dispatch.put(selection, "Text",s1);
}
}
Dispatch.call((Dispatch) Dispatch.call(word, "WordBasic").getDispatch(),
"FileSaveAs",导出文件名);
} catch (Exception e1) {e1.printStackTrace();
} finally {Dispatch.call(word, "Quit");
}
} catch (Exception e1) {
e1.printStackTrace();
}
return;
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){
到word.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到word);
按钮左边距=按钮左边距+按钮宽;
}
JButton 到excel = new JButton(按钮集[1]);
到excel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.xls","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".xls")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".xls";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".xls";
}
}
InputStream is = null;
HSSFWorkbook wbWorkbook = null;
try {
is = new FileInputStream(导出文件名);
wbWorkbook = new HSSFWorkbook(is);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败,请检查路径是否正确!", "错误",
JOptionPane.INFORMATION_MESSAGE);
} catch (IOException e2) {
e2.printStackTrace();
}
HSSFSheet sheet = wbWorkbook.getSheetAt(0);
int lastRowNum = sheet.getLastRowNum();
int 导入表格行数 = sheet.getPhysicalNumberOfRows();
HSSFRow row = sheet.getRow(1);
int 导入表格列数=row.getPhysicalNumberOfCells();
if (导入表格列数!=列数)
JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同,不能作修改式导出!");
String[] val;
int k2=0,k5=0;
String value = "";
for (int i = 0; i < 导入表格行数; i++) {
row = sheet.getRow(i);
if (row != null) {
for (int j = 0; j < 导入表格列数; j++) {
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()){
case HSSFCell.CELL_TYPE_FORMULA:
break;
case HSSFCell.CELL_TYPE_NUMERIC:
value += cell.getNumericCellValue() + ",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += "0";
break;
}
}
}
val = value.split(",");
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+val[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){
s2="";
for (int k4=0;k4<关键字名.length;k4++)
s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
if (s3.trim().equalsIgnoreCase(s2.trim())) {
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(val);
记录条数++;
}
k5=0;
value = "";
}
}
HSSFWorkbook book = new HSSFWorkbook();
sheet = book.createSheet(表名);
HSSFRow header = sheet.createRow(0);
int colCount = 列数;
for (int i = 0; i < 列数; i++) {
HSSFCell cell = header.createCell(i);
cell.setCellValue(new HSSFRichTextString(表格列名[i]));
}
for (int j=0;j<model.getRowCount();j++){
row = sheet.createRow(j);
for (int i = 0; i < colCount; i++) {
HSSFCell cell = row.createCell(i);
s1=""+model.getValueAt(j,i);
cell.setCellValue(new HSSFRichTextString(s1));
}
}
try {
FileOutputStream fileO = new FileOutputStream(导出文件名);
book.write(fileO);
fileO.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){
到excel.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到excel);
按钮左边距=按钮左边距+按钮宽;
}
JButton 到pdf = new JButton(按钮集[2]);
到pdf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.pdf","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".pdf")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".pdf";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".pdf";
}
}
try {
FileInputStream in = new FileInputStream(导出文件名);
PDFParser parser = new PDFParser(in);
parser.parse();
PDDocument pdfdocument = parser.getPDDocument();
PDFTextStripper stripper = new PDFTextStripper();
s1 = stripper.getText(pdfdocument);
in.close();
} catch (Exception e1) {
e1.printStackTrace();
}
String[] 记录=new String[列数];
String s4="";
int k=0,m1=0,k2=0,k5=0;
记录[0]="";
int l1=s1.length();
for (int i1=0;i1<l1;i1++){
s2=s1.substring(i1,i1+1);
if (s1.charAt(i1)=='\r') {}
else if (s1.charAt(i1)=='\n') {}
else if ((s2.trim().equals("│"))&&(m1==1)) {
if (k==列数-1) {
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+记录[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){
s4="";
for (int k4=0;k4<关键字名.length;k4++)
s4=s4+model.getValueAt(j1,关键字序号[k4]).toString().trim();
if (s3.trim().equalsIgnoreCase(s4.trim())) {
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(记录);
记录条数++;
}
k5=0;
k=0;
m1=0;
记录[k]="";
}
else {
k++;
if (k<列数) 记录[k]="";
}
}
else if (s2.trim().equals("│")) {
m1=1;
k=0;
记录[0]="";
}
else if ((k<列数)&&(m1==1)){
try{
记录[k]=记录[k]+s2;
} catch (Exception e1) {
}
}
}
File file = new File(导出文件名);
if (file.exists()) {
file.delete();
}
Document document = new Document();
try {
PdfWriter.getInstance(document, new FileOutputStream(导出文件名));
document.open();
BaseFont bfComic = BaseFont.createFont("c:\\windows\\fonts\\SIMFANG.TTF", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
Font font = new Font(bfComic, 9);
s1="┌";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┬";
}
s1=s1+"┐";
document.add(new Paragraph(s1, font));
int 记录条数2=model.getRowCount();
s4="";
String s5="";
float lengtg1=0;
for (int i=0;i<记录条数2;i++){
s1="│";
for (int j=0;j<表格数据[0].length;j++){
if (model.getValueAt(i,j)==null) s4=" ";
else s4=model.getValueAt(i,j).toString().trim();
s3="";
lengtg1=0;
for (int j1=0;j1<s4.length();j1++){
s5=s4.substring(j1,j1+1);
s1=s1+s5;
if (s5.compareTo("z")<0){
if (s5.compareTo("0")<0)
lengtg1=lengtg1+0.51f;
else lengtg1=lengtg1+0.51f;
}
else lengtg1=lengtg1+1;
}
while (lengtg1<列数据宽度[j]) {
s1=s1+" ";
lengtg1=lengtg1+0.51f;
}
s1=s1+"│";
lengtg1=0;
}
document.add(new Paragraph(s1, font));
if (i<记录条数2-1){
s1="├";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┼";
}
s1=s1+"┤";
document.add(new Paragraph(s1, font));
}
else {
s1="└";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┴";
}
s1=s1+"┘";
document.add(new Paragraph(s1, font));
}
}
}
catch(DocumentException de) {
System.err.println(de.getMessage());
}
catch(IOException ioe) {
System.err.println(ioe.getMessage());
}
document.close();
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){
到pdf.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到pdf);
按钮左边距=按钮左边距+按钮宽;
}
JButton exitButton = new JButton(按钮集[3]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){
exitButton.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(exitButton);
按钮左边距=按钮左边距+按钮宽;
}
frame.add(panel);
frame.setVisible(true); // 显示窗体
}
static void 数据表查询结构001(String 数据表名001) {
try
{
cont4=main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1= "select * from "+数据表名001;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
列数0 = rsmdt4.getColumnCount();
列名0 = new String[列数0];
for (int i=0;i<列数0;i++) {
列名0[i] = rsmdt4.getColumnName(i + 1);
}
rs.close();
stat4.close();
cont4.close();
} catch(SQLException e1){
JOptionPane.showMessageDialog( null, "读取数据表结构出错!");
}
列名表="";
int b0=0;
while (b0 < 列名.length){
if (b0==0) 列名表=列名0[b0];
else 列名表=列名表+","+列名0[b0];
b0++;
}
}
static void 数据表查询结构002() {
String[] t11 = 表名.split(",");
String 列名表0 = "";
连接条件 = "";
if (t11.length > 1) {
for (int i = 0; i < t11.length; i++) {
数据表查询结构001(t11[i]);
for (int j = 0; j < 列名0.length; j++)
if (("," + 列名表0 + ",").indexOf("," + 列名0[j] + ",") >= 0) {
if (连接条件.length() == 0)
连接条件 = t11[i - 1] + "." + 列名0[j] + "=" + t11[i]
+ "." + 列名0[j];
else
连接条件 = 连接条件 + " and " + t11[i - 1] + "." + 列名0[j]
+ "=" + t11[i] + "." + 列名0[j];
}
if (列名表0.length() == 0)
列名表0 = 列名表;
else
列名表0 = 列名表0 + "," + 列名表;
}
}
}
}
47.源码47,部件程序,从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表数据导入部件。
/**
* 程序文件名:dataTransfer6.java
* 作者:程学先
* 功能:修改式导出到office文件,包括word、excel、pdf文件。
* 原目的文件内容保留,当前表数据导出到指定文件中,如果关键字值和已有数据相同则更改已有数据
* 否则添加到原文件尾部,如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容,符合本程序中“类型对照表"设置的对应关系。
* 完成日期:2013年1月22日
* 被调用语句:dataTransfer6.means(parameter)
* 必须提供的参数:数据“表名”、“导出文件名”。
* 可选择参数:“字段号表”、“要求按钮号表”、
* 要求字段号表:所操作数据可以是表的全部字段,也可以只涉及部分字段。如果选择全部字段,初始值设为"";
* 否则写入所有将涉及的字段在表中的顺序号,号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个,序号及按钮名:1修改式导出到word文件、2修改式导出到excel文件、
* 3修改式导出到PDF文件、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到Office文件要求下载以下文件并设置构建路径:
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果导出到PDF文件。不支持大数据类型,每字段宽度不超过50字符。
* 导入部件只能对由dataTransfer4.java生成的PDF文件进行修改式导入。
* 如果导出到WORD文件,文件名必须带路径全称,否则会存放到我的文档中。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.poi.hssf.usermodel.HSSFCell;
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.hwpf.extractor.WordExtractor;
import org.apache.poi.ss.usermodel.Sheet;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
public class dataTransfer6 extends JFrame {
static dataTransfer6 frame = new dataTransfer6(); // 创建窗体
private static JTable table; //创建表格
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
static int 列数; //数据表列数
static int 列数1;
static String [][] 列名; //数据表列名
static String [] 列名1;
static int[] 对应目的表序号; //存放当前记录各字段数据宽度的数组
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[] 表格数据1;
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
static String 关键字;
static String[] 关键字名,关键字名1;
static int[] 关键字序号,关键字序号1;
private static Connection cont4; // 连接数据库
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static String[] 列名0; // 数据表列名
private static String 列名表=""; //包括全部列名的字符串
private static int 列数0;
private static String 连接条件;
static String s1="",s2="",s3="";
static String s4=" ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
{"java" ,"string","string","string" ,"int" ,"int" ,"string","string" ,"string","string","boolean","byte" ,"short" ,"long" ,"float" ,"int" ,"double","float" ,"float" ,"byte[]"},
{"sqlserver","char" ,"nchar" ,"nvarchar" ,"int" ,"float" ,"datetime" ,"datetime","text","ntext" ,"bit" ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
{"vfp" ,"c" ,"c" ,"c" ,"i" ,"n" ,"d" ,"t" ,"m" ,"m" ,"l" ,"i" ,"i" ,"i" ,"n" ,"i" ,"n" ,"b" ,"y" ,"g" },
{"access" ,"text" ,"text" ,"text" ,"integer","integer" ,"date" ,"date" ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float" ,"integer","float" ,"float" ,"float" ,"general"},
{"oracle" ,"char" ,"char" ,"char" ,"number" ,"number" ,"date" ,"date" ,"long" ,"long" ,"char" ,"raw" ,"number" ,"number" ,"number" ,"number" ,"number" ,"number","number","blob"},
{"mysql" ,"char" ,"char" ,"varchar" ,"int" ,"float" ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float" ,"integer","double" ,"float" ,"float" ,"blob"}
};
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame = new dataTransfer6(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0; //记录条数
s1="";s2="";s3="";
x1=10;x2=13;x3='"';x4=',';
类型对照表[0][0]="java";类型对照表[0][1]="string";
类型对照表[0][2]="string";类型对照表[0][3]="string";
类型对照表[0][4]="int";类型对照表[0][5]="int";
类型对照表[0][6]="string";类型对照表[0][7]="string";
类型对照表[0][8]="string";类型对照表[0][9]="string";
类型对照表[0][10]="boolean";类型对照表[0][11]="byte";
类型对照表[0][12]="short";类型对照表[0][13]="long";
类型对照表[0][14]="float";类型对照表[0][15]="int";
类型对照表[0][16]="double";类型对照表[0][17]="float";
类型对照表[0][18]="float";类型对照表[0][19]="byte[]";
类型对照表[1][0]="sqlserver";类型对照表[1][1]="char";
类型对照表[1][2]="nchar";类型对照表[1][3]="nvarchar";
类型对照表[1][4]="int";类型对照表[1][5]="float";
类型对照表[1][6]="datetime";类型对照表[1][7]="datetime";
类型对照表[1][8]="text";类型对照表[1][9]="ntext";
类型对照表[1][10]="bit";类型对照表[1][11]="tinyint";
类型对照表[1][12]="smallint";类型对照表[1][13]="bigint";
类型对照表[1][14]="numeric";类型对照表[1][15]="integer";
类型对照表[1][16]="double";类型对照表[1][17]="money";
类型对照表[1][18]="real";类型对照表[1][19]="image";
类型对照表[2][0]="vfp";类型对照表[2][1]="c";
类型对照表[2][2]="c";类型对照表[2][3]="c";
类型对照表[2][4]="i";类型对照表[2][5]="n";
类型对照表[2][6]="d";类型对照表[2][7]="t";
类型对照表[2][8]="m";类型对照表[2][9]="m";
类型对照表[2][10]="l";类型对照表[2][11]="i";
类型对照表[2][12]="i";类型对照表[2][13]="i";
类型对照表[2][14]="n";类型对照表[2][15]="i";
类型对照表[2][16]="n";类型对照表[2][17]="b";
类型对照表[2][18]="y";类型对照表[2][19]="g";
类型对照表[3][0]="access";类型对照表[3][1]="text";
类型对照表[3][2]="text";类型对照表[3][3]="text";
类型对照表[3][4]="integer";类型对照表[3][5]="integer";
类型对照表[3][6]="date";类型对照表[3][7]="date";
类型对照表[3][8]="memo";类型对照表[3][9]="memo";
类型对照表[3][10]="logical";类型对照表[3][11]="integer";
类型对照表[3][12]="integer";类型对照表[3][13]="integer";
类型对照表[3][14]="float";类型对照表[3][15]="integer";
类型对照表[3][16]="float";类型对照表[3][17]="float";
类型对照表[3][18]="float";类型对照表[3][19]="general";
类型对照表[4][0]="oracle";类型对照表[4][1]="char";
类型对照表[4][2]="char";类型对照表[4][3]="char";
类型对照表[4][4]="number";类型对照表[4][5]="number";
类型对照表[4][6]="date";类型对照表[4][7]="date";
类型对照表[4][8]="long";类型对照表[4][9]="long";
类型对照表[4][10]="char";类型对照表[4][11]="raw";
类型对照表[4][12]="number";类型对照表[4][13]="number";
类型对照表[4][14]="number";类型对照表[4][15]="number";
类型对照表[4][16]="number";类型对照表[4][17]="number";
类型对照表[4][18]="number";类型对照表[4][19]="blob";
类型对照表[5][0]="mysql";类型对照表[5][1]="char";
类型对照表[5][2]="char";类型对照表[5][3]="varchar";
类型对照表[5][4]="int";类型对照表[5][5]="float";
类型对照表[5][6]="date";类型对照表[5][7]="datetime";
类型对照表[5][8]="text";类型对照表[5][9]="text";
类型对照表[5][10]="tinyint";类型对照表[5][11]="tinyint";
类型对照表[5][12]="smallint";类型对照表[5][13]="bigint";
类型对照表[5][14]="float";类型对照表[5][15]="integer";
类型对照表[5][16]="double";类型对照表[5][17]="float";
类型对照表[5][18]="float";类型对照表[5][19]="blob";
连接条件="";
File file = new File(".\\com\\iText-5.0.5.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\jacob.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\poi-3.8-20120326.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\PDFBox-0.7.3.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
表名=parameter[4] ; // 数据表名
字段号表=parameter[8];
导出文件名=parameter[18];
导出表名=parameter[2];
String [] 按钮集01={"导出到word","导出到excel","导出到PDF","退出"};
按钮集=new String[按钮集01.length];
按钮数=0;
for (int i0=0;i0<按钮集01.length;i0++)
按钮集[i0]= 按钮集01[i0];
if (parameter[11].length()>0){
要求按钮号表=parameter[11] ;// 需要显示的按钮的顺序号
//将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表=要求按钮号表.replaceAll(";",";");
要求按钮号表=要求按钮号表.replaceAll("。",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
if (要求按钮号表.indexOf(";")>0){ //如果有按钮更名要求
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (s601[i01].indexOf(";")>0){
String s602[]=s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))]=s602[1];
要求按钮号表=要求按钮号表+","+s602[0];//只留号,去更名
按钮数++;
}
else {
要求按钮号表=要求按钮号表+","+s601[i01];//只留号,原无更名
按钮数++;
}
}
} //如果没有按钮更名要求,要求按钮号长度又大于0,保持原有摸样
else {
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (i01==0) 要求按钮号表=s601[i01];
else 要求按钮号表=要求按钮号表+","+s601[i01];
按钮数++;
}
}
}
else {
要求按钮号表=""; //没输入要求按钮号,定全部按钮号
for (int i1=0;i1<按钮集.length;i1++){
if (i1==0) 要求按钮号表=要求按钮号表+i1;
else 要求按钮号表=要求按钮号表+","+i1;
按钮数++;
}
}
要求按钮号表=","+要求按钮号表+",";
窗口宽=main1.窗口宽; 窗口高=main1.窗口高;
int m1,m2;
try{
if (parameter[17].length()==0) {
m1=0;m2=0;
}
else {
m1=Integer.parseInt(parameter[17]) ;//宽度参数
m2=Integer.parseInt(parameter[18]) ;
}
if (m1>0){
if (m2<80){
m1=m1*10;
m2=m2*10;
}
窗口宽=m1 ;
窗口高=m2 ;
}
}catch(Exception e2){}
关键字=parameter[6];
String 字段名表=parameter[19].trim();
if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equals(",")))
字段名表=字段名表.substring(0,字段名表.length()-1);
String 表名表=parameter[0];
String [] l3=字段名表.split(",");
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
String[] l1;
if (字段号表.length()>0){
l1=字段号表.split(",");
int [] l2=new int[l1.length];
for (int i=0;i<l1.length;i++){
l2[i]=Integer.valueOf(l1[i]);
}
列数=l1.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[l2[i]];
列名[1][i]=列名[0][i];
}
}
else {
列数=l3.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[i];
列名[1][i]=列名[0][i];
}
}
s1="";
for (int i=0;i<列数;i++)
s1=s1+列名[0][i]+",";
s1=s1.substring(0,s1.length()-1);
try
{
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+s1+" from "+表名;
数据表查询结构002();
if (连接条件.length()>0) s1=s1+" where "+连接条件;
ResultSet rs=sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数];
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数];
for (int i=0;i<列数;i++) {
列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i]=列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i]<列名[0][i].length()) 列数据宽度[i]=列名[0][i].length();
if (列数据宽度[i]<列名[1][i].length()) 列数据宽度[i]=列名[1][i].length();
if (列数据宽度[i]>50) 列数据宽度[i]=50;
}
关键字名=关键字.split(",");
关键字名1=new String[关键字名.length];
关键字序号=new int[关键字名.length];
关键字序号1=new int[关键字名.length];
表格列名=new String[列数];
表列数据类型=new String[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
}
记录条数=0; //记录条数
rs.last();
记录条数=rs.getRow();
表格数据=new String[记录条数][列数];
rs.absolute(1);
c=0; //行号
b=0; //列号
while(c<记录条数) {
rs.absolute(c+1);
while(b<列数){
表格数据[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close(); //关闭查询结果集
sta4.close(); //关闭连接
con1.close();
}
catch(SQLException e)
{
JOptionPane.showMessageDialog( null, "读取数据出错!");
}
if (字典表名.length()>0){
try
{
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名; // 查取全表数据
rs = sta4.executeQuery(s1);
String s4="";
String s5="";
b=1;
while (rs.absolute(b)) {
b++;
s4=rs.getString(1).trim(); //字段名
s5=rs.getString(2).trim();
for (int j=0;j<列数;j++){
if (列名[0][j].trim().equalsIgnoreCase(s4.trim())){
列名[1][j]=s5;
break;
}
}
}
rs.close(); //关闭查询结果集
con1.close();
sta4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!");
}
}
for (int i=0;i<列数;i++) {
for (int j=0;j<关键字名.length;j++)
if (关键字名[j].trim().equalsIgnoreCase(列名[0][i].trim())){
关键字名1[j]=列名[1][i];
关键字序号[j]=i;
}
}
frame.setTitle("数据修改式导出到office文件部件。根据关键字查出关键字相同记录用当前表中数据替代。 作者:程学先");
frame.setBounds(10, 10, 窗口宽, 窗口高);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(10, 10,窗口宽,窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
scrollPane.setBounds(0,0,窗口宽-20,窗口高-100); //定义滚动面板大小位置
panel.add(scrollPane);
model = new DefaultTableModel(表格数据,列名[1]); // 创建表格模型
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for(int i=0;i<列数;i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i]*14);
tc.setMaxWidth(列数据宽度[i]*14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
按钮宽=(窗口宽-60)/按钮数;
int 按钮左边距=30;
JButton 到word = new JButton(按钮集[0]);
到word.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.doc","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".doc")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".doc";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".doc";
}
}
try {
FileInputStream in=new FileInputStream(new File(导出文件名));
WordExtractor extractor=null;
extractor=new WordExtractor(in);
String 内容=extractor.getText();
int m1=0;;
String[] 记录=new String[列数];
int k=0;
int k2=0,k5=0;
记录[k]="";
for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){ //找到一个回车
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+记录[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){ //表中所有记录
s2="";
for (int k4=0;k4<关键字名.length;k4++){
s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
}
if (s3.trim().equalsIgnoreCase(s2.trim())) { //找到关键字相同记录
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(记录);
记录条数++;
}
k5=0;
记录[0]="";
k=0;
m1=1;
if ((i<内容.length()-2)&&(内容.charAt(i+2)=='\r')) break;
}
else if (内容.charAt(i)=='\n'){}
else if ((byte)(内容.charAt(i))==9){
k++;
m1=0;
if (k<列数) 记录[k]="";
}
else if (k<列数){
记录[k]=记录[k]+内容.charAt(i); //记录[k]+
}
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据出错,可能是原文件中数据结构与数据表不同,不能作修改式导出!");
}
try{
ActiveXComponent word = new ActiveXComponent("Word.Application");
Dispatch documents = word.getProperty("Documents").toDispatch();
try { //用覆盖方式或添加方式加入表格
Dispatch doc = Dispatch.call(documents, "Add").toDispatch();
Dispatch selection = Dispatch.get(word,"Selection").toDispatch();
Dispatch.call(selection, "HomeKey");
Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
Dispatch range = Dispatch.get(selection, "Range").toDispatch();
Dispatch newTable = Dispatch.call(tables, "Add", range,
new Variant(记录条数), new Variant(列数)).toDispatch();
for(int i1=0;i1<model.getRowCount();i1++){
for(int j=0;j<列数;j++){
Dispatch table = Dispatch.call(tables, "Item", new Variant(1))
.toDispatch();
Dispatch cell = Dispatch.call(table, "Cell", new Variant(i1+1),
new Variant(j+1)).toDispatch();
Dispatch.call(cell, "Select");
s1=""+model.getValueAt(i1,j);
Dispatch.put(selection, "Text",s1);
}
}
Dispatch.call((Dispatch) Dispatch.call(word, "WordBasic").getDispatch(),
"FileSaveAs",导出文件名);
} catch (Exception e1) {e1.printStackTrace();
} finally {Dispatch.call(word, "Quit");
}
} catch (Exception e1) {
e1.printStackTrace();
}
return;
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){
到word.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到word);
按钮左边距=按钮左边距+按钮宽;
}
JButton 到excel = new JButton(按钮集[1]);
到excel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.xls","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".xls")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".xls";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".xls";
}
}
InputStream is = null;
HSSFWorkbook wbWorkbook = null;
try {
is = new FileInputStream(导出文件名);
wbWorkbook = new HSSFWorkbook(is);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败,请检查路径是否正确!", "错误",
JOptionPane.INFORMATION_MESSAGE);
} catch (IOException e2) {
e2.printStackTrace();
}
HSSFSheet sheet = wbWorkbook.getSheetAt(0);
int lastRowNum = sheet.getLastRowNum();
int 导入表格行数 = sheet.getPhysicalNumberOfRows();
HSSFRow row = sheet.getRow(1);
int 导入表格列数=row.getPhysicalNumberOfCells();
if (导入表格列数!=列数)
JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同,不能作修改式导出!");
String[] val;
int k2=0,k5=0;
String value = "";
for (int i = 0; i < 导入表格行数; i++) {
row = sheet.getRow(i);
if (row != null) {
for (int j = 0; j < 导入表格列数; j++) {
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()){
case HSSFCell.CELL_TYPE_FORMULA:
break;
case HSSFCell.CELL_TYPE_NUMERIC:
value += cell.getNumericCellValue() + ",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += "0";
break;
}
}
}
val = value.split(",");
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+val[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){
s2="";
for (int k4=0;k4<关键字名.length;k4++)
s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
if (s3.trim().equalsIgnoreCase(s2.trim())) {
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(val);
记录条数++;
}
k5=0;
value = "";
}
}
HSSFWorkbook book = new HSSFWorkbook();
sheet = book.createSheet(表名);
HSSFRow header = sheet.createRow(0);
int colCount = 列数;
for (int i = 0; i < 列数; i++) {
HSSFCell cell = header.createCell(i);
cell.setCellValue(new HSSFRichTextString(表格列名[i]));
}
for (int j=0;j<model.getRowCount();j++){
row = sheet.createRow(j);
for (int i = 0; i < colCount; i++) {
HSSFCell cell = row.createCell(i);
s1=""+model.getValueAt(j,i);
cell.setCellValue(new HSSFRichTextString(s1));
}
}
try {
FileOutputStream fileO = new FileOutputStream(导出文件名);
book.write(fileO);
fileO.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){
到excel.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到excel);
按钮左边距=按钮左边距+按钮宽;
}
JButton 到pdf = new JButton(按钮集[2]);
到pdf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (导出文件名.length()==0){
导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径 例如:F:\\java.pdf","");
return;
}
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".pdf")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".pdf";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".pdf";
}
}
try {
FileInputStream in = new FileInputStream(导出文件名);
PDFParser parser = new PDFParser(in);
parser.parse();
PDDocument pdfdocument = parser.getPDDocument();
PDFTextStripper stripper = new PDFTextStripper();
s1 = stripper.getText(pdfdocument);
in.close();
} catch (Exception e1) {
e1.printStackTrace();
}
String[] 记录=new String[列数];
String s4="";
int k=0,m1=0,k2=0,k5=0;
记录[0]="";
int l1=s1.length();
for (int i1=0;i1<l1;i1++){
s2=s1.substring(i1,i1+1);
if (s1.charAt(i1)=='\r') {}
else if (s1.charAt(i1)=='\n') {}
else if ((s2.trim().equals("│"))&&(m1==1)) {
if (k==列数-1) {
s3="";
for (int k3=0;k3<关键字名.length;k3++)
s3=s3+记录[关键字序号[k3]].trim();
k2=0;
for (int j1=0;j1<model.getRowCount();j1++){
s4="";
for (int k4=0;k4<关键字名.length;k4++)
s4=s4+model.getValueAt(j1,关键字序号[k4]).toString().trim();
if (s3.trim().equalsIgnoreCase(s4.trim())) {
k2=j1;
k5=1;
break;
}
}
if (k5==0){
model.addRow(记录);
记录条数++;
}
k5=0;
k=0;
m1=0;
记录[k]="";
}
else {
k++;
if (k<列数) 记录[k]="";
}
}
else if (s2.trim().equals("│")) {
m1=1;
k=0;
记录[0]="";
}
else if ((k<列数)&&(m1==1)){
try{
记录[k]=记录[k]+s2;
} catch (Exception e1) {
}
}
}
File file = new File(导出文件名);
if (file.exists()) {
file.delete();
}
Document document = new Document();
try {
PdfWriter.getInstance(document, new FileOutputStream(导出文件名));
document.open();
BaseFont bfComic = BaseFont.createFont("c:\\windows\\fonts\\SIMFANG.TTF", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
Font font = new Font(bfComic, 9);
s1="┌";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┬";
}
s1=s1+"┐";
document.add(new Paragraph(s1, font));
int 记录条数2=model.getRowCount();
s4="";
String s5="";
float lengtg1=0;
for (int i=0;i<记录条数2;i++){
s1="│";
for (int j=0;j<表格数据[0].length;j++){
if (model.getValueAt(i,j)==null) s4=" ";
else s4=model.getValueAt(i,j).toString().trim();
s3="";
lengtg1=0;
for (int j1=0;j1<s4.length();j1++){
s5=s4.substring(j1,j1+1);
s1=s1+s5;
if (s5.compareTo("z")<0){
if (s5.compareTo("0")<0)
lengtg1=lengtg1+0.51f;
else lengtg1=lengtg1+0.51f;
}
else lengtg1=lengtg1+1;
}
while (lengtg1<列数据宽度[j]) {
s1=s1+" ";
lengtg1=lengtg1+0.51f;
}
s1=s1+"│";
lengtg1=0;
}
document.add(new Paragraph(s1, font));
if (i<记录条数2-1){
s1="├";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┼";
}
s1=s1+"┤";
document.add(new Paragraph(s1, font));
}
else {
s1="└";
for (int j=0;j<列数;j++){
for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┴";
}
s1=s1+"┘";
document.add(new Paragraph(s1, font));
}
}
}
catch(DocumentException de) {
System.err.println(de.getMessage());
}
catch(IOException ioe) {
System.err.println(ioe.getMessage());
}
document.close();
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){
到pdf.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(到pdf);
按钮左边距=按钮左边距+按钮宽;
}
JButton exitButton = new JButton(按钮集[3]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){
exitButton.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(exitButton);
按钮左边距=按钮左边距+按钮宽;
}
frame.add(panel);
frame.setVisible(true); // 显示窗体
}
static void 数据表查询结构001(String 数据表名001) {
try
{
cont4=main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1= "select * from "+数据表名001;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
列数0 = rsmdt4.getColumnCount();
列名0 = new String[列数0];
for (int i=0;i<列数0;i++) {
列名0[i] = rsmdt4.getColumnName(i + 1);
}
rs.close();
stat4.close();
cont4.close();
} catch(SQLException e1){
JOptionPane.showMessageDialog( null, "读取数据表结构出错!");
}
列名表="";
int b0=0;
while (b0 < 列名.length){
if (b0==0) 列名表=列名0[b0];
else 列名表=列名表+","+列名0[b0];
b0++;
}
}
static void 数据表查询结构002() {
String[] t11 = 表名.split(",");
String 列名表0 = "";
连接条件 = "";
if (t11.length > 1) {
for (int i = 0; i < t11.length; i++) {
数据表查询结构001(t11[i]);
for (int j = 0; j < 列名0.length; j++)
if (("," + 列名表0 + ",").indexOf("," + 列名0[j] + ",") >= 0) {
if (连接条件.length() == 0)
连接条件 = t11[i - 1] + "." + 列名0[j] + "=" + t11[i]
+ "." + 列名0[j];
else
连接条件 = 连接条件 + " and " + t11[i - 1] + "." + 列名0[j]
+ "=" + t11[i] + "." + 列名0[j];
}
if (列名表0.length() == 0)
列名表0 = 列名表;
else
列名表0 = 列名表0 + "," + 列名表;
}
}
}
}
48.源码48,部件程序,从纯文本文件、XML文件或其他数据表添加式导入数据到当前表数据导入部件。
/**
* 程序文件名:dataTransfer8.java
* 作者:程学先
* 功能:从纯文本文件、XML文件或其他数据表添加式导入数据到当前表。
* 原有标数据全部保留,导入数据添加到尾部。
* 特别注意,本程序未检查实体完整性,需要关注关键字重复记录问题。
* 如果从数据表导入,当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容,
* 符合本程序中“类型对照表"设置的对应关系。
* 完成日期:2013年1月22日
* 被调用语句:dataTransfer8.means(parameter)
* 必须提供的参数:目的数据“表名”。
* 应当提供的参数:“导入文件名”、“源表名”。二选一。
* 可选参数:“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
* 要求字段号表:所操作数据可以是源表的全部字段,也可以只涉及部分字段。如果选择全部字段,初始值设为"";
* 否则写入所有将涉及的字段在表中的顺序号,号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个,序号及按钮名:1添加式导入到数据库表、2从纯文本文按标准格式添加式导入、
* 3从纯文本文以紧缩格式添加式导入、4从纯文本文一自定义格式添加式导入、5从XML文件以添加方式导入、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 以标准格式导入时将会首先读入数据,并根据当前数据库中各列宽度对之切割,不支持大数据类型,
* 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式(特别是每个数据宽度与数据类型)应当与当前数据库表中数据一致,否则出错。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class dataTransfer8 extends JFrame {
static dataTransfer8 frame = new dataTransfer8(); // 创建窗体
private static JTable table; //创建表格
static Connection con; //连接数据库
static Connection con1;
static String url;
static String ODBC数据源1;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs; //数据库数据集,存放查询的结果
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
static int 列数; //数据表列数
static int 列数1;
static String [][] 列名; //数据表列名
static String [] 列名1;
static int[] 对应目的表序号; //存放当前记录各字段数据宽度的数组
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int[] 表列数据宽度,表列小数位数;
static int 记录条数=0,记录条数1=0; //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[][] 表格数据1;
static DefaultTableModel model;
static String 表名; //数据表名
static String 表名表;
static String 字典表名;
static String 导入表名,导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String s1="",s2="",s3="";
static String s6=" ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
{"java" ,"string","string","string" ,"int" ,"int" ,"string","string" ,"string","string","boolean","byte" ,"short" ,"long" ,"float" ,"int" ,"double","float" ,"float" ,"byte[]"},
{"sqlserver","char" ,"nchar" ,"nvarchar" ,"int" ,"float" ,"datetime" ,"datetime","text","ntext" ,"bit" ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
{"vfp" ,"c" ,"c" ,"c" ,"i" ,"n" ,"d" ,"t" ,"m" ,"m" ,"l" ,"i" ,"i" ,"i" ,"n" ,"i" ,"n" ,"b" ,"y" ,"g" },
{"access" ,"text" ,"text" ,"text" ,"integer","integer" ,"date" ,"date" ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float" ,"integer","float" ,"float" ,"float" ,"general"},
{"oracle" ,"char" ,"char" ,"char" ,"number" ,"number" ,"date" ,"date" ,"long" ,"long" ,"char" ,"raw" ,"number" ,"number" ,"number" ,"number" ,"number" ,"number","number","blob"},
{"mysql" ,"char" ,"char" ,"varchar" ,"int" ,"float" ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float" ,"integer","double" ,"float" ,"float" ,"blob"}
};
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
frame = new dataTransfer8(); // 创建窗体
窗口宽 = 800;
窗口高 = 600;// 窗口宽、窗口高
记录条数 = 0;
记录条数1 = 0; // 记录条数
s1 = "";
s2 = "";
s3 = "";
s6 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
类型1 = main1.类型1;
类型对照表[0][0] = "java";
类型对照表[0][1] = "string";
类型对照表[0][2] = "string";
类型对照表[0][3] = "string";
类型对照表[0][4] = "int";
类型对照表[0][5] = "int";
类型对照表[0][6] = "string";
类型对照表[0][7] = "string";
类型对照表[0][8] = "string";
类型对照表[0][9] = "string";
类型对照表[0][10] = "boolean";
类型对照表[0][11] = "byte";
类型对照表[0][12] = "short";
类型对照表[0][13] = "long";
类型对照表[0][14] = "float";
类型对照表[0][15] = "int";
类型对照表[0][16] = "double";
类型对照表[0][17] = "float";
类型对照表[0][18] = "float";
类型对照表[0][19] = "byte[]";
类型对照表[1][0] = "sqlserver";
类型对照表[1][1] = "char";
类型对照表[1][2] = "nchar";
类型对照表[1][3] = "nvarchar";
类型对照表[1][4] = "int";
类型对照表[1][5] = "float";
类型对照表[1][6] = "datetime";
类型对照表[1][7] = "datetime";
类型对照表[1][8] = "text";
类型对照表[1][9] = "ntext";
类型对照表[1][10] = "bit";
类型对照表[1][11] = "tinyint";
类型对照表[1][12] = "smallint";
类型对照表[1][13] = "bigint";
类型对照表[1][14] = "numeric";
类型对照表[1][15] = "integer";
类型对照表[1][16] = "double";
类型对照表[1][17] = "money";
类型对照表[1][18] = "real";
类型对照表[1][19] = "image";
类型对照表[2][0] = "vfp";
类型对照表[2][1] = "c";
类型对照表[2][2] = "c";
类型对照表[2][3] = "c";
类型对照表[2][4] = "i";
类型对照表[2][5] = "n";
类型对照表[2][6] = "d";
类型对照表[2][7] = "t";
类型对照表[2][8] = "m";
类型对照表[2][9] = "m";
类型对照表[2][10] = "l";
类型对照表[2][11] = "i";
类型对照表[2][12] = "i";
类型对照表[2][13] = "i";
类型对照表[2][14] = "n";
类型对照表[2][15] = "i";
类型对照表[2][16] = "n";
类型对照表[2][17] = "b";
类型对照表[2][18] = "y";
类型对照表[2][19] = "g";
类型对照表[3][0] = "access";
类型对照表[3][1] = "text";
类型对照表[3][2] = "text";
类型对照表[3][3] = "text";
类型对照表[3][4] = "integer";
类型对照表[3][5] = "integer";
类型对照表[3][6] = "date";
类型对照表[3][7] = "date";
类型对照表[3][8] = "memo";
类型对照表[3][9] = "memo";
类型对照表[3][10] = "logical";
类型对照表[3][11] = "integer";
类型对照表[3][12] = "integer";
类型对照表[3][13] = "integer";
类型对照表[3][14] = "float";
类型对照表[3][15] = "integer";
类型对照表[3][16] = "float";
类型对照表[3][17] = "float";
类型对照表[3][18] = "float";
类型对照表[3][19] = "general";
类型对照表[4][0] = "oracle";
类型对照表[4][1] = "char";
类型对照表[4][2] = "char";
类型对照表[4][3] = "char";
类型对照表[4][4] = "number";
类型对照表[4][5] = "number";
类型对照表[4][6] = "date";
类型对照表[4][7] = "date";
类型对照表[4][8] = "long";
类型对照表[4][9] = "long";
类型对照表[4][10] = "char";
类型对照表[4][11] = "raw";
类型对照表[4][12] = "number";
类型对照表[4][13] = "number";
类型对照表[4][14] = "number";
类型对照表[4][15] = "number";
类型对照表[4][16] = "number";
类型对照表[4][17] = "number";
类型对照表[4][18] = "number";
类型对照表[4][19] = "blob";
类型对照表[5][0] = "mysql";
类型对照表[5][1] = "char";
类型对照表[5][2] = "char";
类型对照表[5][3] = "varchar";
类型对照表[5][4] = "int";
类型对照表[5][5] = "float";
类型对照表[5][6] = "date";
类型对照表[5][7] = "datetime";
类型对照表[5][8] = "text";
类型对照表[5][9] = "text";
类型对照表[5][10] = "tinyint";
类型对照表[5][11] = "tinyint";
类型对照表[5][12] = "smallint";
类型对照表[5][13] = "bigint";
类型对照表[5][14] = "float";
类型对照表[5][15] = "integer";
类型对照表[5][16] = "double";
类型对照表[5][17] = "float";
类型对照表[5][18] = "float";
类型对照表[5][19] = "blob";
表名 = parameter[4];
字段号表 = parameter[8];
导入文件名 = parameter[18];
导入表名 = parameter[2];
String[] 按钮集01 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入", "从XML文件导入",
"退出" };
按钮集 = new String[按钮集01.length];
按钮数 = 0;
for (int i0 = 0; i0 < 按钮集01.length; i0++)
按钮集[i0] = 按钮集01[i0];
if (parameter[11].length() > 0) {
要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
// 将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表 = 要求按钮号表.replaceAll(";", ";");
要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))] = s602[1];
要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号,去更名
按钮数++;
} else {
要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号,原无更名
按钮数++;
}
}
} // 如果没有按钮更名要求,要求按钮号长度又大于0,保持原有摸样
else {
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
要求按钮号表 = s601[i01];
else
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
按钮数++;
}
}
} else {
要求按钮号表 = ""; // 没输入要求按钮号,定全部按钮号
for (int i1 = 0; i1 < 按钮集.length; i1++) {
if (i1 == 0)
要求按钮号表 = 要求按钮号表 + i1;
else
要求按钮号表 = 要求按钮号表 + "," + i1;
按钮数++;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
DBMS名称1 = parameter[1];
ODBC数据源1 = parameter[3];
if ((DBMS名称1 == null) || (DBMS名称1.length() == 0))
DBMS名称1 = main1.DBMS系统;
if ((ODBC数据源1 == null) || (ODBC数据源1.length() == 0))
ODBC数据源1 = main1.ODBC数据源;
String 字段名表 = parameter[19].trim();
if ((字段名表.length() > 0)
&& (字段名表.substring(字段名表.length() - 1).equals(",")))
字段名表 = 字段名表.substring(0, 字段名表.length() - 1);
表名表 = parameter[0];
String[] l3 = 字段名表.split(",");
字典表名 = "";
String[] t1;
int b = 0, c = 0;
if (表名表.lastIndexOf(表名 + "字典表") >= 0) {
t1 = 表名表.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(表名 + "字典表") >= 0)
字典表名 = t1[i];
}
String[] l1;
if (字段号表.length() > 0) {
l1 = 字段号表.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
列数 = l1.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[l2[i]];
列名[1][i] = 列名[0][i];
}
} else {
列数 = l3.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[i];
列名[1][i] = 列名[0][i];
}
}
s1 = "";
for (int i = 0; i < 列数; i++) {
s1 = s1 + 列名[0][i] + ",";
}
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();// 连接数据库
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + 表名;
} else {
JOptionPane.showMessageDialog(null, "目的数据表不存在,不能导入!");
return;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
表格列名 = new String[列数];
表列数据宽度 = new int[列数];
表列数据类型 = new String[列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i] = 列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i] < 列名[0][i].length())
列数据宽度[i] = 列名[0][i].length();
if (列数据宽度[i] < 列名[1][i].length())
列数据宽度[i] = 列名[1][i].length();
if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
}
if (((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0))
&& (DBMS名称1.trim().length() > 0)) {
int 类型序号 = 0, 类型序号1 = 0;
for (int i = 0; i < 类型对照表.length; i++) {
if (DBMS名称1.trim().equals(类型对照表[i][0]))
类型序号1 = i;
if (main1.DBMS系统.equals(类型对照表[i][0]))
类型序号 = i;
}
for (b = 0; b < 列数; b++) {
表格列名[b] = 列名[1][b];
表列数据宽度[b] = 列数据宽度[b];
for (int i = 1; i < 类型对照表[0].length; i++) {
if (列数据类型[b].toLowerCase().trim()
.equals(类型对照表[类型序号][i])) {
表列数据类型[b] = 类型对照表[类型序号1][i];
break;
}
}
}
}
记录条数 = 0; // 记录条数
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close(); // 关闭查询结果集
sta4.close(); // 关闭连接
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
if (字典表名.length() > 0) {
try {
main1.driver1();
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta3.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1); // 字段名
s5 = rs.getString(2);
for (int j = 0; j < 列数; j++) {
if (列名[0][j].trim().equals(s4.trim())) {
列名[1][j] = s5;
表格列名[j] = s5;
break;
}
}
}
rs.close(); // 关闭查询结果集
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
s2 = "";
for (int i = 0; i < 列数; i++) {
s2 = s2 + 列名[1][i] + ",";
}
s2 = s2.substring(0, s2.length() - 1);
frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者:程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
final JPanel panel = new JPanel(false); // 定义面板
panel.setLayout(null); // 关闭面板布局管理器
panel.setBounds(10, 10, 窗口宽, 窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 100); // 定义滚动面板大小位置
panel.add(scrollPane);
// 创建表格列名数组
model = new DefaultTableModel(表格数据, 列名[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i] * 14);
tc.setMaxWidth(列数据宽度[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
按钮宽 = (窗口宽 - 60) / 按钮数;
int 按钮左边距 = 30;
for (int i = 0; i < 100; i++)
s3 = s3 + " ";
JButton 到数据库 = new JButton(按钮集[0]);
到数据库.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat4;
Statement stat3;
try {
if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s2 + " from " + 导入表名;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
记录条数1 = rs1.getRow();
列名1 = s2.split(",");
列数1 = 列名1.length;
表格数据1 = new String[记录条数1][列数1];
rs1.absolute(1);
int c = 0; // 行号
int b = 0; // 列号
while (c < 记录条数1) {
rs1.absolute(c + 1);
while (b < 列数) {
表格数据1[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close(); // 关闭查询结果集
stat4.close();
con1.close();
}
} catch (SQLException e1) {
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < 表格数据1.length; i++) {
s1 = "insert into " + 表名 + " (";
for (int k1 = 0; k1 < 列名[1].length; k1++)
s1 = s1 + 列名[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (表格数据1[i][j] == null)
表格数据1[i][j] = "0";
s1 = s1 + 表格数据1[i][j];
} else {
if (表格数据1[i][j] == null)
表格数据1[i][j] = " ";
s1 = s1 + "'" + 表格数据1[i][j] + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
}
stat3.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
到数据库.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(到数据库);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 标准格式 = new JButton(按钮集[1]);
标准格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
int k1 = 0, k2 = 0, k5 = 0;
for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
for (int j = 0; j < 列数; j++) {
空记录1[j] = tempStr.substring(k1, k1 + 列数据宽度[j]);
k1 = k1 + 列数据宽度[j];
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + " (";
for (int k3 = 0; k3 < 列名[1].length; k3++)
s1 = s1 + 列名[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j].trim();
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j].trim() + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
k1 = 0;
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
标准格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(标准格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 紧缩格式 = new JButton(按钮集[2]);
紧缩格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
char x6 = '"';
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
空记录1 = tempStr.split(",");
for (int j = 0; j < 列数; j++) {
if (空记录1[j].lastIndexOf("" + x6) >= 0)
空记录1[j] = 空记录1[j].substring(1,
空记录1[j].length() - 1);
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + " (";
for (int k3 = 0; k3 < 列名[1].length; k3++)
s1 = s1 + 列名[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j].trim();
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j].trim() + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0)) {
紧缩格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(紧缩格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 自定义格式 = new JButton(按钮集[3]);
自定义格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
String x6 = "", x7 = null;
char x1 = 13;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
x6 = tempStr;
while (x6.indexOf("】【") < 0) {
if ((tempStr = br.readLine()) != null) {
x6 = x6 + x1 + tempStr;
i++;
}
}
x6 = x6.substring(0, x6.length() - 2);
空记录1 = x6.split(x5);
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + " (";
for (int k3 = 0; k3 < 列名[1].length; k3++)
s1 = s1 + 列名[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j].trim();
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j].trim() + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0)) {
自定义格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(自定义格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 到XML文件 = new JButton(按钮集[4]);
到XML文件.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(导入文件名));
Element elmtInfo = doc.getDocumentElement();
NodeList nodes = elmtInfo.getChildNodes();
String[] 列名0 = new String[列数];
String[] 空记录 = new String[列数];
String[] 空记录1 = new String[列数];
int k = 0, k1 = 0;
for (int i = 0; i < nodes.getLength(); i++) {
NodeList ns = nodes.item(i).getChildNodes();
k = 0;
for (int j2 = 0; j2 < 列数; j2++)
空记录1[j2] = "";
k1 = 0;
for (int j = 0; j < ns.getLength(); j++) {
Node record = ns.item(j);
if (record.toString().lastIndexOf("null") > 0) {
列名0[k] = ns
.item(j)
.toString()
.substring(
1,
record.toString().lastIndexOf(
":"));
空记录[k] = record.getTextContent();
for (int j2 = 0; j2 < 列数; j2++) {
if (列名[1][j2].lastIndexOf(列名0[k]) >= 0) {
空记录1[j2] = 空记录[k];
break;
}
}
k++;
k1 = 1;
}
}
if (k1 > 0) {
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + " (";
for (int k3 = 0; k3 < 列名[1].length; k3++)
s1 = s1 + 列名[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j].trim();
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j].trim() + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {
到XML文件.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(到XML文件);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton exitButton = new JButton(按钮集[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 0)) {
exitButton.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(exitButton);
按钮左边距 = 按钮左边距 + 按钮宽;
}
main1.driver1();
frame.add(panel);
frame.setVisible(true); // 显示窗体
}
}
49.源码49,部件程序,从纯文本文件、XML文件或其他数据表修改式导入数据到当前表数据导入部件。
/**
* 程序文件名:dataTransfer9.java
* 作者:程学先
* 功能:从纯文本文件、XML文件或其他数据表修改式导入数据到当前表。
* 关键字子相同记录按导入表更新,关键字不在原表中的记录作为新记录添加在尾部。
* 如果目的表已经存在,必须与源表数据类型、数据宽度对应相容,符合本程序中“类型对照表"设置的对应关系。
* 从数据表导入,本地表经字典表变换后的字段名也必须和源表相同,数量和次序可以随意。
* 如果从文本文件或XML文件导入,当前表必须存在。
* 完成日期:2013年1月22日
* 被调用语句:dataTransfer9.means(parameter)
* 必须提供的参数:目的数据“表名”、“关键字”。
* 应当提供的参数:“导入文件名”、“源表名”。二选一。
* 可选参数:“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
* 要求字段号表:所操作数据可以是源表的全部字段,也可以只涉及部分字段。如果选择全部字段,初始值设为"";
* 否则写入所有将涉及的字段在表中的顺序号,号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个,序号及按钮名:1修改式导入到数据库表、2从纯文本文按标准格式修改式导入、
* 3从纯文本文以紧缩格式修改式导入、4从纯文本文一自定义格式修改式导入、5从XML文件以修改方式导入、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 以标准格式导入时将会首先读入数据,并根据当前数据库中各列宽度对之切割,不支持大数据类型,
* 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式(特别是每个数据宽度与数据类型)应当与当前数据库表中数据一致,否则出错。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class dataTransfer9 extends JFrame {
static dataTransfer9 frame = new dataTransfer9(); // 创建窗体
private static JTable table; //创建表格
static Connection con;
static Connection con1;
static String url;
static String ODBC数据源1;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
static int 列数; //数据表列数
static int 列数1;
static String [][] 列名; //数据表列名
static String [] 列名1;
static int[] 对应目的表序号; //存放当前记录各字段数据宽度的数组
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int[] 表列数据宽度,表列小数位数;
static int 记录条数=0,记录条数1=0; //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[][] 表格数据1;
static DefaultTableModel model;
static String 表名; //数据表名
static String 表名表;
static String 字典表名;
static String 导入表名,导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String 关键字;
static String [] 关键字数据1;
static String[] 关键字名,关键字名1;
static int[] 关键字序号,关键字序号1;
static String s1="",s2="",s3="";
static String s6=" ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
{"java" ,"string","string","string" ,"int" ,"int" ,"string","string" ,"string","string","boolean","byte" ,"short" ,"long" ,"float" ,"int" ,"double","float" ,"float" ,"byte[]"},
{"sqlserver","char" ,"nchar" ,"nvarchar" ,"int" ,"float" ,"datetime" ,"datetime","text","ntext" ,"bit" ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
{"vfp" ,"c" ,"c" ,"c" ,"i" ,"n" ,"d" ,"t" ,"m" ,"m" ,"l" ,"i" ,"i" ,"i" ,"n" ,"i" ,"n" ,"b" ,"y" ,"g" },
{"access" ,"text" ,"text" ,"text" ,"integer","integer" ,"date" ,"date" ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float" ,"integer","float" ,"float" ,"float" ,"general"},
{"oracle" ,"char" ,"char" ,"char" ,"number" ,"number" ,"date" ,"date" ,"long" ,"long" ,"char" ,"raw" ,"number" ,"number" ,"number" ,"number" ,"number" ,"number","number","blob"},
{"mysql" ,"char" ,"char" ,"varchar" ,"int" ,"float" ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float" ,"integer","double" ,"float" ,"float" ,"blob"}
};
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
frame = new dataTransfer9(); // 创建窗体
窗口宽 = 800;
窗口高 = 600;// 窗口宽、窗口高
记录条数 = 0;
记录条数1 = 0; // 记录条数
s1 = "";
s2 = "";
s3 = "";
s6 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
类型1 = main1.类型1;
类型对照表[0][0] = "java";
类型对照表[0][1] = "string";
类型对照表[0][2] = "string";
类型对照表[0][3] = "string";
类型对照表[0][4] = "int";
类型对照表[0][5] = "int";
类型对照表[0][6] = "string";
类型对照表[0][7] = "string";
类型对照表[0][8] = "string";
类型对照表[0][9] = "string";
类型对照表[0][10] = "boolean";
类型对照表[0][11] = "byte";
类型对照表[0][12] = "short";
类型对照表[0][13] = "long";
类型对照表[0][14] = "float";
类型对照表[0][15] = "int";
类型对照表[0][16] = "double";
类型对照表[0][17] = "float";
类型对照表[0][18] = "float";
类型对照表[0][19] = "byte[]";
类型对照表[1][0] = "sqlserver";
类型对照表[1][1] = "char";
类型对照表[1][2] = "nchar";
类型对照表[1][3] = "nvarchar";
类型对照表[1][4] = "int";
类型对照表[1][5] = "float";
类型对照表[1][6] = "datetime";
类型对照表[1][7] = "datetime";
类型对照表[1][8] = "text";
类型对照表[1][9] = "ntext";
类型对照表[1][10] = "bit";
类型对照表[1][11] = "tinyint";
类型对照表[1][12] = "smallint";
类型对照表[1][13] = "bigint";
类型对照表[1][14] = "numeric";
类型对照表[1][15] = "integer";
类型对照表[1][16] = "double";
类型对照表[1][17] = "money";
类型对照表[1][18] = "real";
类型对照表[1][19] = "image";
类型对照表[2][0] = "vfp";
类型对照表[2][1] = "c";
类型对照表[2][2] = "c";
类型对照表[2][3] = "c";
类型对照表[2][4] = "i";
类型对照表[2][5] = "n";
类型对照表[2][6] = "d";
类型对照表[2][7] = "t";
类型对照表[2][8] = "m";
类型对照表[2][9] = "m";
类型对照表[2][10] = "l";
类型对照表[2][11] = "i";
类型对照表[2][12] = "i";
类型对照表[2][13] = "i";
类型对照表[2][14] = "n";
类型对照表[2][15] = "i";
类型对照表[2][16] = "n";
类型对照表[2][17] = "b";
类型对照表[2][18] = "y";
类型对照表[2][19] = "g";
类型对照表[3][0] = "access";
类型对照表[3][1] = "text";
类型对照表[3][2] = "text";
类型对照表[3][3] = "text";
类型对照表[3][4] = "integer";
类型对照表[3][5] = "integer";
类型对照表[3][6] = "date";
类型对照表[3][7] = "date";
类型对照表[3][8] = "memo";
类型对照表[3][9] = "memo";
类型对照表[3][10] = "logical";
类型对照表[3][11] = "integer";
类型对照表[3][12] = "integer";
类型对照表[3][13] = "integer";
类型对照表[3][14] = "float";
类型对照表[3][15] = "integer";
类型对照表[3][16] = "float";
类型对照表[3][17] = "float";
类型对照表[3][18] = "float";
类型对照表[3][19] = "general";
类型对照表[4][0] = "oracle";
类型对照表[4][1] = "char";
类型对照表[4][2] = "char";
类型对照表[4][3] = "char";
类型对照表[4][4] = "number";
类型对照表[4][5] = "number";
类型对照表[4][6] = "date";
类型对照表[4][7] = "date";
类型对照表[4][8] = "long";
类型对照表[4][9] = "long";
类型对照表[4][10] = "char";
类型对照表[4][11] = "raw";
类型对照表[4][12] = "number";
类型对照表[4][13] = "number";
类型对照表[4][14] = "number";
类型对照表[4][15] = "number";
类型对照表[4][16] = "number";
类型对照表[4][17] = "number";
类型对照表[4][18] = "number";
类型对照表[4][19] = "blob";
类型对照表[5][0] = "mysql";
类型对照表[5][1] = "char";
类型对照表[5][2] = "char";
类型对照表[5][3] = "varchar";
类型对照表[5][4] = "int";
类型对照表[5][5] = "float";
类型对照表[5][6] = "date";
类型对照表[5][7] = "datetime";
类型对照表[5][8] = "text";
类型对照表[5][9] = "text";
类型对照表[5][10] = "tinyint";
类型对照表[5][11] = "tinyint";
类型对照表[5][12] = "smallint";
类型对照表[5][13] = "bigint";
类型对照表[5][14] = "float";
类型对照表[5][15] = "integer";
类型对照表[5][16] = "double";
类型对照表[5][17] = "float";
类型对照表[5][18] = "float";
类型对照表[5][19] = "blob";
表名 = parameter[4]; // 数据表名
字段号表 = parameter[8];
导入文件名 = parameter[18];
导入表名 = parameter[2];
String[] 按钮集01 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入", "从XML文件导入",
"退出" };
按钮集 = new String[按钮集01.length];
按钮数 = 0;
for (int i0 = 0; i0 < 按钮集01.length; i0++)
按钮集[i0] = 按钮集01[i0];
if (parameter[11].length() > 0) {
要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
// 将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表 = 要求按钮号表.replaceAll(";", ";");
要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))] = s602[1];
要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号,去更名
按钮数++;
} else {
要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号,原无更名
按钮数++;
}
}
} // 如果没有按钮更名要求,要求按钮号长度又大于0,保持原有摸样
else {
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
要求按钮号表 = s601[i01];
else
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
按钮数++;
}
}
} else {
要求按钮号表 = ""; // 没输入要求按钮号,定全部按钮号
for (int i1 = 0; i1 < 按钮集.length; i1++) {
if (i1 == 0)
要求按钮号表 = 要求按钮号表 + i1;
else
要求按钮号表 = 要求按钮号表 + "," + i1;
按钮数++;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
DBMS名称1 = parameter[1];
ODBC数据源1 = parameter[3];
if ((DBMS名称1 == null) || (DBMS名称1.length() == 0))
DBMS名称1 = main1.DBMS系统;
if ((ODBC数据源1 == null) || (ODBC数据源1.length() == 0))
ODBC数据源1 = main1.ODBC数据源;
关键字 = parameter[6];
String 字段名表 = parameter[19].trim();
if ((字段名表.length() > 0)
&& (字段名表.substring(字段名表.length() - 1).equals(",")))
字段名表 = 字段名表.substring(0, 字段名表.length() - 1);
表名表 = parameter[0];
String[] l3 = 字段名表.split(",");
字典表名 = "";
String[] t1;
int b = 0, c = 0;
if (表名表.lastIndexOf(表名 + "字典表") >= 0) {
t1 = 表名表.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(表名 + "字典表") > 00)
字典表名 = t1[i];
}
String[] l1;
if (字段号表.length() > 0) {
l1 = 字段号表.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
列数 = l1.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[l2[i]];
列名[1][i] = 列名[0][i];
}
} else {
列数 = l3.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[i];
列名[1][i] = 列名[0][i];
}
}
s1 = "";
for (int i = 0; i < 列数; i++) {
s1 = s1 + 列名[0][i] + ",";
}
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();// 连接数据库
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + 表名;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
for (int i = 0; i < 列数; i++) {
列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i] = 列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i] < 列名[0][i].length())
列数据宽度[i] = 列名[0][i].length();
if (列数据宽度[i] < 列名[1][i].length())
列数据宽度[i] = 列名[1][i].length();
if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
}
关键字名 = 关键字.split(",");
关键字名1 = new String[关键字名.length];
关键字序号 = new int[关键字名.length];
关键字序号1 = new int[关键字名.length];
if (((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0))
&& (DBMS名称1.trim().length() > 0)) {
int 类型序号 = 0, 类型序号1 = 0;
for (int i = 0; i < 类型对照表.length; i++) {
if (DBMS名称1.trim().equals(类型对照表[i][0]))
类型序号1 = i;
if (main1.DBMS系统.equals(类型对照表[i][0]))
类型序号 = i;
}
表格列名 = new String[列数];
表列数据类型 = new String[列数];
表列数据宽度 = new int[列数];
for (b = 0; b < 列数; b++) {
表格列名[b] = 列名[1][b];
表列数据宽度[b] = 列数据宽度[b];
for (int i = 1; i < 类型对照表[0].length; i++) {
if (列数据类型[b].toLowerCase().trim()
.equals(类型对照表[类型序号][i])) {
表列数据类型[b] = 类型对照表[类型序号1][i];
break;
}
}
}
}
记录条数 = 0; // 记录条数
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close(); // 关闭查询结果集
sta4.close(); // 关闭连接
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
for (int i = 0; i < 列数; i++) {
for (int j = 0; j < 关键字名.length; j++)
if (关键字名[j].trim().equals(列名[0][i].trim())) {
关键字名1[j] = 列名[1][i];
关键字序号[j] = i;
}
}
if (字典表名.length() > 0) {
try {
main1.driver1();
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta3.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1); // 字段名
s5 = rs.getString(2);
for (int j = 0; j < 列数; j++) {
if (列名[0][j].trim().equals(s4.trim())) {
列名[1][j] = s5;
表格列名[j] = s5;
break;
}
}
}
rs.close(); // 关闭查询结果集
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
s2 = "";
for (int i = 0; i < 列数; i++) {
s2 = s2 + 列名[1][i] + ",";
}
s2 = s2.substring(0, s2.length() - 1);
frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。 作者:程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
final JPanel panel = new JPanel(false); // 定义面板
panel.setLayout(null); // 关闭面板布局管理器
panel.setBounds(10, 10, 窗口宽, 窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 100); // 定义滚动面板大小位置
panel.add(scrollPane);
// 创建表格列名数组
model = new DefaultTableModel(表格数据, 列名[1]); // 创建表格模型
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i] * 14);
tc.setMaxWidth(列数据宽度[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
按钮宽 = (窗口宽 - 60) / 按钮数;
int 按钮左边距 = 30;
for (int i = 0; i < 100; i++)
s3 = s3 + " ";
JButton 到数据库 = new JButton(按钮集[0]);
到数据库.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat4;
Statement stat3;
try {
if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s2 + " from " + 导入表名;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
记录条数1 = rs1.getRow();
关键字数据1 = new String[记录条数1];
列名1 = s2.split(",");
列数1 = 列名1.length;
for (int k = 0; k < 关键字名.length; k++) {
for (int j = 0; j < 列数1; j++) {
if (关键字名1[k].trim().equals(列名1[j].trim())) {
关键字序号1[k] = j;
break;
}
}
}
表格数据1 = new String[记录条数1][列数1];
rs1.absolute(1);
int c = 0; // 行号
int b = 0; // 列号
s2 = "";
while (c < 记录条数1) {
rs1.absolute(c + 1);
while (b < 列数) {
表格数据1[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
for (int i = 0; i < 记录条数1; i++) {
关键字数据1[i] = "";
for (int k = 0; k < 关键字名.length; k++) {
关键字数据1[i] = 关键字数据1[i]
+ 表格数据1[i][关键字序号1[k]].trim();
}
}
rs1.close(); // 关闭查询结果集
stat4.close();
con1.close();
}
} catch (SQLException e1) {
}
try { // 以下导入
main1.driver1();
con = main1.getConn();
stat4 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
int f0 = 0;
for (int i = 0; i < 记录条数; i++) {
s3 = "";
for (int j = 0; j < 关键字名.length; j++)
s3 = s3 + 表格数据[i][关键字序号[j]].trim();
f0 = 0;
for (int i1 = 0; i1 < 记录条数1; i1++) {
if (关键字数据1[i1].trim().equals(s3.trim()))
f0 = 1;
}
if (f0 == 0) {
s1 = "insert into " + 表名 + " (";
for (int k1 = 0; k1 < 列名[1].length; k1++)
s1 = s1 + 列名[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (表格数据1[i][j] == null)
表格数据1[i][j] = "0";
s1 = s1 + 表格数据1[i][j];
} else {
if (表格数据1[i][j] == null)
表格数据1[i][j] = " ";
s1 = s1 + "'" + 表格数据1[i][j] + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat4.executeUpdate(s1);
} else {
s1 = "update " + 表名 + " set ";
for (int k1 = 0; k1 < 列名[1].length; k1++) {
s1 = s1 + 列名[1][k1] + "=";
if (类型1.lastIndexOf("," + 列数据类型[k1] + ",") >= 0) {
if (表格数据1[i][k1] == null)
表格数据1[i][k1] = "0";
s1 = s1 + 表格数据1[i][k1];
} else {
if (表格数据1[i][k1] == null)
表格数据1[i][k1] = " ";
s1 = s1 + "'" + 表格数据1[i][k1] + "'";
}
if (k1 != 列名[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < 关键字名.length; k++) {
s2 = s2 + 关键字名1[k] + "='" + 表格数据1[i][关键字序号1[k]]
+ "'";
if (k < 关键字名.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat4.executeUpdate(s1);
}
}
stat4.close(); // 关闭连接
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
到数据库.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(到数据库);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 标准格式 = new JButton(按钮集[1]);
标准格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
int k1 = 0, k2 = 0, k5 = 0;
for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
k5 = 0;
for (int j = 0; j < 列数; j++) {
空记录1[j] = tempStr.substring(k1, k1 + 列数据宽度[j]);
k1 = k1 + 列数据宽度[j];
}
s3 = "";
for (int k3 = 0; k3 < 关键字名.length; k3++)
s3 = s3 + 空记录1[关键字序号[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < 记录条数; j1++) {
s2 = "";
for (int k4 = 0; k4 < 关键字名.length; k4++)
s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) { // 添加
s1 = "insert into " + 表名 + " (";
for (int k6 = 0; k6 < 列名[1].length; k6++)
s1 = s1 + 列名[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j];
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j] + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + 表名 + " set ";
for (int k6 = 0; k6 < 列名[1].length; k6++) {
s1 = s1 + 列名[1][k6] + "=";
if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
if (空记录1[k6] == null)
空记录1[k6] = "0";
s1 = s1 + 空记录1[k6];
} else {
if (空记录1[k6] == null)
空记录1[k6] = " ";
s1 = s1 + "'" + 空记录1[k6] + "'";
}
if (k6 != 列名[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < 关键字名.length; k++) {
s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
+ "'";
if (k < 关键字名.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
k1 = 0;
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
标准格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(标准格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 紧缩格式 = new JButton(按钮集[2]);
紧缩格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
int k2 = 0, k5 = 0;
char x6 = '"';
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
k5 = 0;
空记录1 = tempStr.split(",");
for (int j = 0; j < 列数; j++) {
if (空记录1[j].lastIndexOf("" + x6) >= 0)
空记录1[j] = 空记录1[j].substring(1,
空记录1[j].length() - 1);
}
s3 = "";
for (int k3 = 0; k3 < 关键字名.length; k3++)
s3 = s3 + 空记录1[关键字序号[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < 记录条数; j1++) {
s2 = "";
for (int k4 = 0; k4 < 关键字名.length; k4++)
s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + 表名 + " (";
for (int k6 = 0; k6 < 列名[1].length; k6++)
s1 = s1 + 列名[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j];
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j] + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + 表名 + " set ";
for (int k6 = 0; k6 < 列名[1].length; k6++) {
s1 = s1 + 列名[1][k6] + "=";
if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
if (空记录1[k6] == null)
空记录1[k6] = "0";
s1 = s1 + 空记录1[k6];
} else {
if (空记录1[k6] == null)
空记录1[k6] = " ";
s1 = s1 + "'" + 空记录1[k6] + "'";
}
if (k6 != 列名[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < 关键字名.length; k++) {
s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
+ "'";
if (k < 关键字名.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0)) {
紧缩格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(紧缩格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 自定义格式 = new JButton(按钮集[3]);
自定义格式.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(导入文件名);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] 空记录1 = new String[列数];
int k2 = 0, k5 = 0;
String s5 = "";
String x6 = "", x7 = null;
char x1 = 13;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
k5 = 0;
x6 = tempStr;
while (x6.indexOf("】【") < 0) {
if ((tempStr = br.readLine()) != null) {
x6 = x6 + x1 + tempStr;
i++;
}
}
x6 = x6.substring(0, x6.length() - 2);
空记录1 = x6.split(x5);
s3 = "";
for (int k3 = 0; k3 < 关键字名.length; k3++)
s3 = s3 + 空记录1[关键字序号[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < 记录条数; j1++) {
s2 = "";
for (int k4 = 0; k4 < 关键字名.length; k4++)
s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + 表名 + " (";
for (int k6 = 0; k6 < 列名[1].length; k6++)
s1 = s1 + 列名[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j];
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j] + "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + 表名 + " set ";
for (int k6 = 0; k6 < 列名[1].length; k6++) {
s1 = s1 + 列名[1][k6] + "=";
if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
if (空记录1[k6] == null)
空记录1[k6] = "0";
s1 = s1 + 空记录1[k6];
} else {
if (空记录1[k6] == null)
空记录1[k6] = " ";
s1 = s1 + "'" + 空记录1[k6] + "'";
}
if (k6 != 列名[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < 关键字名.length; k++) {
s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
+ "'";
if (k < 关键字名.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0)) {
自定义格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(自定义格式);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 到XML文件 = new JButton(按钮集[4]);
到XML文件.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(导入文件名));
Element elmtInfo = doc.getDocumentElement();
NodeList nodes = elmtInfo.getChildNodes();
String[] 列名0 = new String[列数];
String[] 空记录 = new String[列数];
String[] 空记录1 = new String[列数];
int k = 0, k1 = 0, k2 = 0, k5 = 0;
for (int i = 0; i < nodes.getLength(); i++) {
k5 = 0;
NodeList ns = nodes.item(i).getChildNodes();
k = 0;
for (int j2 = 0; j2 < 列数; j2++)
空记录1[j2] = "";
k1 = 0;
for (int j = 0; j < ns.getLength(); j++) {
Node record = ns.item(j);
if (record.toString().lastIndexOf("null") > 0) {
列名0[k] = ns
.item(j)
.toString()
.substring(
1,
record.toString().lastIndexOf(
":"));
空记录[k] = record.getTextContent();
for (int j2 = 0; j2 < 列数; j2++) {
if (列名[1][j2].lastIndexOf(列名0[k]) >= 0) {
空记录1[j2] = 空记录[k];
break;
}
}
k++;
k1 = 1;
}
}
if (k1 > 0) {
s3 = "";
for (int k3 = 0; k3 < 关键字名.length; k3++)
s3 = s3 + 空记录1[关键字序号[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < 记录条数; j1++) {
s2 = "";
for (int k4 = 0; k4 < 关键字名.length; k4++)
s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + 表名 + " (";
for (int k6 = 0; k6 < 列名[1].length; k6++)
s1 = s1 + 列名[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < 列名[1].length; j++) {
if (类型1.lastIndexOf("," + 列数据类型[j]
+ ",") >= 0) {
if (空记录1[j] == null)
空记录1[j] = "0";
s1 = s1 + 空记录1[j].trim();
} else {
if (空记录1[j] == null)
空记录1[j] = " ";
s1 = s1 + "'" + 空记录1[j].trim()
+ "'";
}
if (j != 列名[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + 表名 + " set ";
for (int k6 = 0; k6 < 列名[1].length; k6++) {
s1 = s1 + 列名[1][k6] + "=";
if (类型1.lastIndexOf("," + 列数据类型[k6]
+ ",") >= 0) {
if (空记录1[k6] == null)
空记录1[k6] = "0";
s1 = s1 + 空记录1[k6].trim();
} else {
if (空记录1[k6] == null)
空记录1[k6] = " ";
s1 = s1 + "'" + 空记录1[k6].trim()
+ "'";
}
if (k6 != 列名[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k7 = 0; k7 < 关键字名.length; k7++) {
s2 = s2 + 关键字名1[k7] + "='"
+ 空记录1[关键字序号1[k7]].trim() + "'";
if (k7 < 关键字名.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {
到XML文件.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(到XML文件);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton exitButton = new JButton(按钮集[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 0)) {
exitButton.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
panel.add(exitButton);
按钮左边距 = 按钮左边距 + 按钮宽;
}
main1.driver1();
frame.add(panel);
frame.setVisible(true); // 显示窗体
}
}
50.源码50,部件程序,覆盖式从office文件,包括word、excel、pdf文件导入数据导入部件。
/**
* 程序文件名:dataTransfer10.java
* 作者:程学先
* 功能:覆盖式从office文件,包括word、excel、pdf文件导入。
* 原目的表内容将删除。
* 目的表与源表数据类型、数据宽度应当对应相容。
* 完成日期:2013年1月22日
* 被调用语句:dataTransfer10.means(parameter)
* 必须提供的参数:数据“表名”、“导入文件名”。
* 可选择参数:“字段号表”、“要求按钮号表”、
* 要求字段号表:所操作数据可以是表的全部字段,也可以只涉及部分字段。如果选择全部字段,初始值设为"";
* 否则写入所有将涉及的字段在表中的顺序号,号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个,序号及按钮名:1覆盖式从word文件导入、2覆盖式从excel文件导入、
* 3覆盖式从PDF文件导入、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导入到Office文件要求下载以下文件并设置构建路径:
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果从PDF文件导入。不支持大数据类型,每字段宽度不超过50字符。只能从由dataTransfer4.java生成的PDF文件导入。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
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.hwpf.extractor.WordExtractor;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
public class dataTransfer10 extends JFrame {
static dataTransfer10 frame = new dataTransfer10(); // 创建窗体
private static JTable table; //创建表格
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs; //数据库数据集,存放查询的结果
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
static int 列数; //数据表列数
static int 列数1;
static String [][] 列名; //数据表列名
static String [] 列名1;
static int[] 对应目的表序号; //存放当前记录各字段数据宽度的数组
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
static int[] 表列数据宽度,表列小数位数;
static int 当前记录号;
static String[][] 表格数据;
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
public static String [] sw=new String[11];
static String s1="",s2="",s3="";
static String s4=" ";
static char x1=10,x2=13,x3='"',x4=',';
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame = new dataTransfer10();
窗口宽=800;窗口高=600;
记录条数=0;记录条数1=0;
s1="";s2="";s3="";
s4=" ";
x1=10;x2=13;x3='"';x4=',';
类型1=main1.类型1;
File file = new File(".\\com\\iText-5.0.5.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\jacob.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\poi-3.8-20120326.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
file = new File(".\\com\\PDFBox-0.7.3.jar");
if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中!"); return;}
sw=new String [11];
sw[1]=main1.sw1+"";sw[2]=main1.sw2;sw[3]=main1.sw3; //为了不出现0影响判断,在树程序中将工序号统加1
sw[4]=main1.sw4;sw[5]=main1.sw5;sw[6]=main1.sw6;
sw[7]=main1.sw7;sw[8]=main1.sw8;sw[9]=main1.sw9;
sw[10]=main1.sw10;
main1.sw1=0;main1.sw2="";main1.sw3="";
main1.sw4="";main1.sw5="";main1.sw6="";
main1.sw7="";main1.sw8="";main1.sw9="";main1.sw10="";
表名=parameter[4] ; // 数据表名
字段号表=parameter[8];
导入文件名=parameter[18];
String [] 按钮集01={"从word导入","从excel导入","从PDF文件导入","退出"};
按钮集=new String[按钮集01.length];
按钮数=0;
for (int i0=0;i0<按钮集01.length;i0++)
按钮集[i0]= 按钮集01[i0];
if (parameter[11].length()>0){
要求按钮号表=parameter[11] ;// 需要显示的按钮的顺序号
//将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表=要求按钮号表.replaceAll(";",";");
要求按钮号表=要求按钮号表.replaceAll("。",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
要求按钮号表=要求按钮号表.replaceAll(":",";");
if (要求按钮号表.indexOf(";")>0){ //如果有按钮更名要求
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (s601[i01].indexOf(";")>0){
String s602[]=s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))]=s602[1];
要求按钮号表=要求按钮号表+","+s602[0];//只留号,去更名
按钮数++;
}
else {
要求按钮号表=要求按钮号表+","+s601[i01];//只留号,原无更名
按钮数++;
}
}
} //如果没有按钮更名要求,要求按钮号长度又大于0,保持原有摸样
else {
String s601[]=要求按钮号表.split(",");
要求按钮号表="";
for (int i01=0;i01<s601.length;i01++){
if (i01==0) 要求按钮号表=s601[i01];
else 要求按钮号表=要求按钮号表+","+s601[i01];
按钮数++;
}
}
}
else {
要求按钮号表=""; //没输入要求按钮号,定全部按钮号
for (int i1=0;i1<按钮集.length;i1++){
if (i1==0) 要求按钮号表=要求按钮号表+i1;
else 要求按钮号表=要求按钮号表+","+i1;
按钮数++;
}
}
要求按钮号表=","+要求按钮号表+",";
窗口宽=main1.窗口宽; 窗口高=main1.窗口高;
int m1,m2;
try{
if (parameter[17].length()==0) {
m1=0;m2=0;
}
else {
m1=Integer.parseInt(parameter[17]) ;//宽度参数
m2=Integer.parseInt(parameter[18]) ;
}
if (m1>0){
if (m2<80){
m1=m1*10;
m2=m2*10;
}
窗口宽=m1 ;
窗口高=m2 ;
}
}catch(Exception e2){}
String 字段名表=parameter[19].trim();
if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equals(",")))
字段名表=字段名表.substring(0,字段名表.length()-1);
String 表名表=parameter[0];
String [] l3=字段名表.split(",");
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
String[] l1;
if (字段号表.length()>0){
l1=字段号表.split(",");
int [] l2=new int[l1.length];
for (int i=0;i<l1.length;i++){
l2[i]=Integer.valueOf(l1[i]);
}
列数=l1.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[l2[i]];
列名[1][i]=列名[0][i];
}
}
else {
列数=l3.length;
列名=new String[2][列数];
for (int i=0;i<列数;i++){
列名[0][i]=l3[i];
列名[1][i]=列名[0][i];
}
}
s1="";
for (int i=0;i<列数;i++)
s1=s1+列名[0][i]+",";
s1=s1.substring(0,s1.length()-1);
try {
if ((","+表名表).lastIndexOf(","+表名+",")>=0){
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+s1+" from "+表名;
if ((sw[3].length()>0)&&(sw[4].length()>0))
s1=s1+" where "+sw[4]+" = '"+sw[5]+"'";
}
else {
JOptionPane.showMessageDialog( null, "目的数据表不存在,不能导入!");
return;
}
ResultSet rs=sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
for (int i=0;i<列数;i++) {
列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i]=列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i]<列名[0][i].length()) 列数据宽度[i]=列名[0][i].length();
if (列数据宽度[i]<列名[1][i].length()) 列数据宽度[i]=列名[1][i].length();
if (列数据宽度[i]>50) 列数据宽度[i]=50;
}
表格列名=new String[列数];
表列数据类型=new String[列数];
表列数据宽度=new int[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
表列数据宽度[b]=列数据宽度[b];
}
记录条数=0;
rs.last();
记录条数=rs.getRow();
表格数据=new String[记录条数][列数];
rs.absolute(1);
c=0; //行号
b=0; //列号
while(c<记录条数) {
rs.absolute(c+1);
while(b<列数){
表格数据[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close(); //关闭查询结果集
sta4.close(); //关闭连接
con1.close();
}
catch(SQLException e)
{
JOptionPane.showMessageDialog( null, "读取数据出错!");
}
if (字典表名.length()>0){
try
{
con1=main1.getConn();// 连接数据库
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta4.executeQuery(s1);
String s4="";
String s5="";
b=1;
while (rs.absolute(b)) {
b++;
s4=rs.getString(1); //字段名
s5=rs.getString(2);
for (int j=0;j<列数;j++){
if (列名[0][j].trim().equals(s4.trim())){
列名[1][j]=s5;
表格列名[j]=s5;
break;
}
}
}
rs.close(); //关闭查询结果集
con1.close();
sta4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!");
}
}
frame.setTitle("数据覆盖式从office文件导入部件。 作者:程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(10, 10,窗口宽,窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
scrollPane.setBounds(0,0,窗口宽-20,窗口高-100); //定义滚动面板大小位置
panel.add(scrollPane);
model = new DefaultTableModel(表格数据,列名[1]); // 创建表格模型
table = new JTable(model);// 创建指定表格模型的表格
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for(int i=0;i<列数;i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i]*14);
tc.setMaxWidth(列数据宽度[i]*14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
按钮宽=(窗口宽-60)/按钮数;
int 按钮左边距=30;
JButton 从word = new JButton(按钮集[0]);
从word.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int k0=model.getRowCount();
for (int i1=0;i1<k0;i1++){
model.removeRow(0);
}
当前记录号= model.getRowCount();
if (导入文件名.length()==0){
导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径 例如:F:\\java.doc","");
return;
}
int p1=0,p2=0;
if (导入文件名.lastIndexOf(".doc")<0){
p1=导入文件名.lastIndexOf(".");
p2=导入文件名.lastIndexOf("\\\\");
if (p2>p1){
导入文件名=导入文件名+".doc";
导入文件名=导入文件名.replace("\\.","\\.\\.");
}
else {
导入文件名=导入文件名.substring(0,p1)+".doc";
}
}
try {
FileInputStream in=new FileInputStream(new File(导入文件名));
WordExtractor extractor=null;
extractor=new WordExtractor(in);
String 内容=extractor.getText();
int m1=0;;
String[] 记录=new String[列数];
int k=0;
int k2=0,k5=0;
记录[k]="";
for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){
k5=0;
model.addRow(记录); 记录条数++;
记录[0]="";
k=0;
m1=1;
if ((i<内容.length()-2)&&(内容.charAt(i+2)=='\r')) break;
}
else if (内容.charAt(i)=='\n'){}
else if ((byte)(内容.charAt(i))==9){
k++;
m1=0;
if (k<列数) 记录[k]="";
}
else if (k<列数){
记录[k]=记录[k]+内容.charAt(i);
}
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
try {
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="delete from "+表名;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
}catch(SQLException e1){
}
try{
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i=0;i<model.getRowCount();i++){
s1="insert into "+表名+" (";
for (int k1=0;k1<列名[1].length;k1++)
s1=s1+列名[1][k1]+",";
s1=s1.substring(0,s1.length()-1)+" ) values (";
for (int j=0;j<列名[1].length;j++){
if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
if (model.getValueAt(i,j)==null) s1=s1+"0";
else s1=s1+model.getValueAt(i,j).toString().trim();
}
else{
if (model.getValueAt(i,j)==null) s1=s1+" ";
else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
}
if (j!=列名[1].length-1) s1=s1+",";
}
s1=s1+")";
sta4.executeUpdate(s1);
}
sta4.close(); //关闭连接
con1.close();
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错,请检查数据表名是否重复,录入语句是否正确!"+s1);
}
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){
从word.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(从word);
按钮左边距=按钮左边距+按钮宽;
}
JButton 从excel = new JButton(按钮集[1]);
从excel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int k0=model.getRowCount();
for (int i1=0;i1<k0;i1++){
model.removeRow(0);
}
当前记录号= model.getRowCount();
当前记录号= model.getRowCount();
if (导入文件名.length()==0){
导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径 例如:F:\\java.xls","");
return;
}
int p1=0,p2=0;
if (导入文件名.lastIndexOf(".xls")<0){
p1=导入文件名.lastIndexOf(".");
p2=导入文件名.lastIndexOf("\\\\");
if (p2>p1){
导入文件名=导入文件名+".xls";
导入文件名=导入文件名.replace("\\.","\\.\\.");
}
else {
导入文件名=导入文件名.substring(0,p1)+".xls";
}
}
InputStream is = null;
HSSFWorkbook wbWorkbook = null;
try {
is = new FileInputStream(导入文件名);
wbWorkbook = new HSSFWorkbook(is);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败,请检查路径是否正确!", "错误",
JOptionPane.INFORMATION_MESSAGE);
} catch (IOException e2) {
e2.printStackTrace();
}
HSSFSheet sheet = wbWorkbook.getSheetAt(0);
int lastRowNum = sheet.getLastRowNum();
int 导入表格行数 = sheet.getPhysicalNumberOfRows();
HSSFRow row = sheet.getRow(1);
int 导入表格列数=row.getPhysicalNumberOfCells();
if (导入表格列数!=列数)
JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同!");
String[] val;
int k2=0,k5=0;
String value = "";
for (int i = 0; i < 导入表格行数; i++) {
row = sheet.getRow(i);
if (row != null) {
for (int j = 0; j < 导入表格列数; j++) {
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()){
case HSSFCell.CELL_TYPE_FORMULA:
break;
case HSSFCell.CELL_TYPE_NUMERIC:
value += cell.getNumericCellValue() + ",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += "0";
break;
}
}
}
val = value.split(",");
k5=0;
model.addRow(val);
value = "";
}
}
try {
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="delete from "+表名;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
}catch(SQLException e1){
}
try{
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i=当前记录号;i<model.getRowCount();i++){
s1="insert into "+表名+" (";
for (int k1=0;k1<列名[1].length;k1++)
s1=s1+列名[1][k1]+",";
s1=s1.substring(0,s1.length()-1)+" ) values (";
for (int j=0;j<列名[1].length;j++){
if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
if (model.getValueAt(i,j)==null) s1=s1+"0";
else s1=s1+model.getValueAt(i,j).toString().trim();
}
else{
if (model.getValueAt(i,j)==null) s1=s1+"' '";
else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
}
if (j!=列名[1].length-1) s1=s1+",";
}
s1=s1+")";
sta4.executeUpdate(s1);
}
sta4.close(); //关闭连接
con1.close();
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错,请检查数据表名是否重复,录入语句是否正确!"+s1);
}
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){
从excel.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(从excel);
按钮左边距=按钮左边距+按钮宽;
}
JButton 从pdf = new JButton(按钮集[2]);
从pdf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int k0=model.getRowCount();
for (int i1=0;i1<k0;i1++){
model.removeRow(0);
}
当前记录号= model.getRowCount();
if (导入文件名.length()==0){
导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径 例如:F:\\java.pdf","");
return;
}
int p1=0,p2=0;
if (导入文件名.lastIndexOf(".pdf")<0){
p1=导入文件名.lastIndexOf(".");
p2=导入文件名.lastIndexOf("\\\\");
if (p2>p1){
导入文件名=导入文件名+".pdf";
导入文件名=导入文件名.replace("\\.","\\.\\.");
}
else {
导入文件名=导入文件名.substring(0,p1)+".pdf";
}
}
try {
FileInputStream in = new FileInputStream(导入文件名);
PDFParser parser = new PDFParser(in);
parser.parse();
PDDocument pdfdocument = parser.getPDDocument();
PDFTextStripper stripper = new PDFTextStripper();
s1 = stripper.getText(pdfdocument);
in.close();
} catch (Exception e1) {
e1.printStackTrace();
}
String[] 记录=new String[列数];
String s4="";
int k=0,m1=0,k2=0,k5=0;
记录[0]="";
int l1=s1.length();
for (int i1=0;i1<l1;i1++){
s2=s1.substring(i1,i1+1);
if (s1.charAt(i1)=='\r') {}
else if (s1.charAt(i1)=='\n') {}
else if ((s2.trim().equals("│"))&&(m1==1)) {
if (k==列数-1) {
k5=0;
model.addRow(记录);
k=0;
m1=0;
记录[k]="";
}
else {
k++;
if (k<列数) 记录[k]="";
}
}
else if (s2.trim().equals("│")) {
m1=1;
k=0;
记录[0]="";
}
else if ((k<列数)&&(m1==1)){
try{
记录[k]=记录[k]+s2;
} catch (Exception e1) {
}
}
}
try {
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="delete from "+表名;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
}catch(SQLException e1){
}
try{
main1.driver1();
con1=main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i=当前记录号;i<model.getRowCount();i++){
s1="insert into "+表名+" (";
for (int k1=0;k1<列名[1].length;k1++)
s1=s1+列名[1][k1]+",";
s1=s1.substring(0,s1.length()-1)+" ) values (";
for (int j=0;j<列名[1].length;j++){
if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
if (model.getValueAt(i,j)==null) s1=s1+"0";
else s1=s1+model.getValueAt(i,j).toString().trim();
}
else{
if (model.getValueAt(i,j)==null) s1=s1+" ";
else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
}
if (j!=列名[1].length-1) s1=s1+",";
}
s1=s1+")";
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错,请检查数据表名是否重复,录入语句是否正确!"+s1);
}
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){
从pdf.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(从pdf);
按钮左边距=按钮左边距+按钮宽;
}
JButton exitButton = new JButton(按钮集[3]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ((sw[2].length()>0)&&(sw[3].length()>0)&&(sw[4].length()>0))
WorkflowDrivek1.means(sw);
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){
exitButton.setBounds(按钮左边距,窗口高-80,按钮宽,20);
panel.add(exitButton);
按钮左边距=按钮左边距+按钮宽;
}
frame.add(panel);
frame.setVisible(true); // 显示窗体
}
}
版本2
46.源码46,部件程序,修改式导出到office文件,包括word、excel、pdf文件数据导出部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.poi.hssf.usermodel.HSSFCell;
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.hwpf.extractor.WordExtractor;
import org.apache.poi.ss.usermodel.Sheet;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
/**
* 程序文件名:dataTransfer6.java 作者:程学先 功能:修改式导出到office文件,包括word、excel、pdf文件。
* 原目的文件内容保留,当前表数据导出到指定文件中,如果关键字值和已有数据相同则更改已有数据 否则添加到原文件尾部,如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容,符合本程序中“类型对照表"设置的对应关系。 完成日期:2013年1月22日
*/
public class dataTransfer6 extends JFrame {
static dataTransfer6 frame = new dataTransfer6();
private static JTable table;
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1679, variabl1463;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1735;
static String variabl2253;
static String[] variabl2053, variabl20531;
static int[] variabl1287, variabl12871;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static String[] variabl25170;
private static String variabl2309 = "";
private static int variabl26510;
private static String variabl2049;
static String s1 = "", s2 = "", s3 = "";
static String s4 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
{ "java", "string", "string", "string", "int", "int", "string",
"string", "string", "string", "boolean", "byte", "short",
"long", "float", "int", "double", "float", "float",
"byte[]" },
{ "sqlserver", "char", "nchar", "nvarchar", "int", "float",
"datetime", "datetime", "text", "ntext", "bit", "tinyint",
"smallint", "bigint", "numeric", "integer", "double",
"money", "real", "image" },
{ "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
"i", "i", "n", "i", "n", "b", "y", "g" },
{ "access", "text", "text", "text", "integer", "integer", "date",
"date", "memo", "memo", "logical", "integer", "integer",
"integer", "float", "integer", "float", "float", "float",
"general" },
{ "oracle", "char", "char", "char", "number", "number", "date",
"date", "long", "long", "char", "raw", "number", "number",
"number", "number", "number", "number", "number", "blob" },
{ "mysql", "char", "char", "varchar", "int", "float", "date",
"datetime", "text", "text", "tinyint", "tinyint",
"smallint", "bigint", "float", "integer", "double",
"float", "float", "blob" } };
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataTransfer6();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
variabl1601[0][0] = "java";
variabl1601[0][1] = "string";
variabl1601[0][2] = "string";
variabl1601[0][3] = "string";
variabl1601[0][4] = "int";
variabl1601[0][5] = "int";
variabl1601[0][6] = "string";
variabl1601[0][7] = "string";
variabl1601[0][8] = "string";
variabl1601[0][9] = "string";
variabl1601[0][10] = "boolean";
variabl1601[0][11] = "byte";
variabl1601[0][12] = "short";
variabl1601[0][13] = "long";
variabl1601[0][14] = "float";
variabl1601[0][15] = "int";
variabl1601[0][16] = "double";
variabl1601[0][17] = "float";
variabl1601[0][18] = "float";
variabl1601[0][19] = "byte[]";
variabl1601[1][0] = "sqlserver";
variabl1601[1][1] = "char";
variabl1601[1][2] = "nchar";
variabl1601[1][3] = "nvarchar";
variabl1601[1][4] = "int";
variabl1601[1][5] = "float";
variabl1601[1][6] = "datetime";
variabl1601[1][7] = "datetime";
variabl1601[1][8] = "text";
variabl1601[1][9] = "ntext";
variabl1601[1][10] = "bit";
variabl1601[1][11] = "tinyint";
variabl1601[1][12] = "smallint";
variabl1601[1][13] = "bigint";
variabl1601[1][14] = "numeric";
variabl1601[1][15] = "integer";
variabl1601[1][16] = "double";
variabl1601[1][17] = "money";
variabl1601[1][18] = "real";
variabl1601[1][19] = "image";
variabl1601[2][0] = "vfp";
variabl1601[2][1] = "c";
variabl1601[2][2] = "c";
variabl1601[2][3] = "c";
variabl1601[2][4] = "i";
variabl1601[2][5] = "n";
variabl1601[2][6] = "d";
variabl1601[2][7] = "t";
variabl1601[2][8] = "m";
variabl1601[2][9] = "m";
variabl1601[2][10] = "l";
variabl1601[2][11] = "i";
variabl1601[2][12] = "i";
variabl1601[2][13] = "i";
variabl1601[2][14] = "n";
variabl1601[2][15] = "i";
variabl1601[2][16] = "n";
variabl1601[2][17] = "b";
variabl1601[2][18] = "y";
variabl1601[2][19] = "g";
variabl1601[3][0] = "access";
variabl1601[3][1] = "text";
variabl1601[3][2] = "text";
variabl1601[3][3] = "text";
variabl1601[3][4] = "integer";
variabl1601[3][5] = "integer";
variabl1601[3][6] = "date";
variabl1601[3][7] = "date";
variabl1601[3][8] = "memo";
variabl1601[3][9] = "memo";
variabl1601[3][10] = "logical";
variabl1601[3][11] = "integer";
variabl1601[3][12] = "integer";
variabl1601[3][13] = "integer";
variabl1601[3][14] = "float";
variabl1601[3][15] = "integer";
variabl1601[3][16] = "float";
variabl1601[3][17] = "float";
variabl1601[3][18] = "float";
variabl1601[3][19] = "general";
variabl1601[4][0] = "oracle";
variabl1601[4][1] = "char";
variabl1601[4][2] = "char";
variabl1601[4][3] = "char";
variabl1601[4][4] = "number";
variabl1601[4][5] = "number";
variabl1601[4][6] = "date";
variabl1601[4][7] = "date";
variabl1601[4][8] = "long";
variabl1601[4][9] = "long";
variabl1601[4][10] = "char";
variabl1601[4][11] = "raw";
variabl1601[4][12] = "number";
variabl1601[4][13] = "number";
variabl1601[4][14] = "number";
variabl1601[4][15] = "number";
variabl1601[4][16] = "number";
variabl1601[4][17] = "number";
variabl1601[4][18] = "number";
variabl1601[4][19] = "blob";
variabl1601[5][0] = "mysql";
variabl1601[5][1] = "char";
variabl1601[5][2] = "char";
variabl1601[5][3] = "varchar";
variabl1601[5][4] = "int";
variabl1601[5][5] = "float";
variabl1601[5][6] = "date";
variabl1601[5][7] = "datetime";
variabl1601[5][8] = "text";
variabl1601[5][9] = "text";
variabl1601[5][10] = "tinyint";
variabl1601[5][11] = "tinyint";
variabl1601[5][12] = "smallint";
variabl1601[5][13] = "bigint";
variabl1601[5][14] = "float";
variabl1601[5][15] = "integer";
variabl1601[5][16] = "double";
variabl1601[5][17] = "float";
variabl1601[5][18] = "float";
variabl1601[5][19] = "blob";
variabl2049 = "";
File file = new File(".\\com\\iText-5.0.5.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\jacob.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\poi-3.8-20120326.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\PDFBox-0.7.3.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1463 = parameter[18];
variabl1679 = parameter[2];
String[] variabl240501 = { "导出到word", "导出到excel", "导出到PDF", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl2253 = parameter[6];
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1).equals(",")))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
String variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
int b = 0, c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++)
s1 = s1 + variabl2517[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + variabl2603;
数据表查询结构002();
if (variabl2049.length() > 0)
s1 = s1 + " where " + variabl2049;
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
}
variabl2053 = variabl2253.split(",");
variabl20531 = new String[variabl2053.length];
variabl1287 = new int[variabl2053.length];
variabl12871 = new int[variabl2053.length];
variabl1913 = new String[variabl2651];
variabl1169 = new String[variabl2651];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
if (variabl1873.length() > 0) {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta4.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1).trim();
s5 = rs.getString(2).trim();
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim()
.equalsIgnoreCase(s4.trim())) {
variabl2517[1][j] = s5;
break;
}
}
}
rs.close();
con1.close();
sta4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
for (int i = 0; i < variabl2651; i++) {
for (int j = 0; j < variabl2053.length; j++)
if (variabl2053[j].trim().equalsIgnoreCase(
variabl2517[0][i].trim())) {
variabl20531[j] = variabl2517[1][i];
variabl1287[j] = i;
}
}
frame.setTitle("数据修改式导出到office文件部件。根据关键字查出关键字相同记录用当前表中数据替代。 作者:程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 14);
tc.setMaxWidth(variabl1489[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 30;
JButton variabl1439 = new JButton(variabl2405[0]);
variabl1439.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl1463.length() == 0) {
variabl1463 = JOptionPane.showInputDialog(
"请输入导出文件完整路径 例如:F:\\java.doc", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1463.lastIndexOf(".doc") < 0) {
p1 = variabl1463.lastIndexOf(".");
p2 = variabl1463.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1463 = variabl1463 + ".doc";
variabl1463 = variabl1463.replace("\\.", "\\.\\.");
} else {
variabl1463 = variabl1463.substring(0, p1) + ".doc";
}
}
try {
FileInputStream in = new FileInputStream(new File(
variabl1463));
WordExtractor extractor = null;
extractor = new WordExtractor(in);
String variabl2581 = extractor.getText();
int m1 = 0;
;
String[] variabl2615 = new String[variabl2651];
int k = 0;
int k2 = 0, k5 = 0;
variabl2615[k] = "";
for (int i = 0; i < variabl2581.length(); i++) {
if (variabl2581.charAt(i) == '\r') {
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl2615[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++) {
s2 = s2
+ model.getValueAt(j1,
variabl1287[k4]).toString()
.trim();
}
if (s3.trim().equalsIgnoreCase(s2.trim())) {
k2 = j1;
k5 = 1;
break;
}
}
if (k5 == 0) {
model.addRow(variabl2615);
variabl1853++;
}
k5 = 0;
variabl2615[0] = "";
k = 0;
m1 = 1;
if ((i < variabl2581.length() - 2)
&& (variabl2581.charAt(i + 2) == '\r'))
break;
} else if (variabl2581.charAt(i) == '\n') {
} else if ((byte) (variabl2581.charAt(i)) == 9) {
k++;
m1 = 0;
if (k < variabl2651)
variabl2615[k] = "";
} else if (k < variabl2651) {
variabl2615[k] = variabl2615[k]
+ variabl2581.charAt(i);
}
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null,
"读取数据出错,可能是原文件中数据结构与数据表不同,不能作修改式导出!");
}
try {
ActiveXComponent word = new ActiveXComponent(
"Word.Application");
Dispatch documents = word.getProperty("Documents")
.toDispatch();
try {
Dispatch doc = Dispatch.call(documents, "Add")
.toDispatch();
Dispatch selection = Dispatch.get(word, "Selection")
.toDispatch();
Dispatch.call(selection, "HomeKey");
Dispatch tables = Dispatch.get(doc, "Tables")
.toDispatch();
Dispatch range = Dispatch.get(selection, "Range")
.toDispatch();
Dispatch newTable = Dispatch.call(tables, "Add", range,
new Variant(variabl1853),
new Variant(variabl2651)).toDispatch();
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
for (int j = 0; j < variabl2651; j++) {
Dispatch table = Dispatch.call(tables, "Item",
new Variant(1)).toDispatch();
Dispatch cell = Dispatch
.call(table, "Cell",
new Variant(i1 + 1),
new Variant(j + 1))
.toDispatch();
Dispatch.call(cell, "Select");
s1 = "" + model.getValueAt(i1, j);
Dispatch.put(selection, "Text", s1);
}
}
Dispatch.call(
(Dispatch) Dispatch.call(word, "WordBasic")
.getDispatch(), "FileSaveAs",
variabl1463);
} catch (Exception e1) {
e1.printStackTrace();
} finally {
Dispatch.call(word, "Quit");
}
} catch (Exception e1) {
e1.printStackTrace();
}
return;
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1439.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1439);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1141 = new JButton(variabl2405[1]);
variabl1141.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl1463.length() == 0) {
variabl1463 = JOptionPane.showInputDialog(
"请输入导出文件完整路径 例如:F:\\java.xls", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1463.lastIndexOf(".xls") < 0) {
p1 = variabl1463.lastIndexOf(".");
p2 = variabl1463.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1463 = variabl1463 + ".xls";
variabl1463 = variabl1463.replace("\\.", "\\.\\.");
} else {
variabl1463 = variabl1463.substring(0, p1) + ".xls";
}
}
InputStream is = null;
HSSFWorkbook wbWorkbook = null;
try {
is = new FileInputStream(variabl1463);
wbWorkbook = new HSSFWorkbook(is);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败,请检查路径是否正确!",
"错误", JOptionPane.INFORMATION_MESSAGE);
} catch (IOException e2) {
e2.printStackTrace();
}
HSSFSheet sheet = wbWorkbook.getSheetAt(0);
int lastRowNum = sheet.getLastRowNum();
int variabl1157 = sheet.getPhysicalNumberOfRows();
HSSFRow row = sheet.getRow(1);
int variabl1185 = row.getPhysicalNumberOfCells();
if (variabl1185 != variabl2651)
JOptionPane.showMessageDialog(null,
"原文件中数据结构与数据表不同,不能作修改式导出!");
String[] val;
int k2 = 0, k5 = 0;
String value = "";
for (int i = 0; i < variabl1157; i++) {
row = sheet.getRow(i);
if (row != null) {
for (int j = 0; j < variabl1185; j++) {
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()) {
case HSSFCell.CELL_TYPE_FORMULA:
break;
case HSSFCell.CELL_TYPE_NUMERIC:
value += cell.getNumericCellValue() + ",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += "0";
break;
}
}
}
val = value.split(",");
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + val[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ model.getValueAt(j1, variabl1287[k4])
.toString().trim();
if (s3.trim().equalsIgnoreCase(s2.trim())) {
k2 = j1;
k5 = 1;
break;
}
}
if (k5 == 0) {
model.addRow(val);
variabl1853++;
}
k5 = 0;
value = "";
}
}
HSSFWorkbook book = new HSSFWorkbook();
sheet = book.createSheet(variabl2603);
HSSFRow header = sheet.createRow(0);
int colCount = variabl2651;
for (int i = 0; i < variabl2651; i++) {
HSSFCell cell = header.createCell(i);
cell.setCellValue(new HSSFRichTextString(variabl1913[i]));
}
for (int j = 0; j < model.getRowCount(); j++) {
row = sheet.createRow(j);
for (int i = 0; i < colCount; i++) {
HSSFCell cell = row.createCell(i);
s1 = "" + model.getValueAt(j, i);
cell.setCellValue(new HSSFRichTextString(s1));
}
}
try {
FileOutputStream fileO = new FileOutputStream(variabl1463);
book.write(fileO);
fileO.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl1141.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1141);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2095 = new JButton(variabl2405[2]);
variabl2095.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl1463.length() == 0) {
variabl1463 = JOptionPane.showInputDialog(
"请输入导出文件完整路径 例如:F:\\java.pdf", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1463.lastIndexOf(".pdf") < 0) {
p1 = variabl1463.lastIndexOf(".");
p2 = variabl1463.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1463 = variabl1463 + ".pdf";
variabl1463 = variabl1463.replace("\\.", "\\.\\.");
} else {
variabl1463 = variabl1463.substring(0, p1) + ".pdf";
}
}
try {
FileInputStream in = new FileInputStream(variabl1463);
PDFParser parser = new PDFParser(in);
parser.parse();
PDDocument pdfdocument = parser.getPDDocument();
PDFTextStripper stripper = new PDFTextStripper();
s1 = stripper.getText(pdfdocument);
in.close();
} catch (Exception e1) {
e1.printStackTrace();
}
String[] variabl2615 = new String[variabl2651];
String s4 = "";
int k = 0, m1 = 0, k2 = 0, k5 = 0;
variabl2615[0] = "";
int l1 = s1.length();
for (int i1 = 0; i1 < l1; i1++) {
s2 = s1.substring(i1, i1 + 1);
if (s1.charAt(i1) == '\r') {
} else if (s1.charAt(i1) == '\n') {
} else if ((s2.trim().equals("│")) && (m1 == 1)) {
if (k == variabl2651 - 1) {
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl2615[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
s4 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s4 = s4
+ model.getValueAt(j1,
variabl1287[k4]).toString()
.trim();
if (s3.trim().equalsIgnoreCase(s4.trim())) {
k2 = j1;
k5 = 1;
break;
}
}
if (k5 == 0) {
model.addRow(variabl2615);
variabl1853++;
}
k5 = 0;
k = 0;
m1 = 0;
variabl2615[k] = "";
} else {
k++;
if (k < variabl2651)
variabl2615[k] = "";
}
} else if (s2.trim().equals("│")) {
m1 = 1;
k = 0;
variabl2615[0] = "";
} else if ((k < variabl2651) && (m1 == 1)) {
try {
variabl2615[k] = variabl2615[k] + s2;
} catch (Exception e1) {
}
}
}
File file = new File(variabl1463);
if (file.exists()) {
file.delete();
}
Document document = new Document();
try {
PdfWriter.getInstance(document, new FileOutputStream(
variabl1463));
document.open();
BaseFont bfComic = BaseFont.createFont(
"c:\\windows\\fonts\\SIMFANG.TTF",
BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
Font font = new Font(bfComic, 9);
s1 = "┌";
for (int j = 0; j < variabl2651; j++) {
for (int k0 = 0; k0 < variabl1489[j]; k0++)
s1 = s1 + "─";
if (j != variabl2651 - 1)
s1 = s1 + "┬";
}
s1 = s1 + "┐";
document.add(new Paragraph(s1, font));
int variabl18532 = model.getRowCount();
s4 = "";
String s5 = "";
float lengtg1 = 0;
for (int i = 0; i < variabl18532; i++) {
s1 = "│";
for (int j = 0; j < variabl2197[0].length; j++) {
if (model.getValueAt(i, j) == null)
s4 = " ";
else
s4 = model.getValueAt(i, j).toString().trim();
s3 = "";
lengtg1 = 0;
for (int j1 = 0; j1 < s4.length(); j1++) {
s5 = s4.substring(j1, j1 + 1);
s1 = s1 + s5;
if (s5.compareTo("z") < 0) {
if (s5.compareTo("0") < 0)
lengtg1 = lengtg1 + 0.51f;
else
lengtg1 = lengtg1 + 0.51f;
} else
lengtg1 = lengtg1 + 1;
}
while (lengtg1 < variabl1489[j]) {
s1 = s1 + " ";
lengtg1 = lengtg1 + 0.51f;
}
s1 = s1 + "│";
lengtg1 = 0;
}
document.add(new Paragraph(s1, font));
if (i < variabl18532 - 1) {
s1 = "├";
for (int j = 0; j < variabl2651; j++) {
for (int k0 = 0; k0 < variabl1489[j]; k0++)
s1 = s1 + "─";
if (j != variabl2651 - 1)
s1 = s1 + "┼";
}
s1 = s1 + "┤";
document.add(new Paragraph(s1, font));
} else {
s1 = "└";
for (int j = 0; j < variabl2651; j++) {
for (int k0 = 0; k0 < variabl1489[j]; k0++)
s1 = s1 + "─";
if (j != variabl2651 - 1)
s1 = s1 + "┴";
}
s1 = s1 + "┘";
document.add(new Paragraph(s1, font));
}
}
} catch (DocumentException de) {
System.err.println(de.getMessage());
} catch (IOException ioe) {
System.err.println(ioe.getMessage());
}
document.close();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl2095.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2095);
variabl1423 = variabl1423 + variabl2339;
}
JButton exitButton = new JButton(variabl2405[3]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
exitButton
.setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
panel.add(exitButton);
variabl1423 = variabl1423 + variabl2339;
}
frame.add(panel);
frame.setVisible(true);
}
static void variabl1005(String variabl1103) {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select * from " + variabl1103;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
variabl26510 = rsmdt4.getColumnCount();
variabl25170 = new String[variabl26510];
for (int i = 0; i < variabl26510; i++) {
variabl25170[i] = rsmdt4.getColumnName(i + 1);
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据表结构出错!");
}
variabl2309 = "";
int b0 = 0;
while (b0 < variabl2517.length) {
if (b0 == 0)
variabl2309 = variabl25170[b0];
else
variabl2309 = variabl2309 + "," + variabl25170[b0];
b0++;
}
}
static void 数据表查询结构002() {
String[] t11 = variabl2603.split(",");
String variabl23090 = "";
variabl2049 = "";
if (t11.length > 1) {
for (int i = 0; i < t11.length; i++) {
variabl1005(t11[i]);
for (int j = 0; j < variabl25170.length; j++)
if (("," + variabl23090 + ",").indexOf(","
+ variabl25170[j] + ",") >= 0) {
if (variabl2049.length() == 0)
variabl2049 = t11[i - 1] + "." + variabl25170[j]
+ "=" + t11[i] + "." + variabl25170[j];
else
variabl2049 = variabl2049 + " and " + t11[i - 1]
+ "." + variabl25170[j] + "=" + t11[i]
+ "." + variabl25170[j];
}
if (variabl23090.length() == 0)
variabl23090 = variabl2309;
else
variabl23090 = variabl23090 + "," + variabl2309;
}
}
}
}
47.源码47,部件程序,从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* 程序文件名:dataTransfer7.java 作者:程学先 功能:从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表。
* 如果从数据表导入,当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容, 符合本程序中“类型对照表"设置的对应关系。
* 完成日期:2013年1月22日 被调用语句:dataTransfer7.means(parameter) 必须提供的参数:目的数据“表名”。
* 应当提供的参数:“导入文件名”、“源表名”。二选一。 可选参数:“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
*/
public class dataTransfer7 extends JFrame {
static dataTransfer7 frame = new dataTransfer7();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
public static String[] sw = new String[11];
static String s1 = "", s2 = "", s3 = "";
static String s6 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
{ "java", "string", "string", "string", "int", "int", "string",
"string", "string", "string", "boolean", "byte", "short",
"long", "float", "int", "double", "float", "float",
"byte[]" },
{ "sqlserver", "char", "nchar", "nvarchar", "int", "float",
"datetime", "datetime", "text", "ntext", "bit", "tinyint",
"smallint", "bigint", "numeric", "integer", "double",
"money", "real", "image" },
{ "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
"i", "i", "n", "i", "n", "b", "y", "g" },
{ "access", "text", "text", "text", "integer", "integer", "date",
"date", "memo", "memo", "logical", "integer", "integer",
"integer", "float", "integer", "float", "float", "float",
"general" },
{ "oracle", "char", "char", "char", "number", "number", "date",
"date", "long", "long", "char", "raw", "number", "number",
"number", "number", "number", "number", "number", "blob" },
{ "mysql", "char", "char", "varchar", "int", "float", "date",
"datetime", "text", "text", "tinyint", "tinyint",
"smallint", "bigint", "float", "integer", "double",
"float", "float", "blob" } };
static String variabl2511 = main1.variabl2511;
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
sw = new String[11];
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3;
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[9] = main1.sw9;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw9 = "";
main1.sw10 = "";
frame = new dataTransfer7();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
s6 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
variabl2511 = main1.variabl2511;
variabl25111 = main1.variabl25111;
variabl1601[0][0] = "java";
variabl1601[0][1] = "string";
variabl1601[0][2] = "string";
variabl1601[0][3] = "string";
variabl1601[0][4] = "int";
variabl1601[0][5] = "int";
variabl1601[0][6] = "string";
variabl1601[0][7] = "string";
variabl1601[0][8] = "string";
variabl1601[0][9] = "string";
variabl1601[0][10] = "boolean";
variabl1601[0][11] = "byte";
variabl1601[0][12] = "short";
variabl1601[0][13] = "long";
variabl1601[0][14] = "float";
variabl1601[0][15] = "int";
variabl1601[0][16] = "double";
variabl1601[0][17] = "float";
variabl1601[0][18] = "float";
variabl1601[0][19] = "byte[]";
variabl1601[1][0] = "sqlserver";
variabl1601[1][1] = "char";
variabl1601[1][2] = "nchar";
variabl1601[1][3] = "nvarchar";
variabl1601[1][4] = "int";
variabl1601[1][5] = "float";
variabl1601[1][6] = "datetime";
variabl1601[1][7] = "datetime";
variabl1601[1][8] = "text";
variabl1601[1][9] = "ntext";
variabl1601[1][10] = "bit";
variabl1601[1][11] = "tinyint";
variabl1601[1][12] = "smallint";
variabl1601[1][13] = "bigint";
variabl1601[1][14] = "numeric";
variabl1601[1][15] = "integer";
variabl1601[1][16] = "double";
variabl1601[1][17] = "money";
variabl1601[1][18] = "real";
variabl1601[1][19] = "image";
variabl1601[2][0] = "vfp";
variabl1601[2][1] = "c";
variabl1601[2][2] = "c";
variabl1601[2][3] = "c";
variabl1601[2][4] = "i";
variabl1601[2][5] = "n";
variabl1601[2][6] = "d";
variabl1601[2][7] = "t";
variabl1601[2][8] = "m";
variabl1601[2][9] = "m";
variabl1601[2][10] = "l";
variabl1601[2][11] = "i";
variabl1601[2][12] = "i";
variabl1601[2][13] = "i";
variabl1601[2][14] = "n";
variabl1601[2][15] = "i";
variabl1601[2][16] = "n";
variabl1601[2][17] = "b";
variabl1601[2][18] = "y";
variabl1601[2][19] = "g";
variabl1601[3][0] = "access";
variabl1601[3][1] = "text";
variabl1601[3][2] = "text";
variabl1601[3][3] = "text";
variabl1601[3][4] = "integer";
variabl1601[3][5] = "integer";
variabl1601[3][6] = "date";
variabl1601[3][7] = "date";
variabl1601[3][8] = "memo";
variabl1601[3][9] = "memo";
variabl1601[3][10] = "logical";
variabl1601[3][11] = "integer";
variabl1601[3][12] = "integer";
variabl1601[3][13] = "integer";
variabl1601[3][14] = "float";
variabl1601[3][15] = "integer";
variabl1601[3][16] = "float";
variabl1601[3][17] = "float";
variabl1601[3][18] = "float";
variabl1601[3][19] = "general";
variabl1601[4][0] = "oracle";
variabl1601[4][1] = "char";
variabl1601[4][2] = "char";
variabl1601[4][3] = "char";
variabl1601[4][4] = "number";
variabl1601[4][5] = "number";
variabl1601[4][6] = "date";
variabl1601[4][7] = "date";
variabl1601[4][8] = "long";
variabl1601[4][9] = "long";
variabl1601[4][10] = "char";
variabl1601[4][11] = "raw";
variabl1601[4][12] = "number";
variabl1601[4][13] = "number";
variabl1601[4][14] = "number";
variabl1601[4][15] = "number";
variabl1601[4][16] = "number";
variabl1601[4][17] = "number";
variabl1601[4][18] = "number";
variabl1601[4][19] = "blob";
variabl1601[5][0] = "mysql";
variabl1601[5][1] = "char";
variabl1601[5][2] = "char";
variabl1601[5][3] = "varchar";
variabl1601[5][4] = "int";
variabl1601[5][5] = "float";
variabl1601[5][6] = "date";
variabl1601[5][7] = "datetime";
variabl1601[5][8] = "text";
variabl1601[5][9] = "text";
variabl1601[5][10] = "tinyint";
variabl1601[5][11] = "tinyint";
variabl1601[5][12] = "smallint";
variabl1601[5][13] = "bigint";
variabl1601[5][14] = "float";
variabl1601[5][15] = "integer";
variabl1601[5][16] = "double";
variabl1601[5][17] = "float";
variabl1601[5][18] = "float";
variabl1601[5][19] = "blob";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1339 = parameter[18];
variabl1625 = parameter[2];
String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
"从XML文件导入", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl12491 = parameter[1];
variabl10911 = parameter[3];
if ((variabl12491 == null) || (variabl12491.length() == 0))
variabl12491 = main1.variabl1275;
if ((variabl10911 == null) || (variabl10911.length() == 0))
variabl10911 = main1.variabl1091;
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1).equals(",")))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
int b = 0, c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++) {
s1 = s1 + variabl2517[0][i] + ",";
}
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + variabl2603;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
} else {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (variabl1625.length() < 1) {
JOptionPane
.showMessageDialog(null, "源、目的数据表都不存在,必须存在其中一个!");
return;
}
s1 = "select * from " + variabl1625;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
}
if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
&& (variabl12491.trim().length() > 0)) {
int variabl2111 = 0, variabl21111 = 0;
for (int i = 0; i < variabl1601.length; i++) {
if (variabl12491.trim().equals(variabl1601[i][0]))
variabl21111 = i;
if (main1.variabl1275.equals(variabl1601[i][0]))
variabl2111 = i;
}
variabl1913 = new String[variabl2651];
variabl1169 = new String[variabl2651];
variabl1119 = new int[variabl2651];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
variabl1119[b] = variabl1489[b];
for (int i = 1; i < variabl1601[0].length; i++) {
if (variabl1501[b].toLowerCase().trim()
.equals(variabl1601[variabl2111][i].trim())) {
variabl1169[b] = variabl1601[variabl21111][i];
break;
}
}
}
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
if (variabl1873.length() > 0) {
try {
main1.driver1();
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1);
s5 = rs.getString(2);
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equals(s4.trim())) {
variabl2517[1][j] = s5;
variabl1913[j] = s5;
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
s2 = "";
for (int i = 0; i < variabl2651; i++) {
s2 = s2 + variabl2517[1][i] + ",";
}
s2 = s2.substring(0, s2.length() - 1);
frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。 作者:程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 14);
tc.setMaxWidth(variabl1489[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 30;
for (int i = 0; i < 100; i++)
s3 = s3 + " ";
JButton variabl1933 = new JButton(variabl2405[0]);
variabl1933.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat4;
Statement stat3;
try {
if (("," + variabl2429)
.lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s2 + " from " + variabl1625;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
variabl18531 = rs1.getRow();
variabl25171 = s2.split(",");
variabl26511 = variabl25171.length;
variabl21971 = new String[variabl18531][variabl26511];
rs1.absolute(1);
int c = 0;
int b = 0;
while (c < variabl18531) {
rs1.absolute(c + 1);
while (b < variabl2651) {
variabl21971[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
stat4.close();
con1.close();
}
} catch (SQLException e1) {
}
if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "drop table " + variabl2603;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
}
try {
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "CREATE TABLE " + variabl2603 + " (";
for (int i = 0; i < variabl2517[1].length; i++) {
s1 = s1 + variabl2517[1][i] + " " + variabl1169[i];
if (variabl2511.lastIndexOf("," + variabl1501[i] + ",") < 0)
s1 = s1 + "(" + variabl1489[i] + ")";
if (i != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
if (("," + variabl2429)
.lastIndexOf("," + variabl2603 + ",") < 0) {
variabl18531 = variabl1853;
variabl26511 = variabl2651;
variabl25171 = new String[variabl26511];
variabl21971 = new String[variabl18531][variabl26511];
for (int b = 0; b < variabl26511; b++) {
variabl25171[b] = variabl1913[b];
variabl1489[b] = variabl1119[b];
variabl1501[b] = variabl1169[b];
}
for (int i = 0; i < variabl1853; i++)
for (int j = 0; j < variabl2651; j++) {
variabl21971[i][j] = variabl2197[i][j];
}
}
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < variabl21971.length; i++) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf("," + variabl1501[j]
+ ",") >= 0) {
if (variabl21971[i][j] == null)
variabl21971[i][j] = "0";
s1 = s1 + variabl21971[i][j];
} else {
if (variabl21971[i][j] == null)
variabl21971[i][j] = " ";
s1 = s1 + "'" + variabl21971[i][j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
}
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1933);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2225 = new JButton(variabl2405[1]);
variabl2225.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k1 = 0, k2 = 0, k5 = 0;
for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
for (int j = 0; j < variabl2651; j++) {
variabl23691[j] = tempStr.substring(k1, k1
+ variabl1489[j]);
k1 = k1 + variabl1489[j];
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
k1 = 0;
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2225);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1891 = new JButton(variabl2405[2]);
variabl1891.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
char x6 = '"';
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
variabl23691 = tempStr.split(",");
for (int j = 0; j < variabl2651; j++) {
if (variabl23691[j].lastIndexOf("" + x6) >= 0)
variabl23691[j] = variabl23691[j].substring(1,
variabl23691[j].length() - 1);
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl1891.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1891);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1403 = new JButton(variabl2405[3]);
variabl1403.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
char x1 = 13, x2 = 10;
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
String x6 = "", x7 = null;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
x6 = tempStr;
while (x6.indexOf("】【") < 0) {
if ((tempStr = br.readLine()) != null) {
x6 = x6 + x1 + tempStr;
i++;
}
}
x6 = x6.substring(0, x6.length() - 2);
variabl23691 = x6.split(x5);
x6 = "";
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl1403.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1403);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1163 = new JButton(variabl2405[4]);
variabl1163.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(variabl1339));
Element elmtInfo = doc.getDocumentElement();
NodeList nodes = elmtInfo.getChildNodes();
String[] variabl25170 = new String[variabl2651];
String[] variabl2369 = new String[variabl2651];
String[] variabl23691 = new String[variabl2651];
int k = 0, k1 = 0;
for (int i = 0; i < nodes.getLength(); i++) {
NodeList ns = nodes.item(i).getChildNodes();
k = 0;
for (int j2 = 0; j2 < variabl2651; j2++)
variabl23691[j2] = "";
k1 = 0;
for (int j = 0; j < ns.getLength(); j++) {
Node record = ns.item(j);
if (record.toString().lastIndexOf("null") > 0) {
variabl25170[k] = ns
.item(j)
.toString()
.substring(
1,
record.toString().lastIndexOf(
":"));
variabl2369[k] = record.getTextContent();
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2517[1][j2]
.lastIndexOf(variabl25170[k]) >= 0) {
variabl23691[j2] = variabl2369[k];
break;
}
}
k++;
k1 = 1;
}
}
if (k1 > 0) {
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl1163.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1163);
variabl1423 = variabl1423 + variabl2339;
}
JButton exitButton = new JButton(variabl2405[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ((sw[2].length() > 0) && (sw[3].length() > 0)
&& (sw[4].length() > 0))
WorkflowDrivek1.means(sw);
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
exitButton
.setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
panel.add(exitButton);
variabl1423 = variabl1423 + variabl2339;
}
main1.driver1();
frame.add(panel);
frame.setVisible(true);
}
}
48.源码48,部件程序,从纯文本文件、XML文件或其他数据表添加式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* 程序文件名:dataTransfer8.java 作者:程学先 功能:从纯文本文件、XML文件或其他数据表添加式导入数据到当前表。
* 原有标数据全部保留,导入数据添加到尾部。 特别注意,本程序未检查实体完整性,需要关注关键字重复记录问题。
* 如果从数据表导入,当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容, 符合本程序中“类型对照表"设置的对应关系。
*/
public class dataTransfer8 extends JFrame {
static dataTransfer8 frame = new dataTransfer8();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static String s1 = "", s2 = "", s3 = "";
static String s6 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
{ "java", "string", "string", "string", "int", "int", "string",
"string", "string", "string", "boolean", "byte", "short",
"long", "float", "int", "double", "float", "float",
"byte[]" },
{ "sqlserver", "char", "nchar", "nvarchar", "int", "float",
"datetime", "datetime", "text", "ntext", "bit", "tinyint",
"smallint", "bigint", "numeric", "integer", "double",
"money", "real", "image" },
{ "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
"i", "i", "n", "i", "n", "b", "y", "g" },
{ "access", "text", "text", "text", "integer", "integer", "date",
"date", "memo", "memo", "logical", "integer", "integer",
"integer", "float", "integer", "float", "float", "float",
"general" },
{ "oracle", "char", "char", "char", "number", "number", "date",
"date", "long", "long", "char", "raw", "number", "number",
"number", "number", "number", "number", "number", "blob" },
{ "mysql", "char", "char", "varchar", "int", "float", "date",
"datetime", "text", "text", "tinyint", "tinyint",
"smallint", "bigint", "float", "integer", "double",
"float", "float", "blob" } };
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataTransfer8();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
s6 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
variabl25111 = main1.variabl25111;
variabl1601[0][0] = "java";
variabl1601[0][1] = "string";
variabl1601[0][2] = "string";
variabl1601[0][3] = "string";
variabl1601[0][4] = "int";
variabl1601[0][5] = "int";
variabl1601[0][6] = "string";
variabl1601[0][7] = "string";
variabl1601[0][8] = "string";
variabl1601[0][9] = "string";
variabl1601[0][10] = "boolean";
variabl1601[0][11] = "byte";
variabl1601[0][12] = "short";
variabl1601[0][13] = "long";
variabl1601[0][14] = "float";
variabl1601[0][15] = "int";
variabl1601[0][16] = "double";
variabl1601[0][17] = "float";
variabl1601[0][18] = "float";
variabl1601[0][19] = "byte[]";
variabl1601[1][0] = "sqlserver";
variabl1601[1][1] = "char";
variabl1601[1][2] = "nchar";
variabl1601[1][3] = "nvarchar";
variabl1601[1][4] = "int";
variabl1601[1][5] = "float";
variabl1601[1][6] = "datetime";
variabl1601[1][7] = "datetime";
variabl1601[1][8] = "text";
variabl1601[1][9] = "ntext";
variabl1601[1][10] = "bit";
variabl1601[1][11] = "tinyint";
variabl1601[1][12] = "smallint";
variabl1601[1][13] = "bigint";
variabl1601[1][14] = "numeric";
variabl1601[1][15] = "integer";
variabl1601[1][16] = "double";
variabl1601[1][17] = "money";
variabl1601[1][18] = "real";
variabl1601[1][19] = "image";
variabl1601[2][0] = "vfp";
variabl1601[2][1] = "c";
variabl1601[2][2] = "c";
variabl1601[2][3] = "c";
variabl1601[2][4] = "i";
variabl1601[2][5] = "n";
variabl1601[2][6] = "d";
variabl1601[2][7] = "t";
variabl1601[2][8] = "m";
variabl1601[2][9] = "m";
variabl1601[2][10] = "l";
variabl1601[2][11] = "i";
variabl1601[2][12] = "i";
variabl1601[2][13] = "i";
variabl1601[2][14] = "n";
variabl1601[2][15] = "i";
variabl1601[2][16] = "n";
variabl1601[2][17] = "b";
variabl1601[2][18] = "y";
variabl1601[2][19] = "g";
variabl1601[3][0] = "access";
variabl1601[3][1] = "text";
variabl1601[3][2] = "text";
variabl1601[3][3] = "text";
variabl1601[3][4] = "integer";
variabl1601[3][5] = "integer";
variabl1601[3][6] = "date";
variabl1601[3][7] = "date";
variabl1601[3][8] = "memo";
variabl1601[3][9] = "memo";
variabl1601[3][10] = "logical";
variabl1601[3][11] = "integer";
variabl1601[3][12] = "integer";
variabl1601[3][13] = "integer";
variabl1601[3][14] = "float";
variabl1601[3][15] = "integer";
variabl1601[3][16] = "float";
variabl1601[3][17] = "float";
variabl1601[3][18] = "float";
variabl1601[3][19] = "general";
variabl1601[4][0] = "oracle";
variabl1601[4][1] = "char";
variabl1601[4][2] = "char";
variabl1601[4][3] = "char";
variabl1601[4][4] = "number";
variabl1601[4][5] = "number";
variabl1601[4][6] = "date";
variabl1601[4][7] = "date";
variabl1601[4][8] = "long";
variabl1601[4][9] = "long";
variabl1601[4][10] = "char";
variabl1601[4][11] = "raw";
variabl1601[4][12] = "number";
variabl1601[4][13] = "number";
variabl1601[4][14] = "number";
variabl1601[4][15] = "number";
variabl1601[4][16] = "number";
variabl1601[4][17] = "number";
variabl1601[4][18] = "number";
variabl1601[4][19] = "blob";
variabl1601[5][0] = "mysql";
variabl1601[5][1] = "char";
variabl1601[5][2] = "char";
variabl1601[5][3] = "varchar";
variabl1601[5][4] = "int";
variabl1601[5][5] = "float";
variabl1601[5][6] = "date";
variabl1601[5][7] = "datetime";
variabl1601[5][8] = "text";
variabl1601[5][9] = "text";
variabl1601[5][10] = "tinyint";
variabl1601[5][11] = "tinyint";
variabl1601[5][12] = "smallint";
variabl1601[5][13] = "bigint";
variabl1601[5][14] = "float";
variabl1601[5][15] = "integer";
variabl1601[5][16] = "double";
variabl1601[5][17] = "float";
variabl1601[5][18] = "float";
variabl1601[5][19] = "blob";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1339 = parameter[18];
variabl1625 = parameter[2];
String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
"从XML文件导入", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl12491 = parameter[1];
variabl10911 = parameter[3];
if ((variabl12491 == null) || (variabl12491.length() == 0))
variabl12491 = main1.variabl1275;
if ((variabl10911 == null) || (variabl10911.length() == 0))
variabl10911 = main1.variabl1091;
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1).equals(",")))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
int b = 0, c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++) {
s1 = s1 + variabl2517[0][i] + ",";
}
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + variabl2603;
} else {
JOptionPane.showMessageDialog(null, "目的数据表不存在,不能导入!");
return;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl1913 = new String[variabl2651];
variabl1119 = new int[variabl2651];
variabl1169 = new String[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
}
if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
&& (variabl12491.trim().length() > 0)) {
int variabl2111 = 0, variabl21111 = 0;
for (int i = 0; i < variabl1601.length; i++) {
if (variabl12491.trim().equals(variabl1601[i][0]))
variabl21111 = i;
if (main1.variabl1275.equals(variabl1601[i][0]))
variabl2111 = i;
}
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
variabl1119[b] = variabl1489[b];
for (int i = 1; i < variabl1601[0].length; i++) {
if (variabl1501[b].toLowerCase().trim()
.equals(variabl1601[variabl2111][i])) {
variabl1169[b] = variabl1601[variabl21111][i];
break;
}
}
}
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
if (variabl1873.length() > 0) {
try {
main1.driver1();
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1);
s5 = rs.getString(2);
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equals(s4.trim())) {
variabl2517[1][j] = s5;
variabl1913[j] = s5;
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
s2 = "";
for (int i = 0; i < variabl2651; i++) {
s2 = s2 + variabl2517[1][i] + ",";
}
s2 = s2.substring(0, s2.length() - 1);
frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者:程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 14);
tc.setMaxWidth(variabl1489[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 30;
for (int i = 0; i < 100; i++)
s3 = s3 + " ";
JButton variabl1933 = new JButton(variabl2405[0]);
variabl1933.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat4;
Statement stat3;
try {
if (("," + variabl2429)
.lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s2 + " from " + variabl1625;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
variabl18531 = rs1.getRow();
variabl25171 = s2.split(",");
variabl26511 = variabl25171.length;
variabl21971 = new String[variabl18531][variabl26511];
rs1.absolute(1);
int c = 0;
int b = 0;
while (c < variabl18531) {
rs1.absolute(c + 1);
while (b < variabl2651) {
variabl21971[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
stat4.close();
con1.close();
}
} catch (SQLException e1) {
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < variabl21971.length; i++) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf("," + variabl1501[j]
+ ",") >= 0) {
if (variabl21971[i][j] == null)
variabl21971[i][j] = "0";
s1 = s1 + variabl21971[i][j];
} else {
if (variabl21971[i][j] == null)
variabl21971[i][j] = " ";
s1 = s1 + "'" + variabl21971[i][j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
}
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1933);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2225 = new JButton(variabl2405[1]);
variabl2225.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k1 = 0, k2 = 0, k5 = 0;
for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
for (int j = 0; j < variabl2651; j++) {
variabl23691[j] = tempStr.substring(k1, k1
+ variabl1489[j]);
k1 = k1 + variabl1489[j];
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
k1 = 0;
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2225);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1891 = new JButton(variabl2405[2]);
variabl1891.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
char x6 = '"';
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
variabl23691 = tempStr.split(",");
for (int j = 0; j < variabl2651; j++) {
if (variabl23691[j].lastIndexOf("" + x6) >= 0)
variabl23691[j] = variabl23691[j].substring(1,
variabl23691[j].length() - 1);
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl1891.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1891);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1403 = new JButton(variabl2405[3]);
variabl1403.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
String x6 = "", x7 = null;
char x1 = 13;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
x6 = tempStr;
while (x6.indexOf("】【") < 0) {
if ((tempStr = br.readLine()) != null) {
x6 = x6 + x1 + tempStr;
i++;
}
}
x6 = x6.substring(0, x6.length() - 2);
variabl23691 = x6.split(x5);
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl1403.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1403);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1163 = new JButton(variabl2405[4]);
variabl1163.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(variabl1339));
Element elmtInfo = doc.getDocumentElement();
NodeList nodes = elmtInfo.getChildNodes();
String[] variabl25170 = new String[variabl2651];
String[] variabl2369 = new String[variabl2651];
String[] variabl23691 = new String[variabl2651];
int k = 0, k1 = 0;
for (int i = 0; i < nodes.getLength(); i++) {
NodeList ns = nodes.item(i).getChildNodes();
k = 0;
for (int j2 = 0; j2 < variabl2651; j2++)
variabl23691[j2] = "";
k1 = 0;
for (int j = 0; j < ns.getLength(); j++) {
Node record = ns.item(j);
if (record.toString().lastIndexOf("null") > 0) {
variabl25170[k] = ns
.item(j)
.toString()
.substring(
1,
record.toString().lastIndexOf(
":"));
variabl2369[k] = record.getTextContent();
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2517[1][j2]
.lastIndexOf(variabl25170[k]) >= 0) {
variabl23691[j2] = variabl2369[k];
break;
}
}
k++;
k1 = 1;
}
}
if (k1 > 0) {
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + " (";
for (int k3 = 0; k3 < variabl2517[1].length; k3++)
s1 = s1 + variabl2517[1][k3] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl1163.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1163);
variabl1423 = variabl1423 + variabl2339;
}
JButton exitButton = new JButton(variabl2405[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
exitButton
.setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
panel.add(exitButton);
variabl1423 = variabl1423 + variabl2339;
}
main1.driver1();
frame.add(panel);
frame.setVisible(true);
}
}
49.源码49,部件程序,从纯文本文件、XML文件或其他数据表修改式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* 程序文件名:dataTransfer9.java 作者:程学先 功能:从纯文本文件、XML文件或其他数据表修改式导入数据到当前表。
* 关键字子相同记录按导入表更新,关键字不在原表中的记录作为新记录添加在尾部。
* 如果目的表已经存在,必须与源表数据类型、数据宽度对应相容,符合本程序中“类型对照表"设置的对应关系。
*/
public class dataTransfer9 extends JFrame {
static dataTransfer9 frame = new dataTransfer9();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static String variabl2253;
static String[] variabl14211;
static String[] variabl2053, variabl20531;
static int[] variabl1287, variabl12871;
static String s1 = "", s2 = "", s3 = "";
static String s6 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
{ "java", "string", "string", "string", "int", "int", "string",
"string", "string", "string", "boolean", "byte", "short",
"long", "float", "int", "double", "float", "float",
"byte[]" },
{ "sqlserver", "char", "nchar", "nvarchar", "int", "float",
"datetime", "datetime", "text", "ntext", "bit", "tinyint",
"smallint", "bigint", "numeric", "integer", "double",
"money", "real", "image" },
{ "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
"i", "i", "n", "i", "n", "b", "y", "g" },
{ "access", "text", "text", "text", "integer", "integer", "date",
"date", "memo", "memo", "logical", "integer", "integer",
"integer", "float", "integer", "float", "float", "float",
"general" },
{ "oracle", "char", "char", "char", "number", "number", "date",
"date", "long", "long", "char", "raw", "number", "number",
"number", "number", "number", "number", "number", "blob" },
{ "mysql", "char", "char", "varchar", "int", "float", "date",
"datetime", "text", "text", "tinyint", "tinyint",
"smallint", "bigint", "float", "integer", "double",
"float", "float", "blob" } };
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataTransfer9();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
s6 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
variabl25111 = main1.variabl25111;
variabl1601[0][0] = "java";
variabl1601[0][1] = "string";
variabl1601[0][2] = "string";
variabl1601[0][3] = "string";
variabl1601[0][4] = "int";
variabl1601[0][5] = "int";
variabl1601[0][6] = "string";
variabl1601[0][7] = "string";
variabl1601[0][8] = "string";
variabl1601[0][9] = "string";
variabl1601[0][10] = "boolean";
variabl1601[0][11] = "byte";
variabl1601[0][12] = "short";
variabl1601[0][13] = "long";
variabl1601[0][14] = "float";
variabl1601[0][15] = "int";
variabl1601[0][16] = "double";
variabl1601[0][17] = "float";
variabl1601[0][18] = "float";
variabl1601[0][19] = "byte[]";
variabl1601[1][0] = "sqlserver";
variabl1601[1][1] = "char";
variabl1601[1][2] = "nchar";
variabl1601[1][3] = "nvarchar";
variabl1601[1][4] = "int";
variabl1601[1][5] = "float";
variabl1601[1][6] = "datetime";
variabl1601[1][7] = "datetime";
variabl1601[1][8] = "text";
variabl1601[1][9] = "ntext";
variabl1601[1][10] = "bit";
variabl1601[1][11] = "tinyint";
variabl1601[1][12] = "smallint";
variabl1601[1][13] = "bigint";
variabl1601[1][14] = "numeric";
variabl1601[1][15] = "integer";
variabl1601[1][16] = "double";
variabl1601[1][17] = "money";
variabl1601[1][18] = "real";
variabl1601[1][19] = "image";
variabl1601[2][0] = "vfp";
variabl1601[2][1] = "c";
variabl1601[2][2] = "c";
variabl1601[2][3] = "c";
variabl1601[2][4] = "i";
variabl1601[2][5] = "n";
variabl1601[2][6] = "d";
variabl1601[2][7] = "t";
variabl1601[2][8] = "m";
variabl1601[2][9] = "m";
variabl1601[2][10] = "l";
variabl1601[2][11] = "i";
variabl1601[2][12] = "i";
variabl1601[2][13] = "i";
variabl1601[2][14] = "n";
variabl1601[2][15] = "i";
variabl1601[2][16] = "n";
variabl1601[2][17] = "b";
variabl1601[2][18] = "y";
variabl1601[2][19] = "g";
variabl1601[3][0] = "access";
variabl1601[3][1] = "text";
variabl1601[3][2] = "text";
variabl1601[3][3] = "text";
variabl1601[3][4] = "integer";
variabl1601[3][5] = "integer";
variabl1601[3][6] = "date";
variabl1601[3][7] = "date";
variabl1601[3][8] = "memo";
variabl1601[3][9] = "memo";
variabl1601[3][10] = "logical";
variabl1601[3][11] = "integer";
variabl1601[3][12] = "integer";
variabl1601[3][13] = "integer";
variabl1601[3][14] = "float";
variabl1601[3][15] = "integer";
variabl1601[3][16] = "float";
variabl1601[3][17] = "float";
variabl1601[3][18] = "float";
variabl1601[3][19] = "general";
variabl1601[4][0] = "oracle";
variabl1601[4][1] = "char";
variabl1601[4][2] = "char";
variabl1601[4][3] = "char";
variabl1601[4][4] = "number";
variabl1601[4][5] = "number";
variabl1601[4][6] = "date";
variabl1601[4][7] = "date";
variabl1601[4][8] = "long";
variabl1601[4][9] = "long";
variabl1601[4][10] = "char";
variabl1601[4][11] = "raw";
variabl1601[4][12] = "number";
variabl1601[4][13] = "number";
variabl1601[4][14] = "number";
variabl1601[4][15] = "number";
variabl1601[4][16] = "number";
variabl1601[4][17] = "number";
variabl1601[4][18] = "number";
variabl1601[4][19] = "blob";
variabl1601[5][0] = "mysql";
variabl1601[5][1] = "char";
variabl1601[5][2] = "char";
variabl1601[5][3] = "varchar";
variabl1601[5][4] = "int";
variabl1601[5][5] = "float";
variabl1601[5][6] = "date";
variabl1601[5][7] = "datetime";
variabl1601[5][8] = "text";
variabl1601[5][9] = "text";
variabl1601[5][10] = "tinyint";
variabl1601[5][11] = "tinyint";
variabl1601[5][12] = "smallint";
variabl1601[5][13] = "bigint";
variabl1601[5][14] = "float";
variabl1601[5][15] = "integer";
variabl1601[5][16] = "double";
variabl1601[5][17] = "float";
variabl1601[5][18] = "float";
variabl1601[5][19] = "blob";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1339 = parameter[18];
variabl1625 = parameter[2];
String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
"从XML文件导入", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl12491 = parameter[1];
variabl10911 = parameter[3];
if ((variabl12491 == null) || (variabl12491.length() == 0))
variabl12491 = main1.variabl1275;
if ((variabl10911 == null) || (variabl10911.length() == 0))
variabl10911 = main1.variabl1091;
variabl2253 = parameter[6];
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1).equals(",")))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
int b = 0, c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") > 00)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++) {
s1 = s1 + variabl2517[0][i] + ",";
}
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + variabl2603;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
}
variabl2053 = variabl2253.split(",");
variabl20531 = new String[variabl2053.length];
variabl1287 = new int[variabl2053.length];
variabl12871 = new int[variabl2053.length];
if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
&& (variabl12491.trim().length() > 0)) {
int variabl2111 = 0, variabl21111 = 0;
for (int i = 0; i < variabl1601.length; i++) {
if (variabl12491.trim().equals(variabl1601[i][0]))
variabl21111 = i;
if (main1.variabl1275.equals(variabl1601[i][0]))
variabl2111 = i;
}
variabl1913 = new String[variabl2651];
variabl1169 = new String[variabl2651];
variabl1119 = new int[variabl2651];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
variabl1119[b] = variabl1489[b];
for (int i = 1; i < variabl1601[0].length; i++) {
if (variabl1501[b].toLowerCase().trim()
.equals(variabl1601[variabl2111][i])) {
variabl1169[b] = variabl1601[variabl21111][i];
break;
}
}
}
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
for (int i = 0; i < variabl2651; i++) {
for (int j = 0; j < variabl2053.length; j++)
if (variabl2053[j].trim().equals(variabl2517[0][i].trim())) {
variabl20531[j] = variabl2517[1][i];
variabl1287[j] = i;
}
}
if (variabl1873.length() > 0) {
try {
main1.driver1();
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1);
s5 = rs.getString(2);
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equals(s4.trim())) {
variabl2517[1][j] = s5;
variabl1913[j] = s5;
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
s2 = "";
for (int i = 0; i < variabl2651; i++) {
s2 = s2 + variabl2517[1][i] + ",";
}
s2 = s2.substring(0, s2.length() - 1);
frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。 作者:程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 14);
tc.setMaxWidth(variabl1489[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 30;
for (int i = 0; i < 100; i++)
s3 = s3 + " ";
JButton variabl1933 = new JButton(variabl2405[0]);
variabl1933.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat4;
Statement stat3;
try {
if (("," + variabl2429)
.lastIndexOf("," + variabl2603 + ",") >= 0) {
main1.driver1();
con1 = main1.getConn();
stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s2 + " from " + variabl1625;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
variabl18531 = rs1.getRow();
variabl14211 = new String[variabl18531];
variabl25171 = s2.split(",");
variabl26511 = variabl25171.length;
for (int k = 0; k < variabl2053.length; k++) {
for (int j = 0; j < variabl26511; j++) {
if (variabl20531[k].trim().equals(
variabl25171[j].trim())) {
variabl12871[k] = j;
break;
}
}
}
variabl21971 = new String[variabl18531][variabl26511];
rs1.absolute(1);
int c = 0;
int b = 0;
s2 = "";
while (c < variabl18531) {
rs1.absolute(c + 1);
while (b < variabl2651) {
variabl21971[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
for (int i = 0; i < variabl18531; i++) {
variabl14211[i] = "";
for (int k = 0; k < variabl2053.length; k++) {
variabl14211[i] = variabl14211[i]
+ variabl21971[i][variabl12871[k]]
.trim();
}
}
rs1.close();
stat4.close();
con1.close();
}
} catch (SQLException e1) {
}
try {
main1.driver1();
con = main1.getConn();
stat4 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
int f0 = 0;
for (int i = 0; i < variabl1853; i++) {
s3 = "";
for (int j = 0; j < variabl2053.length; j++)
s3 = s3 + variabl2197[i][variabl1287[j]].trim();
f0 = 0;
for (int i1 = 0; i1 < variabl18531; i1++) {
if (variabl14211[i1].trim().equals(s3.trim()))
f0 = 1;
}
if (f0 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl21971[i][j] == null)
variabl21971[i][j] = "0";
s1 = s1 + variabl21971[i][j];
} else {
if (variabl21971[i][j] == null)
variabl21971[i][j] = " ";
s1 = s1 + "'" + variabl21971[i][j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat4.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k1 = 0; k1 < variabl2517[1].length; k1++) {
s1 = s1 + variabl2517[1][k1] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k1] + ",") >= 0) {
if (variabl21971[i][k1] == null)
variabl21971[i][k1] = "0";
s1 = s1 + variabl21971[i][k1];
} else {
if (variabl21971[i][k1] == null)
variabl21971[i][k1] = " ";
s1 = s1 + "'" + variabl21971[i][k1] + "'";
}
if (k1 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl2053.length; k++) {
s2 = s2 + variabl20531[k] + "='"
+ variabl21971[i][variabl12871[k]]
+ "'";
if (k < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat4.executeUpdate(s1);
}
}
stat4.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1933);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2225 = new JButton(variabl2405[1]);
variabl2225.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k1 = 0, k2 = 0, k5 = 0;
for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
k5 = 0;
for (int j = 0; j < variabl2651; j++) {
variabl23691[j] = tempStr.substring(k1, k1
+ variabl1489[j]);
k1 = k1 + variabl1489[j];
}
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl23691[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < variabl1853; j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ variabl2197[j1][variabl1287[k4]]
.trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k6 = 0; k6 < variabl2517[1].length; k6++)
s1 = s1 + variabl2517[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j];
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
s1 = s1 + variabl2517[1][k6] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k6] + ",") >= 0) {
if (variabl23691[k6] == null)
variabl23691[k6] = "0";
s1 = s1 + variabl23691[k6];
} else {
if (variabl23691[k6] == null)
variabl23691[k6] = " ";
s1 = s1 + "'" + variabl23691[k6] + "'";
}
if (k6 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl2053.length; k++) {
s2 = s2 + variabl20531[k] + "='"
+ variabl23691[variabl12871[k]]
+ "'";
if (k < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
k1 = 0;
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2225);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1891 = new JButton(variabl2405[2]);
variabl1891.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k2 = 0, k5 = 0;
char x6 = '"';
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
k5 = 0;
variabl23691 = tempStr.split(",");
for (int j = 0; j < variabl2651; j++) {
if (variabl23691[j].lastIndexOf("" + x6) >= 0)
variabl23691[j] = variabl23691[j].substring(1,
variabl23691[j].length() - 1);
}
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl23691[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < variabl1853; j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ variabl2197[j1][variabl1287[k4]]
.trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k6 = 0; k6 < variabl2517[1].length; k6++)
s1 = s1 + variabl2517[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j];
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
s1 = s1 + variabl2517[1][k6] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k6] + ",") >= 0) {
if (variabl23691[k6] == null)
variabl23691[k6] = "0";
s1 = s1 + variabl23691[k6];
} else {
if (variabl23691[k6] == null)
variabl23691[k6] = " ";
s1 = s1 + "'" + variabl23691[k6] + "'";
}
if (k6 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl2053.length; k++) {
s2 = s2 + variabl20531[k] + "='"
+ variabl23691[variabl12871[k]]
+ "'";
if (k < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl1891.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1891);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1403 = new JButton(variabl2405[3]);
variabl1403.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(variabl1339);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k2 = 0, k5 = 0;
String s5 = "";
String x6 = "", x7 = null;
char x1 = 13;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
k5 = 0;
x6 = tempStr;
while (x6.indexOf("】【") < 0) {
if ((tempStr = br.readLine()) != null) {
x6 = x6 + x1 + tempStr;
i++;
}
}
x6 = x6.substring(0, x6.length() - 2);
variabl23691 = x6.split(x5);
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl23691[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < variabl1853; j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ variabl2197[j1][variabl1287[k4]]
.trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k6 = 0; k6 < variabl2517[1].length; k6++)
s1 = s1 + variabl2517[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j];
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'" + variabl23691[j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
s1 = s1 + variabl2517[1][k6] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k6] + ",") >= 0) {
if (variabl23691[k6] == null)
variabl23691[k6] = "0";
s1 = s1 + variabl23691[k6];
} else {
if (variabl23691[k6] == null)
variabl23691[k6] = " ";
s1 = s1 + "'" + variabl23691[k6] + "'";
}
if (k6 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl2053.length; k++) {
s2 = s2 + variabl20531[k] + "='"
+ variabl23691[variabl12871[k]]
+ "'";
if (k < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl1403.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1403);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1163 = new JButton(variabl2405[4]);
variabl1163.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Statement stat3;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(variabl1339));
Element elmtInfo = doc.getDocumentElement();
NodeList nodes = elmtInfo.getChildNodes();
String[] variabl25170 = new String[variabl2651];
String[] variabl2369 = new String[variabl2651];
String[] variabl23691 = new String[variabl2651];
int k = 0, k1 = 0, k2 = 0, k5 = 0;
for (int i = 0; i < nodes.getLength(); i++) {
k5 = 0;
NodeList ns = nodes.item(i).getChildNodes();
k = 0;
for (int j2 = 0; j2 < variabl2651; j2++)
variabl23691[j2] = "";
k1 = 0;
for (int j = 0; j < ns.getLength(); j++) {
Node record = ns.item(j);
if (record.toString().lastIndexOf("null") > 0) {
variabl25170[k] = ns
.item(j)
.toString()
.substring(
1,
record.toString().lastIndexOf(
":"));
variabl2369[k] = record.getTextContent();
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2517[1][j2]
.lastIndexOf(variabl25170[k]) >= 0) {
variabl23691[j2] = variabl2369[k];
break;
}
}
k++;
k1 = 1;
}
}
if (k1 > 0) {
s3 = "";
for (int k3 = 0; k3 < variabl2053.length; k3++)
s3 = s3 + variabl23691[variabl1287[k3]].trim();
k2 = 0;
for (int j1 = 0; j1 < variabl1853; j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ variabl2197[j1][variabl1287[k4]]
.trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
try {
main1.driver1();
con = main1.getConn();
stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (k5 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k6 = 0; k6 < variabl2517[1].length; k6++)
s1 = s1 + variabl2517[1][k6] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if (variabl23691[j] == null)
variabl23691[j] = "0";
s1 = s1 + variabl23691[j].trim();
} else {
if (variabl23691[j] == null)
variabl23691[j] = " ";
s1 = s1 + "'"
+ variabl23691[j].trim()
+ "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat3.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
s1 = s1 + variabl2517[1][k6] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k6] + ",") >= 0) {
if (variabl23691[k6] == null)
variabl23691[k6] = "0";
s1 = s1 + variabl23691[k6].trim();
} else {
if (variabl23691[k6] == null)
variabl23691[k6] = " ";
s1 = s1 + "'"
+ variabl23691[k6].trim()
+ "'";
}
if (k6 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k7 = 0; k7 < variabl2053.length; k7++) {
s2 = s2
+ variabl20531[k7]
+ "='"
+ variabl23691[variabl12871[k7]]
.trim() + "'";
if (k7 < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl1163.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1163);
variabl1423 = variabl1423 + variabl2339;
}
JButton exitButton = new JButton(variabl2405[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
exitButton
.setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
panel.add(exitButton);
variabl1423 = variabl1423 + variabl2339;
}
main1.driver1();
frame.add(panel);
frame.setVisible(true);
}
}
50.源码50,部件程序,覆盖式从office文件,包括word、excel、pdf文件导入数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
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.hwpf.extractor.WordExtractor;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
/**
* 程序文件名:dataTransfer10.java 作者:程学先 功能:覆盖式从office文件,包括word、excel、pdf文件导入。
* 原目的表内容将删除。 目的表与源表数据类型、数据宽度应当对应相容。 完成日期:2013年1月22日
* 被调用语句:dataTransfer10.means(parameter) 必须提供的参数:数据“表名”、“导入文件名”。
*/
public class dataTransfer10 extends JFrame {
static dataTransfer10 frame = new dataTransfer10();
private static JTable table;
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
static int[] variabl1119, variabl1125;
static int variabl1527;
static String[][] variabl2197;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1735;
public static String[] sw = new String[11];
static String s1 = "", s2 = "", s3 = "";
static String s4 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataTransfer10();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
s4 = " ";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
variabl25111 = main1.variabl25111;
File file = new File(".\\com\\iText-5.0.5.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\jacob.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\poi-3.8-20120326.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
file = new File(".\\com\\PDFBox-0.7.3.jar");
if (!file.exists()) {
JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中!");
return;
}
sw = new String[11];
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3;
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[9] = main1.sw9;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw9 = "";
main1.sw10 = "";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1339 = parameter[18];
String[] variabl240501 = { "从word导入", "从excel导入", "从PDF文件导入", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1).equals(",")))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
String variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
int b = 0, c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++)
s1 = s1 + variabl2517[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
try {
if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + s1 + " from " + variabl2603;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
} else {
JOptionPane.showMessageDialog(null, "目的数据表不存在,不能导入!");
return;
}
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
}
variabl1913 = new String[variabl2651];
variabl1169 = new String[variabl2651];
variabl1119 = new int[variabl2651];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
variabl1119[b] = variabl1489[b];
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
if (variabl1873.length() > 0) {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta4.executeQuery(s1);
String s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1);
s5 = rs.getString(2);
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equals(s4.trim())) {
variabl2517[1][j] = s5;
variabl1913[j] = s5;
break;
}
}
}
rs.close();
con1.close();
sta4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
frame.setTitle("数据覆盖式从office文件导入部件。 作者:程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 14);
tc.setMaxWidth(variabl1489[i] * 14);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 30;
JButton variabl1439 = new JButton(variabl2405[0]);
variabl1439.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1527 = model.getRowCount();
if (variabl1339.length() == 0) {
variabl1339 = JOptionPane.showInputDialog(
"请输入导入文件完整路径 例如:F:\\java.doc", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1339.lastIndexOf(".doc") < 0) {
p1 = variabl1339.lastIndexOf(".");
p2 = variabl1339.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1339 = variabl1339 + ".doc";
variabl1339 = variabl1339.replace("\\.", "\\.\\.");
} else {
variabl1339 = variabl1339.substring(0, p1) + ".doc";
}
}
try {
FileInputStream in = new FileInputStream(new File(
variabl1339));
WordExtractor extractor = null;
extractor = new WordExtractor(in);
String variabl2581 = extractor.getText();
int m1 = 0;
;
String[] variabl2615 = new String[variabl2651];
int k = 0;
int k2 = 0, k5 = 0;
variabl2615[k] = "";
for (int i = 0; i < variabl2581.length(); i++) {
if (variabl2581.charAt(i) == '\r') {
k5 = 0;
model.addRow(variabl2615);
variabl1853++;
variabl2615[0] = "";
k = 0;
m1 = 1;
if ((i < variabl2581.length() - 2)
&& (variabl2581.charAt(i + 2) == '\r'))
break;
} else if (variabl2581.charAt(i) == '\n') {
} else if ((byte) (variabl2581.charAt(i)) == 9) {
k++;
m1 = 0;
if (k < variabl2651)
variabl2615[k] = "";
} else if (k < variabl2651) {
variabl2615[k] = variabl2615[k]
+ variabl2581.charAt(i);
}
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据出错!");
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e1) {
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < model.getRowCount(); i++) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf("," + variabl1501[j]
+ ",") >= 0) {
if (model.getValueAt(i, j) == null)
s1 = s1 + "0";
else
s1 = s1
+ model.getValueAt(i, j).toString()
.trim();
} else {
if (model.getValueAt(i, j) == null)
s1 = s1 + " ";
else
s1 = s1
+ "'"
+ model.getValueAt(i, j).toString()
.trim() + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1439.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1439);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1141 = new JButton(variabl2405[1]);
variabl1141.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1527 = model.getRowCount();
if (variabl1339.length() == 0) {
variabl1339 = JOptionPane.showInputDialog(
"请输入导入文件完整路径 例如:F:\\java.xls", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1339.lastIndexOf(".xls") < 0) {
p1 = variabl1339.lastIndexOf(".");
p2 = variabl1339.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1339 = variabl1339 + ".xls";
variabl1339 = variabl1339.replace("\\.", "\\.\\.");
} else {
variabl1339 = variabl1339.substring(0, p1) + ".xls";
}
}
InputStream is = null;
HSSFWorkbook wbWorkbook = null;
try {
is = new FileInputStream(variabl1339);
wbWorkbook = new HSSFWorkbook(is);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败,请检查路径是否正确!",
"错误", JOptionPane.INFORMATION_MESSAGE);
} catch (IOException e2) {
e2.printStackTrace();
}
HSSFSheet sheet = wbWorkbook.getSheetAt(0);
int lastRowNum = sheet.getLastRowNum();
int variabl1157 = sheet.getPhysicalNumberOfRows();
HSSFRow row = sheet.getRow(1);
int variabl1185 = row.getPhysicalNumberOfCells();
if (variabl1185 != variabl2651)
JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同!");
String[] val;
int k2 = 0, k5 = 0;
String value = "";
for (int i = 0; i < variabl1157; i++) {
row = sheet.getRow(i);
if (row != null) {
for (int j = 0; j < variabl1185; j++) {
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()) {
case HSSFCell.CELL_TYPE_FORMULA:
break;
case HSSFCell.CELL_TYPE_NUMERIC:
value += cell.getNumericCellValue() + ",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += "0";
break;
}
}
}
val = value.split(",");
k5 = 0;
model.addRow(val);
value = "";
}
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e1) {
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = variabl1527 + 1; i < model.getRowCount(); i++) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf("," + variabl1501[j]
+ ",") >= 0) {
if (model.getValueAt(i, j) == null)
s1 = s1 + "0";
else
s1 = s1
+ model.getValueAt(i, j).toString()
.trim();
} else {
if (model.getValueAt(i, j) == null)
s1 = s1 + "' '";
else
s1 = s1
+ "'"
+ model.getValueAt(i, j).toString()
.trim() + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl1141.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl1141);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2095 = new JButton(variabl2405[2]);
variabl2095.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1527 = model.getRowCount();
if (variabl1339.length() == 0) {
variabl1339 = JOptionPane.showInputDialog(
"请输入导入文件完整路径 例如:F:\\java.pdf", "");
return;
}
int p1 = 0, p2 = 0;
if (variabl1339.lastIndexOf(".pdf") < 0) {
p1 = variabl1339.lastIndexOf(".");
p2 = variabl1339.lastIndexOf("\\\\");
if (p2 > p1) {
variabl1339 = variabl1339 + ".xls";
variabl1339 = variabl1339.replace("\\.", "\\.\\.");
} else {
variabl1339 = variabl1339.substring(0, p1) + ".pdf";
}
}
try {
FileInputStream in = new FileInputStream(variabl1339);
PDFParser parser = new PDFParser(in);
parser.parse();
PDDocument pdfdocument = parser.getPDDocument();
PDFTextStripper stripper = new PDFTextStripper();
s1 = stripper.getText(pdfdocument);
in.close();
} catch (Exception e1) {
e1.printStackTrace();
}
String[] variabl2615 = new String[variabl2651];
String s4 = "";
int k = 0, m1 = 0, k2 = 0, k5 = 0;
variabl2615[0] = "";
int l1 = s1.length();
for (int i1 = 0; i1 < l1; i1++) {
s2 = s1.substring(i1, i1 + 1);
if (s1.charAt(i1) == '\r') {
} else if (s1.charAt(i1) == '\n') {
} else if ((s2.trim().equals("│")) && (m1 == 1)) {
if (k == variabl2651 - 1) {
k5 = 0;
model.addRow(variabl2615);
k = 0;
m1 = 0;
variabl2615[k] = "";
} else {
k++;
if (k < variabl2651)
variabl2615[k] = "";
}
} else if (s2.trim().equals("│")) {
m1 = 1;
k = 0;
variabl2615[0] = "";
} else if ((k < variabl2651) && (m1 == 1)) {
try {
variabl2615[k] = variabl2615[k] + s2;
} catch (Exception e1) {
}
}
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603;
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e1) {
}
try {
main1.driver1();
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = variabl1527 + 1; i < model.getRowCount(); i++) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517[1].length; k1++)
s1 = s1 + variabl2517[1][k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517[1].length; j++) {
if (variabl25111.lastIndexOf("," + variabl1501[j]
+ ",") >= 0) {
if (model.getValueAt(i, j) == null)
s1 = s1 + "0";
else
s1 = s1
+ model.getValueAt(i, j).toString()
.trim();
} else {
if (model.getValueAt(i, j) == null)
s1 = s1 + " ";
else
s1 = s1
+ "'"
+ model.getValueAt(i, j).toString()
.trim() + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl2095.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2095);
variabl1423 = variabl1423 + variabl2339;
}
JButton exitButton = new JButton(variabl2405[3]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ((sw[2].length() > 0) && (sw[3].length() > 0)
&& (sw[4].length() > 0))
WorkflowDrivek1.means(sw);
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
exitButton
.setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
panel.add(exitButton);
variabl1423 = variabl1423 + variabl2339;
}
frame.add(panel);
frame.setVisible(true);
}
}
Archiver|手机版|科学网 ( 京ICP备07017567号-12 )
GMT+8, 2024-10-19 22:14
Powered by ScienceNet.cn
Copyright © 2007- 中国科学报社