简单快速的将数据库中的表引入swing之内

　　如果你已经用过数据库了，你很可能已经用过为数据库提供的维护和查询表的工具:命令行工具很适合作简单而直接的工作，但是很难完成大量数据的处理工作。在一次查询中写一条返回10或20列的数据就已经很困难了-更糟的是由于换行而使每条记录都有很多行的情况，此时你根本无法区分一条记录在哪一行结束，另一条记录在哪一行开始。
　　如果能够将数据库中表的内容映射到swing的jtable中是否好一些呢？加上一些jdbc语句，添加到jframe上，顷刻之间就形成了图形界面。

建立连接

　　如果你同时用到jdbc和swing，只需要一句话你就可以抓住要点：使用数据库表的元数据来建立swing表控件模型。如果你还没用到它们，下面就是你需要了解的背景知识：jdbc提供许多抽象方法来存取数据库。对于一个数据库有效的java代码也应该对其他数据库有效，唯一的不同之处在于jdbc与不同的数据库建立连接时所需要提供的下面的一些字符串也是不同的：
¨        一个驱动程序类的类名，提供各种不同的java.sql接口的实现。
¨        一个连接到数据库的url。这就意味着可能会用到socket，尽管这不是一定的。一些小的可嵌入的数据库就像你的应用程序一样可以存活于java虚拟机中。
¨        一个可选的用户名。
¨        一个可选的密码。

　　一旦建立了连接，你就可以发送一些命令(创建、删除、或修改表)，或者通过该连接，创建sql语句来对数据库进行查询。你也能通过该连接得到数据库的元数据，例如它所支持的各种特性，某一字符串的最大长度等等。更重要的是，它可以让你知道数据库中都有哪些表，它们都有哪些字段，每个字段的数据类型是什么。

　　因此，假设连接到了数据库，并且知道该数据库中的一个表的表名，你就可以利用两次查询将表的内容用java表现出来。第一次查询能得到该表的各字段的元数据并且将字段名和字段的类型构建成一个数组。这些能被适当地而且很好地映射到java类中，至少支持你想支持的各种类型。第二次查询得到表中所有的数据。对于每行数据，对应字段它都有相应的值。这些数据可以放入一个二维数组中，该数组存放的是整个表的内容。

　　通过这两次查询，也就完成了要实现abstracttablemodel类中的抽象方法的所有准备:
¨        getrowcount()：是你所创建的内容数组contents的长度。
¨        getcolumncount()：如果没有内容则为0，否则为数组contents的第一项(该项也是一个数组，因为内容数组是一个二维数组)的长度。
¨        getvalueat()：contents[row][col]的值。

　　abstracttablemodel已经完全的实现了getcolumnclass()和getcolumnname()两个方法，因此，前者总是返回object.class，后者返回"a"，"b"，"c"，等等；你也可以利用第一次查询的字段元数据覆盖这两个方法，以更好的实现它们。
例3-12演示jdbctablemodel如何被实现。

例3-12.由数据库连接生成的swing表控件模型

        import javax.swing.*;
        import javax.swing.table.*;
        import java.sql.*;
        import java.util.*;
        /** an immutable table model built from getting
                metadata about a table in a jdbc database
        */
        public class jdbctablemodel extends abstracttablemodel {
                object[][] contents;
                string[] columnnames;
                class[] columnclasses;

                public jdbctablemodel (connection conn, string tablename)
                        throws sqlexception {
                        super();
                        gettablecontents (conn, tablename);
                }
                protected void gettablecontents (connection conn,
                                         string tablename)
                        throws sqlexception {

                // get metadata: what columns exist and what
                // types (classes) are they?
                databasemetadata meta = conn.getmetadata();
                system.out.println ("got meta = " + meta);
                resultset results =
                        meta.getcolumns (null, null, tablename, null);
                system.out.println ("got column results");
                arraylist colnameslist = new arraylist();
                arraylist colclasseslist = new arraylist();
                while (results.next()) {
                        colnameslist.add (results.getstring ("column_name"));
                        system.out.println ("name: " +
                                results.getstring ("column_name"));
                        int dbtype = results.getint ("data_type");
                        switch (dbtype) {
                        case types.integer:
                colclasseslist.add (integer.class); break;
                        case types.float:
                colclasseslist.add (float.class); break;
                        case types.double:
                        case types.real:
                colclasseslist.add (double.class); break;
                        case types.date:
                        case types.time:
                        case types.timestamp:
                colclasseslist.add (java.sql.date.class); break;
                        default:
                colclasseslist.add (string.class); break;
                        };
                        system.out.println ("type: " +
                                results.getint ("data_type"));
                        }
                        columnnames = new string [colnameslist.size()];
                        colnameslist.toarray (columnnames);
                        columnclasses = new class [colclasseslist.size()];
                        colclasseslist.toarray (columnclasses);
                        
                        // get all data from table and put into
                        // contents array

                        statement statement =
                conn.createstatement ();
                        results = statement.executequery ("select * from " +
                                                  tablename);
                        arraylist rowlist = new arraylist();
                        while (results.next()) {
                arraylist celllist = new arraylist();
                for (int i = 0; i<columnclasses.length; i++) {
                        object cellvalue = null;


                        if (columnclasses[i] == string.class)
                cellvalue = results.getstring (columnnames[i]);
                        else if (columnclasses[i] == integer.class)
                cellvalue = new integer (
                                results.getint (columnnames[i]));
                        else if (columnclasses[i] == float.class)
                cellvalue = new float (
                                results.getint (columnnames[i]));
                        else if (columnclasses[i] == double.class)
                cellvalue = new double (
                                results.getdouble (columnnames[i]));
                        else if (columnclasses[i] == java.sql.date.class)
                cellvalue = results.getdate (columnnames[i]);
                        else
                system.out.println ("can't assign " +
                                columnnames[i]);
                        celllist.add (cellvalue);
                }// for
                object[] cells = celllist.toarray();
                rowlist.add (cells);
        } // while
        // finally create contents two-dim array
        contents = new object[rowlist.size()] [];
        for (int i=0; i<contents.length; i++)

                contents[i] = (object []) rowlist.get (i);
        system.out.println ("created model with " +
                           contents.length + " rows");

        // close stuff
        results.close();
        statement.close();

        }
        // abstracttablemodel methods
        public int getrowcount() {
                return contents.length;
        }

        public int getcolumncount() {
                if (contents.length == 0)
                        return 0;
                else
                        return contents[0].length;
                }

                public object getvalueat (int row, int column) {
                        return contents [row][column];
                }

                // overrides methods for which abstracttablemodel
                // has trivial implementations

                public class getcolumnclass (int col) {
                        return columnclasses [col];
                }

                public string getcolumnname (int col) {
                        return columnnames [col];
                }
        }
　　构造函数将实际的工作交给了gettablecontents()方法，它负责刚才所提到的两次查询。通过连接得到databasemetadata类的对象，之后调用getcolumns()函数得到字段信息。这个方法的参数是catalog，schemapattern，tablenamepattern，columnnamepattern;这里忽略了catalog，schemapattern，然而如果你用的是一个复杂的数据库，可能你就需要详细的描述这两项。getcolumns()返回一个结果集resultset，就像通常jdbc查询得到的结果集一样，对它进行迭代就可以了。
　　要得到字段名是很容易的：只需要调用getstring("column_name")方法就可以了。但要得到数据类型就要有趣得多，当调用getint("data_type")时会返回一个int型数据，该类型是java.sql.types类的常数之一。在上例中，我们只是简单地将字符串类型和基本的数字类型恰当的映射到java类中。timestamp是sql中的一个有关时间（日期和时间）的类型，因此，要将它映射到java的date类。知道这些数据正确的数据类型将会使你更容易并且能够更准确的使用相应的getxxx()方法来检索实际的表中的数据。

　　第二次查询是一个简单的查询语句select * from tablename。由于查询中没有where子句的约束，这将会得到表中所有记录组成的结果集resultset。我应该不需要提到下面这些，就是如果tablename是一张有数以百万计的记录的表，你生成的表控件模型就将无法存放到内存中。你应该知道这些的，对吗?

　　此外，你需要对结果集resultset进行迭代。每次如果results.next()返回true，则表示还有结果，此前在查询元数据的时候我们就已经清楚地知道表中每个字段信息了。这意味着在查询数据时需要调用getxxx()方法并且将字段名作为参数传入该方法，而且在此前的查询中，我们已经很清楚哪个字段应该使用哪一个getxxx()方法。因为jtables有基于类的解析机制，它可以将数据中的数字转换成合适的类型（如integer、double等等）。你可能需要决定使用tablecellrenderer并通过format类对表中所有的double类型的数据进行格式化，即以特定的小数格式来格式化数字，或者将日期转换成"今天"或"在25个小时以前"这类与时间或日期相关的词，并在模型中对这类数据加粗显示会非常有用。

　　当查询结束后，你需要将arraylist转换成数组。(数组一般提供能够快速查找到元素的方法)。abstracttablemodel类中的抽象方法的实现在前面已经提到过了，连同getcolumnclass()和getcolumnname()实现的覆盖和优化，columnnames，columnclasses和由该方法创建的内容数组contents的简单使用也讲完了。

测试

　　在你说"我不能运行这个例子，我没有数据库"之前，先别急！开源世界有你想要的东西。而且并不像jboss那样那么大。hsqldb，它原来的名字可能更被人所知，hypersonic，这是一个用java写的jdbc关系数据库引擎。它很小而且能够独自运行或在你的java虚拟机里面运行。你可以到http://hsqldb.sourceforge.net/上下载hsqldb。

　　无论你用的是什么数据库，你都需要一个驱动程序的名字，url，用户名和密码来建立与数据库的连接。如果你已经拥有一个数据库了，我相信你应该很清楚这些。如果你刚下载了刚才所说的hsqldb，你将会用到下列的信息:
¨        驱动程序:org.hsqldb.jdbcdriver
¨        url:jdbc:hsqldb:文件:testdb
¨        用户名:sa
¨        密码:（空）

　　假设你将hsql添加为你的应用程序的一部分，这就需要你在classpath中添加上hsqldb.jar文件。你可能注意到，这将会在当前目录中产生一个testdb文件，之后你可以将其删除掉。你也可以给出其他的目录的全路径；详细的信息请参照hsqldb的相关文档。
　　这个测试程序所期望的连接数据库的字符串的形式要像属性（properties）文件中的一样，如jdbctable.driver，jdbctable.url，jdbctable.user和jdbctable.pass。为了使之更方便一些，有二个方法将这些信息传入程序中:或者通过系统属性(通常在java命令后加上参数-d来指定)，或者写在一个叫jdbctable.properties的文件中。书上的源代码中有一个设置hsqldb默认值的例子用的就是第二种方法。

　　为了测试jdbctablemodel，testjdbctable在数据库中生成了一个新的完整的表。该模型得到数据库的连接和这个表的表名以及数据库中的数据。然后测试类只是简单的利用模型创建一个jtable而且把它放入到jframe中。例3-13给出了这个例子的源代码。

例子3-13.测试基于jdbc的表控件
        import javax.swing.*;
        import javax.swing.table.*;
        import java.sql.*;
        import java.util.*;
        import java.io.*;
        public class testjdbctable {
                public static void main (string[] args) {
                        try {

                /*
                 driver, url, user, and pass can be passed in as
                 system properties "jdbctable.driver",
                 "jdbctable.url", "jdbctable.user", and
                 "jdbctable.pass", or specified in a file
                 called "jdbctable.properties" in current
                 directory
                */
                properties testprops = new properties();
                string ddriver = system.getproperty ("jdbctable.driver");
                string durl = system.getproperty ("jdbctable.url");
                string duser = system.getproperty ("jdbctable.user");
                string dpass = system.getproperty ("jdbctable.pass");

                if (ddriver != null)
                        testprops.setproperty ("jdbctable.driver", ddriver);
                if (durl != null)
                        testprops.setproperty ("jdbctable.url", durl);
                if (duser != null)
                        testprops.setproperty ("jdbctable.user", duser);
                if (dpass != null)
                        testprops.setproperty ("jdbctable.pass", dpass);
                try {
                        testprops.load (new fileinputstream (
                                        new file ("jdbctable.properties")));
                } catch (exception e) {} // ignore fnf, etc.
                system.out.println ("test properties:");
                testprops.list (system.out);
                // now get a connection
                // note care to replace nulls with empty strings
                class.forname(testprops.getproperty
                                ("jdbctable.driver")).newinstance();
                string url = testprops.getproperty ("jdbctable.url");
                url = ((url == null) ? "" : url);
                string user = testprops.getproperty ("jdbctable.user");
                user = ((user == null) ? "" : user);
                string pass = testprops.getproperty ("jdbctable.pass");
                pass = ((pass == null) ? "" : pass);

                connection conn =
                        drivermanager.getconnection (url, user, pass);
                // create db table to use
                string tablename = createsampletable(conn);

                // get a model for this db table and add to a jtable
                tablemodel mod =
                        new jdbctablemodel (conn, tablename);
                jtable jtable = new jtable (mod);
                jscrollpane scroller =
                        new jscrollpane (jtable,
                                scrollpaneconstants.vertical_scrollbar_as_needed,
                                scrollpaneconstants.horizontal_scrollbar_as_needed);
                jframe frame = new jframe ("jdbctablemodel demo");
                frame.getcontentpane().add (scroller);
                frame.pack();
                frame.setvisible (true);

                conn.close();

                        } catch (exception e) {
                e.printstacktrace();
                        }
                }

                public static string createsampletable (connection conn)
                        throws sqlexception {

                        statement statement = conn.createstatement();
                        // drop table if it exists
                        try {

                statement.execute ("drop table employees");
                        } catch (sqlexception sqle) {
                sqle.printstacktrace(); // if table !exists
                        }
                        
                        statement.execute ("create table employees " +
                                   "(name char(20), title char(30), salary int)");
                        statement.execute ("insert into employees values " +
                                   "('jill', 'ceo', 200000 )");
                        statement.execute ("insert into employees values " +
                                   "('bob', 'vp', 195000 )");
                        statement.execute ("insert into employees values " +
                                       "('omar', 'vp', 190000 )");
                        statement.execute ("insert into employees values " +
                                   "('amy', 'software engineer', 50000 )");
                        statement.execute ("insert into employees values " +
                                   "('greg', 'software engineer', 45000 )");

             statement.close();
                 return "employees";
                 }
        }

　　createsampletable()方法就是你需要重写的来插入你自定义数据的方法。实际上，由于它返回的是你所创建的表的表名，你需要在数据库中创建许多不同的表来测试模型如何处理他们。或者利用一个循环生成多行数据并且看装载这些数据需要多长时间。
　　最后，当你运行程序的时候，testjdbctable生成了一个带有数据库表的内容的jframe，如图3-9所示。


图3-9.将数据库中的数据填充到jtable中

joshua marinacci是java.net上" the java sketchbook "的专栏作家，范围涉及java客户端和网络编程。
chris adamson是onjava和java.net的编辑，亚特兰大顾问，主攻java，mac操作系统x和多媒体编程。