Resultset zwischenspeichern, dann später in JTable

[p_krger]

Tja, wo fange ich da an... ich muss mich nach etlichen Stunden, Tagen, Wochen doch mal geschlagen geben und hier offiziell um "Hilfe", besser gesagt eine zweite Meinung bitten.

Die Tabelle, die ich erstelle, besser gesagt die Klasse, mit der ich die Tabelle erstelle, erbt von AbstractTableModel und wird bereits mit den Standartwerten generiert. Sichtbar ist sie also und irgendwelche zufälligen Werte stehen auch drin (durch die drei get-Methoden natürlich).

Ich bin erfolgreich auf der Datenbank unterwegs, hole mir die Werte, die ich brauche (Spaltenanzahl, Zeilenanzahl) und lasse die Tabelle anhand dieser Parameter erstellen (zum Beispiel 9 Spalten und exakt 1244 Zeilen). Damit hat die Tabelle schon einmal das passende Format.

Nun gehe ich los, hole mit dem nächsten Befehl das nächste Resultset ab, welches die Spaltennamen sind und speichere diese (auch lesbar) in einer Arraylist<String>ab.

Nun gehts weiter, ich hole mir alles von der Tabelle ab und weiß einfach nicht, wie ich nun diese Daten irgendwie dort hinein bekomme. Erstmal in ein Array/Arraylist/List/String[]? Es handelt sich ja hier nicht um drei Spalten, in denen ich Fa, Fu und Fara und passende kunterbunte Kindermalfarben abbilde, sondern jede der 1244 Zeilen soll auch der passenden der 9 Spalten zugeordnet werden.

Mir geht es eigentlich nur darum: wie kann ich das Resultset so abspeichern, dass ich es über eine simple "werteHinzufuegen()"-Methode später in meine JTable hinein bekomme? Sorry aber ich sehe da den Wald vor lauter Bäumen nicht.

Hier mal der Code (<hierstehengeheimeSachendrin>):

package <Packagename>;


import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;


import javax.swing.JFrame;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.table.AbstractTableModel;


@SuppressWarnings("serial")

public class SQLtoJavaTable extends AbstractTableModel {


	static ArrayList<String> spaltenName;

	static ArrayList<String> results;

	static Connection verbindung;

	static int zeilenAnzahl = 0;

	static int spaltenAnzahl = 0;

	static ResultSet resultSet;

	static Statement stmtSelect;

	static String[] reihe;

	static String[] spaltenNameStringArray;

	static String befehl;


	@Override

	public int getRowCount() {

		// Zeilenanzahl eintragen

		// sollte sich der Zeilenanzahl der gelesenen Tabelle angleichen

		return zeilenAnzahl;

	}


	@Override

	public int getColumnCount() {

		// Spaltenanzahl eintragen

		// sollte sich der Spaltenanzahl der gelesenen Tabelle angleichen

		return spaltenAnzahl;

	}


	@Override

	public Object getValueAt(int row, int col) {

		if (col == 0) {

			return "" + row;

		} else if (col == 1) {

			return "" + row * row;

		} else {

			return "" + row * col;

		}

	}


	public static void main(String[] args) throws ClassNotFoundException, SQLException {

		ausführen();

		erstelleFenster();

	}


	private static void ausführen() throws ClassNotFoundException, SQLException {


		// Wir laden den Treiber

		Class.forName("oracle.jdbc.driver.OracleDriver");

		// ----------------------------------------------------

		// Wir holen uns die Anzahl der Zeilen der Tabelle

		befehl = "SELECT COUNT(*) FROM <Tabelle>";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir speichern die Anzahl der Zeilen weg

		while (resultSet.next()) {

			zeilenAnzahl = Integer.parseInt(resultSet.getString(1));

			System.out.println("Anzahl der Zeilen in der Tabelle: " + zeilenAnzahl);

		}

		// ----------------------------------------------------

		// Wir holen uns die Anzahl der Spalten der Tabelle

		befehl = "SELECT COUNT(*) FROM <Tabelle> WHERE OWNER = <Owner> AND TABLE_NAME = '<Tabelle>'";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir speichern die Anzahl der Spalten weg

		while (resultSet.next()) {

			spaltenAnzahl = Integer.parseInt(resultSet.getString(1));

			System.out.println("Anzahl der Spalten in der Tabelle: " + spaltenAnzahl);

		}

		// ----------------------------------------------------

		// Wir holen uns nun die Spaltennamen

		befehl = "SELECT COLUMN_NAME FROM <Tabelle> WHERE OWNER = <Owner> AND TABLE_NAME = '<Tabelle>'";

		// Befehl ausführen

		resultSet = statementAusfuehren(befehl);

		// Die Spaltennamen werden gespeichert

		spaltenName = new ArrayList<>();

		while (resultSet.next()) {

			spaltenName.add(resultSet.getString(1));

		}

		System.out.println("Die Spaltennamen lauten:\n" + spaltenName);

		// ----------------------------------------------------

		// Wir holen uns nun die gesamte Tabelle

		befehl = "SELECT * FROM <Tabelle>";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir speichern die Ergebnisse weg (2D-Array? Jeder Wert in seiner

		// Zeile zur passenden Spalte!)

		results = new ArrayList<>();

		while (resultSet.next()) {

			reihe = new String[spaltenAnzahl];

			for (int i = 1; i <= spaltenAnzahl; i++) {

				reihe[i - 1] = resultSet.getString(i);

			}

		}

		resultSet.close();

		stmtSelect.close();

		verbindung.close();

	}


	private static ResultSet statementAusfuehren(String befehl2) throws SQLException {

		// mit dieser Methode wird EIN Statement ausgeführt

		verbindung = null;

		verbindung = DriverManager.getConnection("jdbc:oracle:thin:@<Datenbank>", "<Owner>", "<Passwort>");

		stmtSelect = verbindung.createStatement();

		ResultSet rs = stmtSelect.executeQuery(befehl2);

		System.out.println("SELECT successfully executed");

		return rs;

	}


	private static void erstelleFenster() {

		// erstellt das Fenster

		JFrame f = new JFrame();

		f.getContentPane().add(new JScrollPane(new JTable(new SQLtoJavaTable())));

		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		f.setLocationRelativeTo(null);

		f.pack();

		f.setVisible(true);

	}

}

Vielleicht machst sich ja jemand die Mühe und liest sich das alles durch. Und ja, API und Google sind vertraut. Trotzdem bin ich mittlerweile so unglaublich verwirrt, dass ich wahrscheinlich den Fehler nicht mehr sehe oder das, was ich nicht implementiert habe, mir einfach nicht einfällt.

Lg

[p_krger]

Falls es nch jemanden interessiert, hier meine Lösung:

package xxxxxxxx;


import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;


import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTable;


@SuppressWarnings("rawtypes")

public class SQLtoJavaFrame extends JFrame {

	private static final long serialVersionUID = -4662896414136615882L;

	static JPanel contentPanel;

	static JTable tabelle;

	static int spaltenAnzahl = 0;

	static int zeilenAnzahl = 0;


	static ResultSet resultSet;

	static String befehl;

	static ArrayList<String> spaltenName;

	static Connection verbindung;

	static Statement stmtSelect;

	static JFrame fenster;

	static MyTableModel mtm;


	public SQLtoJavaFrame() {

		// Fenster wird initialisiert, visible ganz am Ende!

		fensterInitialisieren();

		tabelle = new JTable(mtm);

		JScrollPane sp = new JScrollPane(tabelle);

		contentPanel.add(sp);

		tabelle.setVisible(true);

	}


	private void fensterInitialisieren() {

		contentPanel = (JPanel) getContentPane();

		setDefaultCloseOperation(EXIT_ON_CLOSE);

		setSize(500, 400);

		setTitle("Frame Title");

		setLocationRelativeTo(null);

	}


	public static void main(String[] args) throws ClassNotFoundException, SQLException {

		// ausführen-Methode hier, weil sonst die Variablen zur Erstellung der

		// Tabelle 0 wären!

		ausführen();

		// Fenster wird erzeugt

		fenster = new SQLtoJavaFrame();

		// wird hier noch nicht visible, da noch geädert wird, visible kommt

		// ganz am Ende!

		// Spaltennamen werden geändert

		spaltenNamenAendern();

	}


	private static void spaltenNamenAendern() {

		// Diese Methode ändert die Namen der Spalten der Tabelle

		for (int i = 0; i < tabelle.getColumnCount(); i++) {

			tabelle.getColumnModel().getColumn(i).setHeaderValue(spaltenName.get(i));


		}

		fenster.pack();

		fenster.setVisible(true);

	}


	@SuppressWarnings("unchecked")

	private static void ausführen() throws ClassNotFoundException, SQLException {

		// Wir gehen los auf die DB und holen uns die benötigten Werte

		Class.forName("oracle.jdbc.driver.OracleDriver");

		// ----------------------------------------------------

		// Wir holen uns die Anzahl der Zeilen der Tabelle

		befehl = "SELECT COUNT(*) FROM xxxxxxxx";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir speichern die Anzahl der Zeilen weg

		while (resultSet.next()) {

			zeilenAnzahl = Integer.parseInt(resultSet.getString(1));

			System.out.println("Anzahl der Zeilen in der Tabelle: " + zeilenAnzahl);

		}

		// ----------------------------------------------------

		// Wir holen uns die Anzahl der Spalten der Tabelle

		befehl = "SELECT COUNT(*) FROM SYS.ALL_TAB_COLUMNS WHERE OWNER = 'xxxxxxxx' AND TABLE_NAME = 'xxxxxxxx'";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir speichern die Anzahl der Spalten weg

		while (resultSet.next()) {

			spaltenAnzahl = Integer.parseInt(resultSet.getString(1));

			System.out.println("Anzahl der Spalten in der Tabelle: " + spaltenAnzahl);

		}

		// ----------------------------------------------------

		// Hier das Table-Model initialisieren, weil vorher die beiden Variablen

		// noch leer waren und dann die Tabelle nicht richtig erstellt wird

		mtm = new MyTableModel(zeilenAnzahl, spaltenAnzahl);

		// ----------------------------------------------------

		// Wir holen uns nun die Spaltennamen:

		befehl = "SELECT COLUMN_NAME FROM SYS.ALL_TAB_COLUMNS WHERE OWNER = 'xxxxxxxx' AND TABLE_NAME = 'xxxxxxxx'";

		// Befehl ausführen

		resultSet = statementAusfuehren(befehl);

		// Die Spaltennamen werden gespeichert

		spaltenName = new ArrayList<String>();

		while (resultSet.next()) {

			spaltenName.add(resultSet.getString(1));

		}

		System.out.println("Die Spaltennamen lauten: " + spaltenName);

		// ----------------------------------------------------

		// Wir holen uns nun die gesamte Tabelle:

		befehl = "SELECT * FROM xxxxxxxx";

		// Wir führen den SQL-Befehl aus

		resultSet = statementAusfuehren(befehl);

		// Wir haben die ganze Tabelle im Resultset

		// und wenn das Resultset noch nicht zu Ende ist...

		while (resultSet.next()) {

			// wird eine Liste angelegt, welche eine Zeile darstellt:

			List rohDaten = new ArrayList<>();

			// und jeder Wert, der sich im Resultset befindet, wird er der Liste

			// für eine Zeile hinzugefügt:

			for (int i = 0; i < spaltenAnzahl; i++) {

				rohDaten.add(resultSet.getObject(spaltenName.get(i)));

			}

			// und schließlich der Tabelle hinzugefügt

			mtm.addRow(rohDaten);

		}

		// ----------------------------------------------------

	}


	private static ResultSet statementAusfuehren(String befehl2) throws SQLException {

		// mit dieser Methode wird EIN Statement ausgeführt

		verbindung = null;

		verbindung = DriverManager.getConnection("jdbc:oracle:thin:@xxxxxxxx", "xxxxxxxx", "xxxxxxxx");

		stmtSelect = verbindung.createStatement();

		ResultSet rs = stmtSelect.executeQuery(befehl2);

		System.out.println("SELECT successfully executed");

		return rs;

	}


}

TableModel:

package xxxxxxxx;


import java.util.ArrayList;

import java.util.List;


import javax.swing.table.AbstractTableModel;


@SuppressWarnings("serial")

public class MyTableModel extends AbstractTableModel {

	int zeilenAnzahl, spaltenAnzahl;

	private final List<List> data = new ArrayList();


	public MyTableModel(int zeilen, int spalten) {

		zeilenAnzahl = zeilen;

		spaltenAnzahl = spalten;

	}


	@Override

	public int getColumnCount() {

		return spaltenAnzahl;

	}


	@Override

	public int getRowCount() {

		return zeilenAnzahl;

	}


	@Override

	public String getColumnName(int spalte) {

		return new String("Spalte " + (spalte + 1));

	}


	@Override

	public Object getValueAt(int zeile, int spalte) {

		return data.get(zeile).get(spalte);

	}


	public void addRow(List rowData) {

		data.add(rowData);

		fireTableRowsInserted(data.size() - 1, data.size() - 1);

	}


}

Ich finde das immer herzlich dämlich, wenn jemand auch genau das gesucht hat, was ich nun suche und niemand auf seine Frage geantwortet hat. Also falls jemand Bedarf daran hat, bitteschön, habe ja geheime Sachen durch "xxxxxxxx" ersetzt.