博文
管理信息系统软件生产线源码32-36
|||
版本1
32.源码32，部件程序，可使用字典表与代码表的表格式数据批修改程序。
/**
* 程序文件名：tableTenance7.java
* 作者： 齐赛
* 功能：可使用字典表与代码表的表格式数据批修改程序。
* 完成日期：2013年2月20日
* 被调用语句：tableTenance7.means(parameter)。
* 要求提供的参数：数据“表名”、“关键字段名”、
* 可选择提供的参数：“要求字段号表”、“要求按钮号表”、“接口参数表名”。
* 操作方法与注意事项：以上所有参数均为字符串数据类型的全局变量。
* 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，
* 可以是单一字段，也可以是多个字段，如果是多字段，以英文逗号分隔。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为空；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 要求按钮号用于选择留在界面中的按钮，号后加分号之后可加变更后的按钮名称。
* 操作时每点击一次 “添加空记录”按钮，将在表中增加一空行，
* 填入数据后，需要点击“本条记录存盘”按钮，才能将新记录填入表内。
* 也可以继续点击一次“添加空记录”按钮，继续添加下一列及之后记录或修改表格中已经有的数据，
* 只到全部数据加入到表格中或全部完成修改后后，最后点击“全部数据存盘”按钮，将所有数据存入数据库。
* 如果要修改表中数据，可先修改表格中数据，可以修改完一条后点击“本条记录存盘”按钮保存修改结果。
* 也可以修改完全部欲改数据，最后点击“全部数据存盘”按钮，将所有修改数据存入数据库。
* 如果删除数据，操作时首先用鼠标点击表格中要删除的记录，之后点击“删除按钮”完成删除。
* 本程序提供各字段共用列表框,可以利用鼠标选择代码或历史数据录入。
* 如果为某字段设计了代码表，要求代码表名字为字段名加“代码表”，其中字段名，一个与字段名相同，
* 另一个为字段名加“代码”或字段名中去掉“代码”二字。例如，关于性别，如果设计用0表示男，1表示女
* 那么，设计“性别代码表”，包括“性别”、“性别代码”二个字段，其中二条记录：男 0；女 1。
* 在数据表中可以有字段“性别代码”，保存的是性别代码数据。也可以有“性别”，即保存的是性别数据。
* 如果数据表中字段名为“性别代码”，在列表框中显示0 1；录入保存的是性别代码。
* 如果数据表中字段名为性别，那么，列表框中显示男 女，录入保存的是性别内容。
* 可以选择接口参数表名可以检查数字类型字段数据关于最大值、最小值、值域、条件表达式等条件是否正确。
* 如果是登录操作之后调用本程序，可以检查操作者是否具有相应权限。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
import java.io.*;
public class tableTenance7 extends JFrame implements ItemListener
{
private static JTable table02; // 创建表格
static Connection con; // 连接数据库
static String url; // 某些数据库的连接URL
static String 表名 ; // 数据表名
static String 接口参数表名;
static String 字典表名 ;// 将操作的数据表的字段名说明
static String[] 关键字段名;// 存放关键字字段名的数组
static int 窗口宽 =900, 窗口高 = 700;// 窗窗口高
static int 列数; // 数据表列数
static int 表格列数;
static String[] 列名; // 数据表列名
static String[] 表格列名;
static String[] 列标题;
static String[] 列数据类型; // 存放当前记录各字段数据类型的数组
static String[] 表列数据类型;
static int[] 列数据宽度; // 存放当前记录各字段数据宽度的数组
static int[] 表列数据宽度;
static int 表格记录条数, 记录条数1,数据库记录条数; // 记录条数
static String[][] 表格数据;// 存放表格数据的数组
static String[][] 备份数据;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 要求字段号表;
static JButton 添加, 本条存盘, 全部存盘, 删除, 退出;
static String[][] 排序数据;
static String[][] 排序备份;
static int 起始序号 = 0, 终了序号 = 0, 当前列号 = 0, 上次列号 = 0;
static String[] 一条空记录;
static String[] 关键字段值;
static int[] 关键字序号;
static String s1 = "", s2 = "", s3 = "";
static DefaultTableModel tableModel; // 定义表格模型对象
static int b = 0, c = 0;
static String[] 当前字段值;
static String 字段名表="";
static PreparedStatement pstmt;
static Statement sta;
static List list1;
static int currentRow = 0;
static int currentColumn = 0;
static String 键盘输入字串="";
static String[][]参数表数据;
static ArrayList<String>接口参数表;
static int 参数表记录条数,参数表列数;
static int 临时=0,按钮数=0;
public static void means(String[] parameter){
起始序号 = 0; 终了序号 = 0; 当前列号 = 0; 上次列号 = 0;
s1 = ""; s2 = ""; s3 = "";
b = 0; c = 0;
currentRow = 0;
currentColumn = 0;
键盘输入字串="";
临时=0;
con = main1.getConn();
起始序号 = 0;终了序号 = 0;当前列号 = 0;上次列号 = 0;
表名=parameter[4] ;
要求字段号表=parameter[8] ;
关键字段名 = parameter[6].split(",");
接口参数表名=parameter[5];
字段名表=parameter[19] ;
final String 表名表 = parameter[0];
String [] 按钮集01={ "添加空记录","删除","当前行存盘","全部表存盘","退出"};
按钮集=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){}
final tableTenance7 frame = new tableTenance7(); // 创建窗体
frame.setTitle("表格式数据维护程序 作者：齐赛");
frame.setBounds(10, 10, 窗口宽, 窗口高); // 窗口位置大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
final JScrollPane scrollPane = new JScrollPane(); // 定义滚动条
scrollPane.setBounds(0, 0, 窗口宽 - 200, 窗口高 - 100); // 定义滚动面板大小位置
frame.getContentPane().add(scrollPane); // 加入滚动条
JLabel jl = new JLabel("字段可选内容 :");
jl.setBounds(窗口宽 - 175, 0, 150, 30);
list1 = new List();
list1.addItemListener(frame);
list1.setBounds(窗口宽 - 175, 30, 150, 窗口高 - 130);
frame.getContentPane().add(list1);
frame.getContentPane().add(jl);
if (关键字段名.length == 0)
{
JOptionPane.showMessageDialog(null, "缺少关键字的说明，请选择关键字后重新操作");
return;
}
for (int i = 0; i < 关键字段名.length; i++)
关键字段值 = new String[关键字段名.length];
关键字序号 = new int[关键字段名.length];
for (int i = 0; i < 关键字段名.length; i++)
{
关键字段值[i] = "";
关键字序号[i] = 0;
}
con = main1.getConn();
try
{
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String [] s6,s7;
s7=parameter[19].split(",");
if (要求字段号表.length()>0) {
字段名表="";
s6=要求字段号表.split(",");
for (int i=0;i<s6.length;i++){
if (字段名表.length()>0)
字段名表=字段名表+","+s7[Integer.valueOf(s6[i])];
else 字段名表=s7[Integer.valueOf(s6[i])];
}
for (int j = 0; j< 关键字段名.length; j++) {
if (字段名表.indexOf(关键字段名[j].trim())<0) {
字段名表=字段名表+","+关键字段名[j];
}
}
s7=字段名表.split(",");
for (int i=0;i<s7.length;i++){
for (int j = 0; j< 关键字段名.length; j++) {
if (关键字段名[j].trim().equals(s7[i].trim()))
关键字序号[j] = i;
}
}
}
else for (int i=0;i<s7.length;i++){
for (int j = 0; j< 关键字段名.length; j++) {
if (关键字段名[j].trim().equals(s7[i].trim()))
关键字序号[j] = i;
}
}
s1="select "+字段名表+" from "+表名;
ResultSet rs = sta.executeQuery(s1);
rs.last();
数据库记录条数 = rs.getRow();
表格记录条数=数据库记录条数;
ResultSetMetaData rsmd = rs.getMetaData();
列数 = rsmd.getColumnCount();
表格列数=列数;
列名 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
列标题 = new String[表格列数];
表格列名 = new String[表格列数];
表列数据类型 = new String[表格列数];
表列数据宽度 = new int[表格列数];
表格数据 = new String[数据库记录条数][表格列数];
一条空记录 = new String[表格列数];
for (int i=0;i<列数;i++) {
列名[i] = rsmd.getColumnName(i + 1);
列数据类型[i] = rsmd.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度[i] < 列名[i].length())
列数据宽度[i] = 列名[i].length();
else if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
表格列名[i] = 列名[i];
表列数据类型[i] = 列数据类型[i];
表列数据宽度[i] = 列数据宽度[i];
列标题[i] = 列名[i];
一条空记录[i] = "";
}
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();
sta.close(); // 关闭连接
con.close();
con = null;
} catch (Exception e)
{
e.printStackTrace();
}
con=main1.getConn();
if((接口参数表名.length()>0)&&(接口参数表名.lastIndexOf(表名.trim()+"接口参数表")>=0))
try
{
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select * from "+表名+"接口参数表 ";
ResultSet rs = sta.executeQuery(s1);
rs.last();
参数表记录条数= rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
参数表列数 = rsmd.getColumnCount(); // 获取列数
参数表数据=new String[参数表记录条数][参数表列数];
for(int i=0;i<参数表记录条数;i++)
{
rs.absolute(i+1);
for(int j=0;j<参数表列数;j++)
{
参数表数据[i][j]=rs.getString(j+1);
}
}
rs.close(); // 关闭查询结果集
sta.close(); // 关闭连接
con.close();
con = null;
} catch (Exception e)
{
e.printStackTrace();
}
字典表名="";
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];
}
if (字典表名.length() > 0)
{
con = main1.getConn();
try
{
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String s1 = "select * from " + 字典表名;
ResultSet rs = sta.executeQuery(s1);
while (rs.next())
{
String 字段名称 = rs.getString(1);
String 标签名称 = rs.getString(2);
b = 0;
while (b < 表格列数)
{
if (列标题[b].compareTo(字段名称) == 0)
{
列标题[b] = 标签名称;
if (列数据宽度[b] < 列标题[b].length())
列数据宽度[b] = 列标题[b].length();
break;
}
b++;
}
}
rs.close();
sta.close(); // 关闭连接
} catch (Exception e1)
{
e1.printStackTrace();
}
}
tableModel = new DefaultTableModel(表格数据, 列标题);
table02 = new JTable(tableModel);
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
table02.addMouseListener(new MouseAdapter()
{
int flag = -1;
public void mouseClicked(MouseEvent e)
{
currentRow = table02.getSelectedRow();// 获得当前行号
currentColumn = table02.getSelectedColumn();// 获得当前列号
if (flag != currentColumn)// 如果之前的列号和当前的列号不同，则更新列表框
{
list1.clear();
if (表名表.lastIndexOf(表格列名[currentColumn]) >= 0
|| 表名表.lastIndexOf(列标题[currentColumn]) >= 0)
{ //查有无代码表
try
{
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String s1 = "select * from " + 表格列名[currentColumn]+"代码表";
ResultSet rs = sta.executeQuery(s1);
while(rs.next())
{
String 代码内容=rs.getString(1);
list1.add(代码内容);
}
} catch (Exception e2)
{
e2.printStackTrace();
}
} else
{
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < 表格记录条数; i++)
{
set.add((String) tableModel.getValueAt(i,
currentColumn));
}
for (String str : set)
list1.add(str);
}
}
flag = currentColumn;
}
});
for (int i = 0; i < 表格列数; i++)
{
TableColumn tc = table02.getColumn(列标题[i]);
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(表列数据宽度[i] * 8);
tc.setMaxWidth(表列数据宽度[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02); // 滚动条加到表格中
table02.addMouseListener(new MouseAdapter() { //鼠标侦听器
public void mouseClicked(MouseEvent e) { //鼠标按键在组件上单击（按下并释放）时调用
int selectedRow = table02.getSelectedRow();
int 行号 = table02.getSelectedRow();
int 列号 = table02.getSelectedColumn();
int k=0;
for (int i = 0; i < 关键字段名.length; i++) {
if (关键字序号[i] == 列号 ) k=1;
}
if (k==0) { //非关键字数据清除，关键字数据保留
tableModel.setValueAt("", 行号, 列号); //清原有数据
}
键盘输入字串 = ""; //清"键盘输入字串"
}
});
table02.addFocusListener(new FocusAdapter() { //键盘焦点
public void focusLost(final FocusEvent arg0) {//组件失去键盘焦点时调用
int 行号 = table02.getSelectedRow();
int 列号 = table02.getSelectedColumn();
if (键盘输入字串.trim().length()>0){
tableModel.setValueAt(键盘输入字串, 行号, 列号);
}
}
});
table02.addKeyListener(new KeyAdapter(){
public void keyPressed(KeyEvent evt) {
键盘输入字串=键盘输入字串+evt.getKeyChar();
}
});
int j = 0;
要求按钮号表 = "," + 要求按钮号表 + ",";
if (要求按钮号表.length() < 3)
j = 5;
else
for (int i = 0; i < 5; i++)
if (要求按钮号表.lastIndexOf("," + i + ",") >= 0)
j = j + 1;
int 按钮宽 = (窗口宽 - 20) / 按钮数 ;
int 按钮左边距 = 5;
添加 = new JButton(按钮集[0]);
添加.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
tableModel.addRow(一条空记录);
表格记录条数 = 表格记录条数 + 1;
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0))
{
添加.setBounds(按钮左边距, 窗口高 - 80, 按钮宽 - 10, 20);
frame.getContentPane().add(添加);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final JButton 删除 = new JButton(按钮集[1]);
删除.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int selectedRow = table02.getSelectedRow();
if (selectedRow != -1)
{
s1 = "";
int j=0;
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = tableModel.getValueAt(selectedRow, 关键字序号[i])
.toString();
if (关键字段值[i].compareTo(" ") < 0)
j = -1;
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 关键字段名[i] + "=" + 关键字段值[i];
else
s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
if (j<0) {
JOptionPane.showMessageDialog(null, "关键字数据不全！");
return;
}
s1 = "delete from " + 表名 + " where " + s1;
try
{
con =main1.getConn();// 连接数据库
pstmt = con.prepareStatement(s1);
pstmt.execute();
tableModel.removeRow(selectedRow);
表格记录条数 = 表格记录条数 - 1;
数据库记录条数=数据库记录条数-1;
pstmt.close();
con.close(); // 关闭连接
} catch (Exception e2)
{
e2.printStackTrace();
}
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0))
{
删除.setBounds(按钮左边距, 窗口高 - 80, 按钮宽 - 10, 20);
frame.getContentPane().add(删除);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final JButton 本条存盘 = new JButton(按钮集[2]);
本条存盘.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
con =main1.getConn(); // 连接数据库
try
{
if (itemCount(currentRow) >= 0) {
if (记录条数1 == 0) {
s1 = insertNewItem(currentRow);
if(s1==null) {
JOptionPane.showMessageDialog(null, "字段内容不在规定的范围内，请检查！");
sta.close();
con.close();
return;
}
pstmt = con.prepareStatement(s1);
pstmt.execute();
数据库记录条数++;
}
else
{
if(currentRow+1>数据库记录条数)
{
JOptionPane.showMessageDialog(null, "新增加的记录关键字不能重复！请检查第"+currentRow+"行！");
return;
}
s1 = updateItem(currentRow);
if(s1==null)
{
JOptionPane.showMessageDialog(null, "字段内容不在规定的范围内，请检查！");
sta.close();
con.close();
return;
}
pstmt = con.prepareStatement(s1);
pstmt.execute();
}
pstmt.close();
con.close();
}
else
{
JOptionPane.showMessageDialog(null, "关键字为空，请重新输入！");
return;
}
} catch (Exception e2)
{
e2.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0))
{
本条存盘.setBounds(按钮左边距, 窗口高 - 80, 按钮宽 - 10, 20);
frame.getContentPane().add(本条存盘);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final JButton 全部存盘 = new JButton(按钮集[3]);
全部存盘.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
con = main1.getConn(); // 连接数据库
try
{
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
} catch (SQLException e2)
{
e2.printStackTrace();
}
for (int i = 0; i < 表格记录条数; i++)
{
if (itemCount(i) >= 0)
{
if (itemCount(i) == 0)
{
s1 = insertNewItem(i);
if(s1==null)
{
JOptionPane.showMessageDialog(null, "字段内容不在规定的范围内，请检查！");
table02.setRowSelectionInterval(i, i);
break;
}
}
else
{
if(i+1>数据库记录条数)
{
JOptionPane.showMessageDialog(null, "新增加的记录关键字不能重复！请检查第"+i+"行！");
table02.setRowSelectionInterval(i, i);
continue;
}
s1 = updateItem(i);
if(s1==null)
{
JOptionPane.showMessageDialog(null, "字段内容不在规定的范围内，请检查！");
break;
}
}
try
{
pstmt = con.prepareStatement(s1);
pstmt.execute();
if(记录条数1==0)
数据库记录条数++;
} catch (SQLException e1)
{
e1.printStackTrace();
}
}
else
{
JOptionPane.showMessageDialog(null, "关键字有的为空，请检查！");
break;
}
}
try
{
sta.close();
con.close();
pstmt.close();
} catch (SQLException e1)
{
e1.printStackTrace();
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0))
{
全部存盘.setBounds(按钮左边距, 窗口高 - 80, 按钮宽 - 10, 20);
frame.getContentPane().add(全部存盘);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final JButton 退出 = new JButton(按钮集[4]);
退出.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
frame.setVisible(false);
frame.dispose();
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0))
{
退出.setBounds(按钮左边距, 窗口高 - 80, 按钮宽 - 10, 20);
frame.getContentPane().add(退出); // 加入退出按钮
按钮左边距 = 按钮左边距 + 按钮宽;
}
frame.setVisible(true); // 显示窗体
}
static String insertNewItem(int row)
{
String ss = new String();
for (int i = 0; i < 表格列数; i++) {
String temp = tableModel.getValueAt(row, i) == null ? null : tableModel
.getValueAt(row, i).toString();
if((temp!=null)&&(接口参数表名.length()>0))
for(int j=0;j<参数表数据.length;j++)
{
if(参数表数据[j][1].trim().equals(表格列名[i].trim()) || 参数表数据[j][1].trim().equals(列标题[i].trim()))
{
if(参数表数据[j][4]==null)
{
if(temp.indexOf(".")>=0 && (Double.parseDouble(temp)>Double.parseDouble(参数表数据[j][2]) ||
Double.parseDouble(temp)<Double.parseDouble(参数表数据[j][3])))
{
return null;
}
else if(Integer.parseInt(temp)>Integer.parseInt(参数表数据[j][2]) ||
Integer.parseInt(temp)<Integer.parseInt(参数表数据[j][3]))
return null;
}
else
{
String strs[]=参数表数据[j][4].split("，");
boolean flag=false;
for(int ii=0;ii<strs.length;ii++)
{
if(strs[ii].trim().equals(temp.trim()))
{
flag=true;
break;
}
}
if(!flag)
return null;
}
}
}
}
ss="insert into "+表名+" values (";
for (int i = 0; i < 列数; i++)
{
if (main1.数字数据类型.lastIndexOf(列数据类型[i]) > 0)
ss += table02.getValueAt(row,i); //当前字段值[i];
else ss += "'"+table02.getValueAt(row,i)+"'";
if (i < 列数-1) ss += ",";
}
ss += ")";
return ss;
}
static String updateItem(int row)
{
String ss = new String();
当前字段值 = new String[表格列数];
for (int i = 0; i < 表格列数; i++)
{
int k;
for (k = 0; k < 关键字序号.length; k++)
{
if (i == 关键字序号[k])
break;
}
if (k < 关键字序号.length)
continue;
String temp;
temp = tableModel.getValueAt(row, i) == null ? null : tableModel
.getValueAt(row, i).toString();
if((temp!=null)&&(接口参数表名.length()>0))
for(int j=0;j<参数表数据.length;j++)
{
if(参数表数据[j][1].trim().equals(表格列名[i].trim()) || 参数表数据[j][1].trim().equals(列标题[i].trim()))
{
if(参数表数据[j][4]==null)
{
if(temp.indexOf(".")>=0 && (Double.parseDouble(temp)>Double.parseDouble(参数表数据[j][2]) ||
Double.parseDouble(temp)<Double.parseDouble(参数表数据[j][3])))
{
return null;
}
else if(Integer.parseInt(temp)>Integer.parseInt(参数表数据[j][2]) ||
Integer.parseInt(temp)<Integer.parseInt(参数表数据[j][3]))
return null;
}
else
{
String strs[]=参数表数据[j][4].split("，");
boolean flag=false;
for(int ii=0;ii<strs.length;ii++)
{
if(strs[ii].trim().equals(temp.trim()))
{
flag=true;
break;
}
}
if(!flag)
return null;
}
}
}
if (main1.数字数据类型.lastIndexOf(列数据类型[i]) > 0)
{
ss += 表格列名[i] + "=" + temp;
} else
{
ss += 表格列名[i] + "='" + temp + "'";
}
if (i < 表格列数 - 1)
ss += ",";
}
ss = " update " + 表名 + " set " + ss + s3;
return ss;
}
static int itemCount(int row)
{ 临时=临时+1;
s1 = "";
int j = 0;
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i]= tableModel.getValueAt(row, 关键字序号[i]) == null ? "" : tableModel
.getValueAt(row, i).toString();
if (关键字段值[i].compareTo(" ") < 0)
j = -1;
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 关键字段名[i] + "=" + 关键字段值[i];
else
s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
if (j >= 0)
{
s3 = " where " + s1;
s1 = "select * from " + 表名 + " where " + s1;
ResultSet rs; //检查关键字重复
try
{
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = sta.executeQuery(s1);
rs.last();
记录条数1 = rs.getRow();
s1 = "";
sta.close();
rs.close();
} catch (SQLException e)
{
e.printStackTrace();
}// 执行查询
return 记录条数1;
} else
return -1;
}
public void itemStateChanged(ItemEvent e)
{
String item = list1.getSelectedItem();
tableModel.setValueAt(item, currentRow, currentColumn);
}
}
33.源码33，部件程序，清库与批处理程序。
/*
* 程序文件名：tableTenance8.java
* 作者：程学先
* 完成时间：2013年11月27日
* 程序功能：清库与批处理程序。
* 全部清空:在清空表名集中输入需要清空的表名，之后点击“字段名清空”。
* 按字段号清空：在调用程序前必须输入表名，运行时选择所有需要清空的列名，再点击“按字段号清空”。
* 批处理：在调用程序前必须输入表名，选择结果字段名，可以有多个，彼此用逗号分隔，例如：应发工资,总扣工资,实发工资
* 之后输入计算公式集，可以有多个，彼此用逗号分隔，例如：
* 基本工资+补发+岗位工资,所得税+行政费,应发工资-总扣工资
* 结果字段名与计算公式的个数应当相同，次序应对应。
* 可以填入条件式，例如：部门号="1"
* 点击“批处理”按钮。可以检查所生成的语句并进行修改。
* 点击“执行SQL语句”完成批处理。
* 覆盖式转存：在调用程序前必须输入表名，选择目的表名，将表格数据转存到另一目的表中。
* 例如对某些财务表期末转期初的操作。表名为期末表名，目的表为期初表名。点击覆盖式转存。
* 如果是转到新表中可以同时完成建表与转存操作。如果原来有同名表，将删除原表之后转存。
* 添加式转存：在调用程序前必须输入表名，选择目的表名，将表格数据转存到另一目的表尾。
* 目的表原有数据保存不变。注意二个表结构应当相同。
* 注意如果涉及条件表达式或计算公式，都必须是SQL语句所允许的格式。
*/
import java.awt.*;
import java.io.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import java.sql.*;
public class tableTenance8 extends JFrame {
static tableTenance8 frame1 = new tableTenance8();
private static String[] 批处理公式集 = { "", "", "" };
private static String[] 结果字段集 = { "", "", "" };
private static DefaultListModel fModel = new DefaultListModel();
private static JPanel 面板 = new JPanel(false);
private static int 窗口宽 = 1000, 窗口高 = 640;
private static Connection dbConn = null;
static Statement sta3;
static ResultSet rs;
static ResultSetMetaData rsmd3;
static String 导出表名1;
static String 清空表名集1;
static String 关键字段名1;
static String 清除字段名表1;
static String 结果字段名1;
static String 条件表达式1;
static String 计算公式1;
static String 表名;
static String 表名表 = "";
static String[] 一条记录 = new String[12];
static String[] 关系符 = { ">", "<", "=", ">=", "<=", "!>" };
static JScrollPane scrollPane = new JScrollPane();
static DefaultTableModel 表格模型;
static JTable 表格;
static JScrollPane scrollPane1 = new JScrollPane();
static String s1 = "", s2 = "", s3 = "", s4 = "", s5 = "";
static int b = 0, c = 0;
static int 列数 = 0, 列数0 = 0, 表数0 = 0, 序号 = 0, 记录条数 = 0;
static String[] 列名;
static String[] 列数据类型;
static int[] 列数据宽度;
static int[] 列小数位;
static String 关键字 = "";
static JLabel 导出表名0 = new JLabel("导出表名");
static JTextField 导出表名 = new JTextField();
static JLabel 清空表名集0 = new JLabel("清空表名集");
static JTextField 清空表名集 = new JTextField();
static JLabel 关键字段名0 = new JLabel("关键字段名");
static JTextField 关键字段名 = new JTextField();
static JLabel 清除字段名表0 = new JLabel("清除字段名表");
static JTextField 清除字段名表 = new JTextField();
static JLabel 结果字段名0 = new JLabel("结果字段名");
static JTextField 结果字段名 = new JTextField();
static JLabel 条件表达式0 = new JLabel("条件表达式");
static JTextField 条件表达式 = new JTextField();
static JLabel 计算公式0 = new JLabel("计算公式");
static JTextField 计算公式 = new JTextField();
static String[][] 表格数据;
static String 字段名串 = ",";
static String 字段名串0 = ",";
static JLabel SQL语句1 = new JLabel("SQL语句");
static JTextArea SQL1文本域 = new JTextArea();
static JScrollPane SQL1文本域滚动条 = new JScrollPane(SQL1文本域);
static java.awt.List 列表框 = new java.awt.List();
static JScrollPane 列表框滚动条 = new JScrollPane(列表框);
static JButton 全部清空 = new JButton();
static JButton 按字段名清空 = new JButton();
static JButton 批处理 = new JButton();
static JButton 覆盖式转存 = new JButton();
static JButton 添加式转存 = new JButton();
static JButton 执行SQL语句 = new JButton();
static JButton 退出按钮 = new JButton();
static char x1 = 10, x2 = 13;
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 按钮数 = 0, 按钮宽 = 0;
public static void means(String[] parameter) {
frame1 = new tableTenance8();
批处理公式集[0] = "";
批处理公式集[1] = "";
批处理公式集[2] = "";
结果字段集[0] = "";
结果字段集[1] = "";
结果字段集[2] = "";
fModel = new DefaultListModel();
面板 = new JPanel(false);
窗口宽 = 1000;
窗口高 = 640;
表名表 = "";
一条记录 = new String[12];
关系符[0] = ">";
关系符[0] = "<";
关系符[0] = "=";
关系符[0] = ">=";
关系符[0] = "<=";
关系符[0] = "!>";
scrollPane = new JScrollPane();
scrollPane1 = new JScrollPane();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
s5 = "";
b = 0;
c = 0;
列数 = 0;
列数0 = 0;
表数0 = 0;
序号 = 0;
记录条数 = 0;
关键字 = "";
导出表名0 = new JLabel("导出表名");
导出表名 = new JTextField();
清空表名集0 = new JLabel("清空表名集");
清空表名集 = new JTextField();
关键字段名0 = new JLabel("关键字段名");
关键字段名 = new JTextField();
清除字段名表0 = new JLabel("清除字段名表");
清除字段名表 = new JTextField();
结果字段名0 = new JLabel("结果字段名");
结果字段名 = new JTextField();
条件表达式0 = new JLabel("条件表达式");
条件表达式 = new JTextField();
计算公式0 = new JLabel("计算公式");
计算公式 = new JTextField();
字段名串 = ",";
字段名串0 = ",";
SQL语句1 = new JLabel("SQL语句");
SQL1文本域 = new JTextArea();
SQL1文本域滚动条 = new JScrollPane(SQL1文本域);
列表框 = new java.awt.List();
列表框滚动条 = new JScrollPane(列表框);
String[] 按钮集01 = { "全部清空", "按字段号清空", "批处理", "覆盖式转存", "添加式转存",
"执行SQL语句", "退出" };
按钮集 = 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) {
}
全部清空 = new JButton();
按字段名清空 = new JButton();
批处理 = new JButton();
覆盖式转存 = new JButton();
添加式转存 = new JButton();
执行SQL语句 = new JButton();
退出按钮 = new JButton();
x1 = 10;
x2 = 13;
导出表名1 = parameter[2];
表名 = parameter[4];
清空表名集1 = parameter[5];
关键字 = parameter[6];
清除字段名表1 = parameter[8];
结果字段名1 = parameter[9];
条件表达式1 = parameter[13];
计算公式1 = parameter[14];
面板.setBackground(Color.lightGray);
面板.setLayout(null);
面板.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 10);
try {
String[] tableType = { "TABLE" };
Connection con;
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
ResultSet resultSet = databaseMetaData.getTables(null, null, "%",
tableType);
while (resultSet.next()) {
表名表 = 表名表 + resultSet.getString("TABLE_NAME") + ",";
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "获取表名失败！");
}
if ((表名 != null) && (表名.length() > 0)) {
int c = 0;
int b = 0;
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 表名;
rs = sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
列数 = rsmd3.getColumnCount();
列名 = new String[列数];
一条记录 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
列小数位 = new int[列数];
int 表1宽度 = 0;
for (int i = 0; i < 列数; i++) {
列名[i] = rsmd3.getColumnName(i + 1);
一条记录[i] = " ";
列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
列小数位[i] = rsmd3.getScale(i + 1);
表1宽度 = 表1宽度 + 列数据宽度[i] * 4;
}
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
dbConn.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据表失败！" + s1);
return;
}
表格模型 = new DefaultTableModel(表格数据, 列名);
表格 = new JTable(表格模型);
表格.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < 列数; i++) {
TableColumn tc = 表格.getColumn(列名[i]);
tc.setPreferredWidth(列数据宽度[i] * 4);
}
scrollPane.getViewport().add(表格, null);
scrollPane.setBounds(10, 140, 700, 270);
面板.add(scrollPane);
}
导出表名0.setBounds(10, 20, 60, 20);
面板.add(导出表名0, null);
导出表名.setBounds(70, 20, 120, 20);
面板.add(导出表名, null);
导出表名.setText(导出表名1);
导出表名.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 1;
列表框.removeAll();
String[] s6 = 表名表.split(",");
for (int i = 0; i < s6.length; i++)
列表框.add(s6[i]);
}
});
清空表名集0.setBounds(190, 20, 80, 20);
面板.add(清空表名集0, null);
清空表名集.setBounds(270, 20, 200, 20);
清空表名集.setText(清空表名集1);
面板.add(清空表名集, null);
清空表名集.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 2;
列表框.removeAll();
String[] s6 = 表名表.split(",");
for (int i = 0; i < s6.length; i++)
列表框.add(s6[i]);
}
});
关键字段名0.setBounds(470, 20, 80, 20);
面板.add(关键字段名0, null);
关键字段名.setBounds(550, 20, 155, 20);
关键字段名.setText(关键字);
面板.add(关键字段名, null);
关键字段名.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 3;
列表框.removeAll();
for (int i = 0; i < 列名.length; i++)
列表框.add(列名[i]);
}
});
清除字段名表0.setBounds(10, 50, 90, 20);
面板.add(清除字段名表0, null);
清除字段名表.setBounds(100, 50, 400, 20);
清除字段名表.setText(清除字段名表1);
面板.add(清除字段名表, null);
清除字段名表.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 4;
列表框.removeAll();
for (int i = 0; i < 列名.length; i++)
列表框.add(列名[i]);
}
});
结果字段名0.setBounds(500, 50, 80, 20);
面板.add(结果字段名0, null);
结果字段名.setBounds(580, 50, 125, 20);
结果字段名.setText(结果字段名1);
面板.add(结果字段名, null);
结果字段名.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 5;
列表框.removeAll();
for (int i = 0; i < 列名.length; i++)
列表框.add(列名[i]);
for (int i = 0; i < 结果字段集.length; i++)
列表框.add(结果字段集[i]);
}
});
条件表达式0.setBounds(10, 80, 80, 20);
面板.add(条件表达式0, null);
条件表达式.setBounds(75, 80, 630, 20);
条件表达式.setText(条件表达式1);
面板.add(条件表达式, null);
条件表达式.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 6;
列表框.removeAll();
for (int i = 0; i < 列名.length; i++)
列表框.add(列名[i]);
列表框.add("以下选择关系符");
for (int i = 0; i < 关系符.length; i++)
列表框.add(关系符[i]);
列表框.add("以下选择逻辑联系符");
列表框.add(" and ");
列表框.add(" or ");
}
});
计算公式0.setBounds(10, 110, 60, 20);
面板.add(计算公式0, null);
计算公式.setBounds(75, 110, 630, 20);
计算公式.setText(计算公式1);
面板.add(计算公式, null);
计算公式.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
序号 = 7;
列表框.removeAll();
for (int i = 0; i < 列名.length; i++)
列表框.add(列名[i]);
for (int i = 0; i < 批处理公式集.length; i++)
列表框.add(批处理公式集[i]);
}
});
SQL语句1.setBounds(20, 450, 70, 20);
面板.add(SQL语句1, null);
SQL1文本域滚动条.setFont(new java.awt.Font("Dialog", 0, 12));
SQL1文本域滚动条.setBounds(new Rectangle(90, 420, 820, 90));
SQL1文本域.setLineWrap(true);
面板.add(SQL1文本域滚动条, null);
列表框滚动条.setFont(new java.awt.Font("Dialog", 0, 12));
列表框滚动条.setBounds(new Rectangle(730, 20, 190, 380));
面板.add(列表框滚动条, null);
列表框.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
switch (序号) {
case 1:
导出表名.setText(列表框.getSelectedItem());
break;
case 2:
if (清空表名集.getText().length() < 1)
清空表名集.setText(列表框.getSelectedItem());
else
清空表名集.setText(清空表名集.getText() + ","
+ 列表框.getSelectedItem());
break;
case 3:
if (关键字段名.getText().length() < 1)
关键字段名.setText(列表框.getSelectedItem());
else
关键字段名.setText(关键字段名.getText() + ","
+ 列表框.getSelectedItem());
break;
case 4:
if (清除字段名表.getText().length() < 1)
清除字段名表.setText(列表框.getSelectedItem());
else
清除字段名表.setText(清除字段名表.getText() + ","
+ 列表框.getSelectedItem());
break;
case 5:
if (结果字段名.getText().length() > 0)
结果字段名.setText(结果字段名.getText() + ","
+ 列表框.getSelectedItem());
else
结果字段名.setText(列表框.getSelectedItem());
break;
case 6:
if (条件表达式.getText().length() < 1)
条件表达式.setText(列表框.getSelectedItem());
else
条件表达式.setText(条件表达式.getText() + ","
+ 列表框.getSelectedItem());
break;
case 7:
if (计算公式.getText().length() < 1)
计算公式.setText(列表框.getSelectedItem());
else
计算公式.setText(计算公式.getText() + " "
+ 列表框.getSelectedItem());
break;
}
}
});
要求按钮号表 = "," + 要求按钮号表 + ",";
int no1 = 0;
;
if (要求按钮号表.length() < 3)
no1 = 7;
else
for (int i = 0; i < 7; i++)
if (要求按钮号表.lastIndexOf("," + i + ",") >= 0)
no1 = no1 + 1;
int 按钮宽 = (窗口宽 - 60) / 按钮数;
int 按钮左边距 = 10;
全部清空.setFont(new java.awt.Font("Dialog", 0, 12));
全部清空.setText(按钮集[0]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
全部清空.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",0,") >= 0) {
面板.add(全部清空);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
全部清空.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
String[] s6 = 清空表名集.getText().trim().split(",");
for (int i = 0; i < s6.length; i++) {
if (s6[i].length() > 0)
s1 = "delete from " + s6[i];
try {
dbConn = main1.getConn();
if (SQL1文本域.getText().length() == 0)
SQL1文本域.setText(s1);
else
SQL1文本域.setText(SQL1文本域.getText() + x1 + x2 + s1);
PreparedStatement pstm4 = dbConn.prepareStatement(s1);
pstm4.execute();
dbConn.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
});
按字段名清空.setFont(new java.awt.Font("Dialog", 0, 12));
按字段名清空.setText(按钮集[1]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
按字段名清空.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",1,") >= 0) {
面板.add(按字段名清空);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
按字段名清空.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String[] s6 = 清除字段名表.getText().trim().split(",");
s1 = "update " + 表名 + " set ";
s2 = "";
for (int i = 0; i < s6.length; i++)
if (s6[i].length() > 0) {
if (s2.length() > 0)
s2 = s2 + "," + s6[i];
else
s2 = s6[i];
s2 = s2 + "=";
for (int j = 0; j < 列数; j++)
if (s6[i].trim().equals(列名[j].trim())) {
if (main1.数字数据类型.lastIndexOf("," + 列数据类型[j]
+ ",") >= 0)
s2 = s2 + "0";
else
s2 = s2 + "' '";
break;
}
}
s1 = s1 + s2;
try {
dbConn = main1.getConn();
SQL1文本域.setText(s1);
PreparedStatement pstm4 = dbConn.prepareStatement(s1);
pstm4.execute();
dbConn.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
});
批处理.setFont(new java.awt.Font("Dialog", 0, 12));
批处理.setText(按钮集[2]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0)) {
批处理.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",2,") >= 0) {
面板.add(批处理);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
批处理.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
String[] s3 = 结果字段名.getText().trim().split(",");
String[] s4 = 计算公式.getText().trim().split(",");
int k = s3.length;
if (s4.length < k)
k = s4.length;
for (int i = 0; i < k; i++) {
s1 = "update " + 表名 + " set ";
s1 = s1 + s3[i];
s1 = s1 + "=";
s1 = s1 + s4[i];
if (条件表达式.getText().trim().length() > 0)
s1 = s1 + " where " + 条件表达式.getText().trim();
if (SQL1文本域.getText().length() > 0)
SQL1文本域.setText(SQL1文本域.getText() + x1 + x2 + s1);
else
SQL1文本域.setText(s1);
}
}
});
执行SQL语句.setFont(new java.awt.Font("Dialog", 0, 12));
执行SQL语句.setText(按钮集[5]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0)) {
执行SQL语句.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",3,") >= 0) {
面板.add(执行SQL语句);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
执行SQL语句.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
char x1 = 10, x2 = 13;
String x = x1 + "" + x2;
String[] s2 = SQL1文本域.getText().toString().split(x);
for (int j = 0; j < s2.length; j++) {
s1 = s2[j];
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
dbConn.close();
}
sta3.close();
if (表名.trim().length() > 0) {
int b = 0, c = 0;
s1 = "select * from " + 表名;
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs1 = sta3.executeQuery(s1);
rsmd3 = rs1.getMetaData();
列数 = rsmd3.getColumnCount();
列名 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i = 0; i < 列数; i++) {
列名[i] = rsmd3.getColumnName(i + 1);
列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
if (列数据宽度[b] < 列名[b].length())
列数据宽度[b] = 列名[b].length();
else if (列数据宽度[b] > 50)
列数据宽度[b] = 50;
}
int rowNumber = 0;
rs1.last();
rowNumber = rs1.getRow();
表格数据 = new String[rowNumber][列数];
rs1.absolute(1);
c = 0;
b = 0;
while (c < rowNumber) {
rs1.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
sta3.close();
dbConn.close();
}
} catch (Exception e1) {
e1.printStackTrace();
}
表格模型 = new DefaultTableModel(表格数据, 列名);
表格 = new JTable(表格模型);
表格.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < 列数; i++) {
TableColumn tc = 表格.getColumn(列名[i]);
tc.setPreferredWidth(列数据宽度[i] * 4);
}
}
});
覆盖式转存.setFont(new java.awt.Font("Dialog", 0, 12));
覆盖式转存.setText(按钮集[3]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {
覆盖式转存.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",4,") >= 0) {
面板.add(覆盖式转存);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
覆盖式转存.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
try {
dbConn = main1.getConn();// 连接目的数据库
Statement stat3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (("," + 表名表).lastIndexOf("," + 导出表名.getText().trim()
+ ",") >= 0) {
s1 = "drop table " + 导出表名.getText().trim();
SQL1文本域.setText(s1);
stat3.executeUpdate(s1);
stat3.close(); // 关闭连接
dbConn.close();
}
} catch (SQLException e1) {
}
{
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * into " + 导出表名.getText().trim()
+ " from " + 表名;
SQL1文本域.setText(s1);
sta3.executeUpdate(s1);
sta3.close(); // 关闭连接
dbConn.close();
sta3.close(); // 关闭连接
dbConn.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
}
});
添加式转存.setFont(new java.awt.Font("Dialog", 0, 12));
添加式转存.setText(按钮集[4]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 0)) {
添加式转存.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",5,") >= 0) {
面板.add(添加式转存);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
添加式转存.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
int b = 0, c = 0;
char x1 = 10, x2 = 13;
s1 = "select * from " + 表名;
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs1 = sta3.executeQuery(s1);
rsmd3 = rs1.getMetaData();
列数 = rsmd3.getColumnCount();
列名 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i = 0; i < 列数; i++) {
列名[i] = rsmd3.getColumnName(i + 1);
列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
}
int rowNumber = 0;
rs1.last();
rowNumber = rs1.getRow();
表格数据 = new String[rowNumber][列数];
rs1.absolute(1);
c = 0;
b = 0;
while (c < rowNumber) {
rs1.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
sta3.close();
dbConn.close();
} catch (Exception e1) {
e1.printStackTrace();
}
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < 表格数据.length; i++) {
s1 = "insert into " + 导出表名.getText() + " (";
for (int k1 = 0; k1 < 列名.length; k1++)
s1 = s1 + 列名[k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < 列名.length; j++) {
if (main1.数字数据类型.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 != 列名.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
SQL1文本域.setText(SQL1文本域.getText() + x1 + x2 + s1);
sta3.executeUpdate(s1);
}
sta3.close(); // 关闭连接
dbConn.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
});
退出按钮.setFont(new java.awt.Font("Dialog", 0, 12));
退出按钮.setText(按钮集[6]);
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",6,") >= 0)) {
退出按钮.setBounds(按钮左边距, 窗口高 - 100, 按钮宽, 20);
if (要求按钮号表.indexOf(",6,") >= 0) {
面板.add(退出按钮);
按钮左边距 = 按钮左边距 + 按钮宽;
}
}
退出按钮.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
}
});
frame1.setTitle("数据表清空与批处理程序 作者：程学先");
frame1.setBounds(0, 0, 窗口宽, 窗口高);
frame1.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
frame1.getContentPane().setLayout(null);
frame1.getContentPane().add(面板, null);
frame1.setVisible(true);
}
}
34.源码34，工具程序，表格式数据维护部件完整性控制条件设置程序。
/*
* 程序文件名：tableTenance7.java
* 作者：齐赛
* 程序功能：用于表格式数据维护部件设置完整性控制条件。
* 数据表常要求做安全性以及完整性检查与控制
* 1.在参数表控件中输入参数表名，若该表在数据库中不存在，则会自动创建一个参数表，
* 字段是： "标志位","字段名称", "最大值", "最小值", "值域", "条件表达式"，"用户名称", "许可字段号", "权限"
* 2.若输入的参数表名存在，则会自动加载到表格中，
* 本程序只显示"字段名称", "最大值", "最小值", "值域", "条件表达式"这5个字段
* 3.在数据存盘时会根据表格数据去验证记录是否重复，验证规则是检查字段名称是否相同
* 4.本程序设定的参数保存时，完整性控制条件的 标志位为3，安全性控制的标志位为2.
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Vector;
public class completeTool4DB extends JFrame
{
static completeTool4DB frame;
static JPanel panel; // 定义面板
static DefaultTableModel 表格模型; // 定义表格模型对象
static JTable 表格; // 定义表格对象
static JScrollPane tableScroll; // 定义表格滚动条
static JScrollPane listScroll; // 定义列表框滚动条
static List list;
static JLabel tNameL, refNameL, fieldNameL, maxL, minL, rangeL, expL;
static JTextField tName, refName,fieldName, max, min, range, exp; // 定义文本框用来放存入、修改数据,分别对应的currentComp为0,1,2,3,4,5,6
static JButton add,del,upd,reset,exit;
static ArrayList<String> 表名=new ArrayList<String>() ;
static String []列名;
private static String[][] 表格数据;
static int currentComp=-1;//标识list选中数据事件填充哪个组件
static Connection con;
static Statement sta;
static ResultSet rt;
static ResultSetMetaData rtmd;
public completeTool4DB()
{
panel=new JPanel();
tableScroll=new JScrollPane();
listScroll=new JScrollPane();
list=new List();
tNameL=new JLabel("数据表名");
refNameL=new JLabel("参数表名");
fieldNameL=new JLabel("字段名称");
maxL=new JLabel("最大值");
minL=new JLabel("最小值");
rangeL=new JLabel("值域");
expL=new JLabel("表达式");
tName=new JTextField();
refName=new JTextField();
fieldName=new JTextField();
max=new JTextField();
min=new JTextField();
range=new JTextField();
exp=new JTextField();
add=new JButton("添加记录");
del=new JButton("删除记录");
upd=new JButton("更改记录");
reset=new JButton("清空参数");
exit=new JButton("退 出");
}
public static void main(String[] args)
{
表名=new ArrayList<String>() ;
currentComp=-1;
frame=new completeTool4DB();
main1.driver1();
frame.initGUI();
}
public void initGUI()
{
this.setTitle("最大值、最小值指该字段输入极限，值域指所填数据只能在该域内数据中选取，条件表达式指该字段数据必须满足的条件。 作者：齐赛"); // 窗口标题
this.setBounds(10, 10, 880, 660); // 窗口位置大小
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
panel.setBounds(10, 10, 880, 660); // 定义面板大小与位置
panel.setLayout(null); // 关闭面板布局管理器
列名 = new String[]{ "字段名称", "最大值", "最小值", "值域", "条件表达式" }; // 定义表格列名数组
tNameL.setBounds(40, 10, 80, 20);
panel.add(tNameL); // 定义文本框的标签
tName.setBounds(130, 10, 100, 20);
panel.add(tName); // 加入文本框
tName.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0) { // 获得焦点
currentComp = 0;
list.removeAll();
if (表名.size() < 1) {
try {
main1.getConn();// 连接数据库
String[] tableType = { "TABLE" };
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData(); // 获取DatabaseMetaData实例
rt = databaseMetaData.getTables(null, null, "%",
tableType);// 获取数据库中所有数据表集合
while (rt.next()) { // 遍历集合
表名.add(rt.getString("TABLE_NAME"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
for (int i = 0; i < 表名.size(); i++)
list.add(表名.get(i).toString());
}
});
refNameL.setBounds(250, 10, 80, 20);
panel.add(refNameL); // 定义文本框的标签
refName.setBounds(330, 10, 100, 20);
panel.add(refName); // 加入文本框
refName.addMouseListener(new MouseAdapter()
{
@Override
public void mouseClicked(MouseEvent e)
{
list.removeAll();
refName.setText(tName.getText()+"接口参数表");
} // 为表格添加鼠标事件监听器
});
refName.addFocusListener(new FocusAdapter()
{ // 加入监听
private String oldTable="";//记录上一次保存的参数表
public void focusLost(final FocusEvent fe)
{
String newTable= refName.getText().trim();
if(newTable.length()>0 && !newTable.equals(oldTable))
{
if(!表名.contains(newTable))
{
createNewTable(newTable);//数据库建表
}
oldTable=newTable;
loadRefTable(newTable);//读取参数表
}
}
});
表格模型 = new DefaultTableModel(表格数据, 列名); // 创建表格模型
表格 = new JTable(表格模型); // 创建指定表格模型的表格
表格.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
表格.addMouseListener(new MouseAdapter()
{ // 为表格添加鼠标事件监听器
public void mouseClicked(MouseEvent e)
{ // 发生了点击事件
int currentRow = 表格.getSelectedRow(); // 获得被选中行的索引
String val="";
for (int j = 0; j < 5; j++)
{
if (表格模型.getValueAt(currentRow, j) != null)
val= 表格模型.getValueAt(currentRow, j).toString();
else
val = "";
switch (j)
{
case 0:
fieldName.setText(val.toString());
break;
case 1:
max.setText(val.toString());
break;
case 2:
min.setText(val.toString());
break;
case 3:
range.setText(val.toString());
break;
case 4:
exp.setText(val.toString());
break;
}
}
}
});
tableScroll.setBounds(10, 40, 700, 400);
tableScroll.setViewportView(表格);
panel.add(tableScroll, BorderLayout.CENTER);
fieldNameL.setBounds(30, 460, 80, 20);
panel.add(fieldNameL); // 定义文本框的标签
fieldName.setBounds(110, 460, 100, 20);
panel.add(fieldName); // 加入文本框
fieldName.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent fe)
{ // 获得焦点
currentComp=2;
if (tName.getText().toString().length() > 0)
{// 如果已经输入了数据表表名
try
{
main1.getConn();// 连接数据库
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE); // 可更新
String sqlStr = "select * from " + tName.getText().trim(); // 查取全表数据
rt = sta.executeQuery(sqlStr);// 执行查询ResultSet
rt.last(); // 移动到最后一行
rtmd = rt.getMetaData();
int count = rtmd.getColumnCount(); // 获取列数
list.removeAll();
for (int i = 0; i < count; i++)
{
list.add(rtmd.getColumnName(i + 1));
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "连接数据库出错！");
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
});
maxL.setBounds(240, 460, 60, 20);
panel.add(maxL); // 定义文本框的标签
max.setBounds(300, 460, 100, 20);
panel.add(max); // 加入文本框
max.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=3;
list.removeAll();
}
});
minL.setBounds(430, 460, 60, 20);
panel.add(minL); // 定义文本框的标签
min.setBounds(490, 460, 100, 20);
panel.add(min); // 加入文本框
min.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=4;
list.removeAll();
}
});
rangeL.setBounds(620, 460, 60, 20);
panel.add(rangeL); // 定义文本框的标签
range.setBounds(680, 460, 100, 20);
panel.add(range); // 加入文本框
range.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=5;
list.removeAll();
}
});
panel.add(expL); // 定义文本框的标签
panel.add(exp); // 加入文本框
expL.setBounds(30, 500, 80, 20);
exp.setBounds(110, 500, 100, 20);
exp.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=6;
list.removeAll();
}
});
list.setBounds(720, 10, 120, 430); // 列表框大小位置
panel.add(list);
list.addMouseListener(new MouseAdapter()
{ // 添加鼠标事件监听器
public void mouseClicked(MouseEvent e)
{
switch (currentComp)
{ // 根据当前列号确定焦点
case 0: // 表名
tName.setText(list.getSelectedItem());
break;
case 2: // 字段名
fieldName.setText(list.getSelectedItem());
break;
case 3: // 最大值
max.setText(list.getSelectedItem());
break;
case 4: // 最小值
min.setText(list.getSelectedItem());
break;
case 5: // 值域
range.setText(list.getSelectedItem());
break;
case 6: // 条件表达式
exp.setText(list.getSelectedItem());
break;
}
}
});
add.setBounds(20, 540, 140, 20);
add.addActionListener(new ActionListener()//添加记录
{
public void actionPerformed(ActionEvent e)
{
String[] rowValues = { fieldName.getText(), max.getText(),
min.getText(), range.getText(), exp.getText() };
for(int i=0;i<rowValues.length;i++)//处理空字符串
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues))
{
JOptionPane.showMessageDialog(frame, "该条记录已经存在!");
}
else
{
insertRecord(rowValues);
}
}
});
panel.add(add);
upd.setBounds(160, 540, 140, 20);
upd.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=表格.getSelectedRow();
if(row==-1)
return;
String[] rowValues = { fieldName.getText(), max.getText(),
min.getText(), range.getText(), exp.getText() };
for(int i=0;i<rowValues.length;i++)//处理空字符串
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues,row))
{
JOptionPane.showMessageDialog(frame, "该记录已存在!");
}
else
{
updateRecord(rowValues,row);
}
}
});
panel.add(upd);
del.setBounds(300, 540, 130, 20);
del.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=表格.getSelectedRow();
if(row==-1)
return;
deleteRecord((Vector)表格模型.getDataVector().elementAt(row),row);
}
});
panel.add(del);
reset.setBounds(430, 540, 130, 20);
reset.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
fieldName.setText("");
max.setText("");
min.setText("");
range.setText("");
exp.setText("");
}
});
panel.add(reset);
exit.setBounds(560, 540, 130, 20);
exit.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
panel.setVisible(false);
frame.setVisible(false);
System.exit(0);
}
});
panel.add(exit);
this.add(panel);
this.setVisible(true);
}
protected void deleteRecord(Vector v,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="delete from "+refName.getText().trim()+" where 标志位=3 AND 字段名称='"+v.get(0)+"'";
sta.executeUpdate(sqlStr);
String [][]tempData=new String[表格数据.length-1][];//更新表格数据
for(int i=0;i<tempData.length;i++)
{
if(i<row)
{
tempData[i]=表格数据[i];
}
else
{
tempData[i]=表格数据[i+1];
}
}
表格数据=tempData;
表格模型.removeRow(row);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void updateRecord(String[] rowValues,int row)//更改记录
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="update "+refName.getText().trim()+" set ";
String temp="";
String temp1="";
for(int i=0;i<列名.length;i++)
{
temp1=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
temp+=列名[i]+"="+temp1;
}
temp=temp.substring(0, temp.length()-1);
sqlStr+=temp+" where 标志位=3 AND 字段名称='"+表格数据[row][0]+"'";
sta.executeUpdate(sqlStr);
表格数据[row]=rowValues;
Vector<String>v=new Vector<String>();
for(int i=0;i<rowValues.length;i++)
{
v.add(rowValues[i]);
}
表格模型.getDataVector().setElementAt(v, row);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues, int row)
{
boolean flag=false;
for(int i=0;i<表格数据.length;i++)
{
if(row==i)
continue;
if((rowValues[0]==表格数据[i][0] || rowValues[0].equals(表格数据[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void insertRecord(String[] rowValues)//数据库插入记录
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="insert into "+refName.getText().trim()+"( 标志位,";
String temp="";
String temp1="values (3,";
for(int i=0;i<列名.length;i++)
{
temp+=列名[i]+",";
temp1+=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
}
temp=temp.substring(0, temp.length()-1)+")";
temp1=temp1.substring(0, temp1.length()-1)+")";
sqlStr+=temp+temp1;
sta.executeUpdate(sqlStr);
String tempArray[][] = new String[表格数据.length+1][];// 更新表格数据
for (int i = 0; i < 表格数据.length; i++)
{
if (i == 表格数据.length - 1)
{
tempArray[i] = rowValues;
} else
{
tempArray[i] = 表格数据[i];
}
}
表格数据 = tempArray;
表格模型.addRow(rowValues);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues)//判断记录是否重复
{
return false;
}
protected void loadRefTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String sqlStr="select 字段名称,最大值,最小值,值域,条件表达式 from "+tname+" where 标志位 = 3";
rt=sta.executeQuery(sqlStr);
rt.last();
int count=rt.getRow();
表格数据=new String[count][5];
rt.absolute(1);
for(int i=0;i<count;i++)
{
for(int j=0;j<5;j++)
{
表格数据[i][j]=rt.getString(j+1);
}
rt.next();
}
表格模型.setDataVector(表格数据, 列名);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(frame, "参数表不正确！");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void createNewTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="CREATE TABLE [dbo].["+tname+"]("+
"[标志位] [tinyint] NOT NULL,"+
"[字段名称] [varchar](50) NULL,"+
"[最大值] [real] NULL,"+
"[最小值] [real] NULL,"+
"[值域] [nvarchar](50) NULL,"+
"[条件表达式] [nvarchar](50) NULL,"+
"[用户名称] [nvarchar](50) NULL,"+
"[许可字段号] [nvarchar](50) NULL,"+
"[权限] [nchar](10) NULL"+
") ON [PRIMARY]";
sta.executeUpdate(sqlStr);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "接口参数表创建失败!");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
35.源码35，工具程序，表格式数据维护部件安全性控制条件设置程序。
/*
* 程序文件名：tableTenance7.java
* 作者：齐赛
* 程序功能：本程序用于维护部件设置安全性控制条件。
* 1.在参数表控件中输入参数表名，若该表在数据库中不存在，则会自动创建一个参数表，
* 字段是： "标志位","字段名称", "最大值", "最小值", "值域", "条件表达式"，"用户名称", "许可字段号", "权限"
* 2.若输入的参数表名存在，则会自动加载到表格中，
* 此程序只显示"用户名称", "许可字段号", "权限"这三个字段
* 3.在数据存盘时会根据表格数据去检查用户名是否具有权限
* 4.数据存盘时，其 标志位为2，表示安全性控制
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Vector;
public class secureTool4DB extends JFrame
{
static secureTool4DB frame;
JPanel panel; // 定义面板
DefaultTableModel 表格模型; // 定义表格模型对象
JTable 表格; // 定义表格对象
JScrollPane tableScroll; // 定义表格滚动条
JScrollPane listScroll; // 定义列表框滚动条
List list;
JLabel tNameL, refNameL, userNameL, permFieldsL, authL;
JTextField tName, refName, userName, permFields, auth; // 定义文本框用来放存入、修改数据,分别对应的currentComp为0,1,2,3,4
JButton add,del,upd,reset,exit;
static String DBMS系统 = "sqlserver";
static String ODBC数据源 = "sql1";
String url;
static ArrayList<String> 表名=new ArrayList<String>() ;
String []列名;
private String[][] 表格数据;
static String []power=new String[]{ "i 录入权限", "u 修改权限",
"d 删除权限", "q 查询显示权限", "a 全部权限"};
static int currentComp=-1;//标识list选中数据事件填充哪个组件
Connection con;
Statement sta;
ResultSet rt;
ResultSetMetaData rtmd;
public secureTool4DB()
{
panel=new JPanel();
tableScroll=new JScrollPane();
listScroll=new JScrollPane();
list=new List();
tNameL=new JLabel("数据表名");
refNameL=new JLabel("参数表名");
userNameL=new JLabel("用户名称");
permFieldsL=new JLabel("许可字段号");
authL=new JLabel("权限");
tName=new JTextField();
refName=new JTextField();
userName=new JTextField();
permFields=new JTextField();
auth=new JTextField();
add=new JButton("添加记录");
del=new JButton("删除记录");
upd=new JButton("更改记录");
reset=new JButton("清空参数");
exit=new JButton("退 出");
}
public static void main(String[] args)
{
DBMS系统 = "sqlserver";
ODBC数据源 = "sql1";
表名=new ArrayList<String>() ;
power[0]="i 录入权限";
power[1]="u 修改权限";
power[2]="d 删除权限";
power[3]="q 查询显示权限";
power[4]="a 全部权限";
currentComp=-1;
frame=new secureTool4DB();
main1.driver1();
frame.initGUI();
}
public void initGUI()
{
this.setTitle("许可字段号填写该用户对该表所能操作的字段的顺序号。权限标志包括：i、u、d、q、a等。 作者：齐赛"); // 窗口标题
this.setBounds(10, 10, 880, 660); // 窗口位置大小
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
panel.setBounds(10, 10, 880, 660); // 定义面板大小与位置
panel.setLayout(null); // 关闭面板布局管理器
列名 = new String[]{ "用户名称", "许可字段号", "权限"}; // 定义表格列名数组
tNameL.setBounds(40, 10, 80, 20);
panel.add(tNameL); // 定义文本框的标签
tName.setBounds(130, 10, 100, 20);
panel.add(tName); // 加入文本框
tName.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0) { // 获得焦点
currentComp = 0;
list.removeAll();
if (表名.size() < 1) {
try {
main1.getConn();// 连接数据库
String[] tableType = { "TABLE" };
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData(); // 获取DatabaseMetaData实例
rt = databaseMetaData.getTables(null, null, "%",
tableType);// 获取数据库中所有数据表集合
while (rt.next()) { // 遍历集合
表名.add(rt.getString("TABLE_NAME"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
for (int i = 0; i < 表名.size(); i++)
list.add(表名.get(i).toString());
}
});
refNameL.setBounds(250, 10, 80, 20);
panel.add(refNameL); // 定义文本框的标签
refName.setBounds(330, 10, 100, 20);
panel.add(refName); // 加入文本框
refName.addMouseListener(new MouseAdapter()
{
@Override
public void mouseClicked(MouseEvent e)
{
list.removeAll();
refName.setText(tName.getText()+"接口参数表");
} // 为表格添加鼠标事件监听器
});
refName.addFocusListener(new FocusAdapter()
{ // 加入监听
private String oldTable="";//记录上一次保存的参数表
public void focusLost(final FocusEvent fe)
{
String newTable= refName.getText().trim();
if(newTable.length()>0 && !newTable.equals(oldTable))
{
if(!表名.contains(newTable))
{
createNewTable(newTable);//数据库建表
}
oldTable=newTable;
loadRefTable(newTable);//读取参数表
}
}
});
表格模型 = new DefaultTableModel(表格数据, 列名); // 创建表格模型
表格 = new JTable(表格模型); // 创建指定表格模型的表格
表格.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
表格.addMouseListener(new MouseAdapter()
{ // 为表格添加鼠标事件监听器
public void mouseClicked(MouseEvent e)
{ // 发生了点击事件
int currentRow = 表格.getSelectedRow(); // 获得被选中行的索引
String val="";
for (int j = 0; j < 3; j++)
{
if (表格模型.getValueAt(currentRow, j) != null)
val= 表格模型.getValueAt(currentRow, j).toString();
else
val = "";
switch (j)
{
case 0:
userName.setText(val.toString());
break;
case 1:
permFields.setText(val.toString());
break;
case 2:
auth.setText(val.toString());
break;
}
}
}
});
tableScroll.setBounds(10, 40, 700, 400);
tableScroll.setViewportView(表格);
panel.add(tableScroll, BorderLayout.CENTER);
userNameL.setBounds(30, 460, 80, 20);
panel.add(userNameL); // 定义文本框的标签
userName.setBounds(110, 460, 100, 20);
panel.add(userName); // 加入文本框
userName.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent fe)
{
currentComp=2;
list.removeAll();
}
});
permFieldsL.setBounds(240, 460, 80, 20);
panel.add(permFieldsL); // 定义文本框的标签
permFields.setBounds(320, 460, 100, 20);
panel.add(permFields); // 加入文本框
permFields.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=3;
list.removeAll();
if (tName.getText().toString().length() > 0)
{// 如果已经输入了数据表表名
try
{
main1.getConn();// 连接数据库
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE); // 可更新
String sqlStr = "select * from " + tName.getText().trim(); // 查取全表数据
rt = sta.executeQuery(sqlStr);// 执行查询ResultSet
rt.last(); // 移动到最后一行
rtmd = rt.getMetaData();
int count = rtmd.getColumnCount(); // 获取列数
list.removeAll();
for (int i = 0; i < count; i++)
{
list.add(rtmd.getColumnName(i + 1));
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "连接数据库出错！");
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
});
authL.setBounds(430, 460, 60, 20);
panel.add(authL); // 定义文本框的标签
auth.setBounds(490, 460, 100, 20);
panel.add(auth); // 加入文本框
auth.addFocusListener(new FocusAdapter()
{ // 加入监听
public void focusGained(final FocusEvent arg0)
{ // 获得焦点
currentComp=4;
list.removeAll();
for (int i = 0; i < power.length; i++)
{
list.add(power[i]);
}
}
});
list.setBounds(720, 10, 120, 430); // 列表框大小位置
panel.add(list);
list.addMouseListener(new MouseAdapter()
{ // 添加鼠标事件监听器
public void mouseClicked(MouseEvent e)
{
switch (currentComp)
{ // 根据当前列号确定焦点
case 0: // 表名
tName.setText(list.getSelectedItem());
break;
case 2: // 用戶名稱
userName.setText(list.getSelectedItem());
break;
case 3: // 许可字段号
permFields.setText(permFields.getText()+ list.getSelectedIndex() + ",");
break;
case 4: // 权限
auth.setText(auth.getText()+ list.getSelectedIndex() + ",");
break;
}
}
});
add.setBounds(20, 540, 140, 20);
add.addActionListener(new ActionListener()//添加记录
{
public void actionPerformed(ActionEvent e)
{
String[] rowValues = { userName.getText(), permFields.getText(),
auth.getText() };
for(int i=0;i<rowValues.length;i++)//处理空字符串
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues))
{
JOptionPane.showMessageDialog(frame, "该条记录已经存在!");
}
else
{
insertRecord(rowValues);
}
}
});
panel.add(add);
upd.setBounds(160, 540, 140, 20);
upd.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=表格.getSelectedRow();
if(row==-1)
return;
String[] rowValues = { userName.getText(), permFields.getText(),
auth.getText() };
for(int i=0;i<rowValues.length;i++)//处理空字符串
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues,row))
{
JOptionPane.showMessageDialog(frame, "该记录已存在!");
}
else
{
updateRecord(rowValues,row);
}
}
});
panel.add(upd);
del.setBounds(300, 540, 130, 20);
del.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=表格.getSelectedRow();
if(row==-1)
return;
deleteRecord((Vector)表格模型.getDataVector().elementAt(row),row);
}
});
panel.add(del);
reset.setBounds(430, 540, 130, 20);
reset.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
userName.setText("");
permFields.setText("");
auth.setText("");
}
});
panel.add(reset);
exit.setBounds(560, 540, 130, 20);
exit.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
panel.setVisible(false);
frame.setVisible(false);
System.exit(0);
}
});
panel.add(exit);
this.add(panel);
this.setVisible(true);
}
protected void deleteRecord(Vector v,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="delete from "+refName.getText().trim()+" where 标志位=2 AND 用户名称='"+v.get(0)+"'";
sta.executeUpdate(sqlStr);
String [][]tempData=new String[表格数据.length-1][];//更新表格数据
for(int i=0;i<tempData.length;i++)
{
if(i<row)
{
tempData[i]=表格数据[i];
}
else
{
tempData[i]=表格数据[i+1];
}
}
表格数据=tempData;
表格模型.removeRow(row);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void updateRecord(String[] rowValues,int row)//更改记录
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="update "+refName.getText().trim()+" set ";
String temp="";
String temp1="";
for(int i=0;i<列名.length;i++)
{
temp1=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
temp+=列名[i]+"="+temp1;
}
temp=temp.substring(0, temp.length()-1);
sqlStr+=temp+" where 标志位=2 AND 用户名称='"+表格数据[row][0]+"'";
sta.executeUpdate(sqlStr);
表格数据[row]=rowValues;
Vector<String>v=new Vector<String>();
for(int i=0;i<rowValues.length;i++)
{
v.add(rowValues[i]);
}
表格模型.getDataVector().setElementAt(v, row);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues, int row)
{
boolean flag=false;
for(int i=0;i<表格数据.length;i++)
{
if(row==i)
continue;
if((rowValues[0]==表格数据[i][0] || rowValues[0].equals(表格数据[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void insertRecord(String[] rowValues)//数据库插入记录
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="insert into "+refName.getText().trim()+"( 标志位,";
String temp="";
String temp1="values (2,";
for(int i=0;i<列名.length;i++)
{
temp+=列名[i]+",";
temp1+=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
}
temp=temp.substring(0, temp.length()-1)+")";
temp1=temp1.substring(0, temp1.length()-1)+")";
sqlStr+=temp+temp1;
sta.executeUpdate(sqlStr);
String tempArray[][] = new String[表格数据.length+1][];// 更新表格数据
for (int i = 0; i < 表格数据.length; i++)
{
if (i == 表格数据.length - 1)
{
tempArray[i] = rowValues;
} else
{
tempArray[i] = 表格数据[i];
}
}
表格数据 = tempArray;
表格模型.addRow(rowValues);
表格.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues)//判断记录是否重复
{
boolean flag=false;
for(int i=0;i<表格数据.length;i++)
{
if((rowValues[0]==表格数据[i][0] || rowValues[0].equals(表格数据[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void loadRefTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String sqlStr="select 用户名称,许可字段号,权限 from "+tname+" where 标志位 = 2";
rt=sta.executeQuery(sqlStr);
rt.last();
int count=rt.getRow();
表格数据=new String[count][3];
rt.absolute(1);
for(int i=0;i<count;i++)
{
for(int j=0;j<3;j++)
{
表格数据[i][j]=rt.getString(j+1);
}
rt.next();
}
表格模型.setDataVector(表格数据, 列名);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(frame, "参数表不正确！");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void createNewTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="CREATE TABLE [dbo].["+tname+"]("+
"[标志位] [tinyint] NOT NULL,"+
"[字段名称] [varchar](50) NULL,"+
"[最大值] [real] NULL,"+
"[最小值] [real] NULL,"+
"[值域] [nvarchar](50) NULL,"+
"[条件表达式] [nvarchar](50) NULL,"+
"[用户名称] [nvarchar](50) NULL,"+
"[许可字段号] [nvarchar](50) NULL,"+
"[权限] [nchar](10) NULL"+
") ON [PRIMARY]";
sta.executeUpdate(sqlStr);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "接口参数表创建失败!");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
36.源码36，部件程序，单记录、表格式混合部件程序。
/**
* 程序文件名：tableTenance7.java
* 作者： 齐赛
* 功能：单记录、表格式混合部件10
* 说明：
* 1.增加了列表框，点击列表框的历史数据即可进行输入，有代码表的，代码表数据也会显示在列表框中
* 2.自定义布局算法，字段采用TextFiled 和 TextArea 布局，主要根据列数据宽度来选择
* 3.数据在修改存盘时，未指定的数据统一用NULL
* 4.当存盘或者删除记录之后，表格进行实时同步更新
* 5.为提高效率，字典表和代码表需要从parameter[0]带入，如果没有指定，则会采用默认
* 6.如果作数据录入使用，需要用鼠标将分隔窗向上提，使单记录式界面展露出来再继续操作。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.plaf.ButtonUI;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
import java.io.*;
public class tableTenance10 extends JFrame
{
static tableTenance10 frame;
static JLabel statusBar1 = new JLabel("一共");
static JLabel totalItems = new JLabel();
static JLabel statusBar2 = new JLabel("条记录");
static JLabel statusBar3 = new JLabel("当前记录是第");
static JLabel currentItem = new JLabel();
static JLabel statusBar4 = new JLabel("条");
static JLabel statusBar40 = new JLabel("提示：如果作数据录入、修改使用，需要用鼠标将分隔窗向上提（或点击向上箭头），使单记录式界面展露出来再继续操作");
static JButton firstItem = new JButton("第一条");
static JButton nextItem = new JButton("下一条");
static JButton previousItem = new JButton("上一条");
static JButton endItem = new JButton("末一条");
static JButton delete = new JButton("删除记录");
static JButton addItem=new JButton("录入存盘");
static JButton updateItem=new JButton("修改存盘");
static JButton exit=new JButton("退 出");
static String [] 按钮集=null;
static String 要求按钮号表;
static int 窗口宽=0,窗口高=0,按钮数=0,按钮宽=0;
static String[] 空记录;
//监听器
MouseMonitor mm= new MouseMonitor();
FocusMonitor fm=new FocusMonitor();
ListSelectionMonitor lsm=new ListSelectionMonitor();
ButtonMonitor1 bm1=new ButtonMonitor1();
ButtonMonitor2 bm2=new ButtonMonitor2();
JTable table; // 创建表格
DefaultTableModel dtm;
JPanel fieldPane;
JPanel listPane;
JList list;
DefaultListModel dlm;
JSplitPane splitPaneV;
JSplitPane splitPaneH;
JScrollPane tableScrollPane;
JScrollPane fieldScrollPane;
JScrollPane listScrollPane;
List<Field>fields;
String 表名;
int[] 关键字表格序号;
int 表格列数;
int 表格行数;
int[] 字段号;
String 表格字段[];
String 表格数据[][];
String[] 关键字段名;
int 列数据宽度[];
String 列数据类型[];
String 字典表名;
String 字典数据[][];
String[] 中文标签;
boolean flags[];
static List<String> 代码表名 = new ArrayList<String>();
static Map<String, Map<String, String>> map = new HashMap<String, Map<String, String>>();
Connection con;
Statement sta;
ResultSet rt;
ResultSetMetaData rtmd;
static int currentRow=-1;//当前选中行
static int currentColumn=-1;
public static void means(String[] parameter)
{
String [] 按钮集01={"第一条","下一条","上一条","末一条","删除记录","录入存盘","修改存盘","退 出"};
按钮集=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){}
statusBar1=new JLabel("一共");
totalItems=new JLabel();
statusBar2=new JLabel("条记录");
statusBar3=new JLabel("当前记录是第");
currentItem=new JLabel();
statusBar4=new JLabel("条");
firstItem=new JButton(按钮集[0]);
nextItem=new JButton(按钮集[1]);
previousItem=new JButton(按钮集[2]);
endItem=new JButton(按钮集[3]);
delete=new JButton(按钮集[4]);
frame=new tableTenance10();
addItem=new JButton(按钮集[5]);
updateItem=new JButton(按钮集[6]);
exit=new JButton(按钮集[7]);
代码表名 = new ArrayList<String>();
map = new HashMap<String, Map<String, String>>();
currentRow=-1;
currentColumn=-1;
frame = new tableTenance10();
frame.initParameter(parameter);
frame.initGUI();
}
private void initGUI()
{
dtm = new DefaultTableModel(表格数据, 中文标签);
dtm.addRow(空记录);
table = new JTable();
table.setModel(dtm);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 单选
table.addMouseListener(mm);
// 改变关键字表头的颜色
table.getTableHeader().setDefaultRenderer(
new DefaultTableCellRenderer()
{
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column)
{
JComponent cell = (JComponent)super
.getTableCellRendererComponent(table, value,
isSelected, hasFocus, row, column);
for (int i = 0; i < 关键字表格序号.length; i++)
{
if (column == 关键字表格序号[i])
{
cell.setBackground(Color.LIGHT_GRAY);
break;
}
cell.setBackground(new Color(238, 238, 238));
}
cell.setBorder(BorderFactory.createRaisedBevelBorder());
return cell;
}
});
for (int i = 0; i < table.getColumnCount(); i++)
{
table.getColumnModel().getColumn(i).setPreferredWidth(100);
}
fieldPane=new JPanel();
fieldPane.setLayout(null);
fieldPane.setBackground(Color.GRAY);
fieldPane.setPreferredSize(new Dimension(850,800));
List<Field> textFields=new ArrayList<Field>();
List<Field> textAreas =new ArrayList<Field>();
int space=3;
int pointX=0,pointY=0,prePointX=0,prePointY=0,preW=0,preH=0,W=0,H=0;
for(int i=0;i<字段号.length;i++)
{
Field temp=new Field(i);
temp.getComponent().addFocusListener(fm);
if(temp.jtf==null?textAreas.add(temp):textFields.add(temp));
fields.add(temp);
}
for(int i=0;i<textFields.size();i++)
{
Field field=textFields.get(i);
if(i==0)
{
preW=(int)field.getPreferredSize().getWidth();
preH=(int)field.getPreferredSize().getHeight();
pointX+=space+preW;
pointY=pointY;
}
else
{
W=(int)field.getPreferredSize().getWidth();
H=(int)field.getPreferredSize().getHeight();
Field preField=textFields.get(i-1);
if(850-pointX>=W)
{
preField.setPreferredSize(new Dimension(preW,preH));
preField.setBounds(prePointX, prePointY, preW, preH);
preW=W;
preH=H;
prePointX=pointX;
prePointY=pointY;
pointX+=space+W;
pointY=pointY;
}
else
{
Component comp=preField.getComponent();
comp.setPreferredSize(new Dimension((int)comp.getPreferredSize().getWidth()+space+850-pointX,(int)comp.getPreferredSize().getHeight()));
preField.setPreferredSize(new Dimension(preW+space+850-pointX,preH));
preField.setBounds(prePointX, prePointY, preW+space+850-pointX, preH);
preW=W;
preH=H;
prePointX=0;
prePointY+=space+preField.getPreferredSize().getHeight();
pointX=space+W;
pointY+=space+preField.getPreferredSize().getHeight();
}
if(i==textFields.size()-1)
{
Component comp=field.getComponent();
comp.setPreferredSize(new Dimension((int)comp.getPreferredSize().getWidth()+space+850-pointX,(int)comp.getPreferredSize().getHeight()));
field.setPreferredSize(new Dimension(preW+space+850-pointX,preH));
field.setBounds(prePointX, prePointY, preW+space+850-pointX, preH);
prePointX=0;
prePointY+=space+field.getPreferredSize().getHeight();
pointX=prePointX;
pointY=prePointY;
}
}
fieldPane.add(field);
}
preW=0;preH=0;W=0;H=0;
for(int i=0;i<textAreas.size();i++)
{
Field field=textAreas.get(i);
if(i==0)
{
preW=(int)field.getPreferredSize().getWidth();
preH=(int)field.getPreferredSize().getHeight();
pointX+=space+preW;
pointY=pointY;
}
else
{
W=(int)field.getPreferredSize().getWidth();
H=(int)field.getPreferredSize().getHeight();
Field preField=textAreas.get(i-1);
if(850-pointX>=W)
{
preField.setPreferredSize(new Dimension(preW,preH));
preField.setBounds(prePointX, prePointY, preW, preH);
preW=W;
preH=H;
prePointX=pointX;
prePointY=pointY;
pointX+=space+W;
pointY=pointY;
}
else
{
Component comp=preField.getComponent();
comp.setPreferredSize(new Dimension((int)comp.getPreferredSize().getWidth()+space+850-pointX,(int)comp.getPreferredSize().getHeight()));
JScrollPane jsp=field.jsp;
jsp.setPreferredSize(new Dimension((int)jsp.getPreferredSize().getWidth()+space+850-pointX,(int)jsp.getPreferredSize().getHeight()));
preField.setPreferredSize(new Dimension(preW+space+850-pointX,preH));
preField.setBounds(prePointX, prePointY, preW+space+850-pointX, preH);
preW=W;
preH=H;
prePointX=0;
prePointY+=space+preField.getPreferredSize().getHeight();
pointX=space+W;
pointY+=space+preField.getPreferredSize().getHeight();
}
if(i==textAreas.size()-1)
{
Component comp=field.getComponent();
comp.setPreferredSize(new Dimension((int)comp.getPreferredSize().getWidth()+space+850-pointX,(int)comp.getPreferredSize().getHeight()));
JScrollPane jsp=field.jsp;
jsp.setPreferredSize(new Dimension((int)jsp.getPreferredSize().getWidth()+space+850-pointX,(int)jsp.getPreferredSize().getHeight()));
field.setPreferredSize(new Dimension(preW+space+850-pointX,preH));
field.setBounds(prePointX, prePointY, preW+space+850-pointX, preH);
pointY+=space+field.getPreferredSize().getHeight();
}
}
fieldPane.add(field);
}
fieldPane.setPreferredSize(new Dimension(850,pointY+10));
list=new JList();
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
dlm=new DefaultListModel();
list.setModel(dlm);
list.addListSelectionListener(lsm);
listScrollPane=new JScrollPane(list);
fieldScrollPane=new JScrollPane(fieldPane);
fieldScrollPane.getVerticalScrollBar().setUnitIncrement(10);
tableScrollPane=new JScrollPane(table);
splitPaneH=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, fieldScrollPane, listScrollPane);
splitPaneH.setDividerLocation(870);
splitPaneH.setOneTouchExpandable(false);
splitPaneV=new JSplitPane(JSplitPane.VERTICAL_SPLIT, tableScrollPane, splitPaneH);
splitPaneV.setDividerLocation(600);
splitPaneV.setOneTouchExpandable(true);
splitPaneV.setBounds(0, 0, 窗口宽, 500); //+185
if (表格行数 == 0)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
}
firstItem.addActionListener(bm1);
nextItem.addActionListener(bm1);
previousItem.addActionListener(bm1);
endItem.addActionListener(bm1);
addItem.addActionListener(bm2);
updateItem.addActionListener(bm2);
delete.addActionListener(bm2);
exit.addActionListener(bm2);
按钮宽=(窗口宽-60)/按钮数;
int 左边距=30;
firstItem.setBounds(左边距, 520, 按钮宽, 30);// 添加按钮
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
previousItem.setBounds(左边距, 520, 按钮宽, 30);
if (要求按钮号表.indexOf(",1,")>=0) 左边距=左边距+按钮宽;
nextItem.setBounds(左边距, 520, 按钮宽, 30);
if (要求按钮号表.indexOf(",2,")>=0) 左边距=左边距+按钮宽;
endItem.setBounds(左边距, 520, 按钮宽, 30);
if (要求按钮号表.indexOf(",3,")>=0) 左边距=左边距+按钮宽;
addItem.setBounds(左边距,520,按钮宽,30);
if (要求按钮号表.indexOf(",5,")>=0) 左边距=左边距+按钮宽;
updateItem.setBounds(左边距, 520, 按钮宽, 30);
if (要求按钮号表.indexOf(",6,")>=0) 左边距=左边距+按钮宽;
delete.setBounds(左边距,520,按钮宽,30);
if (要求按钮号表.indexOf(",4,")>=0) 左边距=左边距+按钮宽;
exit.setBounds(左边距, 520, 按钮宽, 30);
Font f = new Font("仿宋", Font.BOLD, 15);
statusBar1.setBounds(5, 555, 50, 30);
statusBar1.setFont(f);
totalItems.setBounds(55, 555, 50, 30);
totalItems.setText(String.valueOf(表格行数));// 记录总条数
totalItems.setFont(f);
statusBar2.setBounds(85, 555, 50, 30);
statusBar2.setFont(f);
statusBar3.setBounds(140, 555, 100, 30);
statusBar3.setFont(f);
currentItem.setBounds(245, 555, 50, 30);
currentItem.setFont(f);
statusBar4.setBounds(295, 555, 50, 30);
statusBar4.setFont(f);
statusBar40.setBounds(10, 500, 1000,20);
statusBar40.setFont(f);
this.setTitle("表格、单记录混合式数据维护部件11:" + 表名+" 作者：齐赛"); // 窗口标题
this.setBounds(150, 50, 窗口宽, 窗口高); // 窗口位置大小 +200
this.getContentPane().setLayout(null);
this.getContentPane().add(splitPaneV);
if (要求按钮号表.indexOf(",0,")>=0)
this.getContentPane().add(firstItem);
if (要求按钮号表.indexOf(",1,")>=0)
this.getContentPane().add(previousItem);
if (要求按钮号表.indexOf(",2,")>=0)
this.getContentPane().add(nextItem);
if (要求按钮号表.indexOf(",3,")>=0)
this.getContentPane().add(endItem);
if (要求按钮号表.indexOf(",5,")>=0)
this.getContentPane().add(addItem);
if (要求按钮号表.indexOf(",6,")>=0)
this.getContentPane().add(updateItem);
if (要求按钮号表.indexOf(",4,")>=0)
this.getContentPane().add(delete);
if (要求按钮号表.indexOf(",7,")>=0)
this.getContentPane().add(exit);
this.getContentPane().add(statusBar1);
this.getContentPane().add(totalItems);
this.getContentPane().add(statusBar2);
this.getContentPane().add(statusBar3);
this.getContentPane().add(currentItem);
this.getContentPane().add(statusBar4);
this.getContentPane().add(statusBar40);
this.addWindowListener(new WindowMonitor());
this.setVisible(true);
}
private void initParameter(String[] parameter)
{
表名 = parameter[4];
if (parameter[6] == null || parameter[6].length() == 0)
{
JOptionPane.showMessageDialog(null, "缺少关键字！");
return ;
}
关键字段名 = parameter[6].trim().split(",");
关键字表格序号 = new int[关键字段名.length];
ArrayList<Integer> 关键字数据库序号 = new ArrayList<Integer>(关键字段名.length);
for(String item:parameter[0].split(","))
{
if(item.endsWith("代码表"))
{
代码表名.add(item);
}
}
String temp[]=parameter[0].split(",");
for(int i=0;i<temp.length && 字典表名==null;i++)
{
字典表名=temp[i].endsWith("字典表")?temp[i]:null;
}
con=main1.getConn();
if (字典表名 != null && 字典表名.length() > 0)
{
try
{
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rt = sta.executeQuery("select * from " + 字典表名);
rt.last();
int count = rt.getRow();
字典数据 = new String[count][2];
rt.absolute(1);
while (count >= 1)
{
字典数据[count - 1][0] = rt.getString(1);
字典数据[count - 1][1] = rt.getString(2);
count--;
rt.next();
}
} catch (SQLException e1)
{
e1.printStackTrace();
} finally
{
try
{
if (rt != null)
{
rt.close();
rt = null;
}
if (sta != null)
{
sta.close();
sta = null;
}
} catch (SQLException sqle)
{
sqle.printStackTrace();
}
}
}
try
{
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rt = sta.executeQuery("select * from " + 表名);
rtmd = rt.getMetaData();
int columns = rtmd.getColumnCount();
TreeSet<Integer> ts = new TreeSet<Integer>();
for (int i = 1, flag = 0; i <= columns && flag < 关键字段名.length; i++)
{
for (int j = 0; j < 关键字段名.length; j++)
{
if (rtmd.getColumnName(i).trim().equals(关键字段名[j].trim()))
{
ts.add(i);
关键字数据库序号.add(i);
flag++;
break;
}
}
}
if (parameter[8] == "")
{
for (int i = 0; i < columns; i++)
{
parameter[8] +=( i == columns - 1 )? i + "" : i + ",";
}
}
String array[] = parameter[8].trim().split(",");
for (int i = 0; i < array.length; i++)
{
ts.add(Integer.valueOf(array[i]) + 1);
}
int i = 0;
int k = 0;
字段号 = new int[ts.size()];
列数据宽度=new int[ts.size()];
列数据类型=new String[ts.size()];
fields=new ArrayList<Field>(ts.size());
表格列数 = 字段号.length;
表格字段 = new String[字段号.length];
空记录 = new String[字段号.length];
Iterator<Integer> it = ts.iterator();
while (it.hasNext())
{
字段号[i] = it.next();
if (关键字数据库序号.contains(字段号[i]))
{
关键字表格序号[k++] = 字段号[i] - 1;
}
i++;
}
中文标签 = new String[表格字段.length];
flags = new boolean[表格字段.length];
for (i = 0; i < 表格列数; i++)
{
表格字段[i] = rtmd.getColumnName(字段号[i]);
if (字典数据 != null)
{
int j = 0;
for (; j < 字典数据.length; j++)
{
if (字典数据[j][0].trim().equalsIgnoreCase(表格字段[i].trim()))
{
中文标签[i] = 字典数据[j][1];
break;
}
}
if (j >= 字典数据.length)
{
中文标签[i] = 表格字段[i];
}
} else
{
中文标签[i] = 表格字段[i];
}
if (代码表名.contains(中文标签[i] + "代码表") || 代码表名.contains(中文标签[i] + "表"))
{
ResultSet rs1 = null;
Statement sta1 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String str=代码表名.contains(中文标签[i] + "代码表")?中文标签[i] + "代码表":中文标签[i] + "表";
rs1 = sta1.executeQuery("select * from " + str);
Map<String, String> codeTable = new HashMap<String, String>();
while (rs1.next())
{
String label = rs1.getString(1);
String code = rs1.getString(2);
codeTable.put(label, code);
}
map.put(中文标签[i], codeTable);
rs1.close();
rs1 = null;
sta1.close();
sta1 = null;
flags[i] = true;
}
}
rt.last();
表格行数 = rt.getRow();
表格数据 = new String[表格行数][表格列数];
i = 0;
while (i < 表格行数)
{
rt.absolute(i + 1);
for (int j = 0; j < 表格列数; j++)
{
表格数据[i][j] = rt.getString(字段号[j]);
}
i++;
}
for(int j=0;j<表格列数;j++)
{
表格字段[j] = rtmd.getColumnName(j + 1);
列数据类型[j] = rtmd.getColumnTypeName(j+1);
列数据宽度[j] = rtmd.getColumnDisplaySize(j+1);
if (列数据宽度[j] < 表格字段[j].length())
列数据宽度[j] = 表格字段[j].length();
else if (列数据宽度[j] > 50)
列数据宽度[j] = 50;
空记录[j] = "";
}
} catch (SQLException e)
{
e.printStackTrace();
} finally
{
try
{
if (rt != null)
{
rt.close();
rt = null;
}
if (sta != null)
{
sta.close();
sta = null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
private class WindowMonitor extends WindowAdapter
{
public void windowClosing(WindowEvent e)
{
exit();
}
}
public void exit()
{
tableTenance10.this.dispose();
try
{
if (con != null)
con.close();
System.out.println("数据库已断开连接！");
} catch (SQLException e1)
{
e1.printStackTrace();
System.out.println("数据库连接断开时异常！");
}
}
class Field extends JPanel implements Comparable<Field>
{
int id;
JTextField jtf;
JTextArea jta;
JLabel jlb;
JScrollPane jsp;
public Field(int id)
{
this.id = id;
if (列数据宽度[id]<60 )
{
jtf = new JTextField();
jlb = new JLabel(中文标签[id]);
jlb.setFont(new Font("仿宋", Font.BOLD, 18));
jtf.setPreferredSize(new Dimension(列数据宽度[id] * 8, 25));
this.add(jlb);
this.add(jtf);
} else
{
jta = new JTextArea();
jlb = new JLabel(中文标签[id]);
jlb.setFont(new Font("仿宋", Font.BOLD, 18));
jta.setLineWrap(true);
jsp = new JScrollPane(jta);
jsp.setPreferredSize(new Dimension(200, 80));
this.add(jlb);
this.add(jsp);
}
}
public String getFormatText()
{
String text = "";
return text;
}
public String getText()
{
return this.jta==null?jtf.getText():jta.getText();
}
public void setText(Object text)
{
String temp=text!=null?text.toString():"";
if(jta==null)
{
jtf.setText(temp);
}
else
{
jta.setText(temp);
}
}
public Component getComponent()
{
return this.jta==null?jtf:jta;
}
public int compareTo(Field o)
{
return 0;
}
}
private class MouseMonitor extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{
currentRow=table.getSelectedRow();
currentColumn=table.getSelectedColumn();
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText(table.getValueAt(currentRow, i));
}
currentItem.setText(String.valueOf(currentRow+1));
if (currentRow == 0)
{
if (currentRow == 表格行数 - 1)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
} else
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
} else
{
if (currentRow == 表格行数 - 1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
} else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
}
}
private class ButtonMonitor1 implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==firstItem)
{
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == 表格行数 - 1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
} else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
}
else if(e.getSource()==previousItem)
{
if (currentRow == -1)
{
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == 表格行数 - 1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
} else if (currentRow - 1 == 0)
{
currentRow--;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
} else
{
currentRow--;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
else if(e.getSource()==nextItem)
{
if (currentRow == -1)
{
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == 表格行数 - 1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
} else if (currentRow + 1 == 表格行数 - 1)
{
currentRow++;
endItem.setEnabled(false);
nextItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
} else
{
currentRow++;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
else if(e.getSource()==endItem)
{
currentRow = 表格行数 - 1;
endItem.setEnabled(false);
nextItem.setEnabled(false);
if (currentRow == 0)
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
} else
{
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
table.setRowSelectionInterval(currentRow, currentRow);// 选中行
table.scrollRectToVisible(table.getCellRect(currentRow, 0,
true));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText(table.getValueAt(currentRow, i));
}
currentItem.setText(String.valueOf(currentRow + 1));
}
}
private class ButtonMonitor2 implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==addItem)
{
Vector<String> v=new Vector<String>(表格列数);
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText());
}
if(v.size()<fields.size())
{
JOptionPane.showMessageDialog(frame, "关键字重复!");
return;
}
else
{
try
{
insertSQL(v);
JOptionPane.showMessageDialog(frame, "记录添加成功！");
表格行数++;
String tempArray[][] = new String[表格行数][];// 更新表格数据
for (int i = 0; i < 表格行数; i++)
{
if (i == 表格行数 - 1)
{
tempArray[i] = v.toArray(new String[] {});
} else
{
tempArray[i] = 表格数据[i];
}
}
表格数据 = tempArray;
dtm.addRow(空记录);
table.repaint();
totalItems.setText(String.valueOf(表格行数));// 记录总条数
currentItem.setText(String.valueOf(currentRow+1));
} catch (SQLException e1)
{
JOptionPane.showMessageDialog(frame, e1.getMessage());
return;
} finally
{
if(sta!=null)
{
try
{
sta.close();
sta=null;
} catch (SQLException e1)
{
}
}
}
}
}
else if(e.getSource()==updateItem)
{
if(currentRow==-1)
return;
Vector<String> v=new Vector<String>(表格列数);
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText());
}
if(isKeyExist(v, currentRow))
{
JOptionPane.showMessageDialog(frame, "关键字重复!");
return;
}
else
{
try
{
updateSQL(v, currentRow);
JOptionPane.showMessageDialog(frame, "记录更新成功！");
表格数据[currentRow] = v.toArray(new String[] {});// 更新表格数据
dtm.getDataVector().setElementAt(v, currentRow);
table.repaint();
} catch (SQLException e1)
{
JOptionPane.showMessageDialog(frame, e1.getMessage());
return;
} finally
{
if(sta!=null)
{
try
{
sta.close();
sta=null;
} catch (SQLException e1)
{
}
}
}
}
}
else if(e.getSource()==delete)
{
if(currentRow==-1)
return;
try
{
deleteSQL(表格数据[currentRow]);
String [][]tempData=new String[表格数据.length-1][];
for(int i=0;i<tempData.length;i++)
{
if(i<currentRow)
{
tempData[i]=表格数据[i];
}
else
{
tempData[i]=表格数据[i+1];
}
}
表格数据=tempData;
表格行数--;
dtm.removeRow(currentRow);
table.repaint();
currentRow=-1;
totalItems.setText(String.valueOf(表格行数));// 记录总条数
currentItem.setText(" ");
JOptionPane.showMessageDialog(frame, "记录删除成功！");
} catch (SQLException e1)
{
JOptionPane.showConfirmDialog(frame, e1.getMessage(), "数据库出错", JOptionPane.DEFAULT_OPTION, JOptionPane.ERROR_MESSAGE);
} finally
{
if(sta!=null)
{
try
{
sta.close();
sta=null;
} catch (SQLException e1)
{
e1.printStackTrace();
}
}
}
}
else if(e.getSource()==exit)
{
exit();
}
}
}
private class FocusMonitor implements FocusListener
{
int fieldID=-1;
public void focusGained(FocusEvent e)
{
Component c = (Component) e.getSource();
c.setBackground(Color.CYAN);
dlm.clear();
if(c.getParent() instanceof Field )
{
fieldID=((Field)c.getParent()).id;
if(flags[fieldID])
{
HashMap<String,String>hm=(HashMap<String, String>) map.get(中文标签[fieldID]);
if(中文标签[fieldID].endsWith("代码"))
{
for(String element:hm.values())
{
dlm.addElement(element);
}
}
else
{
for(String element:hm.keySet())
{
dlm.addElement(element);
}
}
}
else
{
Set<String> contents=new HashSet<String>();
for(int i=0;i<表格行数;i++)
{
if(contents.add(表格数据[i][fieldID]))
dlm.addElement(表格数据[i][fieldID]);
}
}
}
}
public void focusLost(FocusEvent e)
{
Component c = (Component) e.getSource();
c.setBackground(Color.WHITE);
}
}
private class ListSelectionMonitor implements ListSelectionListener
{
public void valueChanged(ListSelectionEvent e)
{
if(e.getValueIsAdjusting())
{
String item=(String) list.getSelectedValue();
JTextField jt=(JTextField)(fields.get(fm.fieldID).getComponent());
jt.setText(item);
}
}
}
/**
* @param lastRow
* 要更新的行号
* @return 如果除lastRow有重复的关键字，则返回false
*/
public boolean isKeyExist(Vector<String> v, int lastRow)
{
for (int i = 0; i < 表格行数; i++)
{
if (i == lastRow)
continue;
int j = 0;
for (; j < 关键字表格序号.length; j++)
{
if (v.get(关键字表格序号[j]) != 表格数据[i][关键字表格序号[j]]
&& !v.get(关键字表格序号[j]).trim().equals(表格数据[i][关键字表格序号[j]].trim()))
break;
}
if (j >= 关键字表格序号.length)
{
return true;
}
}
return false;
}
/**
* @param v 将要存盘的一行数据
* @return 如果为true，表示关键字已经存在
*/
public boolean isKeyExist(Vector<String> v)
{
for (int i = 0; i < 表格行数; i++)
{
int j = 0;
for (; j < 关键字表格序号.length; j++)
{
if (v.get(关键字表格序号[j]) != 表格数据[i][关键字表格序号[j]]
&& !v.get(关键字表格序号[j]).trim().equals(表格数据[i][关键字表格序号[j]].trim()))
break;
}
if (j >= 关键字表格序号.length)
{
return true;
}
}
return false;
}
/**
* @param v 改变后的行内容
* @param lastRow 要更新的行号
* @throws SQLException
*/
public void updateSQL(Vector<String> v, int lastRow) throws SQLException
{
String preSQL = "update " + 表名 + " set ";
String rearSQL = " where ";
String strSQL = "";
for (int i = 0, flag = 0; i < 表格字段.length; i++)
{
if (i != 表格字段.length - 1)
{
if( v.get(i)==null || v.get(i).length()<=0)
{
preSQL += 表格字段[i] + "=NULL,";
}
else
{
preSQL += 表格字段[i] + "='" + v.get(i) + "',";
}
for (int j = 0; j < 关键字表格序号.length && flag < 关键字表格序号.length; j++)
{
if (关键字表格序号[j] == i)
{
flag++;
if (j != 关键字表格序号.length - 1)
rearSQL += 表格字段[i] + "='" + 表格数据[lastRow][i]
+ "' AND ";
else
rearSQL += 表格字段[i] + "='" + 表格数据[lastRow][i] + "'";
break;
}
}
} else
{
if( v.get(i)==null || v.get(i).length()<=0)
{
preSQL += 表格字段[i] + "=NULL";
}
else
{
preSQL += 表格字段[i] + "='" + v.get(i) + "' ";
}
}
}
strSQL = preSQL + rearSQL;
updateExecute(strSQL);
}
private void updateExecute(String strSQL) throws SQLException
{
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
/**
* @param v 将要存盘的一行数据
* @throws SQLException 存盘时候发生异常
*/
public void insertSQL(Vector<String> v) throws SQLException
{
String rearSQL = " values (";
String preSQL = "insert into " + 表名 + " (";
String strSQL = "";
for (int i = 0; i < 表格字段.length; i++)
{
if (i != 表格字段.length - 1)
{
preSQL += 表格字段[i] + ",";
if( v.get(i)==null || v.get(i).length()<=0)
{
rearSQL +="NULL,";
}
else
{
rearSQL += "'" + v.get(i) + "',";
}
} else
{
preSQL += 表格字段[i] + ")";
if( v.get(i)==null || v.get(i).length()<=0)
{
rearSQL +="NULL)";
}
else
{
rearSQL += "'" + v.get(i) + "')";
}
}
}
strSQL = preSQL + rearSQL;
insertExecute(strSQL);
}
private void insertExecute(String strSQL) throws SQLException
{
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
private void deleteSQL(String[] array) throws SQLException
{
String rearSQL = "";
String preSQL = "delete from "+表名+" where ";
String strSQL = "";
for(int i=0;i<关键字表格序号.length;i++)
{
if(i!=关键字表格序号.length-1)
{
rearSQL+=表格字段[关键字表格序号[i]]+"='"+array[i]+"' AND ";
}
else
{
rearSQL+=表格字段[关键字表格序号[i]]+"='"+array[i]+"'";
}
}
strSQL = preSQL + rearSQL;
deleteExecute(strSQL);
}
private void deleteExecute(String strSQL) throws SQLException
{
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
}
版本2
32.源码32，部件程序，可使用字典表与代码表的表格式数据批修改程序。
/**
* 程序文件名：tableTenance7.java
* 作者： 齐赛
* 功能：可使用字典表与代码表的表格式数据批修改程序。
* 完成日期：2013年2月20日
* 被调用语句：tableTenance7.means(parameter)。
* 要求提供的参数：数据“表名”、“关键字段名”、
* 可选择提供的参数：“要求字段号表”、“要求按钮号表”、“接口参数表名”。
* 操作方法与注意事项：以上所有参数均为字符串数据类型的全局变量。
* 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，
* 可以是单一字段，也可以是多个字段，如果是多字段，以英文逗号分隔。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为空；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 要求按钮号用于选择留在界面中的按钮，号后加分号之后可加变更后的按钮名称。
* 操作时每点击一次 “添加空记录”按钮，将在表中增加一空行，
* 填入数据后，需要点击“本条记录存盘”按钮，才能将新记录填入表内。
* 也可以继续点击一次“添加空记录”按钮，继续添加下一列及之后记录或修改表格中已经有的数据，
* 只到全部数据加入到表格中或全部完成修改后后，最后点击“全部数据存盘”按钮，将所有数据存入数据库。
* 如果要修改表中数据，可先修改表格中数据，可以修改完一条后点击“本条记录存盘”按钮保存修改结果。
* 也可以修改完全部欲改数据，最后点击“全部数据存盘”按钮，将所有修改数据存入数据库。
* 如果删除数据，操作时首先用鼠标点击表格中要删除的记录，之后点击“删除按钮”完成删除。
* 本程序提供各字段共用列表框,可以利用鼠标选择代码或历史数据录入。
* 如果为某字段设计了代码表，要求代码表名字为字段名加“代码表”，其中字段名，一个与字段名相同，
* 另一个为字段名加“代码”或字段名中去掉“代码”二字。例如，关于性别，如果设计用0表示男，1表示女
* 那么，设计“性别代码表”，包括“性别”、“性别代码”二个字段，其中二条记录：男 0；女 1。
* 在数据表中可以有字段“性别代码”，保存的是性别代码数据。也可以有“性别”，即保存的是性别数据。
* 如果数据表中字段名为“性别代码”，在列表框中显示0 1；录入保存的是性别代码。
* 如果数据表中字段名为性别，那么，列表框中显示男 女，录入保存的是性别内容。
* 可以选择接口参数表名可以检查数字类型字段数据关于最大值、最小值、值域、条件表达式等条件是否正确。
* 如果是登录操作之后调用本程序，可以检查操作者是否具有相应权限。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
import java.io.*;
public class tableTenance7 extends JFrame implements ItemListener {
private static JTable table02;
static Connection con;
static String url;
static String variabl2603;
static String variabl1221;
static String variabl1873;
static String[] variabl1525;
static int variabl2483 = 900, variabl2503 = 700;
static int variabl2651;
static int variabl2113;
static String[] variabl2517;
static String[] variabl1913;
static String[] variabl2411;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489;
static int[] variabl1119;
static int variabl1235, variabl18531, variabl1089;
static String[][] variabl2197;
static String[][] variabl1701;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1153;
static JButton variabl2641, variabl1855, variabl1619, variabl2633,
variabl2599;
static String[][] variabl1753;
static String[][] variabl1631;
static int variabl1901 = 0, variabl1691 = 0, variabl1739 = 0,
variabl1899 = 0;
static String[] variabl1507;
static String[] variabl1377;
static int[] variabl1287;
static String s1 = "", s2 = "", s3 = "";
static DefaultTableModel tableModel;
static int b = 0, c = 0;
static String[] variabl1425;
static String variabl1633 = "";
static PreparedStatement pstmt;
static Statement sta;
static List list1;
static int currentRow = 0;
static int currentColumn = 0;
static String variabl1175 = "";
static String[][] variabl1563;
static ArrayList<String> variabl1427;
static int variabl1087, variabl1351;
static int variabl2677 = 0, variabl2851 = 0;
public static void means(String[] parameter) {
variabl1901 = 0;
variabl1691 = 0;
variabl1739 = 0;
variabl1899 = 0;
s1 = "";
s2 = "";
s3 = "";
b = 0;
c = 0;
currentRow = 0;
currentColumn = 0;
variabl1175 = "";
variabl2677 = 0;
con = main1.getConn();
variabl1901 = 0;
variabl1691 = 0;
variabl1739 = 0;
variabl1899 = 0;
variabl2603 = parameter[4];
variabl1153 = parameter[8];
variabl1525 = parameter[6].split(",");
variabl1221 = parameter[5];
variabl1633 = parameter[19];
final String variabl2429 = parameter[0];
String[] variabl240501 = { "添加空记录", "删除", "当前行存盘", "全部表存盘", "退出" };
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) {
}
final tableTenance7 frame = new tableTenance7();
frame.setTitle("表格式数据维护程序 作者：齐赛");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 200, variabl2503 - 100);
frame.getContentPane().add(scrollPane);
JLabel jl = new JLabel("字段可选内容 :");
jl.setBounds(variabl2483 - 175, 0, 150, 30);
list1 = new List();
list1.addItemListener(frame);
list1.setBounds(variabl2483 - 175, 30, 150, variabl2503 - 130);
frame.getContentPane().add(list1);
frame.getContentPane().add(jl);
if (variabl1525.length == 0) {
JOptionPane.showMessageDialog(null, "缺少关键字的说明，请选择关键字后重新操作");
return;
}
for (int i = 0; i < variabl1525.length; i++)
variabl1377 = new String[variabl1525.length];
variabl1287 = new int[variabl1525.length];
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = "";
variabl1287[i] = 0;
}
con = main1.getConn();
try {
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String[] s6, s7;
s7 = parameter[19].split(",");
if (variabl1153.length() > 0) {
variabl1633 = "";
s6 = variabl1153.split(",");
for (int i = 0; i < s6.length; i++) {
if (variabl1633.length() > 0)
variabl1633 = variabl1633 + ","
+ s7[Integer.valueOf(s6[i])];
else
variabl1633 = s7[Integer.valueOf(s6[i])];
}
for (int j = 0; j < variabl1525.length; j++) {
if (variabl1633.indexOf(variabl1525[j].trim()) < 0) {
variabl1633 = variabl1633 + "," + variabl1525[j];
}
}
s7 = variabl1633.split(",");
for (int i = 0; i < s7.length; i++) {
for (int j = 0; j < variabl1525.length; j++) {
if (variabl1525[j].trim().equals(s7[i].trim()))
variabl1287[j] = i;
}
}
} else
for (int i = 0; i < s7.length; i++) {
for (int j = 0; j < variabl1525.length; j++) {
if (variabl1525[j].trim().equals(s7[i].trim()))
variabl1287[j] = i;
}
}
s1 = "select " + variabl1633 + " from " + variabl2603;
ResultSet rs = sta.executeQuery(s1);
rs.last();
variabl1089 = rs.getRow();
variabl1235 = variabl1089;
ResultSetMetaData rsmd = rs.getMetaData();
variabl2651 = rsmd.getColumnCount();
variabl2113 = variabl2651;
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl2411 = new String[variabl2113];
variabl1913 = new String[variabl2113];
variabl1169 = new String[variabl2113];
variabl1119 = new int[variabl2113];
variabl2197 = new String[variabl1089][variabl2113];
variabl1507 = new String[variabl2113];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd.getColumnName(i + 1);
variabl1501[i] = rsmd.getColumnTypeName(i + 1);
variabl1489[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[i].length())
variabl1489[i] = variabl2517[i].length();
else if (variabl1489[i] > 50)
variabl1489[i] = 50;
variabl1913[i] = variabl2517[i];
variabl1169[i] = variabl1501[i];
variabl1119[i] = variabl1489[i];
variabl2411[i] = variabl2517[i];
variabl1507[i] = "";
}
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1089) {
rs.absolute(c + 1);
while (b < variabl2113) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta.close();
con.close();
con = null;
} catch (Exception e) {
e.printStackTrace();
}
con = main1.getConn();
if ((variabl1221.length() > 0)
&& (variabl1221.lastIndexOf(variabl2603.trim() + "接口参数表") >= 0))
try {
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603 + "接口参数表 ";
ResultSet rs = sta.executeQuery(s1);
rs.last();
variabl1087 = rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
variabl1351 = rsmd.getColumnCount();
variabl1563 = new String[variabl1087][variabl1351];
for (int i = 0; i < variabl1087; i++) {
rs.absolute(i + 1);
for (int j = 0; j < variabl1351; j++) {
variabl1563[i][j] = rs.getString(j + 1);
}
}
rs.close();
sta.close();
con.close();
con = null;
} catch (Exception e) {
e.printStackTrace();
}
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];
}
if (variabl1873.length() > 0) {
con = main1.getConn();
try {
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
String s1 = "select * from " + variabl1873;
ResultSet rs = sta.executeQuery(s1);
while (rs.next()) {
String variabl2153 = rs.getString(1);
String variabl1755 = rs.getString(2);
b = 0;
while (b < variabl2113) {
if (variabl2411[b].compareTo(variabl2153) == 0) {
variabl2411[b] = variabl1755;
if (variabl1489[b] < variabl2411[b].length())
variabl1489[b] = variabl2411[b].length();
break;
}
b++;
}
}
rs.close();
sta.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
tableModel = new DefaultTableModel(variabl2197, variabl2411);
table02 = new JTable(tableModel);
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
table02.addMouseListener(new MouseAdapter() {
int flag = -1;
public void mouseClicked(MouseEvent e) {
currentRow = table02.getSelectedRow();
currentColumn = table02.getSelectedColumn();
if (flag != currentColumn) {
list1.clear();
if (variabl2429.lastIndexOf(variabl1913[currentColumn]) >= 0
|| variabl2429
.lastIndexOf(variabl2411[currentColumn]) >= 0) {
try {
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String s1 = "select * from "
+ variabl1913[currentColumn] + "代码表";
ResultSet rs = sta.executeQuery(s1);
while (rs.next()) {
String variabl2163 = rs.getString(1);
list1.add(variabl2163);
}
} catch (Exception e2) {
e2.printStackTrace();
}
} else {
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < variabl1235; i++) {
set.add((String) tableModel.getValueAt(i,
currentColumn));
}
for (String str : set)
list1.add(str);
}
}
flag = currentColumn;
}
});
for (int i = 0; i < variabl2113; i++) {
TableColumn tc = table02.getColumn(variabl2411[i]);
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(variabl1119[i] * 8);
tc.setMaxWidth(variabl1119[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02);
table02.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int selectedRow = table02.getSelectedRow();
int variabl2593 = table02.getSelectedRow();
int variabl2547 = table02.getSelectedColumn();
int k = 0;
for (int i = 0; i < variabl1525.length; i++) {
if (variabl1287[i] == variabl2547)
k = 1;
}
if (k == 0) {
tableModel.setValueAt("", variabl2593, variabl2547);
}
variabl1175 = "";
}
});
table02.addFocusListener(new FocusAdapter() {
public void focusLost(final FocusEvent arg0) {
int variabl2593 = table02.getSelectedRow();
int variabl2547 = table02.getSelectedColumn();
if (variabl1175.trim().length() > 0) {
tableModel
.setValueAt(variabl1175, variabl2593, variabl2547);
}
}
});
table02.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
variabl1175 = variabl1175 + evt.getKeyChar();
}
});
int j = 0;
variabl1187 = "," + variabl1187 + ",";
if (variabl1187.length() < 3)
j = 5;
else
for (int i = 0; i < 5; i++)
if (variabl1187.lastIndexOf("," + i + ",") >= 0)
j = j + 1;
int variabl2339 = (variabl2483 - 20) / variabl2851;
int variabl1423 = 5;
variabl2641 = new JButton(variabl2405[0]);
variabl2641.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
tableModel.addRow(variabl1507);
variabl1235 = variabl1235 + 1;
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl2641.setBounds(variabl1423, variabl2503 - 80,
variabl2339 - 10, 20);
frame.getContentPane().add(variabl2641);
variabl1423 = variabl1423 + variabl2339;
}
final JButton variabl2633 = new JButton(variabl2405[1]);
variabl2633.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int selectedRow = table02.getSelectedRow();
if (selectedRow != -1) {
s1 = "";
int j = 0;
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = tableModel.getValueAt(selectedRow,
variabl1287[i]).toString();
if (variabl1377[i].compareTo(" ") < 0)
j = -1;
if (main1.variabl1545
.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl1525[i] + "=" + variabl1377[i];
else
s1 = s1 + variabl1525[i] + "='" + variabl1377[i]
+ "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
if (j < 0) {
JOptionPane.showMessageDialog(null, "关键字数据不全！");
return;
}
s1 = "delete from " + variabl2603 + " where " + s1;
try {
con = main1.getConn();
pstmt = con.prepareStatement(s1);
pstmt.execute();
tableModel.removeRow(selectedRow);
variabl1235 = variabl1235 - 1;
variabl1089 = variabl1089 - 1;
pstmt.close();
con.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl2633.setBounds(variabl1423, variabl2503 - 80,
variabl2339 - 10, 20);
frame.getContentPane().add(variabl2633);
variabl1423 = variabl1423 + variabl2339;
}
final JButton variabl1855 = new JButton(variabl2405[2]);
variabl1855.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
con = main1.getConn();
try {
if (itemCount(currentRow) >= 0) {
if (variabl18531 == 0) {
s1 = insertNewItem(currentRow);
if (s1 == null) {
JOptionPane.showMessageDialog(null,
"字段内容不在规定的范围内，请检查！");
sta.close();
con.close();
return;
}
pstmt = con.prepareStatement(s1);
pstmt.execute();
variabl1089++;
} else {
if (currentRow + 1 > variabl1089) {
JOptionPane.showMessageDialog(null,
"新增加的记录关键字不能重复！请检查第" + currentRow
+ "行！");
return;
}
s1 = updateItem(currentRow);
if (s1 == null) {
JOptionPane.showMessageDialog(null,
"字段内容不在规定的范围内，请检查！");
sta.close();
con.close();
return;
}
pstmt = con.prepareStatement(s1);
pstmt.execute();
}
pstmt.close();
con.close();
} else {
JOptionPane.showMessageDialog(null, "关键字为空，请重新输入！");
return;
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl1855.setBounds(variabl1423, variabl2503 - 80,
variabl2339 - 10, 20);
frame.getContentPane().add(variabl1855);
variabl1423 = variabl1423 + variabl2339;
}
final JButton variabl1619 = new JButton(variabl2405[3]);
variabl1619.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
con = main1.getConn();
try {
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
} catch (SQLException e2) {
e2.printStackTrace();
}
for (int i = 0; i < variabl1235; i++) {
if (itemCount(i) >= 0) {
if (itemCount(i) == 0) {
s1 = insertNewItem(i);
if (s1 == null) {
JOptionPane.showMessageDialog(null,
"字段内容不在规定的范围内，请检查！");
table02.setRowSelectionInterval(i, i);
break;
}
} else {
if (i + 1 > variabl1089) {
JOptionPane.showMessageDialog(null,
"新增加的记录关键字不能重复！请检查第" + i + "行！");
table02.setRowSelectionInterval(i, i);
continue;
}
s1 = updateItem(i);
if (s1 == null) {
JOptionPane.showMessageDialog(null,
"字段内容不在规定的范围内，请检查！");
break;
}
}
try {
pstmt = con.prepareStatement(s1);
pstmt.execute();
if (variabl18531 == 0)
variabl1089++;
} catch (SQLException e1) {
e1.printStackTrace();
}
} else {
JOptionPane.showMessageDialog(null, "关键字有的为空，请检查！");
break;
}
}
try {
sta.close();
con.close();
pstmt.close();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl1619.setBounds(variabl1423, variabl2503 - 80,
variabl2339 - 10, 20);
frame.getContentPane().add(variabl1619);
variabl1423 = variabl1423 + variabl2339;
}
final JButton variabl2599 = new JButton(variabl2405[4]);
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl2599.setBounds(variabl1423, variabl2503 - 80,
variabl2339 - 10, 20);
frame.getContentPane().add(variabl2599);
variabl1423 = variabl1423 + variabl2339;
}
frame.setVisible(true);
}
static String insertNewItem(int row) {
String ss = new String();
for (int i = 0; i < variabl2113; i++) {
String temp = tableModel.getValueAt(row, i) == null ? null
: tableModel.getValueAt(row, i).toString();
if ((temp != null) && (variabl1221.length() > 0))
for (int j = 0; j < variabl1563.length; j++) {
if (variabl1563[j][1].trim().equals(variabl1913[i].trim())
|| variabl1563[j][1].trim().equals(
variabl2411[i].trim())) {
if (variabl1563[j][4] == null) {
if (temp.indexOf(".") >= 0
&& (Double.parseDouble(temp) > Double
.parseDouble(variabl1563[j][2]) || Double
.parseDouble(temp) < Double
.parseDouble(variabl1563[j][3]))) {
return null;
} else if (Integer.parseInt(temp) > Integer
.parseInt(variabl1563[j][2])
|| Integer.parseInt(temp) < Integer
.parseInt(variabl1563[j][3]))
return null;
} else {
String strs[] = variabl1563[j][4].split("，");
boolean flag = false;
for (int ii = 0; ii < strs.length; ii++) {
if (strs[ii].trim().equals(temp.trim())) {
flag = true;
break;
}
}
if (!flag)
return null;
}
}
}
}
ss = "insert into " + variabl2603 + " values (";
for (int i = 0; i < variabl2651; i++) {
if (main1.variabl1545.lastIndexOf(variabl1501[i]) > 0)
ss += table02.getValueAt(row, i);
else
ss += "'" + table02.getValueAt(row, i) + "'";
if (i < variabl2651 - 1)
ss += ",";
}
ss += ")";
return ss;
}
static String updateItem(int row) {
String ss = new String();
variabl1425 = new String[variabl2113];
for (int i = 0; i < variabl2113; i++) {
int k;
for (k = 0; k < variabl1287.length; k++) {
if (i == variabl1287[k])
break;
}
if (k < variabl1287.length)
continue;
String temp;
temp = tableModel.getValueAt(row, i) == null ? null : tableModel
.getValueAt(row, i).toString();
if ((temp != null) && (variabl1221.length() > 0))
for (int j = 0; j < variabl1563.length; j++) {
if (variabl1563[j][1].trim().equals(variabl1913[i].trim())
|| variabl1563[j][1].trim().equals(
variabl2411[i].trim())) {
if (variabl1563[j][4] == null) {
if (temp.indexOf(".") >= 0
&& (Double.parseDouble(temp) > Double
.parseDouble(variabl1563[j][2]) || Double
.parseDouble(temp) < Double
.parseDouble(variabl1563[j][3]))) {
return null;
} else if (Integer.parseInt(temp) > Integer
.parseInt(variabl1563[j][2])
|| Integer.parseInt(temp) < Integer
.parseInt(variabl1563[j][3]))
return null;
} else {
String strs[] = variabl1563[j][4].split("，");
boolean flag = false;
for (int ii = 0; ii < strs.length; ii++) {
if (strs[ii].trim().equals(temp.trim())) {
flag = true;
break;
}
}
if (!flag)
return null;
}
}
}
if (main1.variabl1545.lastIndexOf(variabl1501[i]) > 0) {
ss += variabl1913[i] + "=" + temp;
} else {
ss += variabl1913[i] + "='" + temp + "'";
}
if (i < variabl2113 - 1)
ss += ",";
}
ss = " update " + variabl2603 + " set " + ss + s3;
return ss;
}
static int itemCount(int row) {
variabl2677 = variabl2677 + 1;
s1 = "";
int j = 0;
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = tableModel.getValueAt(row, variabl1287[i]) == null ? ""
: tableModel.getValueAt(row, i).toString();
if (variabl1377[i].compareTo(" ") < 0)
j = -1;
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl1525[i] + "=" + variabl1377[i];
else
s1 = s1 + variabl1525[i] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
if (j >= 0) {
s3 = " where " + s1;
s1 = "select * from " + variabl2603 + " where " + s1;
ResultSet rs;
try {
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = sta.executeQuery(s1);
rs.last();
variabl18531 = rs.getRow();
s1 = "";
sta.close();
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
return variabl18531;
} else
return -1;
}
public void itemStateChanged(ItemEvent e) {
String item = list1.getSelectedItem();
tableModel.setValueAt(item, currentRow, currentColumn);
}
}
33.源码33，部件程序，清库与批处理程序。
/*
* 程序文件名：tableTenance8.java
* 作者：程学先
* 完成时间：2013年11月27日
* 程序功能：清库与批处理程序。
* 全部清空:在清空表名集中输入需要清空的表名，之后点击“字段名清空”。
* 按字段号清空：在调用程序前必须输入表名，运行时选择所有需要清空的列名，再点击“按字段号清空”。
* 批处理：在调用程序前必须输入表名，选择结果字段名，可以有多个，彼此用逗号分隔，例如：应发工资,总扣工资,实发工资
* 之后输入计算公式集，可以有多个，彼此用逗号分隔，例如：
* 基本工资+补发+岗位工资,所得税+行政费,应发工资-总扣工资
* 结果字段名与计算公式的个数应当相同，次序应对应。
* 可以填入条件式，例如：部门号="1"
* 点击“批处理”按钮。可以检查所生成的语句并进行修改。
* 点击“执行SQL语句”完成批处理。
* 覆盖式转存：在调用程序前必须输入表名，选择目的表名，将表格数据转存到另一目的表中。
* 例如对某些财务表期末转期初的操作。表名为期末表名，目的表为期初表名。点击覆盖式转存。
* 如果是转到新表中可以同时完成建表与转存操作。如果原来有同名表，将删除原表之后转存。
* 添加式转存：在调用程序前必须输入表名，选择目的表名，将表格数据转存到另一目的表尾。
* 目的表原有数据保存不变。注意二个表结构应当相同。
* 注意如果涉及条件表达式或计算公式，都必须是SQL语句所允许的格式。
*/
import java.awt.*;
import java.io.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import java.sql.*;
public class tableTenance8 extends JFrame {
static tableTenance8 frame1 = new tableTenance8();
private static String[] variabl1271 = { "", "", "" };
private static String[] variabl1485 = { "", "", "" };
private static DefaultListModel fModel = new DefaultListModel();
private static JPanel variabl2613 = new JPanel(false);
private static int variabl2483 = 1000, variabl2503 = 640;
private static Connection dbConn = null;
static Statement sta3;
static ResultSet rs;
static ResultSetMetaData rsmd3;
static String variabl16791;
static String variabl15891;
static String variabl15251;
static String variabl11711;
static String variabl13751;
static String variabl14131;
static String variabl17131;
static String variabl2603;
static String variabl2429 = "";
static String[] variabl1919 = new String[12];
static String[] variabl2259 = { ">", "<", "=", ">=", "<=", "!>" };
static JScrollPane scrollPane = new JScrollPane();
static DefaultTableModel variabl1965;
static JTable variabl2655;
static JScrollPane scrollPane1 = new JScrollPane();
static String s1 = "", s2 = "", s3 = "", s4 = "", s5 = "";
static int b = 0, c = 0;
static int variabl2651 = 0, variabl26510 = 0, variabl25710 = 0,
variabl2673 = 0, variabl1853 = 0;
static String[] variabl2517;
static String[] variabl1501;
static int[] variabl1489;
static int[] variabl1795;
static String variabl2253 = "";
static JLabel variabl16790 = new JLabel("导出表名");
static JTextField variabl1679 = new JTextField();
static JLabel variabl15890 = new JLabel("清空表名集");
static JTextField variabl1589 = new JTextField();
static JLabel variabl15250 = new JLabel("关键字段名");
static JTextField variabl1525 = new JTextField();
static JLabel variabl11710 = new JLabel("清除字段名表");
static JTextField variabl1171 = new JTextField();
static JLabel variabl13750 = new JLabel("结果字段名");
static JTextField variabl1375 = new JTextField();
static JLabel variabl14130 = new JLabel("条件表达式");
static JTextField variabl1413 = new JTextField();
static JLabel variabl17130 = new JLabel("计算公式");
static JTextField variabl1713 = new JTextField();
static String[][] variabl2197;
static String variabl1787 = ",";
static String variabl17870 = ",";
static JLabel variabl15111 = new JLabel("SQL语句");
static JTextArea variabl1083 = new JTextArea();
static JScrollPane variabl1007 = new JScrollPane(variabl1083);
static java.awt.List variabl2311 = new java.awt.List();
static JScrollPane variabl1227 = new JScrollPane(variabl2311);
static JButton variabl1799 = new JButton();
static JButton variabl1165 = new JButton();
static JButton variabl2315 = new JButton();
static JButton variabl1535 = new JButton();
static JButton variabl1299 = new JButton();
static JButton variabl1101 = new JButton();
static JButton variabl1865 = new JButton();
static char x1 = 10, x2 = 13;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new tableTenance8();
variabl1271[0] = "";
variabl1271[1] = "";
variabl1271[2] = "";
variabl1485[0] = "";
variabl1485[1] = "";
variabl1485[2] = "";
fModel = new DefaultListModel();
variabl2613 = new JPanel(false);
variabl2483 = 1000;
variabl2503 = 640;
variabl2429 = "";
variabl1919 = new String[12];
variabl2259[0] = ">";
variabl2259[0] = "<";
variabl2259[0] = "=";
variabl2259[0] = ">=";
variabl2259[0] = "<=";
variabl2259[0] = "!>";
scrollPane = new JScrollPane();
scrollPane1 = new JScrollPane();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
s5 = "";
b = 0;
c = 0;
variabl2651 = 0;
variabl26510 = 0;
variabl25710 = 0;
variabl2673 = 0;
variabl1853 = 0;
variabl2253 = "";
variabl16790 = new JLabel("导出表名");
variabl1679 = new JTextField();
variabl15890 = new JLabel("清空表名集");
variabl1589 = new JTextField();
variabl15250 = new JLabel("关键字段名");
variabl1525 = new JTextField();
variabl11710 = new JLabel("清除字段名表");
variabl1171 = new JTextField();
variabl13750 = new JLabel("结果字段名");
variabl1375 = new JTextField();
variabl14130 = new JLabel("条件表达式");
variabl1413 = new JTextField();
variabl17130 = new JLabel("计算公式");
variabl1713 = new JTextField();
variabl1787 = ",";
variabl17870 = ",";
variabl15111 = new JLabel("SQL语句");
variabl1083 = new JTextArea();
variabl1007 = new JScrollPane(variabl1083);
variabl2311 = new java.awt.List();
variabl1227 = new JScrollPane(variabl2311);
String[] variabl240501 = { "全部清空", "按字段号清空", "批处理", "覆盖式转存", "添加式转存",
"执行SQL语句", "退出" };
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) {
}
variabl1799 = new JButton();
variabl1165 = new JButton();
variabl2315 = new JButton();
variabl1535 = new JButton();
variabl1299 = new JButton();
variabl1101 = new JButton();
variabl1865 = new JButton();
x1 = 10;
x2 = 13;
variabl16791 = parameter[2];
variabl2603 = parameter[4];
variabl15891 = parameter[5];
variabl2253 = parameter[6];
variabl11711 = parameter[8];
variabl13751 = parameter[9];
variabl14131 = parameter[13];
variabl17131 = parameter[14];
variabl2613.setBackground(Color.lightGray);
variabl2613.setLayout(null);
variabl2613.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10);
try {
String[] tableType = { "TABLE" };
Connection con;
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
ResultSet resultSet = databaseMetaData.getTables(null, null, "%",
tableType);
while (resultSet.next()) {
variabl2429 = variabl2429 + resultSet.getString("TABLE_NAME")
+ ",";
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "获取表名失败！");
}
if ((variabl2603 != null) && (variabl2603.length() > 0)) {
int c = 0;
int b = 0;
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603;
rs = sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1919 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl1795 = new int[variabl2651];
int variabl2187 = 0;
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd3.getColumnName(i + 1);
variabl1919[i] = " ";
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
variabl1795[i] = rsmd3.getScale(i + 1);
variabl2187 = variabl2187 + variabl1489[i] * 4;
}
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
dbConn.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取数据表失败！" + s1);
return;
}
variabl1965 = new DefaultTableModel(variabl2197, variabl2517);
variabl2655 = new JTable(variabl1965);
variabl2655.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = variabl2655.getColumn(variabl2517[i]);
tc.setPreferredWidth(variabl1489[i] * 4);
}
scrollPane.getViewport().add(variabl2655, null);
scrollPane.setBounds(10, 140, 700, 270);
variabl2613.add(scrollPane);
}
variabl16790.setBounds(10, 20, 60, 20);
variabl2613.add(variabl16790, null);
variabl1679.setBounds(70, 20, 120, 20);
variabl2613.add(variabl1679, null);
variabl1679.setText(variabl16791);
variabl1679.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 1;
variabl2311.removeAll();
String[] s6 = variabl2429.split(",");
for (int i = 0; i < s6.length; i++)
variabl2311.add(s6[i]);
}
});
variabl15890.setBounds(190, 20, 80, 20);
variabl2613.add(variabl15890, null);
variabl1589.setBounds(270, 20, 200, 20);
variabl1589.setText(variabl15891);
variabl2613.add(variabl1589, null);
variabl1589.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 2;
variabl2311.removeAll();
String[] s6 = variabl2429.split(",");
for (int i = 0; i < s6.length; i++)
variabl2311.add(s6[i]);
}
});
variabl15250.setBounds(470, 20, 80, 20);
variabl2613.add(variabl15250, null);
variabl1525.setBounds(550, 20, 155, 20);
variabl1525.setText(variabl2253);
variabl2613.add(variabl1525, null);
variabl1525.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 3;
variabl2311.removeAll();
for (int i = 0; i < variabl2517.length; i++)
variabl2311.add(variabl2517[i]);
}
});
variabl11710.setBounds(10, 50, 90, 20);
variabl2613.add(variabl11710, null);
variabl1171.setBounds(100, 50, 400, 20);
variabl1171.setText(variabl11711);
variabl2613.add(variabl1171, null);
variabl1171.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 4;
variabl2311.removeAll();
for (int i = 0; i < variabl2517.length; i++)
variabl2311.add(variabl2517[i]);
}
});
variabl13750.setBounds(500, 50, 80, 20);
variabl2613.add(variabl13750, null);
variabl1375.setBounds(580, 50, 125, 20);
variabl1375.setText(variabl13751);
variabl2613.add(variabl1375, null);
variabl1375.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 5;
variabl2311.removeAll();
for (int i = 0; i < variabl2517.length; i++)
variabl2311.add(variabl2517[i]);
for (int i = 0; i < variabl1485.length; i++)
variabl2311.add(variabl1485[i]);
}
});
variabl14130.setBounds(10, 80, 80, 20);
variabl2613.add(variabl14130, null);
variabl1413.setBounds(75, 80, 630, 20);
variabl1413.setText(variabl14131);
variabl2613.add(variabl1413, null);
variabl1413.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 6;
variabl2311.removeAll();
for (int i = 0; i < variabl2517.length; i++)
variabl2311.add(variabl2517[i]);
variabl2311.add("以下选择关系符");
for (int i = 0; i < variabl2259.length; i++)
variabl2311.add(variabl2259[i]);
variabl2311.add("以下选择逻辑联系符");
variabl2311.add(" and ");
variabl2311.add(" or ");
}
});
variabl17130.setBounds(10, 110, 60, 20);
variabl2613.add(variabl17130, null);
variabl1713.setBounds(75, 110, 630, 20);
variabl1713.setText(variabl17131);
variabl2613.add(variabl1713, null);
variabl1713.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl2673 = 7;
variabl2311.removeAll();
for (int i = 0; i < variabl2517.length; i++)
variabl2311.add(variabl2517[i]);
for (int i = 0; i < variabl1271.length; i++)
variabl2311.add(variabl1271[i]);
}
});
variabl15111.setBounds(20, 450, 70, 20);
variabl2613.add(variabl15111, null);
variabl1007.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1007.setBounds(new Rectangle(90, 420, 820, 90));
variabl1083.setLineWrap(true);
variabl2613.add(variabl1007, null);
variabl1227.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1227.setBounds(new Rectangle(730, 20, 190, 380));
variabl2613.add(variabl1227, null);
variabl2311.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
switch (variabl2673) {
case 1:
variabl1679.setText(variabl2311.getSelectedItem());
break;
case 2:
if (variabl1589.getText().length() < 1)
variabl1589.setText(variabl2311.getSelectedItem());
else
variabl1589.setText(variabl1589.getText() + ","
+ variabl2311.getSelectedItem());
break;
case 3:
if (variabl1525.getText().length() < 1)
variabl1525.setText(variabl2311.getSelectedItem());
else
variabl1525.setText(variabl1525.getText() + ","
+ variabl2311.getSelectedItem());
break;
case 4:
if (variabl1171.getText().length() < 1)
variabl1171.setText(variabl2311.getSelectedItem());
else
variabl1171.setText(variabl1171.getText() + ","
+ variabl2311.getSelectedItem());
break;
case 5:
if (variabl1375.getText().length() > 0)
variabl1375.setText(variabl1375.getText() + ","
+ variabl2311.getSelectedItem());
else
variabl1375.setText(variabl2311.getSelectedItem());
break;
case 6:
if (variabl1413.getText().length() < 1)
variabl1413.setText(variabl2311.getSelectedItem());
else
variabl1413.setText(variabl1413.getText() + ","
+ variabl2311.getSelectedItem());
break;
case 7:
if (variabl1713.getText().length() < 1)
variabl1713.setText(variabl2311.getSelectedItem());
else
variabl1713.setText(variabl1713.getText() + " "
+ variabl2311.getSelectedItem());
break;
}
}
});
variabl1187 = "," + variabl1187 + ",";
int no1 = 0;
;
if (variabl1187.length() < 3)
no1 = 7;
else
for (int i = 0; i < 7; i++)
if (variabl1187.lastIndexOf("," + i + ",") >= 0)
no1 = no1 + 1;
int variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl1423 = 10;
variabl1799.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1799.setText(variabl2405[0]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl1799.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",0,") >= 0) {
variabl2613.add(variabl1799);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1799.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
String[] s6 = variabl1589.getText().trim().split(",");
for (int i = 0; i < s6.length; i++) {
if (s6[i].length() > 0)
s1 = "delete from " + s6[i];
try {
dbConn = main1.getConn();
if (variabl1083.getText().length() == 0)
variabl1083.setText(s1);
else
variabl1083.setText(variabl1083.getText() + x1 + x2
+ s1);
PreparedStatement pstm4 = dbConn.prepareStatement(s1);
pstm4.execute();
dbConn.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
});
variabl1165.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1165.setText(variabl2405[1]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl1165.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2613.add(variabl1165);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1165.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String[] s6 = variabl1171.getText().trim().split(",");
s1 = "update " + variabl2603 + " set ";
s2 = "";
for (int i = 0; i < s6.length; i++)
if (s6[i].length() > 0) {
if (s2.length() > 0)
s2 = s2 + "," + s6[i];
else
s2 = s6[i];
s2 = s2 + "=";
for (int j = 0; j < variabl2651; j++)
if (s6[i].trim().equals(variabl2517[j].trim())) {
if (main1.variabl1545.lastIndexOf(","
+ variabl1501[j] + ",") >= 0)
s2 = s2 + "0";
else
s2 = s2 + "' '";
break;
}
}
s1 = s1 + s2;
try {
dbConn = main1.getConn();
variabl1083.setText(s1);
PreparedStatement pstm4 = dbConn.prepareStatement(s1);
pstm4.execute();
dbConn.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
});
variabl2315.setFont(new java.awt.Font("Dialog", 0, 12));
variabl2315.setText(variabl2405[2]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl2315.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",2,") >= 0) {
variabl2613.add(variabl2315);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl2315.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
String[] s3 = variabl1375.getText().trim().split(",");
String[] s4 = variabl1713.getText().trim().split(",");
int k = s3.length;
if (s4.length < k)
k = s4.length;
for (int i = 0; i < k; i++) {
s1 = "update " + variabl2603 + " set ";
s1 = s1 + s3[i];
s1 = s1 + "=";
s1 = s1 + s4[i];
if (variabl1413.getText().trim().length() > 0)
s1 = s1 + " where " + variabl1413.getText().trim();
if (variabl1083.getText().length() > 0)
variabl1083.setText(variabl1083.getText() + x1 + x2
+ s1);
else
variabl1083.setText(s1);
}
}
});
variabl1101.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1101.setText(variabl2405[5]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl1101.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",3,") >= 0) {
variabl2613.add(variabl1101);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1101.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
char x1 = 10, x2 = 13;
String x = x1 + "" + x2;
String[] s2 = variabl1083.getText().toString().split(x);
for (int j = 0; j < s2.length; j++) {
s1 = s2[j];
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
dbConn.close();
}
sta3.close();
if (variabl2603.trim().length() > 0) {
int b = 0, c = 0;
s1 = "select * from " + variabl2603;
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs1 = sta3.executeQuery(s1);
rsmd3 = rs1.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd3.getColumnName(i + 1);
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
if (variabl1489[b] < variabl2517[b].length())
variabl1489[b] = variabl2517[b].length();
else if (variabl1489[b] > 50)
variabl1489[b] = 50;
}
int rowNumber = 0;
rs1.last();
rowNumber = rs1.getRow();
variabl2197 = new String[rowNumber][variabl2651];
rs1.absolute(1);
c = 0;
b = 0;
while (c < rowNumber) {
rs1.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
sta3.close();
dbConn.close();
}
} catch (Exception e1) {
e1.printStackTrace();
}
variabl1965 = new DefaultTableModel(variabl2197, variabl2517);
variabl2655 = new JTable(variabl1965);
variabl2655
.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = variabl2655.getColumn(variabl2517[i]);
tc.setPreferredWidth(variabl1489[i] * 4);
}
}
});
variabl1535.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1535.setText(variabl2405[3]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl1535.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",4,") >= 0) {
variabl2613.add(variabl1535);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1535.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
try {
dbConn = main1.getConn();
Statement stat3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (("," + variabl2429).lastIndexOf(","
+ variabl1679.getText().trim() + ",") >= 0) {
s1 = "drop table " + variabl1679.getText().trim();
variabl1083.setText(s1);
stat3.executeUpdate(s1);
stat3.close();
dbConn.close();
}
} catch (SQLException e1) {
}
{
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * into " + variabl1679.getText().trim()
+ " from " + variabl2603;
variabl1083.setText(s1);
sta3.executeUpdate(s1);
sta3.close();
dbConn.close();
sta3.close();
dbConn.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
}
});
variabl1299.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1299.setText(variabl2405[4]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
variabl1299.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",5,") >= 0) {
variabl2613.add(variabl1299);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1299.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
int b = 0, c = 0;
char x1 = 10, x2 = 13;
s1 = "select * from " + variabl2603;
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs1 = sta3.executeQuery(s1);
rsmd3 = rs1.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd3.getColumnName(i + 1);
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
}
int rowNumber = 0;
rs1.last();
rowNumber = rs1.getRow();
variabl2197 = new String[rowNumber][variabl2651];
rs1.absolute(1);
c = 0;
b = 0;
while (c < rowNumber) {
rs1.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs1.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs1.close();
sta3.close();
dbConn.close();
} catch (Exception e1) {
e1.printStackTrace();
}
try {
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
for (int i = 0; i < variabl2197.length; i++) {
s1 = "insert into " + variabl1679.getText() + " (";
for (int k1 = 0; k1 < variabl2517.length; k1++)
s1 = s1 + variabl2517[k1] + ",";
s1 = s1.substring(0, s1.length() - 1) + " ) values (";
for (int j = 0; j < variabl2517.length; j++) {
if (main1.variabl1545.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.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
dbConn = main1.getConn();
sta3 = dbConn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
variabl1083.setText(variabl1083.getText() + x1 + x2
+ s1);
sta3.executeUpdate(s1);
}
sta3.close();
dbConn.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
});
variabl1865.setFont(new java.awt.Font("Dialog", 0, 12));
variabl1865.setText(variabl2405[6]);
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",6,") >= 0)) {
variabl1865.setBounds(variabl1423, variabl2503 - 100, variabl2339,
20);
if (variabl1187.indexOf(",6,") >= 0) {
variabl2613.add(variabl1865);
variabl1423 = variabl1423 + variabl2339;
}
}
variabl1865.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
}
});
frame1.setTitle("数据表清空与批处理程序 作者：程学先");
frame1.setBounds(0, 0, variabl2483, variabl2503);
frame1.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
frame1.getContentPane().setLayout(null);
frame1.getContentPane().add(variabl2613, null);
frame1.setVisible(true);
}
}
34.源码34，工具程序，表格式数据维护部件完整性控制条件设置程序。
/*
* 程序文件名：tableTenance7.java
* 作者：齐赛
* 程序功能：用于表格式数据维护部件设置完整性控制条件。
* 数据表常要求做安全性以及完整性检查与控制
* 1.在参数表控件中输入参数表名，若该表在数据库中不存在，则会自动创建一个参数表，
* 字段是： "标志位","字段名称", "最大值", "最小值", "值域", "条件表达式"，"用户名称", "许可字段号", "权限"
* 2.若输入的参数表名存在，则会自动加载到表格中，
* 本程序只显示"字段名称", "最大值", "最小值", "值域", "条件表达式"这5个字段
* 3.在数据存盘时会根据表格数据去验证记录是否重复，验证规则是检查字段名称是否相同
* 4.本程序设定的参数保存时，完整性控制条件的 标志位为3，安全性控制的标志位为2.
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Vector;
public class completeTool4DB extends JFrame
{
static completeTool4DB frame;
static JPanel panel;
static DefaultTableModel variabl1965;
static JTable variabl2655;
static JScrollPane tableScroll;
static JScrollPane listScroll;
static List list;
static JLabel tNameL, refNameL, fieldNameL, maxL, minL, rangeL, expL;
static JTextField tName, refName,fieldName, max, min, range, exp;
static JButton add,del,upd,reset,exit;
static ArrayList<String> variabl2603=new ArrayList<String>() ;
static String []variabl2517;
private static String[][] variabl2197;
static int currentComp=-1;
static Connection con;
static Statement sta;
static ResultSet rt;
static ResultSetMetaData rtmd;
public completeTool4DB()
{
panel=new JPanel();
tableScroll=new JScrollPane();
listScroll=new JScrollPane();
list=new List();
tNameL=new JLabel("数据表名");
refNameL=new JLabel("参数表名");
fieldNameL=new JLabel("字段名称");
maxL=new JLabel("最大值");
minL=new JLabel("最小值");
rangeL=new JLabel("值域");
expL=new JLabel("表达式");
tName=new JTextField();
refName=new JTextField();
fieldName=new JTextField();
max=new JTextField();
min=new JTextField();
range=new JTextField();
exp=new JTextField();
add=new JButton("添加记录");
del=new JButton("删除记录");
upd=new JButton("更改记录");
reset=new JButton("清空参数");
exit=new JButton("退 出");
}
public static void main(String[] args)
{
variabl2603=new ArrayList<String>() ;
currentComp=-1;
frame=new completeTool4DB();
main1.driver1();
frame.initGUI();
}
public void initGUI()
{
this.setTitle("最大值、最小值指该字段输入极限，值域指所填数据只能在该域内数据中选取，条件表达式指该字段数据必须满足的条件。 作者：齐赛");
this.setBounds(10, 10, 880, 660);
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
panel.setBounds(10, 10, 880, 660);
panel.setLayout(null);
variabl2517 = new String[]{ "字段名称", "最大值", "最小值", "值域", "条件表达式" };
tNameL.setBounds(40, 10, 80, 20);
panel.add(tNameL);
tName.setBounds(130, 10, 100, 20);
panel.add(tName);
tName.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0) {
currentComp = 0;
list.removeAll();
if (variabl2603.size() < 1) {
try {
main1.getConn();
String[] tableType = { "TABLE" };
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
rt = databaseMetaData.getTables(null, null, "%",
tableType);
while (rt.next()) {
variabl2603.add(rt.getString("TABLE_NAME"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
for (int i = 0; i < variabl2603.size(); i++)
list.add(variabl2603.get(i).toString());
}
});
refNameL.setBounds(250, 10, 80, 20);
panel.add(refNameL);
refName.setBounds(330, 10, 100, 20);
panel.add(refName);
refName.addMouseListener(new MouseAdapter()
{
@Override
public void mouseClicked(MouseEvent e)
{
list.removeAll();
refName.setText(tName.getText()+"接口参数表");
}
});
refName.addFocusListener(new FocusAdapter()
{
private String oldTable="";
public void focusLost(final FocusEvent fe) {
String newTable = refName.getText().trim();
if (newTable.length() > 0 && !newTable.equals(oldTable)) {
if (!variabl2603.contains(newTable)) {
createNewTable(newTable);
}
oldTable = newTable;
loadRefTable(newTable);
}
}
});
variabl1965 = new DefaultTableModel(variabl2197, variabl2517);
variabl2655 = new JTable(variabl1965);
variabl2655.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl2655.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int currentRow = variabl2655.getSelectedRow();
String val="";
for (int j = 0; j < 5; j++)
{
if (variabl1965.getValueAt(currentRow, j) != null)
val= variabl1965.getValueAt(currentRow, j).toString();
else
val = "";
switch (j)
{
case 0:
fieldName.setText(val.toString());
break;
case 1:
max.setText(val.toString());
break;
case 2:
min.setText(val.toString());
break;
case 3:
range.setText(val.toString());
break;
case 4:
exp.setText(val.toString());
break;
}
}
}
});
tableScroll.setBounds(10, 40, 700, 400);
tableScroll.setViewportView(variabl2655);
panel.add(tableScroll, BorderLayout.CENTER);
fieldNameL.setBounds(30, 460, 80, 20);
panel.add(fieldNameL);
fieldName.setBounds(110, 460, 100, 20);
panel.add(fieldName);
fieldName.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent fe)
{
currentComp=2;
if (tName.getText().toString().length() > 0)
{
try
{
main1.getConn();
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String sqlStr = "select * from " + tName.getText().trim();
rt = sta.executeQuery(sqlStr);
rt.last();
rtmd = rt.getMetaData();
int count = rtmd.getColumnCount();
list.removeAll();
for (int i = 0; i < count; i++)
{
list.add(rtmd.getColumnName(i + 1));
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "连接数据库出错！");
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
});
maxL.setBounds(240, 460, 60, 20);
panel.add(maxL);
max.setBounds(300, 460, 100, 20);
panel.add(max);
max.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=3;
list.removeAll();
}
});
minL.setBounds(430, 460, 60, 20);
panel.add(minL);
min.setBounds(490, 460, 100, 20);
panel.add(min);
min.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=4;
list.removeAll();
}
});
rangeL.setBounds(620, 460, 60, 20);
panel.add(rangeL);
range.setBounds(680, 460, 100, 20);
panel.add(range);
range.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=5;
list.removeAll();
}
});
panel.add(expL);
panel.add(exp);
expL.setBounds(30, 500, 80, 20);
exp.setBounds(110, 500, 100, 20);
exp.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=6;
list.removeAll();
}
});
list.setBounds(720, 10, 120, 430);
panel.add(list);
list.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
switch (currentComp)
{
case 0:
tName.setText(list.getSelectedItem());
break;
case 2:
fieldName.setText(list.getSelectedItem());
break;
case 3:
max.setText(list.getSelectedItem());
break;
case 4:
min.setText(list.getSelectedItem());
break;
case 5:
range.setText(list.getSelectedItem());
break;
case 6:
exp.setText(list.getSelectedItem());
break;
}
}
});
add.setBounds(20, 540, 140, 20);
add.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String[] rowValues = { fieldName.getText(), max.getText(),
min.getText(), range.getText(), exp.getText() };
for(int i=0;i<rowValues.length;i++)
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues))
{
JOptionPane.showMessageDialog(frame, "该条记录已经存在!");
}
else
{
insertRecord(rowValues);
}
}
});
panel.add(add);
upd.setBounds(160, 540, 140, 20);
upd.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=variabl2655.getSelectedRow();
if(row==-1)
return;
String[] rowValues = { fieldName.getText(), max.getText(),
min.getText(), range.getText(), exp.getText() };
for(int i=0;i<rowValues.length;i++)
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues,row))
{
JOptionPane.showMessageDialog(frame, "该记录已存在!");
}
else
{
updateRecord(rowValues,row);
}
}
});
panel.add(upd);
del.setBounds(300, 540, 130, 20);
del.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=variabl2655.getSelectedRow();
if(row==-1)
return;
deleteRecord((Vector)variabl1965.getDataVector().elementAt(row),row);
}
});
panel.add(del);
reset.setBounds(430, 540, 130, 20);
reset.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
fieldName.setText("");
max.setText("");
min.setText("");
range.setText("");
exp.setText("");
}
});
panel.add(reset);
exit.setBounds(560, 540, 130, 20);
exit.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
panel.setVisible(false);
frame.setVisible(false);
System.exit(0);
}
});
panel.add(exit);
this.add(panel);
this.setVisible(true);
}
protected void deleteRecord(Vector v,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="delete from "+refName.getText().trim()+" where 标志位=3 AND variabl2153='"+v.get(0)+"'";
sta.executeUpdate(sqlStr);
String [][]tempData=new String[variabl2197.length-1][];
for(int i=0;i<tempData.length;i++)
{
if(i<row)
{
tempData[i]=variabl2197[i];
}
else
{
tempData[i]=variabl2197[i+1];
}
}
variabl2197=tempData;
variabl1965.removeRow(row);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void updateRecord(String[] rowValues,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="update "+refName.getText().trim()+" set ";
String temp="";
String temp1="";
for(int i=0;i<variabl2517.length;i++)
{
temp1=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
temp+=variabl2517[i]+"="+temp1;
}
temp=temp.substring(0, temp.length()-1);
sqlStr+=temp+" where 标志位=3 AND variabl2153='"+variabl2197[row][0]+"'";
sta.executeUpdate(sqlStr);
variabl2197[row]=rowValues;
Vector<String>v=new Vector<String>();
for(int i=0;i<rowValues.length;i++)
{
v.add(rowValues[i]);
}
variabl1965.getDataVector().setElementAt(v, row);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues, int row)
{
boolean flag=false;
for(int i=0;i<variabl2197.length;i++)
{
if(row==i)
continue;
if((rowValues[0]==variabl2197[i][0] || rowValues[0].equals(variabl2197[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void insertRecord(String[] rowValues)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="insert into "+refName.getText().trim()+"( 标志位,";
String temp="";
String temp1="values (3,";
for(int i=0;i<variabl2517.length;i++)
{
temp+=variabl2517[i]+",";
temp1+=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
}
temp=temp.substring(0, temp.length()-1)+")";
temp1=temp1.substring(0, temp1.length()-1)+")";
sqlStr+=temp+temp1;
sta.executeUpdate(sqlStr);
String tempArray[][] = new String[variabl2197.length+1][];
for (int i = 0; i < variabl2197.length; i++)
{
if (i == variabl2197.length - 1)
{
tempArray[i] = rowValues;
} else
{
tempArray[i] = variabl2197[i];
}
}
variabl2197 = tempArray;
variabl1965.addRow(rowValues);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues)
{
return false;
}
protected void loadRefTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String sqlStr="select variabl2153,variabl2281,variabl2371,variabl2605,variabl1413 from "+tname+" where 标志位 = 3";
rt=sta.executeQuery(sqlStr);
rt.last();
int count=rt.getRow();
variabl2197=new String[count][5];
rt.absolute(1);
for(int i=0;i<count;i++)
{
for(int j=0;j<5;j++)
{
variabl2197[i][j]=rt.getString(j+1);
}
rt.next();
}
variabl1965.setDataVector(variabl2197, variabl2517);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(frame, "参数表不正确！");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void createNewTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="CREATE TABLE [dbo].["+tname+"]("+
"[标志位] [tinyint] NOT NULL,"+
"[variabl2153] [varchar](50) NULL,"+
"[variabl2281] [real] NULL,"+
"[variabl2371] [real] NULL,"+
"[variabl2605] [nvarchar](50) NULL,"+
"[variabl1413] [nvarchar](50) NULL,"+
"[用户名称] [nvarchar](50) NULL,"+
"[许可字段号] [nvarchar](50) NULL,"+
"[权限] [nchar](10) NULL"+
") ON [PRIMARY]";
sta.executeUpdate(sqlStr);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "接口参数表创建失败!");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
35.源码35，工具程序，表格式数据维护部件安全性控制条件设置程序。
/*
* 程序文件名：tableTenance7.java
* 作者：齐赛
* 程序功能：本程序用于维护部件设置安全性控制条件。
* 1.在参数表控件中输入参数表名，若该表在数据库中不存在，则会自动创建一个参数表，
* 字段是： "标志位","字段名称", "最大值", "最小值", "值域", "条件表达式"，"用户名称", "许可字段号", "权限"
* 2.若输入的参数表名存在，则会自动加载到表格中，
* 此程序只显示"用户名称", "许可字段号", "权限"这三个字段
* 3.在数据存盘时会根据表格数据去检查用户名是否具有权限
* 4.数据存盘时，其 标志位为2，表示安全性控制
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Vector;
public class secureTool4DB extends JFrame
{
static secureTool4DB frame;
JPanel panel;
DefaultTableModel variabl1965;
JTable variabl2655;
JScrollPane tableScroll;
JScrollPane listScroll;
List list;
JLabel tNameL, refNameL, userNameL, permFieldsL, authL;
JTextField tName, refName, userName, permFields, auth;
JButton add,del,upd,reset,exit;
static String variabl1275 = "sqlserver";
static String variabl1091 = "sql1";
String url;
static ArrayList<String> variabl2603=new ArrayList<String>() ;
String []variabl2517;
private String[][] variabl2197;
static String []power=new String[]{ "i 录入权限", "u 修改权限",
"d 删除权限", "q 查询显示权限", "a 全部权限"};
static int currentComp=-1;
Connection con;
Statement sta;
ResultSet rt;
ResultSetMetaData rtmd;
public secureTool4DB()
{
panel=new JPanel();
tableScroll=new JScrollPane();
listScroll=new JScrollPane();
list=new List();
tNameL=new JLabel("数据表名");
refNameL=new JLabel("参数表名");
userNameL=new JLabel("用户名称");
permFieldsL=new JLabel("许可字段号");
authL=new JLabel("权限");
tName=new JTextField();
refName=new JTextField();
userName=new JTextField();
permFields=new JTextField();
auth=new JTextField();
add=new JButton("添加记录");
del=new JButton("删除记录");
upd=new JButton("更改记录");
reset=new JButton("清空参数");
exit=new JButton("退 出");
}
public static void main(String[] args)
{
variabl1275 = "sqlserver";
variabl1091 = "sql1";
variabl2603=new ArrayList<String>() ;
power[0]="i 录入权限";
power[1]="u 修改权限";
power[2]="d 删除权限";
power[3]="q 查询显示权限";
power[4]="a 全部权限";
currentComp=-1;
frame=new secureTool4DB();
main1.driver1();
frame.initGUI();
}
public void initGUI()
{
this.setTitle("许可字段号填写该用户对该表所能操作的字段的顺序号。权限标志包括：i、u、d、q、a等。 作者：齐赛");
this.setBounds(10, 10, 880, 660);
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
panel.setBounds(10, 10, 880, 660);
panel.setLayout(null);
variabl2517 = new String[]{ "用户名称", "许可字段号", "权限"};
tNameL.setBounds(40, 10, 80, 20);
panel.add(tNameL);
tName.setBounds(130, 10, 100, 20);
panel.add(tName);
tName.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0) {
currentComp = 0;
list.removeAll();
if (variabl2603.size() < 1) {
try {
main1.getConn();
String[] tableType = { "TABLE" };
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
rt = databaseMetaData.getTables(null, null, "%",
tableType);
while (rt.next()) {
variabl2603.add(rt.getString("TABLE_NAME"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
for (int i = 0; i < variabl2603.size(); i++)
list.add(variabl2603.get(i).toString());
}
});
refNameL.setBounds(250, 10, 80, 20);
panel.add(refNameL);
refName.setBounds(330, 10, 100, 20);
panel.add(refName);
refName.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
list.removeAll();
refName.setText(tName.getText()+"接口参数表");
}
});
refName.addFocusListener(new FocusAdapter()
{
private String oldTable="";
public void focusLost(final FocusEvent fe) {
String newTable = refName.getText().trim();
if (newTable.length() > 0 && !newTable.equals(oldTable)) {
if (!variabl2603.contains(newTable)) {
createNewTable(newTable);
}
oldTable = newTable;
loadRefTable(newTable);
}
}
});
variabl1965 = new DefaultTableModel(variabl2197, variabl2517);
variabl2655 = new JTable(variabl1965);
variabl2655.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl2655.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int currentRow = variabl2655.getSelectedRow();
String val="";
for (int j = 0; j < 3; j++)
{
if (variabl1965.getValueAt(currentRow, j) != null)
val= variabl1965.getValueAt(currentRow, j).toString();
else
val = "";
switch (j)
{
case 0:
userName.setText(val.toString());
break;
case 1:
permFields.setText(val.toString());
break;
case 2:
auth.setText(val.toString());
break;
}
}
}
});
tableScroll.setBounds(10, 40, 700, 400);
tableScroll.setViewportView(variabl2655);
panel.add(tableScroll, BorderLayout.CENTER);
userNameL.setBounds(30, 460, 80, 20);
panel.add(userNameL);
userName.setBounds(110, 460, 100, 20);
panel.add(userName);
userName.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent fe)
{
currentComp=2;
list.removeAll();
}
});
permFieldsL.setBounds(240, 460, 80, 20);
panel.add(permFieldsL);
permFields.setBounds(320, 460, 100, 20);
panel.add(permFields);
permFields.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=3;
list.removeAll();
if (tName.getText().toString().length() > 0)
{
try
{
main1.getConn();
sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String sqlStr = "select * from " + tName.getText().trim();
rt = sta.executeQuery(sqlStr);
rt.last();
rtmd = rt.getMetaData();
int count = rtmd.getColumnCount();
list.removeAll();
for (int i = 0; i < count; i++)
{
list.add(rtmd.getColumnName(i + 1));
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "连接数据库出错！");
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
});
authL.setBounds(430, 460, 60, 20);
panel.add(authL);
auth.setBounds(490, 460, 100, 20);
panel.add(auth);
auth.addFocusListener(new FocusAdapter()
{
public void focusGained(final FocusEvent arg0)
{
currentComp=4;
list.removeAll();
for (int i = 0; i < power.length; i++)
{
list.add(power[i]);
}
}
});
list.setBounds(720, 10, 120, 430);
panel.add(list);
list.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
switch (currentComp)
{
case 0:
tName.setText(list.getSelectedItem());
break;
case 2:
userName.setText(list.getSelectedItem());
break;
case 3:
permFields.setText(permFields.getText()+ list.getSelectedIndex() + ",");
break;
case 4:
auth.setText(auth.getText()+ list.getSelectedIndex() + ",");
break;
}
}
});
add.setBounds(20, 540, 140, 20);
add.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String[] rowValues = { userName.getText(), permFields.getText(),
auth.getText() };
for(int i=0;i<rowValues.length;i++)
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues))
{
JOptionPane.showMessageDialog(frame, "该条记录已经存在!");
}
else
{
insertRecord(rowValues);
}
}
});
panel.add(add);
upd.setBounds(160, 540, 140, 20);
upd.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=variabl2655.getSelectedRow();
if(row==-1)
return;
String[] rowValues = { userName.getText(), permFields.getText(),
auth.getText() };
for(int i=0;i<rowValues.length;i++)
{
if(rowValues[i].length()<=0)
{
rowValues[i]=null;
}
}
if(recordExisted(rowValues,row))
{
JOptionPane.showMessageDialog(frame, "该记录已存在!");
}
else
{
updateRecord(rowValues,row);
}
}
});
panel.add(upd);
del.setBounds(300, 540, 130, 20);
del.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
int row=variabl2655.getSelectedRow();
if(row==-1)
return;
deleteRecord((Vector)variabl1965.getDataVector().elementAt(row),row);
}
});
panel.add(del);
reset.setBounds(430, 540, 130, 20);
reset.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
userName.setText("");
permFields.setText("");
auth.setText("");
}
});
panel.add(reset);
exit.setBounds(560, 540, 130, 20);
exit.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
panel.setVisible(false);
frame.setVisible(false);
System.exit(0);
}
});
panel.add(exit);
this.add(panel);
this.setVisible(true);
}
protected void deleteRecord(Vector v,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="delete from "+refName.getText().trim()+" where 标志位=2 AND 用户名称='"+v.get(0)+"'";
sta.executeUpdate(sqlStr);
String [][]tempData=new String[variabl2197.length-1][];
for(int i=0;i<tempData.length;i++)
{
if(i<row)
{
tempData[i]=variabl2197[i];
}
else
{
tempData[i]=variabl2197[i+1];
}
}
variabl2197=tempData;
variabl1965.removeRow(row);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void updateRecord(String[] rowValues,int row)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="update "+refName.getText().trim()+" set ";
String temp="";
String temp1="";
for(int i=0;i<variabl2517.length;i++)
{
temp1=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
temp+=variabl2517[i]+"="+temp1;
}
temp=temp.substring(0, temp.length()-1);
sqlStr+=temp+" where 标志位=2 AND 用户名称='"+variabl2197[row][0]+"'";
sta.executeUpdate(sqlStr);
variabl2197[row]=rowValues;
Vector<String>v=new Vector<String>();
for(int i=0;i<rowValues.length;i++)
{
v.add(rowValues[i]);
}
variabl1965.getDataVector().setElementAt(v, row);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues, int row)
{
boolean flag=false;
for(int i=0;i<variabl2197.length;i++)
{
if(row==i)
continue;
if((rowValues[0]==variabl2197[i][0] || rowValues[0].equals(variabl2197[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void insertRecord(String[] rowValues)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="insert into "+refName.getText().trim()+"( 标志位,";
String temp="";
String temp1="values (2,";
for(int i=0;i<variabl2517.length;i++)
{
temp+=variabl2517[i]+",";
temp1+=(rowValues[i]==null?"NULL,":"'"+rowValues[i]+"'"+",");
}
temp=temp.substring(0, temp.length()-1)+")";
temp1=temp1.substring(0, temp1.length()-1)+")";
sqlStr+=temp+temp1;
sta.executeUpdate(sqlStr);
String tempArray[][] = new String[variabl2197.length+1][];
for (int i = 0; i < variabl2197.length; i++)
{
if (i == variabl2197.length - 1)
{
tempArray[i] = rowValues;
} else
{
tempArray[i] = variabl2197[i];
}
}
variabl2197 = tempArray;
variabl1965.addRow(rowValues);
variabl2655.repaint();
}catch (SQLException sqle)
{
sqle.printStackTrace();
}finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected boolean recordExisted(String[] rowValues)
{
boolean flag=false;
for(int i=0;i<variabl2197.length;i++)
{
if((rowValues[0]==variabl2197[i][0] || rowValues[0].equals(variabl2197[i][0])))
{
flag=true;
break;
}
}
return flag;
}
protected void loadRefTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String sqlStr="select 用户名称,许可字段号,权限 from "+tname+" where 标志位 = 2";
rt=sta.executeQuery(sqlStr);
rt.last();
int count=rt.getRow();
variabl2197=new String[count][3];
rt.absolute(1);
for(int i=0;i<count;i++)
{
for(int j=0;j<3;j++)
{
variabl2197[i][j]=rt.getString(j+1);
}
rt.next();
}
variabl1965.setDataVector(variabl2197, variabl2517);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(frame, "参数表不正确！");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
protected void createNewTable(String tname)
{
try
{
main1.getConn();
sta=con.createStatement();
String sqlStr="CREATE TABLE [dbo].["+tname+"]("+
"[标志位] [tinyint] NOT NULL,"+
"[variabl2153] [varchar](50) NULL,"+
"[variabl2281] [real] NULL,"+
"[variabl2371] [real] NULL,"+
"[variabl2605] [nvarchar](50) NULL,"+
"[variabl1413] [nvarchar](50) NULL,"+
"[用户名称] [nvarchar](50) NULL,"+
"[许可字段号] [nvarchar](50) NULL,"+
"[权限] [nchar](10) NULL"+
") ON [PRIMARY]";
sta.executeUpdate(sqlStr);
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "接口参数表创建失败!");
e.printStackTrace();
} finally
{
try
{
if(rt!=null)
{
rt.close();
rt=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
}
36.源码36，部件程序，单记录、表格式混合部件程序。
/**
* 程序文件名：tableTenance7.java
* 作者： 齐赛
* 功能：单记录、表格式混合部件10
* 说明：
* 1.增加了列表框，点击列表框的历史数据即可进行输入，有代码表的，代码表数据也会显示在列表框中
* 2.自定义布局算法，字段采用TextFiled variabl2701 TextArea 布局，主要根据列数据宽度来选择
* 3.数据在修改存盘时，未指定的数据统一用NULL
* 4.当存盘或者删除记录之后，表格进行实时同步更新
* 5.为提高效率，字典表和代码表需要从parameter[0]带入，如果没有指定，则会采用默认
* 6.如果作数据录入使用，需要用鼠标将分隔窗向上提，使单记录式界面展露出来再继续操作。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.plaf.ButtonUI;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
import java.io.*;
public class tableTenance10 extends JFrame {
static tableTenance10 frame;
static JLabel statusBar1 = new JLabel("一共");
static JLabel totalItems = new JLabel();
static JLabel statusBar2 = new JLabel("条记录");
static JLabel statusBar3 = new JLabel("当前记录是第");
static JLabel currentItem = new JLabel();
static JLabel statusBar4 = new JLabel("条");
static JLabel statusBar40 = new JLabel(
"提示：如果作数据录入、修改使用，需要用鼠标将分隔窗向上提（或点击向上箭头），使单记录式界面展露出来再继续操作");
static JButton firstItem = new JButton("第一条");
static JButton nextItem = new JButton("下一条");
static JButton previousItem = new JButton("上一条");
static JButton endItem = new JButton("末一条");
static JButton delete = new JButton("删除记录");
static JButton addItem = new JButton("录入存盘");
static JButton updateItem = new JButton("修改存盘");
static JButton exit = new JButton("退 出");
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2483 = 0, variabl2503 = 0, variabl2851 = 0,
variabl2339 = 0;
static String[] variabl2369;
MouseMonitor mm = new MouseMonitor();
FocusMonitor fm = new FocusMonitor();
ListSelectionMonitor lsm = new ListSelectionMonitor();
ButtonMonitor1 bm1 = new ButtonMonitor1();
ButtonMonitor2 bm2 = new ButtonMonitor2();
JTable table;
DefaultTableModel dtm;
JPanel fieldPane;
JPanel listPane;
JList list;
DefaultListModel dlm;
JSplitPane splitPaneV;
JSplitPane splitPaneH;
JScrollPane tableScrollPane;
JScrollPane fieldScrollPane;
JScrollPane listScrollPane;
List<Field> fields;
String variabl2603;
int[] variabl1055;
int variabl2113;
int variabl2193;
int[] variabl2275;
String variabl2069[];
String variabl2197[][];
String[] variabl1525;
int variabl1489[];
String variabl1501[];
String variabl1873;
String variabl1837[][];
String[] variabl1749;
boolean flags[];
static List<String> variabl2233 = new ArrayList<String>();
static Map<String, Map<String, String>> map = new HashMap<String, Map<String, String>>();
Connection con;
Statement sta;
ResultSet rt;
ResultSetMetaData rtmd;
static int currentRow = -1;
static int currentColumn = -1;
public static void means(String[] parameter) {
String[] variabl240501 = { "第一条", "下一条", "上一条", "末一条", "删除记录", "录入存盘",
"修改存盘", "退 出" };
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) {
}
statusBar1 = new JLabel("一共");
totalItems = new JLabel();
statusBar2 = new JLabel("条记录");
statusBar3 = new JLabel("当前记录是第");
currentItem = new JLabel();
statusBar4 = new JLabel("条");
firstItem = new JButton(variabl2405[0]);
nextItem = new JButton(variabl2405[1]);
previousItem = new JButton(variabl2405[2]);
endItem = new JButton(variabl2405[3]);
delete = new JButton(variabl2405[4]);
frame = new tableTenance10();
addItem = new JButton(variabl2405[5]);
updateItem = new JButton(variabl2405[6]);
exit = new JButton(variabl2405[7]);
variabl2233 = new ArrayList<String>();
map = new HashMap<String, Map<String, String>>();
currentRow = -1;
currentColumn = -1;
frame = new tableTenance10();
frame.initParameter(parameter);
frame.initGUI();
}
private void initGUI() {
dtm = new DefaultTableModel(variabl2197, variabl1749);
dtm.addRow(variabl2369);
table = new JTable();
table.setModel(dtm);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
table.addMouseListener(mm);
table.getTableHeader().setDefaultRenderer(
new DefaultTableCellRenderer() {
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column) {
JComponent cell = (JComponent) super
.getTableCellRendererComponent(table, value,
isSelected, hasFocus, row, column);
for (int i = 0; i < variabl1055.length; i++) {
if (column == variabl1055[i]) {
cell.setBackground(Color.LIGHT_GRAY);
break;
}
cell.setBackground(new Color(238, 238, 238));
}
cell.setBorder(BorderFactory.createRaisedBevelBorder());
return cell;
}
});
for (int i = 0; i < table.getColumnCount(); i++) {
table.getColumnModel().getColumn(i).setPreferredWidth(100);
}
fieldPane = new JPanel();
fieldPane.setLayout(null);
fieldPane.setBackground(Color.GRAY);
fieldPane.setPreferredSize(new Dimension(850, 800));
List<Field> textFields = new ArrayList<Field>();
List<Field> textAreas = new ArrayList<Field>();
int space = 3;
int pointX = 0, pointY = 0, prePointX = 0, prePointY = 0, preW = 0, preH = 0, W = 0, H = 0;
for (int i = 0; i < variabl2275.length; i++) {
Field temp = new Field(i);
temp.getComponent().addFocusListener(fm);
if (temp.jtf == null ? textAreas.add(temp) : textFields.add(temp))
;
fields.add(temp);
}
for (int i = 0; i < textFields.size(); i++) {
Field field = textFields.get(i);
if (i == 0) {
preW = (int) field.getPreferredSize().getWidth();
preH = (int) field.getPreferredSize().getHeight();
pointX += space + preW;
pointY = pointY;
} else {
W = (int) field.getPreferredSize().getWidth();
H = (int) field.getPreferredSize().getHeight();
Field preField = textFields.get(i - 1);
if (850 - pointX >= W) {
preField.setPreferredSize(new Dimension(preW, preH));
preField.setBounds(prePointX, prePointY, preW, preH);
preW = W;
preH = H;
prePointX = pointX;
prePointY = pointY;
pointX += space + W;
pointY = pointY;
} else {
Component comp = preField.getComponent();
comp.setPreferredSize(new Dimension((int) comp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) comp.getPreferredSize().getHeight()));
preField.setPreferredSize(new Dimension(preW + space + 850
- pointX, preH));
preField.setBounds(prePointX, prePointY, preW + space + 850
- pointX, preH);
preW = W;
preH = H;
prePointX = 0;
prePointY += space
+ preField.getPreferredSize().getHeight();
pointX = space + W;
pointY += space + preField.getPreferredSize().getHeight();
}
if (i == textFields.size() - 1) {
Component comp = field.getComponent();
comp.setPreferredSize(new Dimension((int) comp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) comp.getPreferredSize().getHeight()));
field.setPreferredSize(new Dimension(preW + space + 850
- pointX, preH));
field.setBounds(prePointX, prePointY, preW + space + 850
- pointX, preH);
prePointX = 0;
prePointY += space + field.getPreferredSize().getHeight();
pointX = prePointX;
pointY = prePointY;
}
}
fieldPane.add(field);
}
preW = 0;
preH = 0;
W = 0;
H = 0;
for (int i = 0; i < textAreas.size(); i++) {
Field field = textAreas.get(i);
if (i == 0) {
preW = (int) field.getPreferredSize().getWidth();
preH = (int) field.getPreferredSize().getHeight();
pointX += space + preW;
pointY = pointY;
} else {
W = (int) field.getPreferredSize().getWidth();
H = (int) field.getPreferredSize().getHeight();
Field preField = textAreas.get(i - 1);
if (850 - pointX >= W) {
preField.setPreferredSize(new Dimension(preW, preH));
preField.setBounds(prePointX, prePointY, preW, preH);
preW = W;
preH = H;
prePointX = pointX;
prePointY = pointY;
pointX += space + W;
pointY = pointY;
} else {
Component comp = preField.getComponent();
comp.setPreferredSize(new Dimension((int) comp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) comp.getPreferredSize().getHeight()));
JScrollPane jsp = field.jsp;
jsp.setPreferredSize(new Dimension((int) jsp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) jsp.getPreferredSize().getHeight()));
preField.setPreferredSize(new Dimension(preW + space + 850
- pointX, preH));
preField.setBounds(prePointX, prePointY, preW + space + 850
- pointX, preH);
preW = W;
preH = H;
prePointX = 0;
prePointY += space
+ preField.getPreferredSize().getHeight();
pointX = space + W;
pointY += space + preField.getPreferredSize().getHeight();
}
if (i == textAreas.size() - 1) {
Component comp = field.getComponent();
comp.setPreferredSize(new Dimension((int) comp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) comp.getPreferredSize().getHeight()));
JScrollPane jsp = field.jsp;
jsp.setPreferredSize(new Dimension((int) jsp
.getPreferredSize().getWidth()
+ space
+ 850
- pointX, (int) jsp.getPreferredSize().getHeight()));
field.setPreferredSize(new Dimension(preW + space + 850
- pointX, preH));
field.setBounds(prePointX, prePointY, preW + space + 850
- pointX, preH);
pointY += space + field.getPreferredSize().getHeight();
}
}
fieldPane.add(field);
}
fieldPane.setPreferredSize(new Dimension(850, pointY + 10));
list = new JList();
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
dlm = new DefaultListModel();
list.setModel(dlm);
list.addListSelectionListener(lsm);
listScrollPane = new JScrollPane(list);
fieldScrollPane = new JScrollPane(fieldPane);
fieldScrollPane.getVerticalScrollBar().setUnitIncrement(10);
tableScrollPane = new JScrollPane(table);
splitPaneH = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
fieldScrollPane, listScrollPane);
splitPaneH.setDividerLocation(870);
splitPaneH.setOneTouchExpandable(false);
splitPaneV = new JSplitPane(JSplitPane.VERTICAL_SPLIT, tableScrollPane,
splitPaneH);
splitPaneV.setDividerLocation(600);
splitPaneV.setOneTouchExpandable(true);
splitPaneV.setBounds(0, 0, variabl2483, 500);
if (variabl2193 == 0) {
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
}
firstItem.addActionListener(bm1);
nextItem.addActionListener(bm1);
previousItem.addActionListener(bm1);
endItem.addActionListener(bm1);
addItem.addActionListener(bm2);
updateItem.addActionListener(bm2);
delete.addActionListener(bm2);
exit.addActionListener(bm2);
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl2337 = 30;
firstItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
previousItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",1,") >= 0)
variabl2337 = variabl2337 + variabl2339;
nextItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",2,") >= 0)
variabl2337 = variabl2337 + variabl2339;
endItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",3,") >= 0)
variabl2337 = variabl2337 + variabl2339;
addItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",5,") >= 0)
variabl2337 = variabl2337 + variabl2339;
updateItem.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",6,") >= 0)
variabl2337 = variabl2337 + variabl2339;
delete.setBounds(variabl2337, 520, variabl2339, 30);
if (variabl1187.indexOf(",4,") >= 0)
variabl2337 = variabl2337 + variabl2339;
exit.setBounds(variabl2337, 520, variabl2339, 30);
Font f = new Font("仿宋", Font.BOLD, 15);
statusBar1.setBounds(5, 555, 50, 30);
statusBar1.setFont(f);
totalItems.setBounds(55, 555, 50, 30);
totalItems.setText(String.valueOf(variabl2193));
totalItems.setFont(f);
statusBar2.setBounds(85, 555, 50, 30);
statusBar2.setFont(f);
statusBar3.setBounds(140, 555, 100, 30);
statusBar3.setFont(f);
currentItem.setBounds(245, 555, 50, 30);
currentItem.setFont(f);
statusBar4.setBounds(295, 555, 50, 30);
statusBar4.setFont(f);
statusBar40.setBounds(10, 500, 1000, 20);
statusBar40.setFont(f);
this.setTitle("表格、单记录混合式数据维护部件11:" + variabl2603 + " 作者：齐赛");
this.setBounds(150, 50, variabl2483, variabl2503);
this.getContentPane().setLayout(null);
this.getContentPane().add(splitPaneV);
if (variabl1187.indexOf(",0,") >= 0)
this.getContentPane().add(firstItem);
if (variabl1187.indexOf(",1,") >= 0)
this.getContentPane().add(previousItem);
if (variabl1187.indexOf(",2,") >= 0)
this.getContentPane().add(nextItem);
if (variabl1187.indexOf(",3,") >= 0)
this.getContentPane().add(endItem);
if (variabl1187.indexOf(",5,") >= 0)
this.getContentPane().add(addItem);
if (variabl1187.indexOf(",6,") >= 0)
this.getContentPane().add(updateItem);
if (variabl1187.indexOf(",4,") >= 0)
this.getContentPane().add(delete);
if (variabl1187.indexOf(",7,") >= 0)
this.getContentPane().add(exit);
this.getContentPane().add(statusBar1);
this.getContentPane().add(totalItems);
this.getContentPane().add(statusBar2);
this.getContentPane().add(statusBar3);
this.getContentPane().add(currentItem);
this.getContentPane().add(statusBar4);
this.getContentPane().add(statusBar40);
this.addWindowListener(new WindowMonitor());
this.setVisible(true);
}
private void initParameter(String[] parameter) {
variabl2603 = parameter[4];
if (parameter[6] == null || parameter[6].length() == 0) {
JOptionPane.showMessageDialog(null, "缺少关键字！");
return;
}
variabl1525 = parameter[6].trim().split(",");
variabl1055 = new int[variabl1525.length];
ArrayList<Integer> variabl1025 = new ArrayList<Integer>(
variabl1525.length);
for (String item : parameter[0].split(",")) {
if (item.endsWith("代码表")) {
variabl2233.add(item);
}
}
String temp[] = parameter[0].split(",");
for (int i = 0; i < temp.length && variabl1873 == null; i++) {
variabl1873 = temp[i].endsWith("字典表") ? temp[i] : null;
}
con = main1.getConn();
if (variabl1873 != null && variabl1873.length() > 0) {
try {
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rt = sta.executeQuery("select * from " + variabl1873);
rt.last();
int count = rt.getRow();
variabl1837 = new String[count][2];
rt.absolute(1);
while (count >= 1) {
variabl1837[count - 1][0] = rt.getString(1);
variabl1837[count - 1][1] = rt.getString(2);
count--;
rt.next();
}
} catch (SQLException e1) {
e1.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (sta != null) {
sta.close();
sta = null;
}
} catch (SQLException sqle) {
sqle.printStackTrace();
}
}
}
try {
sta = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rt = sta.executeQuery("select * from " + variabl2603);
rtmd = rt.getMetaData();
int columns = rtmd.getColumnCount();
TreeSet<Integer> ts = new TreeSet<Integer>();
for (int i = 1, flag = 0; i <= columns && flag < variabl1525.length; i++) {
for (int j = 0; j < variabl1525.length; j++) {
if (rtmd.getColumnName(i).trim()
.equals(variabl1525[j].trim())) {
ts.add(i);
variabl1025.add(i);
flag++;
break;
}
}
}
if (parameter[8] == "") {
for (int i = 0; i < columns; i++) {
parameter[8] += (i == columns - 1) ? i + "" : i + ",";
}
}
String array[] = parameter[8].trim().split(",");
for (int i = 0; i < array.length; i++) {
ts.add(Integer.valueOf(array[i]) + 1);
}
int i = 0;
int k = 0;
variabl2275 = new int[ts.size()];
variabl1489 = new int[ts.size()];
variabl1501 = new String[ts.size()];
fields = new ArrayList<Field>(ts.size());
variabl2113 = variabl2275.length;
variabl2069 = new String[variabl2275.length];
variabl2369 = new String[variabl2275.length];
Iterator<Integer> it = ts.iterator();
while (it.hasNext()) {
variabl2275[i] = it.next();
if (variabl1025.contains(variabl2275[i])) {
variabl1055[k++] = variabl2275[i] - 1;
}
i++;
}
variabl1749 = new String[variabl2069.length];
flags = new boolean[variabl2069.length];
for (i = 0; i < variabl2113; i++) {
variabl2069[i] = rtmd.getColumnName(variabl2275[i]);
if (variabl1837 != null) {
int j = 0;
for (; j < variabl1837.length; j++) {
if (variabl1837[j][0].trim().equalsIgnoreCase(
variabl2069[i].trim())) {
variabl1749[i] = variabl1837[j][1];
break;
}
}
if (j >= variabl1837.length) {
variabl1749[i] = variabl2069[i];
}
} else {
variabl1749[i] = variabl2069[i];
}
if (variabl2233.contains(variabl1749[i] + "代码表")
|| variabl2233.contains(variabl1749[i] + "表")) {
ResultSet rs1 = null;
Statement sta1 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
String str = variabl2233.contains(variabl1749[i] + "代码表") ? variabl1749[i]
+ "代码表"
: variabl1749[i] + "表";
rs1 = sta1.executeQuery("select * from " + str);
Map<String, String> codeTable = new HashMap<String, String>();
while (rs1.next()) {
String label = rs1.getString(1);
String code = rs1.getString(2);
codeTable.put(label, code);
}
map.put(variabl1749[i], codeTable);
rs1.close();
rs1 = null;
sta1.close();
sta1 = null;
flags[i] = true;
}
}
rt.last();
variabl2193 = rt.getRow();
variabl2197 = new String[variabl2193][variabl2113];
i = 0;
while (i < variabl2193) {
rt.absolute(i + 1);
for (int j = 0; j < variabl2113; j++) {
variabl2197[i][j] = rt.getString(variabl2275[j]);
}
i++;
}
for (int j = 0; j < variabl2113; j++) {
variabl2069[j] = rtmd.getColumnName(j + 1);
variabl1501[j] = rtmd.getColumnTypeName(j + 1);
variabl1489[j] = rtmd.getColumnDisplaySize(j + 1);
if (variabl1489[j] < variabl2069[j].length())
variabl1489[j] = variabl2069[j].length();
else if (variabl1489[j] > 50)
variabl1489[j] = 50;
variabl2369[j] = "";
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (rt != null) {
rt.close();
rt = null;
}
if (sta != null) {
sta.close();
sta = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
private class WindowMonitor extends WindowAdapter {
public void windowClosing(WindowEvent e) {
exit();
}
}
public void exit() {
tableTenance10.this.dispose();
try {
if (con != null)
con.close();
System.out.println("数据库已断开连接！");
} catch (SQLException e1) {
e1.printStackTrace();
System.out.println("数据库连接断开时异常！");
}
}
class Field extends JPanel implements Comparable<Field> {
int id;
JTextField jtf;
JTextArea jta;
JLabel jlb;
JScrollPane jsp;
public Field(int id) {
this.id = id;
if (variabl1489[id] < 60) {
jtf = new JTextField();
jlb = new JLabel(variabl1749[id]);
jlb.setFont(new Font("仿宋", Font.BOLD, 18));
jtf.setPreferredSize(new Dimension(variabl1489[id] * 8, 25));
this.add(jlb);
this.add(jtf);
} else {
jta = new JTextArea();
jlb = new JLabel(variabl1749[id]);
jlb.setFont(new Font("仿宋", Font.BOLD, 18));
jta.setLineWrap(true);
jsp = new JScrollPane(jta);
jsp.setPreferredSize(new Dimension(200, 80));
this.add(jlb);
this.add(jsp);
}
}
public String getFormatText() {
String text = "";
return text;
}
public String getText() {
return this.jta == null ? jtf.getText() : jta.getText();
}
public void setText(Object text) {
String temp = text != null ? text.toString() : "";
if (jta == null) {
jtf.setText(temp);
} else {
jta.setText(temp);
}
}
public Component getComponent() {
return this.jta == null ? jtf : jta;
}
public int compareTo(Field o) {
return 0;
}
}
private class MouseMonitor extends MouseAdapter {
public void mouseClicked(MouseEvent e) {
currentRow = table.getSelectedRow();
currentColumn = table.getSelectedColumn();
for (int i = 0; i < fields.size(); i++) {
fields.get(i).setText(table.getValueAt(currentRow, i));
}
currentItem.setText(String.valueOf(currentRow + 1));
if (currentRow == 0) {
if (currentRow == variabl2193 - 1) {
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
} else {
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
} else {
if (currentRow == variabl2193 - 1) {
nextItem.setEnabled(false);
endItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
} else {
nextItem.setEnabled(true);
endItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
}
}
private class ButtonMonitor1 implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (e.getSource() == firstItem) {
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == variabl2193 - 1) {
nextItem.setEnabled(false);
endItem.setEnabled(false);
} else {
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
} else if (e.getSource() == previousItem) {
if (currentRow == -1) {
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == variabl2193 - 1) {
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
} else if (currentRow - 1 == 0) {
currentRow--;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
} else {
currentRow--;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
} else if (e.getSource() == nextItem) {
if (currentRow == -1) {
currentRow = 0;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if (currentRow == variabl2193 - 1) {
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
} else if (currentRow + 1 == variabl2193 - 1) {
currentRow++;
endItem.setEnabled(false);
nextItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
} else {
currentRow++;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
} else if (e.getSource() == endItem) {
currentRow = variabl2193 - 1;
endItem.setEnabled(false);
nextItem.setEnabled(false);
if (currentRow == 0) {
firstItem.setEnabled(false);
previousItem.setEnabled(false);
} else {
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
table.setRowSelectionInterval(currentRow, currentRow);
table.scrollRectToVisible(table.getCellRect(currentRow, 0, true));
for (int i = 0; i < fields.size(); i++) {
fields.get(i).setText(table.getValueAt(currentRow, i));
}
currentItem.setText(String.valueOf(currentRow + 1));
}
}
private class ButtonMonitor2 implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (e.getSource() == addItem) {
Vector<String> v = new Vector<String>(variabl2113);
for (int i = 0; i < fields.size(); i++) {
v.add(fields.get(i).getText());
}
if (v.size() < fields.size()) {
JOptionPane.showMessageDialog(frame, "关键字重复!");
return;
} else {
try {
insertSQL(v);
JOptionPane.showMessageDialog(frame, "记录添加成功！");
variabl2193++;
String tempArray[][] = new String[variabl2193][];
for (int i = 0; i < variabl2193; i++) {
if (i == variabl2193 - 1) {
tempArray[i] = v.toArray(new String[] {});
} else {
tempArray[i] = variabl2197[i];
}
}
variabl2197 = tempArray;
dtm.addRow(variabl2369);
table.repaint();
totalItems.setText(String.valueOf(variabl2193));
currentItem.setText(String.valueOf(currentRow + 1));
} catch (SQLException e1) {
JOptionPane.showMessageDialog(frame, e1.getMessage());
return;
} finally {
if (sta != null) {
try {
sta.close();
sta = null;
} catch (SQLException e1) {
}
}
}
}
} else if (e.getSource() == updateItem) {
if (currentRow == -1)
return;
Vector<String> v = new Vector<String>(variabl2113);
for (int i = 0; i < fields.size(); i++) {
v.add(fields.get(i).getText());
}
if (isKeyExist(v, currentRow)) {
JOptionPane.showMessageDialog(frame, "关键字重复!");
return;
} else {
try {
updateSQL(v, currentRow);
JOptionPane.showMessageDialog(frame, "记录更新成功！");
variabl2197[currentRow] = v.toArray(new String[] {});
dtm.getDataVector().setElementAt(v, currentRow);
table.repaint();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(frame, e1.getMessage());
return;
} finally {
if (sta != null) {
try {
sta.close();
sta = null;
} catch (SQLException e1) {
}
}
}
}
} else if (e.getSource() == delete) {
if (currentRow == -1)
return;
try {
deleteSQL(variabl2197[currentRow]);
String[][] tempData = new String[variabl2197.length - 1][];
for (int i = 0; i < tempData.length; i++) {
if (i < currentRow) {
tempData[i] = variabl2197[i];
} else {
tempData[i] = variabl2197[i + 1];
}
}
variabl2197 = tempData;
variabl2193--;
dtm.removeRow(currentRow);
table.repaint();
currentRow = -1;
totalItems.setText(String.valueOf(variabl2193));
currentItem.setText(" ");
JOptionPane.showMessageDialog(frame, "记录删除成功！");
} catch (SQLException e1) {
JOptionPane.showConfirmDialog(frame, e1.getMessage(),
"数据库出错", JOptionPane.DEFAULT_OPTION,
JOptionPane.ERROR_MESSAGE);
} finally {
if (sta != null) {
try {
sta.close();
sta = null;
} catch (SQLException e1) {
e1.printStackTrace();
}
}
}
} else if (e.getSource() == exit) {
exit();
}
}
}
private class FocusMonitor implements FocusListener {
int fieldID = -1;
public void focusGained(FocusEvent e) {
Component c = (Component) e.getSource();
c.setBackground(Color.CYAN);
dlm.clear();
if (c.getParent() instanceof Field) {
fieldID = ((Field) c.getParent()).id;
if (flags[fieldID]) {
HashMap<String, String> hm = (HashMap<String, String>) map
.get(variabl1749[fieldID]);
if (variabl1749[fieldID].endsWith("代码")) {
for (String element : hm.values()) {
dlm.addElement(element);
}
} else {
for (String element : hm.keySet()) {
dlm.addElement(element);
}
}
} else {
Set<String> contents = new HashSet<String>();
for (int i = 0; i < variabl2193; i++) {
if (contents.add(variabl2197[i][fieldID]))
dlm.addElement(variabl2197[i][fieldID]);
}
}
}
}
public void focusLost(FocusEvent e) {
Component c = (Component) e.getSource();
c.setBackground(Color.WHITE);
}
}
private class ListSelectionMonitor implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) {
String item = (String) list.getSelectedValue();
JTextField jt = (JTextField) (fields.get(fm.fieldID)
.getComponent());
jt.setText(item);
}
}
}
/**
* @param lastRow
* 要更新的行号
* @return 如果除lastRow有重复的关键字，则返回false
*/
public boolean isKeyExist(Vector<String> v, int lastRow) {
for (int i = 0; i < variabl2193; i++) {
if (i == lastRow)
continue;
int j = 0;
for (; j < variabl1055.length; j++) {
if (v.get(variabl1055[j]) != variabl2197[i][variabl1055[j]]
&& !v.get(variabl1055[j]).trim()
.equals(variabl2197[i][variabl1055[j]].trim()))
break;
}
if (j >= variabl1055.length) {
return true;
}
}
return false;
}
/**
* @param v
* 将要存盘的一行数据
* @return 如果为true，表示关键字已经存在
*/
public boolean isKeyExist(Vector<String> v) {
for (int i = 0; i < variabl2193; i++) {
int j = 0;
for (; j < variabl1055.length; j++) {
if (v.get(variabl1055[j]) != variabl2197[i][variabl1055[j]]
&& !v.get(variabl1055[j]).trim()
.equals(variabl2197[i][variabl1055[j]].trim()))
break;
}
if (j >= variabl1055.length) {
return true;
}
}
return false;
}
/**
* @param v
* 改变后的行内容
* @param lastRow
* 要更新的行号
* @throws SQLException
*/
public void updateSQL(Vector<String> v, int lastRow) throws SQLException {
String preSQL = "update " + variabl2603 + " set ";
String rearSQL = " where ";
String strSQL = "";
for (int i = 0, flag = 0; i < variabl2069.length; i++) {
if (i != variabl2069.length - 1) {
if (v.get(i) == null || v.get(i).length() <= 0) {
preSQL += variabl2069[i] + "=NULL,";
} else {
preSQL += variabl2069[i] + "='" + v.get(i) + "',";
}
for (int j = 0; j < variabl1055.length
&& flag < variabl1055.length; j++) {
if (variabl1055[j] == i) {
flag++;
if (j != variabl1055.length - 1)
rearSQL += variabl2069[i] + "='"
+ variabl2197[lastRow][i] + "' AND ";
else
rearSQL += variabl2069[i] + "='"
+ variabl2197[lastRow][i] + "'";
break;
}
}
} else {
if (v.get(i) == null || v.get(i).length() <= 0) {
preSQL += variabl2069[i] + "=NULL";
} else {
preSQL += variabl2069[i] + "='" + v.get(i) + "' ";
}
}
}
strSQL = preSQL + rearSQL;
updateExecute(strSQL);
}
private void updateExecute(String strSQL) throws SQLException {
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
/**
* @param v
* 将要存盘的一行数据
* @throws SQLException
* 存盘时候发生异常
*/
public void insertSQL(Vector<String> v) throws SQLException {
String rearSQL = " values (";
String preSQL = "insert into " + variabl2603 + " (";
String strSQL = "";
for (int i = 0; i < variabl2069.length; i++) {
if (i != variabl2069.length - 1) {
preSQL += variabl2069[i] + ",";
if (v.get(i) == null || v.get(i).length() <= 0) {
rearSQL += "NULL,";
} else {
rearSQL += "'" + v.get(i) + "',";
}
} else {
preSQL += variabl2069[i] + ")";
if (v.get(i) == null || v.get(i).length() <= 0) {
rearSQL += "NULL)";
} else {
rearSQL += "'" + v.get(i) + "')";
}
}
}
strSQL = preSQL + rearSQL;
insertExecute(strSQL);
}
private void insertExecute(String strSQL) throws SQLException {
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
private void deleteSQL(String[] array) throws SQLException {
String rearSQL = "";
String preSQL = "delete from " + variabl2603 + " where ";
String strSQL = "";
for (int i = 0; i < variabl1055.length; i++) {
if (i != variabl1055.length - 1) {
rearSQL += variabl2069[variabl1055[i]] + "='" + array[i]
+ "' AND ";
} else {
rearSQL += variabl2069[variabl1055[i]] + "='" + array[i] + "'";
}
}
strSQL = preSQL + rearSQL;
deleteExecute(strSQL);
}
private void deleteExecute(String strSQL) throws SQLException {
sta = con.createStatement();
sta.executeUpdate(strSQL);
}
}
https://blog.sciencenet.cn/blog-2551-1116942.html
上一篇：管理信息系统软件生产线源码27-31
下一篇：管理信息系统软件生产线源码37-40
全部作者的精选博文
全部作者的其他最新博文
全部精选博文导读
相关博文
- • Minerals线下恳谈会：履践致远、与时偕行——对话中国科学院广州地球化学研究所期刊合作学者
- • 聚英才 建高地 | 北京理工大学“特立青年学者”全球招聘开启
- • 700年后日本或濒临灭绝？日本学者推算预测：届时或仅剩1名15岁以下孩子
- • [转载]【同位素视角】非英语母语学者如何区分’e.g.’, ‘i.e.’, ‘namely’与‘such as’等混淆难题
- • 美国佐治亚大学等机构学者：刈割策略对Bulldog 805紫花苜蓿+Tifton 85狗牙根混播草地产量及品质的影响
- • 美国堪萨斯州立大学、密苏里大学等机构学者研究成果：土壤水分管理策略和品种多样性对紫花苜蓿产量、营养品质和农场盈利能力的影