DB Tabelle in JTable anzeigen - Probleme

[dior]

Hi,

ich versuche den Inhalt einer oracle Tabelle in einer JTable anzuzeigen.
Ich bekomme es hin das er mir den Inhalt grundsätzlich zeigt aber er macht mir für jede zeile in der DB eine eigene Tabelle.

Wie kann ich meine Code anpassen das ich das alles in einer einzigen JTable ausgebe?

package GUI;

import db_input.Db_select;
import java.sql.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Vector;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;


/**
 *
 * @author ich :)
 */
public class JTable_Ausgabe {
    public static void main( String[] args ) throws Exception{
                
        Connection conn = getConnection();
        String tableName = "DMT_TESTTABLE1"; 
        String tabelle = tabelle(conn, tableName);
        
        
        
        try {
         
            Statement stmt = null;
            ResultSet rs = null;
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * FROM " + tableName); //tableName);
            int count = 1;
                        
            while (rs.next() ) {
                String s1 = rs.getString(1);
                String s2 = rs.getString(1);
                String s3 = rs.getString(1);
                String s4 = rs.getString(1);
                String s5 = rs.getString(1);
                String s6 = rs.getString(1);
                s1 = rs.getString("VID");
                s2 = rs.getString("VALUE");
                s3 = rs.getString("FILTER");
                s4 = rs.getString("SHORTTEXT");
                s5 = rs.getString("UNUSED");
                s6 = rs.getString("ORDINAL");
                
                System.out.println("Zeile:    " + count);
                System.out.println(s1 + " | " + s2 + "\n");
                
               
            
        Vector data = new Vector();
            Vector rowA = new Vector();
             
                rowA.add(  s1 );
                rowA.add(  s2 );
                rowA.add(  s3 );
                rowA.add(  s4 );
                rowA.add(  s5 );
                rowA.add(  s6 );
//          
        
            data.add( rowA );

                
        // Die Titel für das Table
        Vector title = new Vector();
            title.add( "VID" );
            title.add( "VALUE" );
            title.add( "FILTER" );
            title.add( "SHORTTEXT" );
            title.add( "UNUSED" );
            title.add( "ORDINAL" );
        
        // Das JTable initialisieren
        JTable table = new JTable(  data, title );
        
        JFrame frame = new JFrame( "Demo" );
        frame.getContentPane().add( new JScrollPane( table ) );
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.pack();
        frame.setVisible( true );
            
              
            } 

        }         catch (Exception e){}
            
    }   
            
    
    // ######################  DB Connection  ###############################################################
    
    public static Connection getConnection() throws Exception {
    String driver = "oracle.jdbc.driver.OracleDriver";

      String url = "jdbc:oracle:thin:@xxxxxxxxxxxx:1521:xxxxx"; // NISTEST1
      String username = "xxxxx";
      String password = "xxxxx";


        Class.forName(driver);
        Connection conn = DriverManager.getConnection(url, username, password);
        
        return conn;
    }
    
    // #####################  Result  ########################################################
    String s1 = null;
    
    public static String tabelle(Connection conn, String tableName) throws SQLException {
        String resultTable = "";
        Statement stmt = null;
        ResultSet rs = null;
        try {
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * FROM " + tableName); //tableName);
            
            while (rs.next() ) {
                String s1 = rs.getString(1);
                String s2 = rs.getString(2);
                s1 = rs.getString("VID");
                s2 = rs.getString("VALUE");
               
                
            }

            resultTable = rs.getString(resultTable);
        } catch (SQLException e) {
            
       } finally {
            rs.close();
            stmt.close();
            
        }
        
       return resultTable;
    }
    // ####################  Count auf Tabelle  #####################################################
    
    public static int countRows(Connection conn, String tableName) throws SQLException {
        // select the number of rows in the table
        Statement stmt = null;
        ResultSet rs = null;
        int rowCount = -1;
        try {
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT count(*) FROM " + tableName); //tableName);
            // get the number of rows from the result set
            rs.next();
            rowCount = rs.getInt(1);
        } finally {
            rs.close();
            stmt.close();
        }

        return rowCount;
    }
    
    

}

:rtfm:

 

[c_sidi90]

Ich würde ein DefaultTableModel nehmen, nennen wir es mal "dtm"

 DefaultTableModel dtm = new DefaultTableModel()

Erstell dir eine Methode, welche als Parameter ein ResultSet und ein TableModel übergebgen bekommt. In diesem Beispiel das dtm und ein ResultSet aus deiner Abfrage "SELECT * FROM TABLE XXX".

private void putRSinTableModel(ResultSet rs, DefaultTableModel dtm) {
       
		ResultSetMetaData rsmd = null;
        int clmCnt = -1;
       
        try {
            rsmd = rs.getMetaData();
            clmCnt = rsmd.getColumnCount();
 
        } catch (SQLException e) {
        	 JOptionPane.showMessageDialog(null,e.getMessage(),"Fehler",JOptionPane.ERROR_MESSAGE);
        }
 
        if (rsmd == null || clmCnt == -1) {
            throw new RuntimeException("rsmd is null");
        }
        
        try {
            
        	rs.beforeFirst();
            rs.last();
            int rowCnt = rs.getRow();
            rs.beforeFirst();
 
            Object[][] odata = new Object[rowCnt][clmCnt];
            Object[] clmHeaders = new Object[clmCnt];
           
            //Hier werden dem ObjektArray clmHeaders die Spaltenüberschriften übergeben
            for (int i = 1; i <= clmCnt; i++) {
                clmHeaders[i - 1] = rsmd.getColumnName(i);
            }
 
            int row = 0;

            //SQL Daten in das 2D Object Array laden
            while (rs.next()) {
 
                for (int i = 1; i <= clmCnt; i++) {
                    odata[row][i - 1] = rs.getString(i);
                }
                row++;
            }
 
            dtm.setDataVector(odata, clmHeaders); //Hier übergibst du deinem TableModel die neuen Daten.
           JTable.updateUI();
           JTable.setModel(dtm); //Deiner Tabelle das Model übergeben
           
        } catch (SQLException e1) {
        	 JOptionPane.showMessageDialog(null,e1.getMessage(),"Fehler",JOptionPane.ERROR_MESSAGE);
        }
    }

 

[SlaterB]

grundsätzlich ist das eine bedenkliche Frage,
da steht der Code zur JTable in einer Schleife, wird für jede Zeile ausgeführt, wie auch selber erkannt,

dann ist es nicht möglich durch eigenes Denken zur Erkenntnis zu kommen, dass die JTable NACH der Schleife erstellt werden sollte,
vorher alle Daten zusammensammeln?

für Anfänger-Aufgaben, erstes Kennenlernen von Schleifen & Co. ist das ja noch ein vertretbares Problem,
aber bevor man je Oracle oder JTable hört, sollte man sowas im Grundsatz eigentlich schon Ewigkeiten beherrschen..

 

[dior]

...

 

[SlaterB]

die Wahrheit kann nie herabwürdigend sein und auf einen sauberen Umgangston achte ich stehts aufs äußerste,
aber jedem steht die Interpretation natürlich frei

(edit: Kritik schon wieder editiert)

 

[dior]

War eigentlich nicht als Kritik gedacht, war mehr Frust... 🙁
Es ist ja nicht so das ich das mache weil ich gerade Lust habe etwas zu programmieren was mir mit meinen JavaKenntnissen eigenltich viel zu hoch ist... aber manchmal muss man eben Dinge tun...

Habe jetzt den JTable aufruf nach dem Case, aber es bleibt ein Problem:
Innerhalb der Schleife gibt mir die Konsole mit der Println alle Werte richtig aus. In der Tabelle nur die letzte Zeile...

    Vector data = null; 
           Vector title = null;
           Vector rowA = null;
           Vector rowB = null;
           Vector rowC = null;
        try {
         
            Statement stmt = null;
            ResultSet rs = null;
                        
          
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * FROM " + tableName); //tableName);
      
            int count = 1;
            
        
            while (rs.next() ) {
                
                
                String s1 = rs.getString(1);
                String s2 = rs.getString(1);
                String s3 = rs.getString(1);
                String s4 = rs.getString(1);
                String s5 = rs.getString(1);
                String s6 = rs.getString(1);
                s1 = rs.getString("VID");
                s2 = rs.getString("VALUE");
                s3 = rs.getString("FILTER");
                s4 = rs.getString("SHORTTEXT");
                s5 = rs.getString("UNUSED");
                s6 = rs.getString("ORDINAL");
                
                System.out.println("Zeile:    " + count);
                System.out.println(s1 + " | " + s2 + " | " + s3 + " | " + s4 + " | " + s5 + " | " + s6 + "\n");
                
               count = count+1;
                

            
        data = new Vector();
             rowA = new Vector();
             
                rowA.add(  s1 );
                rowA.add(  s2 );
                rowA.add(  s3 );
                rowA.add(  s4 );
                rowA.add(  s5 );
                rowA.add(  s6 );
             rowB = new Vector();
                rowB.add(  s1 );
                rowB.add(  s2 );
                rowB.add(  s3 );
                rowB.add(  s4 );
                rowB.add(  s5 );
                rowB.add(  s6 );
             rowC = new Vector();
                rowC.add(  s1 );
                rowC.add(  s2 );
                rowC.add(  s3 );
                rowC.add(  s4 );
                rowC.add(  s5 );
                rowC.add(  s6 );
        
            
                
        // Die Titel für das Table
         title = new Vector();
            title.add( "VID" );
            title.add( "VALUE" );
            title.add( "FILTER" );
            title.add( "SHORTTEXT" );
            title.add( "UNUSED" );
            title.add( "ORDINAL" );
                 
            } 

        }         catch (Exception e){}
            
        
        data.add( rowA );
        data.add( rowB );
        data.add( rowC );
        // Das JTable initialisieren
        JTable table = new JTable(  data, title );
        
        JFrame frame = new JFrame( "Demo" );
        frame.getContentPane().add( new JScrollPane( table ) );
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.pack();
        frame.setVisible( true );
        
    }

 

[SlaterB]

der title-Vektor kann offensichtlich auch hinter die Schleife,
und du darst eben nicht für jede Zeile die Daten komplett neuerzeugen

data muss vor der Schleife angelegt werden, rowA, B, C sind ganz gut, oder noch besser nur rowA wie vorher, wozu B und C?

da diese jedenfalls jedes Mal neu erstellt werden und gemerkt werden sollten gehört

        data.add( rowA );
        data.add( rowB );
        data.add( rowC );

wiederum IN die Schleife

 

[dior]

So jetzt gehts... Vector data = data = new Vector(); noch vor die Schleife und rowB und rowC entfernt... und er zeigt mir alle Zeilen an!

vielen Dank für die Hilfe!

und nichts für ungut für meinen kleinen "Frust" am beginn 🙂

 

[c_sidi90]

Wieso machst du es nicht einfach wie ich es dir gesagt hab, funktioniert und ist dynamisch.