JTable and Database communication

Question

Hi all,
I have two files excerpts from my Java application. I feel that in order for me to get understood so well, with regards to a problem that challenged me, I had to post these two files as you can see below. They are called ResultSetTableModel.java and DisplayQueryResults.java [which gets displayed in an internal frame].
I have this code from ResultSetTableModel
// ResultSetTableModel.java
// A TableModel that supplies ResultSet data to a JTable.
import java.sql.Connection;
import java.sql.Statement;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import javax.swing.table.AbstractTableModel;
// ResultSet rows and columns are counted from 1 and JTable
// rows and columns are counted from 0. When processing
// ResultSet rows or columns for use in a JTable, it is
// necessary to add 1 to the row or column number to manipulate
// the appropriate ResultSet column (i.e., JTable column 0 is
// ResultSet column 1 and JTable row 0 is ResultSet row 1).
public class ResultSetTableModel extends AbstractTableModel
   private Connection connection;
   private Statement statement;
   private ResultSet resultSet;
   private ResultSetMetaData metaData;
   private int numberOfRows;
   // keep track of database connection status
   private boolean connectedToDatabase = false;
   // constructor initializes resultSet and obtains its meta data object;
   // determines number of rows
   public ResultSetTableModel(String driver, String url,
      String username, String password, String query)
      throws SQLException, ClassNotFoundException {        
      // load database driver class
      Class.forName(driver);
      // connect to database
      connection = DriverManager.getConnection(url, username, password);
      // create Statement to query database
      statement = connection.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);
      // update database connection status
      connectedToDatabase = true;
      // set query and execute it
      setQuery(query);
   } // end constructor ResultSetTableModel
   // get class that represents column type
   public Class getColumnClass(int column) throws IllegalStateException {
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      // determine Java class of column
      try {
         String className = metaData.getColumnClassName(column + 1);
         // return Class object that represents className
         return Class.forName(className);
      } // end try
      catch (Exception exception) {
         exception.printStackTrace();
      } // end catch
      //return Object.class; // if problems occur above, assume type Object
      return getValueAt(0, column).getClass(); // added January 25, 2008 in stead of the one above
   } // end method getColumnClass
   // get number of columns in ResultSet
   public int getColumnCount() throws IllegalStateException {  
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      // determine number of columns
      try  {
         return metaData.getColumnCount();
      } // end try
      catch (SQLException sqlException) {
         sqlException.printStackTrace();
      } // end catch
      return 0; // if problems occur above, return 0 for number of columns
   } // end method getColumnCount
   // get name of a particular column in ResultSet
   public String getColumnName(int column) throws IllegalStateException {   
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      // determine column name
      try {
         return metaData.getColumnName(column + 1); 
      } // end try
      catch (SQLException sqlException) {
         sqlException.printStackTrace();
      } // end catch
      return ""; // if problems, return empty string for column name
   } // end method getColumnName
   // return number of rows in ResultSet
   public int getRowCount() throws IllegalStateException {     
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      return numberOfRows;
   } // end method getRowCount
   // obtain value in particular row and column
   public Object getValueAt(int row, int column)
      throws IllegalStateException {
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      // obtain a value at specified ResultSet row and column
      try {
         resultSet.absolute(row + 1);
         return resultSet.getObject(column + 1);
      } // end try
      catch ( SQLException sqlException ) {
         sqlException.printStackTrace();
      } // end catch
      return ""; // if problems, return empty string object
   } // end method getValueAt
    * Don't need to implement this method unless your table's
    * editable.
  public boolean isCellEditable(int row, int column) { // Added on January 25, 2008 6:51 A.M.
     //Note that the data/cell address is constant,
     //no matter where the cell appears onscreen.
     if (column < 2) {
        return false;
     } else {
        return true;
   // set new database query string
   public void setQuery(String query)
      throws SQLException, IllegalStateException {
      // ensure database connection is available
      if (!connectedToDatabase)
         throw new IllegalStateException("Not Connected to Database");
      // specify query and execute it
      resultSet = statement.executeQuery(query);
      // obtain meta data for ResultSet
      metaData = resultSet.getMetaData();
      // determine number of rows in ResultSet
      resultSet.last();                   // move to last row
      numberOfRows = resultSet.getRow();  // get row number    
      // notify JTable that model has changed
      fireTableStructureChanged();
   } // end method setQuery
   // close Statement and Connection              
   public void disconnectFromDatabase() {             
      if (!connectedToDatabase)                 
         return;
      // close Statement and Connection           
      try {                                           
         statement.close();                       
         connection.close();                      
      } // end try                                
      catch (SQLException sqlException) {                                           
         sqlException.printStackTrace();          
      } // end catch                              
      finally { // update database connection status                                          
         connectedToDatabase = false;             
      } // end finally                            
   } // end method disconnectFromDatabase         
}  // end class ResultSetTableModelThe DisplayQueryResults code follows:
// DisplayQueryResults.java
// Display the contents of the Authors table in the
// Books database.
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.sql.SQLException;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
import javax.swing.ScrollPaneConstants;
import javax.swing.JTable;
import javax.swing.JOptionPane;
import javax.swing.JButton;
import javax.swing.Box;
import javax.swing.JInternalFrame;
import java.util.*; // for the Bundle
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import javax.swing.event.InternalFrameAdapter;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.*; // step 1
import javax.swing.table.TableModel; // step 1
public class DisplayQueryResults extends JInternalFrame implements TableModelListener { // step 2
   // JDBC driver, database URL, username and password
   ResourceBundle bundle = ResourceBundle.getBundle("Accounting");
   String JDBC_DRIVER = bundle.getString("Driver");
   String DATABASE_URL = bundle.getString("URL");
   String USERNAME = bundle.getString("User");
   String PASSWORD = bundle.getString("Password");
   String DEFAULT_QUERY = bundle.getString("Query");
   private ResultSetTableModel tableModel;
   private JTextArea queryArea;
   static final int xOffset = 0, yOffset = 200;
   // create ResultSetTableModel and GUI
   public DisplayQueryResults() {  
      super("Sales of the Day",
              true, //resizable
              true, //closable
              true, //maximizable
              false);//iconifiable
      //...Create the GUI and put it in the window...
      //Set the window's location.
      setLocation(xOffset, yOffset);
      // create ResultSetTableModel and display database table
      try {
         // create TableModel for results of query SELECT * FROM authors
         tableModel = new ResultSetTableModel(JDBC_DRIVER, DATABASE_URL,
            USERNAME, PASSWORD, DEFAULT_QUERY);
         // set up JTextArea in which user types queries
         queryArea = new JTextArea(DEFAULT_QUERY, 1, 100);
         queryArea.setWrapStyleWord(true);
         queryArea.setLineWrap(true);
         JScrollPane scrollPane = new JScrollPane(queryArea,
            ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
            ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
         // set up JButton for submitting queries
         JButton submitButton = new JButton("Submit Query");
         // create Box to manage placement of queryArea and
         // submitButton in GUI
         Box box = Box.createHorizontalBox();
         box.add(scrollPane);
         box.add(submitButton);
         // create JTable delegate for tableModel
         final JTable resultTable = new JTable(tableModel);
         resultTable.setFillsViewportHeight(true); // Makes the empty space heights white
         resultTable.setRowSelectionAllowed(true);
         resultTable.getModel().addTableModelListener(this); // step 3
         // place GUI components on content pane
         add(box, BorderLayout.NORTH);
         add(new JScrollPane(resultTable), BorderLayout.CENTER);
         // create event listener for submitButton
         submitButton.addActionListener(
            new ActionListener()
               // pass query to table model
               public void actionPerformed(ActionEvent event)
                  // perform a new query
                  try
                     tableModel.setQuery(queryArea.getText());
                  } // end try
                  catch ( SQLException sqlException)
                     JOptionPane.showMessageDialog(null,
                        sqlException.getMessage(), "Database error",
                        JOptionPane.ERROR_MESSAGE);
                     // try to recover from invalid user query
                     // by executing default query
                     try {
                        tableModel.setQuery(DEFAULT_QUERY);
                        queryArea.setText(DEFAULT_QUERY);
                     } // end try
                     catch (SQLException sqlException2) {
                        JOptionPane.showMessageDialog(null,
                           sqlException2.getMessage(), "Database error",
                           JOptionPane.ERROR_MESSAGE);
                        // ensure database connection is closed
                        tableModel.disconnectFromDatabase();
                        System.exit(1); // terminate application
                     } // end inner catch                  
                  } // end outer catch
               } // end actionPerformed
            }  // end ActionListener inner class         
         ); // end call to addActionListener
         //...Then set the window size or call pack...
            setSize(750,300);
         setVisible(true); // display window 
      } // end try
      catch (ClassNotFoundException classNotFound) {
         JOptionPane.showMessageDialog(null,
            "MySQL driver not found", "Driver not found",
            JOptionPane.ERROR_MESSAGE);
         System.exit(1); // terminate application
      } // end catch
      catch (SQLException sqlException) {
         JOptionPane.showMessageDialog(null, sqlException.getMessage(),
            "Database error", JOptionPane.ERROR_MESSAGE);
         // ensure database connection is closed
         tableModel.disconnectFromDatabase();
         System.exit(1);   // terminate application
      } // end catch
      // dispose of window when user quits application (this overrides
      // the default of HIDE_ON_CLOSE)
      setDefaultCloseOperation(DISPOSE_ON_CLOSE);
      // ensure database connection is closed when user quits application
      addInternalFrameListener(
         new InternalFrameAdapter() {
            // disconnect from database and exit when window has closed
            public void windowClosed(WindowEvent event) {
               tableModel.disconnectFromDatabase();
               System.exit(0);
            } // end method windowClosed
         } // end WindowAdapter inner class
      ); // end call to addWindowListener
   } // end DisplayQueryResults constructor
   public void tableChanged(TableModelEvent e) { // step 4
        int row = e.getFirstRow();
        int column = e.getColumn();
        TableModel model = (TableModel)e.getSource();
        String columnName = model.getColumnName(column);
        Object tableModel = model.getValueAt(row, column);
        // Do something with the data...
        System.out.println(tableModel);
        System.out.println("data");
   // execute application
   public static void main(String args[]) {
      new DisplayQueryResults();    
   } // end main
} // end class DisplayQueryResultsMy problem:
is in these lines:
public void tableChanged(TableModelEvent e) { // step 4
        int row = e.getFirstRow();
        int column = e.getColumn();
        TableModel model = (TableModel)e.getSource();
        String columnName = model.getColumnName(column);
        Object tableModel = model.getValueAt(row, column);
        // Do something with the data...
        System.out.println(tableModel);
        System.out.println("data"); // should output in the console
    }How do we notify java that a cell on a row has changed so that we can reflect the changes to the database. The current application shows that the data in cells are editable, but when we edit a cell and hit enter, data changes back to the previous data in that particular cell. And the data as well does not change its state: for example, if a data in the table has a value of boolean value false [checkbox unchecked], I can not modify the checkbox state to checked state. The tableChanged method does not get executed, and therefore, this is a serious error that I cant figure out.
My question:
What code should I write so that I will be able to notify java of the changed cell and how do we write the code that will reflect the changed values in a cell into the database?
Edited by: Oliverbob on Jan 26, 2008 9:54 PM

Answer 1

Why don't you check out the link shown below:
http://www.aokabc.com
and just follow the white rabbit!
;o)
V.V.