Ziel:
Ich lese aus einer Datenbank Werte in eine JTable. Zwei dieser Werte hole ich aus anderen Tabellen und soll sie mit einer JComboBox auswählen können. Einer der Werte ist Boolean zum ankreuzeln.
Insgesamt hat die in der JTable auszugebende Tabelle 6 Spalten.
Durchführung:
Hab mir aus einem AbstractTableModel alles zusammengebaut, den Renderer für die beiden JComboboxen definiere ich im Frame selbst. Der Code ist jetzt nicht außergewöhnlich, aber ich poste ihn für alle Fälle:
Problem:
Prinzipiell läuft alles. Ich kann die JComboBoxen anklicken und etwas auswählen. Die Änderungen werden dann auch erfolgreich in die Datenbank übertragen.
Seltsamerweise funktioniert das Anklicken exakt 1 Mal.
Wenn ich die Land-Box anklicke kann ich auswählen, was ich brauche, die Änderung wird übertragen, aber danach funktioniert keine der beiden Boxen. Es gibt keine Fehlermeldung und die normal editierbaren Zellen lassen Änderungen erfolgreich zu.
Ich vermute, dass die JComboBox überschrieben wird, deswegen habe ich mir die API vom AbstractTableModel durchgesehen, konnte jedoch keine Funktionen finden, die den Zellen oder Spaltentypen definieren (die Überschreibung der Methode getColumnClass bewirkt ebenfalls überhaupt nichts)
Der Code im AbstractTableModel sieht folgendermaßen aus:
Hat jemand eine Idee? Für jede Hilfestellung bin ich sehr dankbar
Ich lese aus einer Datenbank Werte in eine JTable. Zwei dieser Werte hole ich aus anderen Tabellen und soll sie mit einer JComboBox auswählen können. Einer der Werte ist Boolean zum ankreuzeln.
Insgesamt hat die in der JTable auszugebende Tabelle 6 Spalten.
Durchführung:
Hab mir aus einem AbstractTableModel alles zusammengebaut, den Renderer für die beiden JComboboxen definiere ich im Frame selbst. Der Code ist jetzt nicht außergewöhnlich, aber ich poste ihn für alle Fälle:
Java:
private TableColumn tc_land, tc_zweck;
private JComboBox jcb_land, jcb_zweck;
private void fuelleColumnModels() throws SQLException {
try {
DBConnection dbconn = new DBConnection(dbkonfig.getVerbindung() + konfiguration.getDatenbankdatei(), dbkonfig.getKlasse());
ComboTableCellRenderer renderer = new ComboTableCellRenderer();
jcb_land = new JComboBox(dbconn.getAbfragenVektor("SELECT Land FROM Land"));
jcb_zweck = new JComboBox(dbconn.getAbfragenVektor("SELECT Zweck FROM Zweck"));
jcb_land.setRenderer(renderer);
jcb_zweck.setRenderer(renderer);
tc_land = jTable.getColumnModel().getColumn(4);
tc_zweck = jTable.getColumnModel().getColumn(5);
tc_land.setCellRenderer(renderer);
tc_zweck.setCellRenderer(renderer);
tc_land.setCellEditor(new DefaultCellEditor(jcb_land));
tc_zweck.setCellEditor(new DefaultCellEditor(jcb_zweck));
} catch (ClassNotFoundException ex) {
Logger.getLogger(DBJTable.class.getName()).log(Level.SEVERE, null, ex);
}Problem:
Prinzipiell läuft alles. Ich kann die JComboBoxen anklicken und etwas auswählen. Die Änderungen werden dann auch erfolgreich in die Datenbank übertragen.
Seltsamerweise funktioniert das Anklicken exakt 1 Mal.
Wenn ich die Land-Box anklicke kann ich auswählen, was ich brauche, die Änderung wird übertragen, aber danach funktioniert keine der beiden Boxen. Es gibt keine Fehlermeldung und die normal editierbaren Zellen lassen Änderungen erfolgreich zu.
Ich vermute, dass die JComboBox überschrieben wird, deswegen habe ich mir die API vom AbstractTableModel durchgesehen, konnte jedoch keine Funktionen finden, die den Zellen oder Spaltentypen definieren (die Überschreibung der Methode getColumnClass bewirkt ebenfalls überhaupt nichts)
Der Code im AbstractTableModel sieht folgendermaßen aus:
Java:
/**
* Tabelle:
* (ID INTEGER, Datum DATE, Uhrzeit BOOLEAN, Anzahl INTEGER, LandID INTEGER, ZweckID INTEGER);")
* @param value
* @param row
* @param col
*/
@Override
public void setValueAt(Object value, int row, int col) {
DBConnection dbconn = new DBConnection(currentURL, this.dbkonf.getKlasse());
int rowcount = dbconn.getRowCount("Besuchergruppe");
//Zuerst überprüfen, ob schon etwas vorhanden ist.
//Wenn nicht - Ärger umgehen und einfach sofort anlegen, was sich finden lässt.
//Es wird übrigens auch aufgerufen, falls die neue Zeile bearbeitet wird
if ((rowcount == 0) || row >= rowcount) {
try {
System.out.println("insert");
initDB();
// Prepare a statement to insert a record
//(ID INTEGER, Datum DATE, Uhrzeit BOOLEAN, Anzahl INTEGER, LandID INTEGER, ZweckID INTEGER)
String sql = "INSERT INTO Besuchergruppe("
+ "ID,"
+ "Datum,"
+ "Uhrzeit,"
+ "Anzahl,"
+ "LandID,"
+ "ZweckID) "
+ "VALUES(?,?,?,?,?,?)";
System.out.println("Statement: " + sql);
PreparedStatement ps = db.prepareStatement(sql);
System.out.println("prepstat - good");
// Set the values
//Gefüllt wird ja nur eine einzige Zelle - Plus: ID bekannt
//Col ist die gefüllte Zelle
ps.setInt(1, dbconn.getNewID("Besuchergruppe", "ID"));
System.out.println(dbconn.getNewID("Besuchergruppe", "ID"));
System.out.println("col: " + col);
switch (col) {
case 1:
try {
// set the preparedstatement parameters
ps.setDate(2, (Date) ddmmyyyy.parse((String) value)); //Datum
} catch (ParseException ex) {
Logger.getLogger(MyTableModel.class.getName()).log(Level.SEVERE, null, ex);
}
break;
case 2:
ps.setBoolean(3, Boolean.getBoolean((String) value)); //Uhrzeit
break;
case 3:
ps.setInt(4, Integer.parseInt((String) value));
break;
case 4:
ps.setInt(5, Integer.parseInt(dbconn.getIDByInformation("LandID", (String) value, "Land", "Land")));
break;
case 5:
ps.setInt(6, Integer.parseInt(dbconn.getIDByInformation("ZweckID", (String) value, "Zweck", "Zweck")));
break;
}
System.out.println("Execute erfolgreich:" + ps.execute());
} catch (SQLException e) {
System.out.println("SQL-Fehler beim insert");
System.out.println("Code: " + e.getErrorCode());
System.out.println(e.getMessage());
} finally {
closeDB();
}
//Hier gehe ich davon aus, dass eine vorhandene Besuchergruppe verändert wird
} else {
try {
PreparedStatement ps = null;
switch (col) {
case 1:
ps = db.prepareStatement("UPDATE Besuchergruppe SET Datum = ? WHERE id = ?");
try {
// set the preparedstatement parameters
ps.setDate(1, (Date) ddmmyyyy.parse((String) value)); //Datum
} catch (ParseException ex) {
Logger.getLogger(MyTableModel.class.getName()).log(Level.SEVERE, null, ex);
}
break;
case 2:
ps = db.prepareStatement("UPDATE Besuchergruppe SET Uhrzeit = ? WHERE id = ?");
ps.setBoolean(1, Boolean.getBoolean((String) value)); //Uhrzeit
break;
case 3:
ps = db.prepareStatement("UPDATE Besuchergruppe SET Anzahl = ? WHERE id = ?");
ps.setInt(1, Integer.parseInt((String) value));
break;
case 4:
ps = db.prepareStatement("UPDATE Besuchergruppe SET LandID = ? WHERE id = ?");
ps.setInt(1, Integer.parseInt(dbconn.getIDByInformation("LandID", (String) value, "Land", "Land")));
break;
case 5:
ps = db.prepareStatement("UPDATE Besuchergruppe SET ZweckID = ? WHERE id = ?");
ps.setInt(1, Integer.parseInt(dbconn.getIDByInformation("ZweckID", (String) value, "Zweck", "Zweck")));
break;
}
System.out.println("UPDATE Besuchergruppe SET Anzahl = " + cache.get(row)[3] + " WHERE id = " + cache.get(row)[0]);
ps.setString(2, cache.get(row)[0]);
// call executeUpdate to execute our sql update statement
initDB();
ps.executeUpdate();
ps.close();
} catch (SQLException ex) {
Logger.getLogger(MyTableModel.class.getName()).log(Level.SEVERE, null, ex);
} finally {
closeDB();
}
}
setQuery();
fireTableCellUpdated(row, col);
}
// All the real work happens here; in a real application,
// we'd probably perform the query in a separate thread.
public void setQuery() {
initDB();
cache = new Vector<String[]>();
DBConnection dbconn = new DBConnection(currentURL, this.dbkonf.getKlasse());
rs = null;
try {
// Execute the query and store the result set and its metadata
try {
rs = statement.executeQuery("SELECT ID, Datum, Uhrzeit, Anzahl, Land, Zweck FROM Besuchergruppe, Land, Zweck WHERE Besuchergruppe.LandID=Land.LandID AND Besuchergruppe.ZweckID = Zweck.ZweckID");
} catch (SQLException sqe) {
System.err.println(sqe.getSQLState());
}
ResultSetMetaData meta = rs.getMetaData();
colCount = meta.getColumnCount();
// Now we must rebuild the headers array with the new column names
headers = new String[colCount];
for (int h = 1; h <= colCount; h++) {
headers[h - 1] = meta.getColumnName(h);
} // and file the cache with the records from our query. This would
// not be
// practical if we were expecting a few million records in response
// to our
// query, but we aren't, so we can do this.
while (rs.next()) {
String[] record = new String[colCount];
for (int i = 0; i < colCount; i++) {
record[i] = rs.getString(i + 1);
}
cache.addElement(record);
}
fireTableChanged(null); // notify everyone that we have a new table.
} catch (Exception e) {
cache = new Vector(); // blank it out and keep going.
e.printStackTrace();
}
}Hat jemand eine Idee? Für jede Hilfestellung bin ich sehr dankbar
