博文
管理信息系统软件生产线源码41-45
|||
版本1
41.源码41，部件程序，覆盖式导出到纯文本文件、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.*;
/**
* 程序文件名：dataTransfer1.java
* 作者：程学先
* 功能：覆盖式导出到纯文本文件、XML文件与其他数据表。
* 原目的文件内容删除，当前表数据导出到指定文件中，如果原文件不存在，生成新文件。
* 生成的纯文本文件包括按字段长等长存放、非数字类型数据用引号分隔紧缩格式、按自定义格式分隔不同格式。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer1.means(parameter)
* 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1覆盖式导出到数据库表、2标准格式覆盖式导出到纯文本文件、
* 3紧缩格式覆盖式导出到纯文本文件、4自定义格式覆盖式导出到纯文本文件、5覆盖式导出到XML文件、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入。
* 如果标准格式导出到纯文本文件,不支持大数据类型，每字段宽度不超过50字符。
*/
public class dataTransfer1 extends JFrame {
static dataTransfer1 frame = new dataTransfer1(); // 创建窗体
private static JTable table; //创建表格
static Connection con;
static Connection con1;
static String url;
static String ODBC数据源1; //目的库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 String [][] 列名; //数据表列名
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
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 连接条件;
public static String [] sw=new String[11];
static String[][] 表格数据;//存放表格数据的数组
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String s1="",s2="",s3="";
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;
static String 类型=main1.类型;
static String 类型1=main1.类型1;
public static void means(String [] parameter) {
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="";
frame=new dataTransfer1();
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0;//记录条数
列名表="";//包括全部列名的字符串
类型=main1.类型;
类型1=main1.类型1;
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";
连接条件="";
表名=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);
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 "+连接条件;
if ((sw[3].length()>0)&&(sw[4].length()>0))
if (s1.indexOf("where")>0)
s1=s1+" and "+sw[4]+" = '"+sw[5]+"'";
else
s1=s1+" where "+sw[4]+" = '"+sw[5]+"'";
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;
}
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[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
for (int i=1;i<类型对照表[0].length;i++){
if (列数据类型[b].toLowerCase().trim().equals(类型对照表[类型序号][i].trim())){
表列数据类型[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, "读取数据出错！"+s1);
}
if (字典表名.length()>0){
try
{
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns=rsmd.getColumnCount();
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;
break;
}
}
}
rs.close(); //关闭查询结果集
con.close();
sta3.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
try
{
main1.driver1();
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="drop table "+ 导出表名;
stat3.executeUpdate(s1);
stat3.close();
con.close();
}catch(SQLException e1){ }
try
{
s1="CREATE TABLE "+ 导出表名+" (";
for (int i=0;i<列名[1].length;i++){
s1=s1+列名[1][i]+" "+表列数据类型[i];
if (类型.lastIndexOf(","+列数据类型[i]+",")>=0)
s1=s1+"("+列数据宽度[i]+")";
if (i!=列名[1].length-1) s1=s1+",";
}
s1=s1+")";
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1); //建表
for (int i=0;i<表格数据.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 (表格数据[i][j]==null) 表格数据[i][j]="0";
s1=s1+表格数据[i][j];
}
else{
if (表格数据[i][j]==null) 表格数据[i][j]=" ";
s1=s1+"'"+表格数据[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) {
try {
if ((导出文件名==null)||(导出文件名.length()<1)) 导出文件名=导出文件名+"a1.txt";
if (导出文件名.lastIndexOf("txt")<0) 导出文件名=导出文件名+".txt";
File file = new File(导出文件名);
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream fs = new FileOutputStream(file);
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++){
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
fs.write((表格数据[j1][j2]+s3).substring(0,列数据宽度[j2]).getBytes());
}
fs.write((""+x1).getBytes());
}
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) {
try {
if ((导出文件名==null)||(导出文件名.length()<1)) 导出文件名=导出文件名+"a1.txt";
if (导出文件名.lastIndexOf("txt")<0) 导出文件名=导出文件名+".txt";
File file = new File(导出文件名);
if (!file.exists()) {
file.createNewFile();
}
int length=0;
FileOutputStream fs = new FileOutputStream(file);
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++){
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
if (j2<(列数-1))
if ( 类型.lastIndexOf(列数据类型[j2])<0)
fs.write((表格数据[j1][j2]+x4).getBytes());
else
fs.write((x3+表格数据[j1][j2].trim()+x3+x4).getBytes());
else {fs.write((x3+表格数据[j1][j2].trim()+x3).getBytes());
fs.write((""+x1).getBytes());
}
}}
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) {
char x1=13,x2=10;
try {
if ((导出文件名==null)||(导出文件名.length()<1)) 导出文件名=导出文件名+"a1.txt";
if (导出文件名.lastIndexOf("txt")<0) 导出文件名=导出文件名+".txt";
File file = new File(导出文件名);
if (!file.exists()) {
file.createNewFile();
}
int length=0;
String x5=JOptionPane.showInputDialog("请输入字段与字段间分隔符","");
FileOutputStream fs = new FileOutputStream(file);
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++){
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
if (j2<(列数-1))
fs.write((表格数据[j1][j2].trim()+x5).getBytes());
else {fs.write(表格数据[j1][j2].trim().getBytes());
fs.write(("】【"+x1).getBytes());
}
}}
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) {
try {
if ((导出文件名==null)||(导出文件名.length()<1)) 导出文件名=导出文件名+"a1.xml";
if (导出文件名.lastIndexOf("xml")<0) 导出文件名=导出文件名+".xml";
File file = new File(导出文件名);
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream fs = new FileOutputStream(file);
fs.write(("<?xml version="+x3+"1.0"+x3+" encoding="+x3+"GB2312"+x3+"?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1=0;j1<记录条数;j1++){
fs.write((" <"+表名+">").getBytes());
for (int j2=0;j2<列数;j2++){
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
s2=" <"+列名[1][j2]+"> "+表格数据[j1][j2].trim()+" </"+列名[1][j2]+">";
fs.write(s2.getBytes());
}
fs.write((" </"+表名+">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.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) {
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(",5,")>=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 + "," + 列名表;
}
}
}
}
42.源码42，部件程序，添加式导出到纯文本文件、XML文件、其他数据表。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
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;
import java.sql.*;
/**
* 程序文件名：dataTransfer2.java
* 作者：程学先
* 功能：添加式导出到纯文本文件、XML文件、其他数据表。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果原文件不存在将抛出异常。
* 目的表与源表数据类型应当对应相同，如果导出到数据表，字段名也必须相同。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer2.means(parameter)
* 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共5个，序号及按钮名：1添加式导出到数据库表、2标准格式添加式导出到纯文本文件、
* 3紧缩格式添加式导出到纯文本文件、4自定义格式添加式导出到纯文本文件、5退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入，否则报错。
* 以标准格式导出时不支持大数据类型，每字段宽度不超过50字符。
*/
public class dataTransfer2 extends JFrame {
static dataTransfer2 frame = new dataTransfer2(); // 创建窗体
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 String [][] 列名; //数据表列名
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
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[][] 表格数据;//存放表格数据的数组
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static int 按钮数=0,按钮宽=0;
static String s1="",s2="",s3="";
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 类型=main1.类型;
static String 类型1=main1.类型1;
public static void means(String [] parameter) {
frame = new dataTransfer2(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0; //记录条数
s1="";s2="";s3="";
x1=10;x2=13;x3='"';x4=',';
类型=main1.类型;
类型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);
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;
}
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[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
for (int i=1;i<类型对照表[0].length;i++){
if (列数据类型[b].toLowerCase().trim().equals(类型对照表[类型序号][i].trim())){
表列数据类型[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
{
con=main1.getConn();// 连接数据库
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns=rsmd.getColumnCount();
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;
break;
}
}
}
rs.close(); //关闭查询结果集
con.close();
sta3.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错！");
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
try{
main1.driver1();
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i=0;i<表格数据.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 (表格数据[i][j]==null) 表格数据[i][j]="0";
s1=s1+表格数据[i][j];
}
else{
if (表格数据[i][j]==null) 表格数据[i][j]=" ";
s1=s1+"'"+表格数据[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) {
try {
RandomAccessFile file = new RandomAccessFile(导出文件名, "rw");
long fileLength = file.length();
file.seek(fileLength);
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++){
file.write((表格数据[j1][j2]+s3).substring(0,列数据宽度[j2]).getBytes());
}
file.write((""+x1).getBytes());
}
file.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) {
char x1=13;
try {
RandomAccessFile fs = new RandomAccessFile(导出文件名, "rw");
long fileLength = fs.length();
fs.seek(fileLength);
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++) {
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
if (j2<(列数-1))
if (类型.lastIndexOf(列数据类型[j2])<0)
fs.write((表格数据[j1][j2]+x4).getBytes());
else
fs.write((x3+表格数据[j1][j2].trim()+x3+x4).getBytes());
else {fs.write((x3+表格数据[j1][j2].trim()+x3).getBytes());
fs.write((""+x1).getBytes());
}
}}
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) {
try {
RandomAccessFile fs = new RandomAccessFile(导出文件名, "rw");
long fileLength = fs.length();
fs.seek(fileLength);
String x5=JOptionPane.showInputDialog("请输入字段与字段间分隔符","");
for (int j1=0;j1<记录条数;j1++){
for (int j2=0;j2<列数;j2++){
if (表格数据[j1][j2]==null) 表格数据[j1][j2]="";
if (j2<(列数-1))
fs.write((表格数据[j1][j2].trim()+x5).getBytes());
else {fs.write(表格数据[j1][j2].trim().getBytes());
fs.write(("】【"+x1).getBytes());
}
}}
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) {
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; //列序号
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++;
}
}
if (k1>0){
model.addRow(空记录1);
}
}
}
catch (ParserConfigurationException e1){
e1.printStackTrace();
} catch (SAXException e2){
e2.printStackTrace();
}catch (IOException e3){
e3.printStackTrace();
}
try {
FileOutputStream fs = new FileOutputStream(导出文件名); // 创建文件输出流
fs.write(("<?xml version="+x3+"1.0"+x3+" encoding="+x3+"GB2312"+x3+"?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1=0;j1<model.getRowCount();j1++){
fs.write((" <"+表名+">").getBytes());
for (int j2=0;j2<列数;j2++){
s2=" <"+列名[1][j2]+"> "+model.getValueAt(j1,j2).toString().trim()+" </"+列名[1][j2]+">";
fs.write(s2.getBytes());// 将字符串写入到文件中
}
fs.write((" </"+表名+">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.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);
按钮左边距=按钮左边距+按钮宽;
}
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 + "," + 列名表;
}
}
}
}
43.源码43，部件程序，修改式导出到纯文本文件、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;
/**
* 程序文件名：dataTransfer3.java
* 作者：程学先
* 功能：修改式导出到纯文本文件、XML文件与其他数据表。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果关键字值和已有数据相同则更改已有数据
* 否则添加到原文件尾部，如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容，符合本程序中“类型对照表"设置的对应关系。
* 如果导出到数据表，本地表经字典表变换后的字段名也必须和目的表相同，数量和次序可以随意。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer3.means(parameter)
* 必须提供的参数：数据“表名”、“关键字”。
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1修改式导出到数据库表、2标准格式修改式导出到纯文本文件、
* 3紧缩格式修改式导出到纯文本文件、4自定义格式修改式导出到纯文本文件、5修改式导出到XML文件、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入，否则报错。
* 以标准格式导出时将会首先读入数据，并根据当前数据库中各列宽度对之切割，不支持大数据类型，
* 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式（特别是每个数据宽度与数据类型）应当与当前数据库表中数据一致，
* 否则可能出错。
*/
public class dataTransfer3 extends JFrame {
static dataTransfer3 frame = new dataTransfer3(); // 创建窗体
private static JTable table; //创建表格
static Connection con;
static Connection con1;
static String url;
static String ODBC数据源1; //目的库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 记录条数=0,记录条数1=0; //记录条数
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[][] 表格数据;//存放表格数据的数组
static String[] 表格数据1;
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String 关键字;
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 int 按钮数=0,按钮宽=0;
static String 类型=main1.类型;
static String 类型1=main1.类型1;
public static void means(String [] parameter) {
frame = new dataTransfer3(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0; //记录条数
s1="";s2="";s3="";
s6=" ";
x1=10;x2=13;x3='"';x4=',';
类型=main1.类型;
类型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);
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;
}
if (关键字.length()<1) {
JOptionPane.showMessageDialog( null, "请指定关键字！");
return;
}
关键字名=关键字.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[列数];
for (b=0;b<列数;b++){
表格列名[b]=列名[1][b];
for (int i=1;i<类型对照表[0].length;i++){
if (列数据类型[b].toLowerCase().trim().equals(类型对照表[类型序号][i].trim())){
表列数据类型[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
{
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;
break;
}
}
}
rs.close(); //关闭查询结果集
con.close();
sta3.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;
}
}
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) {
try{
main1.driver1();
con1=main1.getConn();
Statement stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 导出表名;
ResultSet rs1=stat4.executeQuery(s1);
rs1.last();
记录条数1=rs1.getRow();
rsmd4 = rs1.getMetaData();
列数1 = rsmd4.getColumnCount();
列名1 = new String[列数1];
for (int i=0;i<列数1;i++) {
列名1[i] = rsmd4.getColumnName(i + 1);
}
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];
for (int i=0;i<记录条数1;i++) {
表格数据1[i]="";
rs1.absolute(i+1);
for (int k=0;k<关键字名.length;k++){
表格数据1[i]=表格数据1[i]+rs1.getString(关键字序号1[k]+1).trim();
}
}
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 (表格数据[i][j]==null) 表格数据[i][j]="0";
s1=s1+表格数据[i][j];
}
else{
if (表格数据[i][j]==null) 表格数据[i][j]=" ";
s1=s1+"'"+表格数据[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 (表格数据[i][k1]==null) 表格数据[i][k1]="0";
s1=s1+表格数据[i][k1];
}
else{
if (表格数据[i][k1]==null) 表格数据[i][k1]=" ";
s1=s1+"'"+表格数据[i][k1]+"'";
}
if (k1!=列名[1].length-1) s1=s1+",";
}
s2=" where ";
for (int k=0;k<关键字名.length;k++){
s2=s2+关键字名1[k]+"='"+表格数据[i][关键字序号1[k]]+"'";
if (k<关键字名.length-1) s2=s2+" and ";
}
s1=s1+s2;
stat4.executeUpdate(s1);
}
}
stat4.close(); //关闭连接
con1.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) {
char x1=13;
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 i = 0; (tempStr = br.readLine()) != null; i++){
for (int j=0;j<列数;j++){
空记录1[j]=tempStr.substring(k1,k1+列数据宽度[j]);
k1=k1+列数据宽度[j];
}
s3="";
k5=0;
for (int k3=0;k3<关键字名.length;k3++){
s3=s3+空记录1[关键字序号[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().equals(s2.trim())){
k2=j1;
k5=1; //某关键字相同
}
}
}
if (k5==0){ //不存在相同关键字
model.addRow(空记录1);
}
k1=0;
}
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
try {
File file = new File(导出文件名);
FileOutputStream fs = new FileOutputStream(file);
for (int j1=0;j1<model.getRowCount();j1++){
for (int j2=0;j2<列数;j2++){
fs.write((model.getValueAt(j1,j2).toString().trim()+s6).substring(0,列数据宽度[j2]).getBytes());
}
fs.write((""+x1).getBytes());
}
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) {
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++){
空记录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="";
k5=0;
for (int k3=0;k3<关键字名.length;k3++){
s3=s3+空记录1[关键字序号[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().equals(s2.trim())){
k2=j1;
k5=1;
}
}
}
if (k5==0){
model.addRow(空记录1);
}
}
fs.close();
FileOutputStream fs1 = new FileOutputStream(导出文件名);
for (int j1=0;j1<model.getRowCount();j1++){
for (int j2=0;j2<列数;j2++)
if (j2<(列数-1))
if (类型.lastIndexOf(列数据类型[j2])<0)
fs1.write((model.getValueAt(j1,j2).toString().trim()+x4).getBytes());
else
fs1.write((x3+model.getValueAt(j1,j2).toString().trim()+x3+x4).getBytes());
else {fs1.write((x3+model.getValueAt(j1,j2).toString().trim()+x3).getBytes());
fs1.write((""+x1).getBytes());
}
}
fs1.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) {
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="";
for (int i = 0; (tempStr = br.readLine()) != null; i++){
空记录1=tempStr.split(x5);
s3="";
k5=0;
for (int k3=0;k3<关键字名.length;k3++){
s3=s3+空记录1[关键字序号[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().equals(s2.trim())){
k2=j1;
k5=1;
}
}
}
if (k5==0){
model.addRow(空记录1);
}
}
fs.close();
FileOutputStream fs1 = new FileOutputStream(导出文件名);
for (int j1=0;j1<model.getRowCount();j1++){
for (int j2=0;j2<列数;j2++){
if (model.getValueAt(j1,j2)==null) s5="";
else s5=model.getValueAt(j1,j2).toString().trim();
if (j2<(列数-1)) {
fs1.write((s5+x5).getBytes());
}
else fs1.write(s5.getBytes());
}
fs1.write(("】【"+x1).getBytes());
}
fs1.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) {
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++){
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<model.getRowCount();j1++){
s2="";
for (int k4=0;k4<关键字名.length;k4++)
s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
if (s3.trim().equals(s2.trim())) {
k2=j1;
k5=1;
}
}
if (k5>0){
model.removeRow(k2);
}
model.addRow(空记录1);
}
}
}
catch (ParserConfigurationException e1){
e1.printStackTrace();
} catch (SAXException e2){
e2.printStackTrace();
}catch (IOException e3){
e3.printStackTrace();
}
try {
FileOutputStream fs = new FileOutputStream(导出文件名);
fs.write(("<?xml version="+x3+"1.0"+x3+" encoding="+x3+"GB2312"+x3+"?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1=0;j1<model.getRowCount();j1++){
fs.write((" <"+表名+">").getBytes());
for (int j2=0;j2<列数;j2++){
s2=" <"+列名[1][j2]+"> "+model.getValueAt(j1,j2).toString().trim()+" </"+列名[1][j2]+">";
fs.write(s2.getBytes());
}
fs.write((" </"+表名+">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();// 释放资源
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.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);
按钮左边距=按钮左边距+按钮宽;
}
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 + "," + 列名表;
}
}
}
}
44.源码44，部件程序，覆盖式导出到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 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 com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import java.sql.*;
import java.util.ArrayList;
import java.util.Vector;
/**
* 程序文件名：dataTransfer4.java
* 作者：程学先
* 功能：覆盖式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容删除，当前表数据导出到指定文件中，如果原文件不存在，生成新文件。
* 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer4.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字符以下较合适。
* 如果导出到WORD文件，文件名必须带路径全称，否则会存放到我的文档中。
*/
public class dataTransfer4 extends JFrame {
static dataTransfer4 frame = new dataTransfer4(); // 创建窗体
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 String [][] 列名;
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
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[][] 表格数据;//存放表格数据的数组
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 char x1=10,x2=13,x3='"',x4=',';
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame = new dataTransfer4(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0; //记录条数
s1="";s2="";s3="";
x1=10;x2=13;x3='"';x4=',';
连接条件="";
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).equalsIgnoreCase(",")))
字段名表=字段名表.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 "+连接条件;
if ((sw[3].length()>0)&&(sw[4].length()>0))
if (s1.indexOf("where")>0)
s1=s1+" and "+sw[4]+" = '"+sw[5]+"'";
else
s1=s1+" where "+sw[4]+" = '"+sw[5]+"'";
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[列数];
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);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns=rsmd.getColumnCount();
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, "连接数据库出错！");
}
}
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]);
JTableHeader header = table.getTableHeader();
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 p1=0,p2=0;
if (导出文件名.lastIndexOf(".doc")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".doc";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".doc";
}
}
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 i=0;i<表格数据.length;i++){
for(int j=0;j<列数;j++){
if (表格数据[i][j]==null) 表格数据[i][j]="";
Dispatch table = Dispatch.call(tables, "Item", new Variant(1))
.toDispatch();
Dispatch cell = Dispatch.call(table, "Cell", new Variant(i+1),
new Variant(j+1)).toDispatch();
Dispatch.call(cell, "Select");
s1=""+表格数据[i][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");
}
}
});
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 (导出文件名.lastIndexOf(".xls")<0)
导出文件名=导出文件名+".xls";
导出文件名=导出文件名.replace("\\.","\\.\\.");
HSSFWorkbook book = new HSSFWorkbook();
HSSFSheet 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<记录条数;j++){
HSSFRow row = sheet.createRow(j);
for (int i = 0; i < colCount; i++) {
HSSFCell cell = row.createCell(i);
cell.setCellValue(new HSSFRichTextString(表格数据[j][i]));
}
}
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) {
int p1=0,p2=0;
if (导出文件名.lastIndexOf(".pdf")<0){
p1=导出文件名.lastIndexOf(".");
p2=导出文件名.lastIndexOf("\\\\");
if (p2>p1){
导出文件名=导出文件名+".pdf";
导出文件名=导出文件名.replace("\\.","\\.\\.");
}
else {
导出文件名=导出文件名.substring(0,p1)+".pdf";
}
}
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 k=0;k<列数据宽度[j];k++)
s1=s1+"─";
if (j!=列数-1) s1=s1+"┬";
}
s1=s1+"┐";
document.add(new Paragraph(s1, font));
String s4="",s5="";
float lengtg1=0;
for (int i=0;i<记录条数;i++){
s1="│";
for (int j=0;j<表格数据[0].length;j++){
s3="";
if (表格数据[i][j]==null) 表格数据[i][j]=" ";
s4=表格数据[i][j];
lengtg1=0;
for (int j1=0;j1<表格数据[i][j].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<记录条数-1){
s1="├";
for (int j=0;j<列数;j++){
for (int k=0;k<列数据宽度[j];k++)
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 k=0;k<列数据宽度[j];k++)
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) {
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); // 显示窗体
}
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 + "," + 列名表;
}
}
}
}
45.源码45，部件程序，添加式导出到office文件，包括word、excel、pdf文件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.table.*;
import javax.swing.*;
import java.sql.*;
import java.util.ArrayList;
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 com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.itextpdf.text.Document;
/**
* 程序文件名：dataTransfer5.java
* 作者：程学先
* 功能：添加式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果原文件不存在将抛出异常。
* 作为学习用程序，本程序不事先检查相容性。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer5.means(parameter)
* 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共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文件进行添加式导入。
*/
public class dataTransfer5 extends JFrame {
static dataTransfer5 frame = new dataTransfer5(); // 创建窗体
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 String [][] 列名; //数据表列名
static String [] 表格列名;
static String[] 列数据类型; //存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度,列小数位数; //存放当前记录各字段数据宽度的数组
static int 记录条数=0,记录条数1=0; //记录条数
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[][] 表格数据;//存放表格数据的数组
static DefaultTableModel model;
static String 表名; //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
static String s1="",s2="",s3="";
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 dataTransfer5(); // 创建窗体
窗口宽=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){}
String 字段名表=parameter[19].trim();
if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equalsIgnoreCase(",")))
字段名表=字段名表.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;
}
表格列名=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);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns=rsmd.getColumnCount();
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;
}
else if (列名[0][j].trim().equalsIgnoreCase(s4.trim())){
列名[1][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]);
JTableHeader header = table.getTableHeader();
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 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;
记录[k]="";
for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){
if (k>列数-2) model.addRow(记录);
记录[0]="";
记录条数++;
k=0;
m1=1;
}
else if ((内容.charAt(i)=='\n')&&(m1==0)){
model.addRow(记录);
记录[0]="";
记录条数++;
m1=1;
k=0;
}
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{
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","");
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;
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(",");
model.addRow(val);
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) {
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[列数];
int k=0,m1=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().equalsIgnoreCase("│"))&&(m1==1)) {
if (k==列数-1) {
model.addRow(记录);
k=0;
m1=0;
记录[k]="";
}
else {
k++;
if (k<列数) 记录[k]="";
}
}
else if (s2.trim().equalsIgnoreCase("│")) {
m1=1;
k=0;
记录[0]="";
}
else if ((k<列数)&&(m1==1)){
try{
记录[k]=记录[k]+s2;
} catch (Exception e1) {
}
}
}
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();
String s4="",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 + "," + 列名表;
}
}
}
}
版本2
41.源码41，部件程序，覆盖式导出到纯文本文件、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.*;
/**
* 程序文件名：dataTransfer1.java 作者：程学先 功能：覆盖式导出到纯文本文件、XML文件与其他数据表部件。
* 原目的文件内容删除，当前表数据导出到指定文件中，如果原文件不存在，生成新文件。
* 生成的纯文本文件包括按字段长等长存放、非数字类型数据用引号分隔紧缩格式、按自定义格式分隔不同格式。 完成日期：2013年1月22日
* 被调用语句：dataTransfer1.means(parameter) 必须提供的参数：数据“表名”、“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1覆盖式导出到数据库表、2标准格式覆盖式导出到纯文本文件、
* 3紧缩格式覆盖式导出到纯文本文件、4自定义格式覆盖式导出到纯文本文件、5覆盖式导出到XML文件、6退出 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入。 如果标准格式导出到纯文本文件,不支持大数据类型，每字段宽度不超过50字符。
*/
public class dataTransfer1 extends JFrame {
static dataTransfer1 frame = new dataTransfer1();
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 String[][] variabl2517;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
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;
public static String[] sw = new String[11];
static String[][] variabl2197;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1679, variabl1463;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static String s1 = "", s2 = "", s3 = "";
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;
static String variabl2511 = main1.variabl2511;
static String variabl25111 = main1.variabl25111;
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 dataTransfer1();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
variabl2309 = "";
variabl2511 = main1.variabl2511;
variabl25111 = main1.variabl25111;
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 = "";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1463 = parameter[18];
variabl1679 = 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);
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;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
if (s1.indexOf("where") > 0)
s1 = s1 + " and " + sw[4] + " = '" + sw[5] + "'";
else
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
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];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][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, "读取数据出错！" + s1);
}
if (variabl1873.length() > 0) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
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;
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
try {
main1.driver1();
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "drop table " + variabl1679;
stat3.executeUpdate(s1);
stat3.close();
con.close();
} catch (SQLException e1) {
}
try {
s1 = "CREATE TABLE " + variabl1679 + " (";
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 + ")";
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
for (int i = 0; i < variabl2197.length; i++) {
s1 = "insert into " + variabl1679 + " (";
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 (variabl2197[i][j] == null)
variabl2197[i][j] = "0";
s1 = s1 + variabl2197[i][j];
} else {
if (variabl2197[i][j] == null)
variabl2197[i][j] = " ";
s1 = s1 + "'" + variabl2197[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) {
try {
if ((variabl1463 == null) || (variabl1463.length() < 1))
variabl1463 = variabl1463 + "a1.txt";
if (variabl1463.lastIndexOf("txt") < 0)
variabl1463 = variabl1463 + ".txt";
File file = new File(variabl1463);
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream fs = new FileOutputStream(file);
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
fs.write((variabl2197[j1][j2] + s3).substring(0,
variabl1489[j2]).getBytes());
}
fs.write(("" + x1).getBytes());
}
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) {
try {
if ((variabl1463 == null) || (variabl1463.length() < 1))
variabl1463 = variabl1463 + "a1.txt";
if (variabl1463.lastIndexOf("txt") < 0)
variabl1463 = variabl1463 + ".txt";
File file = new File(variabl1463);
if (!file.exists()) {
file.createNewFile();
}
int length = 0;
FileOutputStream fs = new FileOutputStream(file);
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
if (j2 < (variabl2651 - 1))
if (variabl2511.lastIndexOf(variabl1501[j2]) < 0)
fs.write((variabl2197[j1][j2] + x4)
.getBytes());
else
fs.write((x3 + variabl2197[j1][j2].trim()
+ x3 + x4).getBytes());
else {
fs.write((x3 + variabl2197[j1][j2].trim() + x3)
.getBytes());
fs.write(("" + x1).getBytes());
}
}
}
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) {
char x1 = 13, x2 = 10;
try {
if ((variabl1463 == null) || (variabl1463.length() < 1))
variabl1463 = variabl1463 + "a1.txt";
if (variabl1463.lastIndexOf("txt") < 0)
variabl1463 = variabl1463 + ".txt";
File file = new File(variabl1463);
if (!file.exists()) {
file.createNewFile();
}
int length = 0;
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileOutputStream fs = new FileOutputStream(file);
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
if (j2 < (variabl2651 - 1))
fs.write((variabl2197[j1][j2].trim() + x5)
.getBytes());
else {
fs.write(variabl2197[j1][j2].trim().getBytes());
fs.write(("】【" + x1).getBytes());
}
}
}
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) {
try {
if ((variabl1463 == null) || (variabl1463.length() < 1))
variabl1463 = variabl1463 + "a1.xml";
if (variabl1463.lastIndexOf("xml") < 0)
variabl1463 = variabl1463 + ".xml";
File file = new File(variabl1463);
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream fs = new FileOutputStream(file);
fs.write(("<?xml version=" + x3 + "1.0" + x3 + " encoding="
+ x3 + "GB2312" + x3 + "?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1 = 0; j1 < variabl1853; j1++) {
fs.write((" <" + variabl2603 + ">").getBytes());
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
s2 = " <" + variabl2517[1][j2] + "> "
+ variabl2197[j1][j2].trim() + " </"
+ variabl2517[1][j2] + ">";
fs.write(s2.getBytes());
}
fs.write((" </" + variabl2603 + ">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.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;
}
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;
}
}
}
}
42.源码42，部件程序，添加式导出到纯文本文件、XML文件、其他数据表。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
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;
import java.sql.*;
/**
* 程序文件名：dataTransfer2.java 作者：程学先 功能：添加式导出到纯文本文件、XML文件、其他数据表。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果原文件不存在将抛出异常。 目的表与源表数据类型应当对应相同，如果导出到数据表，字段名也必须相同。
* 完成日期：2013年1月22日 被调用语句：dataTransfer2.means(parameter) 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共5个，序号及按钮名：1添加式导出到数据库表、2标准格式添加式导出到纯文本文件、
* 3紧缩格式添加式导出到纯文本文件、4自定义格式添加式导出到纯文本文件、5退出 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入，否则报错。 以标准格式导出时不支持大数据类型，每字段宽度不超过50字符。
*/
public class dataTransfer2 extends JFrame {
static dataTransfer2 frame = new dataTransfer2();
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 String[][] variabl2517;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
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[][] variabl2197;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1679, variabl1463;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static int variabl2851 = 0, variabl2339 = 0;
static String s1 = "", s2 = "", s3 = "";
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;
public static void means(String[] parameter) {
frame = new dataTransfer2();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
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";
variabl2049 = "";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1463 = parameter[18];
variabl1679 = 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);
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;
}
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];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][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 {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
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;
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！");
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
try {
main1.driver1();
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < variabl2197.length; i++) {
s1 = "insert into " + variabl1679 + " (";
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 (variabl2197[i][j] == null)
variabl2197[i][j] = "0";
s1 = s1 + variabl2197[i][j];
} else {
if (variabl2197[i][j] == null)
variabl2197[i][j] = " ";
s1 = s1 + "'" + variabl2197[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) {
try {
RandomAccessFile file = new RandomAccessFile(variabl1463,
"rw");
long fileLength = file.length();
file.seek(fileLength);
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
file.write((variabl2197[j1][j2] + s3).substring(0,
variabl1489[j2]).getBytes());
}
file.write(("" + x1).getBytes());
}
file.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) {
char x1 = 13;
try {
RandomAccessFile fs = new RandomAccessFile(variabl1463,
"rw");
long fileLength = fs.length();
fs.seek(fileLength);
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
if (j2 < (variabl2651 - 1))
if (variabl2511.lastIndexOf(variabl1501[j2]) < 0)
fs.write((variabl2197[j1][j2] + x4)
.getBytes());
else
fs.write((x3 + variabl2197[j1][j2].trim()
+ x3 + x4).getBytes());
else {
fs.write((x3 + variabl2197[j1][j2].trim() + x3)
.getBytes());
fs.write(("" + x1).getBytes());
}
}
}
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) {
try {
RandomAccessFile fs = new RandomAccessFile(variabl1463,
"rw");
long fileLength = fs.length();
fs.seek(fileLength);
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
for (int j1 = 0; j1 < variabl1853; j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (variabl2197[j1][j2] == null)
variabl2197[j1][j2] = "";
if (j2 < (variabl2651 - 1))
fs.write((variabl2197[j1][j2].trim() + x5)
.getBytes());
else {
fs.write(variabl2197[j1][j2].trim().getBytes());
fs.write(("】【" + x1).getBytes());
}
}
}
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 variabl2167 = new JButton(variabl2405[4]);
variabl2167.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(variabl1463));
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;
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++;
}
}
if (k1 > 0) {
model.addRow(variabl23691);
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
try {
FileOutputStream fs = new FileOutputStream(variabl1463);
fs.write(("<?xml version=" + x3 + "1.0" + x3 + " encoding="
+ x3 + "GB2312" + x3 + "?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
fs.write((" <" + variabl2603 + ">").getBytes());
for (int j2 = 0; j2 < variabl2651; j2++) {
s2 = " <"
+ variabl2517[1][j2]
+ "> "
+ model.getValueAt(j1, j2).toString()
.trim() + " </"
+ variabl2517[1][j2] + ">";
fs.write(s2.getBytes());
}
fs.write((" </" + variabl2603 + ">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl2167.setBounds(variabl1423, variabl2503 - 80, variabl2339,
20);
panel.add(variabl2167);
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;
}
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;
}
}
}
}
43.源码43，部件程序，修改式导出到纯文本文件、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;
/**
* 程序文件名：dataTransfer3.java 作者：程学先 功能：修改式导出到纯文本文件、XML文件与其他数据表。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果关键字值和已有数据相同则更改已有数据 否则添加到原文件尾部，如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容，符合本程序中“类型对照表"设置的对应关系。
* 如果导出到数据表，本地表经字典表变换后的字段名也必须和目的表相同，数量和次序可以随意。 完成日期：2013年1月22日
* 被调用语句：dataTransfer3.means(parameter) 必须提供的参数：数据“表名”、“关键字”。
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1修改式导出到数据库表、2标准格式修改式导出到纯文本文件、
* 3紧缩格式修改式导出到纯文本文件、4自定义格式修改式导出到纯文本文件、5修改式导出到XML文件、6退出 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到数据库：如果已经存在该表，会检查字段匹配情况。如果完全匹配，则直接导入，否则报错。
* 以标准格式导出时将会首先读入数据，并根据当前数据库中各列宽度对之切割，不支持大数据类型， 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式（特别是每个数据宽度与数据类型）应当与当前数据库表中数据一致， 否则可能出错。
*/
public class dataTransfer3 extends JFrame {
static dataTransfer3 frame = new dataTransfer3();
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 variabl1853 = 0, variabl18531 = 0;
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[][] 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 variabl12491;
static String variabl1735;
static String variabl2253;
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 int variabl2851 = 0, variabl2339 = 0;
static String variabl2511 = main1.variabl2511;
static String variabl25111 = main1.variabl25111;
public static void means(String[] parameter) {
frame = new dataTransfer3();
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";
variabl2049 = "";
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1463 = parameter[18];
variabl1679 = 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);
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;
}
if (variabl2253.length() < 1) {
JOptionPane.showMessageDialog(null, "请指定关键字！");
return;
}
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];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][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 {
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;
break;
}
}
}
rs.close();
con.close();
sta3.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;
}
}
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) {
try {
main1.driver1();
con1 = main1.getConn();
Statement stat4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1679;
ResultSet rs1 = stat4.executeQuery(s1);
rs1.last();
variabl18531 = rs1.getRow();
rsmd4 = rs1.getMetaData();
variabl26511 = rsmd4.getColumnCount();
variabl25171 = new String[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd4.getColumnName(i + 1);
}
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];
for (int i = 0; i < variabl18531; i++) {
variabl21971[i] = "";
rs1.absolute(i + 1);
for (int k = 0; k < variabl2053.length; k++) {
variabl21971[i] = variabl21971[i]
+ rs1.getString(variabl12871[k] + 1).trim();
}
}
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 (variabl21971[i1].trim().equals(s3.trim()))
f0 = 1;
}
if (f0 == 0) {
s1 = "insert into " + variabl1679 + " (";
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 (variabl2197[i][j] == null)
variabl2197[i][j] = "0";
s1 = s1 + variabl2197[i][j];
} else {
if (variabl2197[i][j] == null)
variabl2197[i][j] = " ";
s1 = s1 + "'" + variabl2197[i][j] + "'";
}
if (j != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat4.executeUpdate(s1);
} else {
s1 = "update " + variabl1679 + " set ";
for (int k1 = 0; k1 < variabl2517[1].length; k1++) {
s1 = s1 + variabl2517[1][k1] + "=";
if (variabl25111.lastIndexOf(","
+ variabl1501[k1] + ",") >= 0) {
if (variabl2197[i][k1] == null)
variabl2197[i][k1] = "0";
s1 = s1 + variabl2197[i][k1];
} else {
if (variabl2197[i][k1] == null)
variabl2197[i][k1] = " ";
s1 = s1 + "'" + variabl2197[i][k1] + "'";
}
if (k1 != variabl2517[1].length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl2053.length; k++) {
s2 = s2 + variabl20531[k] + "='"
+ variabl2197[i][variabl12871[k]] + "'";
if (k < variabl2053.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat4.executeUpdate(s1);
}
}
stat4.close();
con1.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) {
char x1 = 13;
try {
FileReader fs = new FileReader(variabl1463);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k1 = 0, k2 = 0, k5 = 0;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
for (int j = 0; j < variabl2651; j++) {
variabl23691[j] = tempStr.substring(k1, k1
+ variabl1489[j]);
k1 = k1 + variabl1489[j];
}
s3 = "";
k5 = 0;
for (int k3 = 0; k3 < variabl2053.length; k3++) {
s3 = s3 + variabl23691[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().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
}
if (k5 == 0) {
model.addRow(variabl23691);
}
k1 = 0;
}
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}
try {
File file = new File(variabl1463);
FileOutputStream fs = new FileOutputStream(file);
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
fs.write((model.getValueAt(j1, j2).toString()
.trim() + s6).substring(0, variabl1489[j2])
.getBytes());
}
fs.write(("" + x1).getBytes());
}
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) {
try {
FileReader fs = new FileReader(variabl1463);
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++) {
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 = "";
k5 = 0;
for (int k3 = 0; k3 < variabl2053.length; k3++) {
s3 = s3 + variabl23691[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().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
}
if (k5 == 0) {
model.addRow(variabl23691);
}
}
fs.close();
FileOutputStream fs1 = new FileOutputStream(variabl1463);
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
for (int j2 = 0; j2 < variabl2651; j2++)
if (j2 < (variabl2651 - 1))
if (variabl2511.lastIndexOf(variabl1501[j2]) < 0)
fs1.write((model.getValueAt(j1, j2)
.toString().trim() + x4).getBytes());
else
fs1.write((x3
+ model.getValueAt(j1, j2)
.toString().trim() + x3 + x4)
.getBytes());
else {
fs1.write((x3
+ model.getValueAt(j1, j2).toString()
.trim() + x3).getBytes());
fs1.write(("" + x1).getBytes());
}
}
fs1.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) {
try {
String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
FileReader fs = new FileReader(variabl1463);
BufferedReader br = new BufferedReader(fs);
String tempStr = null;
String[] variabl23691 = new String[variabl2651];
int k2 = 0, k5 = 0;
String s5 = "";
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
variabl23691 = tempStr.split(x5);
s3 = "";
k5 = 0;
for (int k3 = 0; k3 < variabl2053.length; k3++) {
s3 = s3 + variabl23691[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().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
}
if (k5 == 0) {
model.addRow(variabl23691);
}
}
fs.close();
FileOutputStream fs1 = new FileOutputStream(variabl1463);
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
for (int j2 = 0; j2 < variabl2651; j2++) {
if (model.getValueAt(j1, j2) == null)
s5 = "";
else
s5 = model.getValueAt(j1, j2).toString().trim();
if (j2 < (variabl2651 - 1)) {
fs1.write((s5 + x5).getBytes());
} else
fs1.write(s5.getBytes());
}
fs1.write(("】【" + x1).getBytes());
}
fs1.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) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
Document doc = db.parse(new File(variabl1463));
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++) {
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 < model.getRowCount(); j1++) {
s2 = "";
for (int k4 = 0; k4 < variabl2053.length; k4++)
s2 = s2
+ model.getValueAt(j1,
variabl1287[k4]).toString()
.trim();
if (s3.trim().equals(s2.trim())) {
k2 = j1;
k5 = 1;
}
}
if (k5 > 0) {
model.removeRow(k2);
}
model.addRow(variabl23691);
}
}
} catch (ParserConfigurationException e1) {
e1.printStackTrace();
} catch (SAXException e2) {
e2.printStackTrace();
} catch (IOException e3) {
e3.printStackTrace();
}
try {
FileOutputStream fs = new FileOutputStream(variabl1463);
fs.write(("<?xml version=" + x3 + "1.0" + x3 + " encoding="
+ x3 + "GB2312" + x3 + "?>").getBytes());
fs.write(("<Title>").getBytes());
for (int j1 = 0; j1 < model.getRowCount(); j1++) {
fs.write((" <" + variabl2603 + ">").getBytes());
for (int j2 = 0; j2 < variabl2651; j2++) {
s2 = " <"
+ variabl2517[1][j2]
+ "> "
+ model.getValueAt(j1, j2).toString()
.trim() + " </"
+ variabl2517[1][j2] + ">";
fs.write(s2.getBytes());
}
fs.write((" </" + variabl2603 + ">").getBytes());
}
fs.write(("</Title>").getBytes());
fs.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.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;
}
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;
}
}
}
}
44.源码44，部件程序，覆盖式导出到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 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 com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import java.sql.*;
import java.util.ArrayList;
import java.util.Vector;
/**
* 程序文件名：dataTransfer4.java 作者：程学先 功能：覆盖式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容删除，当前表数据导出到指定文件中，如果原文件不存在，生成新文件。 必须提供的参数：数据“表名”
* 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。 完成日期：2013年1月22日
* 被调用语句：dataTransfer4.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字符以下较合适。 如果导出到WORD文件，文件名必须带路径全称，否则会存放到我的文档中。
*/
public class dataTransfer4 extends JFrame {
static dataTransfer4 frame = new dataTransfer4();
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 String[][] variabl2517;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
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[][] variabl2197;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1679, variabl1463;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1735;
public static String[] sw = new String[11];
static String s1 = "", s2 = "", s3 = "";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataTransfer4();
variabl2483 = 800;
variabl2503 = 600;
variabl1853 = 0;
variabl18531 = 0;
s1 = "";
s2 = "";
s3 = "";
x1 = 10;
x2 = 13;
x3 = '"';
x4 = ',';
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;
}
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];
variabl1463 = 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)
.equalsIgnoreCase(",")))
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;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
if (s1.indexOf("where") > 0)
s1 = s1 + " and " + sw[4] + " = '" + sw[5] + "'";
else
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
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];
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);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
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, "连接数据库出错！");
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
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";
}
}
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 i = 0; i < variabl2197.length; i++) {
for (int j = 0; j < variabl2651; j++) {
if (variabl2197[i][j] == null)
variabl2197[i][j] = "";
Dispatch table = Dispatch.call(tables, "Item",
new Variant(1)).toDispatch();
Dispatch cell = Dispatch.call(table, "Cell",
new Variant(i + 1), new Variant(j + 1))
.toDispatch();
Dispatch.call(cell, "Select");
s1 = "" + variabl2197[i][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");
}
}
});
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.lastIndexOf(".xls") < 0)
variabl1463 = variabl1463 + ".xls";
variabl1463 = variabl1463.replace("\\.", "\\.\\.");
HSSFWorkbook book = new HSSFWorkbook();
HSSFSheet 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 < variabl1853; j++) {
HSSFRow row = sheet.createRow(j);
for (int i = 0; i < colCount; i++) {
HSSFCell cell = row.createCell(i);
cell.setCellValue(new HSSFRichTextString(
variabl2197[j][i]));
}
}
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) {
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";
}
}
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 k = 0; k < variabl1489[j]; k++)
s1 = s1 + "─";
if (j != variabl2651 - 1)
s1 = s1 + "┬";
}
s1 = s1 + "┐";
document.add(new Paragraph(s1, font));
String s4 = "", s5 = "";
float lengtg1 = 0;
for (int i = 0; i < variabl1853; i++) {
s1 = "│";
for (int j = 0; j < variabl2197[0].length; j++) {
s3 = "";
if (variabl2197[i][j] == null)
variabl2197[i][j] = " ";
s4 = variabl2197[i][j];
lengtg1 = 0;
for (int j1 = 0; j1 < variabl2197[i][j].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 < variabl1853 - 1) {
s1 = "├";
for (int j = 0; j < variabl2651; j++) {
for (int k = 0; k < variabl1489[j]; k++)
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 k = 0; k < variabl1489[j]; k++)
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) {
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);
}
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;
}
}
}
}
45.源码45，部件程序，添加式导出到office文件，包括word、excel、pdf文件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.table.*;
import javax.swing.*;
import java.sql.*;
import java.util.ArrayList;
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 com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.itextpdf.text.Document;
/**
* 程序文件名：dataTransfer5.java 作者：程学先 功能：添加式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果原文件不存在将抛出异常。 作为学习用程序，本程序不事先检查相容性。 完成日期：2013年1月22日
* 被调用语句：dataTransfer5.means(parameter) 必须提供的参数：数据“表名” 应当提供的参数：“导出文件名”、“导出数据表名”。
* 可选择参数：“字段号表”、“要求按钮号表”、目的数据库“DBMS名称”、目的数据库"ODBC数据源名称"。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共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文件进行添加式导入。
*/
public class dataTransfer5 extends JFrame {
static dataTransfer5 frame = new dataTransfer5();
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 String[][] variabl2517;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
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[][] variabl2197;
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 s1 = "", s2 = "", s3 = "";
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 dataTransfer5();
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) {
}
String variabl1633 = parameter[19].trim();
if ((variabl1633.length() > 0)
&& (variabl1633.substring(variabl1633.length() - 1)
.equalsIgnoreCase(",")))
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;
}
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);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
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;
} else 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, "连接数据库出错！");
}
}
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]);
JTableHeader header = table.getTableHeader();
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) {
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;
variabl2615[k] = "";
for (int i = 0; i < variabl2581.length(); i++) {
if (variabl2581.charAt(i) == '\r') {
if (k > variabl2651 - 2)
model.addRow(variabl2615);
variabl2615[0] = "";
variabl1853++;
k = 0;
m1 = 1;
} else if ((variabl2581.charAt(i) == '\n') && (m1 == 0)) {
model.addRow(variabl2615);
variabl2615[0] = "";
variabl1853++;
m1 = 1;
k = 0;
} 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", "");
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;
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(",");
model.addRow(val);
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) {
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];
int k = 0, m1 = 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().equalsIgnoreCase("│")) && (m1 == 1)) {
if (k == variabl2651 - 1) {
model.addRow(variabl2615);
k = 0;
m1 = 0;
variabl2615[k] = "";
} else {
k++;
if (k < variabl2651)
variabl2615[k] = "";
}
} else if (s2.trim().equalsIgnoreCase("│")) {
m1 = 1;
k = 0;
variabl2615[0] = "";
} else if ((k < variabl2651) && (m1 == 1)) {
try {
variabl2615[k] = variabl2615[k] + s2;
} catch (Exception e1) {
}
}
}
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();
String s4 = "", 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;
}
}
}
}
https://blog.sciencenet.cn/blog-2551-1118037.html
上一篇：管理信息系统软件生产线源码37-40
下一篇：管理信息系统软件生产线源码46-50
