Anzahl Datensätze ausgeben

[Olli76]

Hallo zusammen,

in einer Aufgabe soll die Anzahl der Datensätze (Tabellen) von einer Datenbank ausgegeben werden. Soweit so gut. Nun ist mir aufgefallen das bei der Navigation rückwärts durch dei Datenbank die gesamtanzahl auch mit runtergezählt wird und die Datensätze gelöscht / zerstört werden. Woran könnte das liegen?
Ich hänge hier mal den Code der betroffenen Klasse an. Das komplette Projekt häng ich in den Anhang.
[CODE lang="java" title="BearbeitenEintrag"]import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.sql.Connection;
import java.sql.ResultSet;
import javax.swing.AbstractAction;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;



public class BearbeitenEintrag extends JDialog{

private static final long serialVersionUID = 1L;

// für die Eingabe
private JTextField name,nachname,strasse,plz,ort,telefon;

// für die Anzeige
private JLabel nummer,anzahlDaten;

// für die Aktionen
private MyAction loeschenAct, vorAct, zurueckAct, startAct, endeAct, aktualisierenAct;

// für die Verbindung
private Connection verbindung;
private ResultSet ergebnisMenge;

// für die Abfrage
private String sqlAbfrage;

class MyAction extends AbstractAction{

private static final long serialVersionUID = 1L;

public MyAction(String text, ImageIcon icon,String beschreibung, KeyStroke shortcut, String actionText) {
super(text,icon);
putValue(SHORT_DESCRIPTION, beschreibung);
putValue(ACCELERATOR_KEY, shortcut);
putValue(ACTION_COMMAND_KEY, actionText);
}

@Override
public void actionPerformed(ActionEvent e) {
switch(e.getActionCommand()) {
case"vor":
ganzVor();
break;
case"zurueck":
ganzZurueck();
break;
case"einenvor":
einenVor();
break;
case"einenzurueck":
einenZurueck();
case"loeschen":
loeschen();
break;
case"aktualisieren":
aktualisieren();
break;
}
}
}

/*
* Die innere Klasse FensterListener mit der Methode windowClosing()
* ist dafür verantwortlich,
* dass wenn das Fenster geschlossen wird, auch die DB Connection
* geschlossen wird.
*/
class FensterListener extends WindowAdapter{
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
try {
BearbeitenEintrag.this.ergebnisMenge.close();
BearbeitenEintrag.this.verbindung.close();
MiniDBTools.schliessenDB("jdbc:derby:adressenDB");
}
catch(Exception exc) {
JOptionPane.showMessageDialog(null, "Problem: \n" + exc.toString());
}

}
}

public BearbeitenEintrag(JFrame parent, boolean modal) {
super(parent,modal);
setTitle("Einträge bearbeiten");
setLayout(new BorderLayout());

// die Aktionen erstellen
loeschenAct = new MyAction("Datensatz löschen", new ImageIcon("icons/Delete24.gif"), "Löscht den aktuellen Datensatz", null, "loeschen");
vorAct = new MyAction("Einen Datensatz weiter", new ImageIcon("icons/Forward24.gif"), "Blättert einen Datensatz weiter", null, "einenvor");
zurueckAct = new MyAction("Einen Datensatz zurück", new ImageIcon("icons/back24.gif"), "Blättert einen Datensatz zurück", null, "einenzurueck");
startAct = new MyAction("Zum ersten Datensatz",new ImageIcon("icons/Front24.gif"), "Geht zum ersten Datensatz", null, "vor");
endeAct = new MyAction("Zum letzten Datensatz", new ImageIcon("icons/End24.gif"), "Geht zum letzten Datensatz", null, "zurueck");
aktualisierenAct = new MyAction("Änderungen speichern", new ImageIcon("icons/Save24.gif"), "Speichert Änderungen am aktuellen Datensatz", null, "aktualisieren");

// Symbolleiste oben einfügen
add(sysmbolleiste(),BorderLayout.NORTH);

// die Oberfläche über initGui() erstellen und einfügen
add(initGui(),BorderLayout.CENTER);

// SQL Befehl der Variablen zuweisen
sqlAbfrage = "SELECT * FROM adressen";

// die Datenbankverbindung herstellen
initDB();

// den FensterListener verbinden
addWindowListener(new FensterListener());

// packen und anzeigen
pack();
setVisible(true);
setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
}

/*
* Die Methode initGui() setz die benötigten Label und Textfelder
* auf das Panel und liefert es zurück.
*/
private JPanel initGui() {

JPanel tempPanel = new JPanel();
tempPanel.setLayout(new GridLayout(0,2));

tempPanel.add(new JLabel("ID-Nummer:"));
nummer = new JLabel();
tempPanel.add(nummer);
tempPanel.add(new JLabel("Vorname:"));
name = new JTextField();
tempPanel.add(name);
tempPanel.add(new JLabel("Nachname:"));
nachname = new JTextField();
tempPanel.add(nachname);
tempPanel.add(new JLabel("Strasse:"));
strasse = new JTextField();
tempPanel.add(strasse);
tempPanel.add(new JLabel("PLZ:"));
plz = new JTextField();
tempPanel.add(plz);
tempPanel.add(new JLabel("Ort:"));
ort = new JTextField();
tempPanel.add(ort);
tempPanel.add(new JLabel("Telefon:"));
telefon = new JTextField();
tempPanel.add(telefon);
tempPanel.add(new JLabel("Datensätze"));
anzahlDaten = new JLabel();
tempPanel.add(anzahlDaten);

return tempPanel;
}

/*
* Die Methode symbolleiste() erstellt die Symbolleiste
* und gibt sie zurück. Dei entsprechenden Sysmbole
* werden über die Aktionen geliefert und eingebunden.
*/
private JToolBar sysmbolleiste() {
JToolBar leiste = new JToolBar();

leiste.add(loeschenAct);
leiste.add(aktualisierenAct);
leiste.addSeparator();
leiste.add(startAct);
leiste.add(zurueckAct);
leiste.add(vorAct);
leiste.add(endeAct);

return (leiste);
}

/*
* Die Methode initDB initialisiert die Datenbank Verbindung.
* Die Verbindung wird über den Aufruf der Klasse MiniDBTools und ihrer Funktion
* oeffnenDB() aufgebaut.Über die Variable sqlAbfrage wir der SQL Befhel weiter gereicht
* und in der Klasse MiniDBTools verarbeitet.
*/
private void initDB() {
try {
verbindung = MiniDBTools.oeffnenDB("jdbc:derby:adressenDB");
ergebnisMenge = MiniDBTools.liefereErgebnis(verbindung, sqlAbfrage);
if(ergebnisMenge.next())
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(this,"Problem: \n" + e.toString());
}
}

/*
* Die Methode datenLesen() liest die Reihe aus auf welche der Zeiger zeigt und
* schreibt die Daten in die ensprechenden Felder. Sollte der Zeiger auf einem
* leeren Datensatz zeigen, wird die Methode wieder verlassen.
*/
private void datenLesen() {
try {
if(ergebnisMenge.getRow() > 0) {
nummer.setText(Integer.toString(ergebnisMenge.getInt(1)));
name.setText(ergebnisMenge.getString(2));
nachname.setText(ergebnisMenge.getString(3));
strasse.setText(ergebnisMenge.getString(4));
plz.setText(ergebnisMenge.getString(5));
ort.setText(ergebnisMenge.getString(6));
telefon.setText(ergebnisMenge.getString(7));
anzahlDaten.setText(Integer.toString(ergebnisMenge.getRow())+ " von: " + anzahlRows());
}
return;
}
catch(Exception e) {
JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
}
}

/*
* Die Methode ganzVor() springt zum ersten Datensatz in der Datenbank.
*/
private void ganzVor() {
try {
ergebnisMenge.first();
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode ganzZurueck() springt zum letzten Datensatz in der Datenbank.
*/
private void ganzZurueck() {
try {
ergebnisMenge.last();
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode einenVor() springt einen Datensatz weiter vor. Bevor der Zeiger verschoben wird,
* schauen wir nach ob wir schon am letzten Datensatz angekommen sind. Dies wird mit der Methode
* isLast() geprüft. Sollten wir uns bereits im letzten Datensatz befinden, verlassen wir
* die Methode einenVor() wieder.
*/
private void einenVor() {
try {
if(ergebnisMenge.isLast()) {
return;
}
else if(ergebnisMenge.next()){
datenLesen();
}
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode einenZurueck() springt einen Datensatz zurück. Bevor der Zeiger ensprechend verschoben wird,
* prüfen wir ob wir schon am ersten Eintrag angekommen sind. Dies erledigen wir mit der Methode
* isFirst(). Sind wir also schon am ersten Datensatz angekommen,
* wird die Methode einenZurueck() wieder verlassen.
*/
private void einenZurueck() {
try {
if(ergebnisMenge.isFirst())
return;
else if (ergebnisMenge.isFirst())
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode loeschen() löscht die Reihe in der der Zeiger aktuell steht.
* Die Funktion merkt sich die aktuelle Position, löscht dann alle Einträge in dieser Reihe
* und schliesst die DB Connection. Dann wird eine neue Verbindung aufgebaut und der Zeiger springt
* an die gespeicherte Position. Da wird geprüft ob es der Eintrag nach dem letzten ist. Wenn ja
* den letzten Eintrag anfahren und die Daten einlesen.
*/
private void loeschen() {
try {
// aktuelle Position merken
int position = ergebnisMenge.getRow();
// den Eintrag löschen
ergebnisMenge.deleteRow();
// ErgebnisMenge schliessen
ergebnisMenge.close();
// ErgebnisMenge neu öffnen
ergebnisMenge = MiniDBTools.liefereErgebnis(verbindung, sqlAbfrage);
// alte Position anfahren
ergebnisMenge.absolute(position);
// stehen wir aktuell hinter dem letzten Datensatz ?
if (ergebnisMenge.isAfterLast())
// dann den letzten anfahren
ergebnisMenge.last();
// die Daten neu lesen
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode aktualisieren() schreibt die Daten neu in die Reihe wo sich aktuell
* der Zeiger befindet. Der Ablauf ist in der Funktion kommentiert.
*/
private void aktualisieren() {
try {
// die Position merken
int position = ergebnisMenge.getRow();
// die Daten aktualisieren
ergebnisMenge.updateString(2, name.getText());
ergebnisMenge.updateString(3, nachname.getText());
ergebnisMenge.updateString(4, strasse.getText());
ergebnisMenge.updateString(5, plz.getText());
ergebnisMenge.updateString(6, ort.getText());
ergebnisMenge.updateString(7, telefon.getText());
// den Datensatz aktualisieren
ergebnisMenge.updateRow();
// ErgebnisMenge schliessen
ergebnisMenge.close();
// und wieder neu öffnen
ergebnisMenge = MiniDBTools.liefereErgebnis(verbindung, sqlAbfrage);
// und zur alten Position gehen
ergebnisMenge.absolute(position);
// die daten neu Lesen
datenLesen();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: \n" + e.toString());
}
}

/*
* Die Methode anzahlRows() schaut wieviele Datensätze / Reihen hat es in der Datenbank.
* Diese Zahl liefert sie über anzahlZeilen zurück. Der genaue Ablauf ist in der Funktion
* kommentiert.
*/
private int anzahlRows() {
int anzahlZeilen = 0;
try {
// die aktuelle Pos. merken
int position = ergebnisMenge.getRow();
// zum letzten Datensatz springen
ergebnisMenge.last();
// die Zeilennummer holen und in der Variablen ablegen
anzahlZeilen = ergebnisMenge.getRow();
// die Verbindung schliessen
ergebnisMenge.close();
// die Verbindung erneut aufbauen
ergebnisMenge = MiniDBTools.liefereErgebnis(verbindung, sqlAbfrage);
// den Zeiger wieder an die alte Position verschieben
ergebnisMenge.absolute(position);

}
catch(Exception e) {
JOptionPane.showMessageDialog(null, "Problem: " + e.toString());
}
return anzahlZeilen;
}
}

[/CODE]

Bin für jeden Tip dankbar

 

[LimDul]

            case"einenzurueck":
                einenZurueck();
            case"loeschen":
                loeschen();
                break;

da fehlt ein break

 

[mihe7]

Noch was, nebenbei:

MiniDBTools.liefereErgebnis(verbindung, sqlAbfrage);

Wenn Du nicht-statische Methoden verwenden würdest, bräuchtest Du keine ominöse Tools-Klasse (sondern könntest eine "richtige" DB-Klasse haben) und könntest Dir die Übergabe der Verbindung sparen.

 

[Olli76]

Hallo LimDul,

danke genau das war das Problem. Ich habe stundenlang verschiedene Methoden probiert um den Fehler zu finden......
Ist schon panne so ein Fehler. Naja manchmal sieht man den Wald vor lauter Bäumen nicht.
@mihe7 Ich finde das auch ziehmlich umständlich aber ich musste halt eine Aufgabe (Vorgabe) passend umstellen. Ich habe vor, mich noch tiefer in das Thema DB einzuarbeiten (MySQL u. PostgresSQL).

Danke für eure Tipps

Gruss Olli

 

[LaraCroft96]

Huhu Olli76,

ich stehe aktuell vor der gleichen Aufgabe und finde deine Lösung mit dem Switch-case echt interessant.

LG

 

[mihe7]

Die Lösung via Switch hat den Nachteil, dass die Fälle hart im Code stehen. Braucht man einen neuen Fall, muss der Code angepasst werden. Ersetzt man den String durch z. B. ein Runnable (oder einen ActionListener oder ein anderes funktionales Interface), kann man nicht nur auf hart-kodierte Fälle verzichten, der Code wird auch noch kürzer und wiederverwendbar.

Hier mal eine Variante, die sowohl Runnable- als auch ActionListener-Implementierungen verarbeitet:

    class SimpleAction extends AbstractAction {
        private static final long serialVersionUID = 1L;
        private final ActionListener listener;

        public SimpleAction(String text, ImageIcon icon, String beschreibung, KeyStroke shortcut, Runnable task) {
            this(text, icon, beschreibung, shortcut, task == null ? null : e -> task.run());
        }

        public SimpleAction(String text, ImageIcon icon, String beschreibung, KeyStroke shortcut, ActionListener listener) {
            super(text, icon);
            putValue(SHORT_DESCRIPTION, beschreibung);
            putValue(ACCELERATOR_KEY, shortcut);
            this.listener = listener;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (listener != null) {
                listener.actionPerformed(e);
            }
        }
    }

Dank Methodenreferenzen kann man dann schreiben:

        loeschenAct = new SimpleAction("Datensatz löschen", new ImageIcon("icons/Delete24.gif"),
                "Löscht den aktuellen Datensatz", null, this::loeschen);
        vorAct = new SimpleAction("Einen Datensatz weiter", new ImageIcon("icons/Forward24.gif"),
                "Blättert einen Datensatz weiter", null, this::einenVor);
        zurueckAct = new SimpleAction("Einen Datensatz zurück", new ImageIcon("icons/back24.gif"),
                "Blättert einen Datensatz zurück", null, this::einenZurueck);
        startAct = new SimpleAction("Zum ersten Datensatz", new ImageIcon("icons/Front24.gif"), "Geht zum ersten Datensatz",
                null, this::ganzVor);
        endeAct = new SimpleAction("Zum letzten Datensatz", new ImageIcon("icons/End24.gif"), "Geht zum letzten Datensatz",
                null, this::ganzZurueck);
        aktualisierenAct = new SimpleAction("Änderungen speichern", new ImageIcon("icons/Save24.gif"),
                "Speichert Änderungen am aktuellen Datensatz", null, this::aktualisieren);