# JTable mit MySQL Datenbank füllen



## AhnungsloserNoob (12. Feb 2006)

hallo!

ich will die daten einer mysql tabelle in ein jtable bringen. das habe ich folgendermaßen versucht:


```
public void Datenbank() 
    {
        java.sql.Connection verbindung;
        String db;
        String user = io.Offnen(5);
        String password = io.Offnen(6);
        
        try
        {
            Class.forName("com.mysql.jdbc.Driver");
            System.out.println("Treiber geladen");
            
            verbindung = null;
            db = "jdbc:mysql://localhost/tms1";
            verbindung = java.sql.DriverManager.getConnection(db,user, password);
            java.sql.Statement stm = verbindung.createStatement();
            
            String sql = "SELECT * from mitglieder ORDER BY nachname";
            java.sql.ResultSet ergebnis = stm.executeQuery(sql);
            String[] auswahl = {"Nummer","Nachname","Vorname","PLZ","Ort","Strasse","Telefon",
                                "Email","Altersgruppe","Bankverbindung","Funktion"};

            for(int zl = 0; zl< 11; zl++) {
                while(ergebnis.next() == true)
                {
                    for(int sp = 0; sp <= 11; ++sp) {
                        jTable1.setValueAt(ergebnis.getString(auswahl[sp]), zl, sp);
                        System.out.println(ergebnis.getString(auswahl[sp]));
                    }

                }
            }
            
        } catch(Exception e) {
            System.err.println("Nicht gefunden    " + e);
        }
        
        
    }
```

leider funktioniert es nicht so ganz wie ich es mir vorgestellt habe. es wird nur die zweite zeile der mysql tabelle in das jtable geschrieben (in die erste zeile des jtables) die mysql tabelle hat aber 3 zeilen und 11 spalten.

was mach ich falsch?

danke im voraus!


----------



## André Uhres (12. Feb 2006)

```
/*
 * TableFromDatabase.java
 */
import java.awt.*;
import java.io.*;
import java.sql.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
public class TableFromDatabase extends JFrame {
    private String databaseName;
    private String databaseURL = "jdbc:odbc:test";
    private final String DATABASE_USER = "root";
    private final String USER_PASSWORD = "sql";
    public TableFromDatabase() {
        Vector<String> columnNames = new Vector<String>();
        Vector<Vector> data = new Vector<Vector>();
        try {
            //  Connect to the Database
            String driver = "sun.jdbc.odbc.JdbcOdbcDriver";
            Class.forName( driver );
            Connection connection = DriverManager.getConnection(databaseURL, DATABASE_USER, USER_PASSWORD);
            //  Read data from a table
            String sql = "Select * from testuhrand";
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery( sql );
            ResultSetMetaData md = rs.getMetaData();
            int columns = md.getColumnCount();
            //  Get column names
            for (int i = 1; i <= columns; i++) {
                columnNames.addElement( md.getColumnName(i) );
            }
            //  Get row data
            while (rs.next()) {
                Vector<Object> row = new Vector<Object>(columns);
                
                for (int i = 1; i <= columns; i++) {
                    row.addElement( rs.getObject(i) );
                }
                data.addElement( row );
            }
            rs.close();
            stmt.close();
        } catch(Exception e) {
            System.out.println( e );
        }
        //  Create table with database data
        JTable table = new JTable(data, columnNames);
        JScrollPane scrollPane = new JScrollPane( table );
        getContentPane().add( scrollPane );
        JPanel buttonPanel = new JPanel();
        getContentPane().add( buttonPanel, BorderLayout.SOUTH );
    }
    public static void main(String[] args) {
        TableFromDatabase frame = new TableFromDatabase();
        frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
        frame.pack();
        frame.setVisible(true);
    }
}
```


----------



## Guest (17. Feb 2006)

ok. ich habe es jetzt anders gelöst. 


```
public void Datenbank() 
    {
        java.sql.Connection verbindung;
        String db;
        String user = io.Offnen(5);
        String password = io.Offnen(6);
        
        try
        {
            Class.forName("com.mysql.jdbc.Driver");
            System.out.println("Treiber geladen");
            
            verbindung = null;
            db = "jdbc:mysql://localhost/tms1";
            verbindung = java.sql.DriverManager.getConnection(db,user, password);
            java.sql.Statement stm = verbindung.createStatement();
            
            String sql = "SELECT * from mitglieder ORDER BY nummer";
            java.sql.ResultSet ergebnis = stm.executeQuery(sql);
            java.sql.ResultSetMetaData md = ergebnis.getMetaData();
            String[] auswahl = {"Nummer","Nachname","Vorname","PLZ","Ort","Strasse","Telefon",
                                "Email","Altersgruppe","Bankverbindung","Funktion"};

            int start = 1;
            for(int zl = 0; zl< 60; zl++) { 
                    jProgressBar1.setIndeterminate(true);
                    jProgressBar1.setValue(10*zl);
                    jProgressBar1.setIndeterminate(false);
                    ergebnis.next();
                    for(int sp = 0; sp <= 10; ++sp) {
                        jTable1.setValueAt(ergebnis.getString(auswahl[sp]), zl, sp);
                    }
            }
        } catch(Exception e) {
            System.err.println("Nicht gefunden    " + e);
        }
    }
```

jetzt habe ich aber ein weiteres problem: wenn ich eine zu große datenbank einlese (also eine tabelle mit vielen zeilen), dann pass diese ja nich mehr rein und ich bekomme eine ArrayIndexOutOfBoundsException, weil das JTable einfach zu wenig zeilen hat.

wie füge ich jetzt einen neue zeile in das JTable ein?

das jtable wurde mit netbeans erstellt.

danke im voraus


----------



## André Uhres (18. Feb 2006)

((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{null});


----------



## Gast (18. Feb 2006)

dank!!!

hat funktioniert!


----------



## bertram (8. Nov 2006)

Guten Tag,

ich schreibe gerade ein Programm in Java, mit dem auf eine MySQL Datenbank zugreife.
In einem Teil des Programms, fülle ich eine JTable mit den Daten einer Tabelle, aus der MySQL Datenbank.

Ich habe das so gelöst:


```
import java.awt.*;
import java.sql.*;
import java.io.*;
import java.util.*;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class Auftragsuebersicht extends javax.swing.JFrame 
{
     String hostname="***.***.***.***";
     String port="****";
     String dbname="****";
     String user="****";
     String pw="****";
     Connection conn=null;
     /** Creates new form Auftragsuebersicht */
     public Auftragsuebersicht()
     {
         setTitle("Auftragsuebersicht");
         setSize(800,600);
         Vector columnNames = new Vector();
         Vector data = new Vector();
         Vector columntype = new Vector();
         Vector columnindex = new Vector();
         try
         {
             Class.forName("com.mysql.jdbc.Driver").newInstance();
             String url="jdbc:mysql://"+hostname+":"+port+"/"+dbname;
             conn=DriverManager.getConnection(url,user,pw);
          
             String sql ="SELECT * FROM alle_auftraege";
             Statement stmt=conn.createStatement();
             ResultSet rs=stmt.executeQuery(sql);
             ResultSetMetaData rsmd=rs.getMetaData();
             int columns=rsmd.getColumnCount();
             for (int i = 1; i <= columns; i++)
             {
                 columnNames.addElement( rsmd.getColumnName(i) );
             }
             while (rs.next()) 
             {
                 Vector<Object> row = new Vector<Object>(columns);
                 for (int i = 1; i <= columns; i++) 
                 {
                     row.addElement( rs.getObject(i) );
                 }
                 data.addElement( row );
             }
             rs.close();
             stmt.close();
         }
         catch(Exception e)
         {
             System.out.println( e );
         }
         JTable table = new JTable(data, columnNames);
         JScrollPane scrollPane = new JScrollPane( table );
         table.setAutoscrolls(true);
         table.setEnabled(true);
         table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
         getContentPane().add( scrollPane );
         JPanel buttonPanel = new JPanel();
         getContentPane().add( buttonPanel, BorderLayout.SOUTH );
     }
                       
     public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new Auftragsuebersicht().setVisible(true);
            }
        });
    }                 
}
```

Das Programm läuft soweit auch, es holt sich die Daten aus der Datenbank und füllt anschließend die JTable damit.

Es gibt nur ein kleines Problem, und zwar sind einige Spalten aus der Tabelle als boolean deklariert,
diese werden bislang mit "true" und "false" in einem TextFeld in der JTable dargetsellt.
Mein Ziel ist es, das die Spalten, bei denen ein boolean Wert auftritt eine checkbox erscheint.

Mir wurde schon gesagt, das ich es mit TableModel oder TableCellRenderer versuchen soll.

Ich habe mir auch schon das tutorial durchgelesen, und auch eine JTable erzeugt in der boolean Werte in einer Checkbox dargestellt werden.

Hier der Code von meiner Versuchs JTable:


```
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.util.Date;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class NewJFrame extends javax.swing.JFrame
{
     public NewJFrame()
     {
         initComponents();
     }
     public static void main( String[] args )
     {
         Model model = new Model();
         JTable table = new JTable( model );
         JFrame frame = new JFrame( "Demo" );
         frame.getContentPane().add( new JScrollPane( table ) );
         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
         frame.pack();
         frame.setVisible( true );
     }
}
class Model extends AbstractTableModel
{
     private String[] strings;
     private int[] integers;
     private double[] doubles;
     private boolean[] booleans;
    
     public Model()
     {
         strings = new String[]{ "hallo", "ich", "bin", "eine", "Demo" };
         integers = new int[]{ 1, 2, 3, 4, 5 };
         doubles = new double[]{ 1.2, 3.4, 5.6, 7.8, 9.11 };
         booleans = new boolean[]{ true, false, false, true, true };
     }
      
      // Die Anzahl Columns
     public int getColumnCount()
     {
         return 4;
     }
      
     // Die Anzahl Rows
     public int getRowCount()
     {
         return 5;
     }
     
     // Die Titel der einzelnen Columns
     public String getColumnName(int column)
     {
         switch( column )
         {
             case 0: return "String";
             case 1: return "Integer";
             case 2: return "Double";
             case 3: return "Boolean";
             default: return null;
         }
     }
   
     // Der Wert der Zelle (rowIndex, columnIndex)
     public Object getValueAt(int rowIndex, int columnIndex) 
     {
         switch( columnIndex )
         {
             case 0: return strings[ rowIndex ];
             case 1: return new Integer( integers[ rowIndex ] );
             case 2: return new Double( doubles[ rowIndex ] );
             case 3: return new Boolean( booleans[ rowIndex ] );
             default: return null;
          }
     }

     // Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
     public Class getColumnClass(int columnIndex)
     {
         switch( columnIndex )
         {
             case 0: return String.class;
             case 1: return Integer.class;
             case 2: return Double.class;
             case 3: return Boolean.class;
             default: return null;
         }
     }
      
     // Jede Zelle ist editierbar
     public boolean isCellEditable(int rowIndex, int columnIndex)
     {
         return true;
     }
   
     // Wird aufgerufen, falls der Wert einer Zelle verändert wurde
     public void setValueAt(Object aValue, int rowIndex, int columnIndex)
     {
         switch( columnIndex )
         {
             case 0:
             strings[ rowIndex ] = aValue.toString();
             break;
             case 1:
             integers[ rowIndex ] = ((Integer)aValue).intValue();
             break;
             case 2:
             doubles[ rowIndex ] = ((Double)aValue).doubleValue();
             break;
             case 3:
             booleans[ rowIndex ] = ((Boolean)aValue).booleanValue();
         }
     }
}
```

Mein größtes Problem ist vor allem, das ich nicht weiss, wie diese beiden Programme am besten kombinieren kann.

Freue mich über jeden Lösungsvorschlag.

Schon einmal vielen Dank im voraus.

MfG

bertram


----------



## André Uhres (8. Nov 2006)

Du brauchst erstmal ein DefaultTableModel (aus dem package javax.swing.table):

```
private DefaultTableModel model;
```
Dann musst du festlegen welchen Typ jede einzelne Spalte hat (String, Boolean, Integer, ...).
Du kannst z.B. einen Array "types" dafür benutzen:

```
private Class[] types = new Class [] {
        String.class, Boolean.class, String.class, Integer.class, String.class
    };
```
Das DefaultTableModel wird dann so erzeugt:

```
model = new DefaultTableModel(data, columnNames) {
            public Class getColumnClass(int columnIndex) {
                return types [columnIndex];
            }
        };
```

Und die JTable so:

```
JTable table = new JTable(model);
```

Dann werden die Booleans automatisch als JCheckBox dargestellt  :wink:


----------



## DonRu (23. Mai 2007)

Ich schreibe wie die meisten hier vor mir ein Programm welches Daten aus einer Mysql Datenbank liest. Ich lese das ResultSet mit ner Schleife in die jtable und gut ist.
Aber ein Problem bekomme ich wenn ich die jtable wieder in die Datenbank speichern will.

Irgendwie klappt es weder mit ner schleife aus der jtable wieder ein resulstset zu machen und es in die db zu schieben. Und auch ansonsten verbeiß ich mich gerade in nichts gutem. Vieleicht hat da jemand einen Denkanstoß, etwas Code oder ne andere Idee.

Gruß DonRu


----------



## André Uhres (23. Mai 2007)

Man könnte z.B. mit SQL "UPDATE" über PK die Zeilen wieder abspeichern, neue Zeilen mit SQL "INSERT".


----------



## DonRu (24. Mai 2007)

ja aber wenn du ne ganze db speichern willst ist das eine unsinnige menge an qrys die du ausführst. Am sinnvollsten ist es wenn man die ganze db in einer qry rüberschieben kann. Da liegt nun mein Problem.


----------



## André Uhres (24. Mai 2007)

DonRu hat gesagt.:
			
		

> ja aber wenn du ne ganze db speichern willst..


Heisst das, daß da einer vor dem Bildschirm sitzt, um sämtliche Zeilen einer Datenbank zu ändern?  :x


----------



## Gast (24. Mai 2007)

zum teil. Es geht darum ne Menge daten in die jtable zu tippen und den schmu dann auf einmal in die db zu schieben.
Aber es muss doch möglich sein genau wie das auslesen aus der db mit 1 qry es wieder mit 1 qry hinein zu schieben. Aber daran scheitert es bei mir...


----------



## André Uhres (24. Mai 2007)

Vielleicht geht's ja mit einem updatable ResultSet: 
http://java.sun.com/docs/books/tutorial/jdbc/basics/updating.html


----------

