# Abhängige JTable - MCV - Frage zu Struktur



## mf4nky (11. Feb 2008)

Hallo zusammen

*Ausgangslage*
Ich plane ein kleines und einfaches Java-Tool zum Verwalten von Logins der Mitarbeiter. Also d.h. es sollen einfach sämtliche Mitarbeiter und pro Mitarbeiter mehrere Logins erfasst werden können.

Ich stelle mir vor, dass folgende paar Informationen erfasst werden müssten:
Mitarbeiter (ID, Vorname, Name, Abteilung)
Login (ID, Programm/System, Benutzername)

*Geplante Struktur*
Das ganze möchte ich mittels zwei JTable unter Beachtung des MVC-Konzepts erarbeiten.

Etwa so sollte das Aussehen:


```
Mitarbeiter
+-------------------------------+
|                               |
|	    JTable 1                |
|                               |
+-------------------------------+

Logins
+-------------------------------+
|                               |
|	    JTable 2                |
|                               |
+-------------------------------+
```

Beim Auswählen eines Mitarbeiters in der JTable1 müssen sich die Login-Einträge in der JTable2 aktualisieren.

*Problemstellung*
Folgende Frage stelle ich mir nun:
Soll ich für die beiden JTable ein gemeinsames DefaultTableModel erstellen, oder pro JTable ein eigenes?

Meine Probleme bei den zwei Varianten:
gemeinsames Model
Pro JTable müsste ich immer nur einen Teil der, im Model verwalteten, Daten verarbeiten, ist wahrscheinlich nicht gerade übersichtlich

eigenes Model
-	Wie kann ich die JTable2 aktualisieren, sobald ich einen Eintrag in JTable1 ausgewählt habe (-> ich müsste ja z.B. die SQL-Abfrage im Model für die Logins, gem. Auswahl des Mitarbeiters in JTable1, anpassen. Wie übertrage ich z.B. die ID des ausgewählten Mitarbeiters in das Model der Logins?).

Ich möchte nicht, dass mir jemand gleich reihenweise Code liefert, sondern nur bisschen beschreibt, wie ihr solche Programme strukturiert, was z.B. die Vor- und Nachteile der verschiedenen Varianten sind.
Oder: Wie muss ich es anstellen, damit die Daten der JTable2 von der Auswahl der JTable1 abhängig sind?

Freue mich jetzt schon über eure hilfreichen Beiträge


----------



## mimo (11. Feb 2008)

Also ich denke schon das jedes Table sein eigenes Model verdient alleine aus dem Grund, dass zumindest das 1 eigenständig arbeiten kann. Die Models würde ich einfach untereinader verknüpfen  ( so ne Art abgespeckte Observer-funktion, stellt keine so besondere Problematik da). So reagiert das zweite Model auf jede Änderung des ersten und besorgt sich die benötigten Daten.
Ein weiterer Vorteil dürfte auch sein, dass du mit ein wenig mehr Code auch das zweite Table unabhängig einbauen kannst was im Bezug auf Wartung und Wiederverwendbarkeit auch nur Vorteile aufweist.

Falls du noch mehrere Tables für die Datenbank aufbauen möchtes, würde ich mir auch mal überlegen ob es sich nicht lohnt mit einer Factory zu arbeiten die dir dein Tableview aufbaut und die Funktionalität verwaltet(lohnt sich natürlich nur bei entsprechender Anzahl von Views, doch ich stand vor kurzem vor dem Problem, dass immer mehr Tables hinzugefügt werden musten, wodurch der Klassenkatalog iregendwann zu explodieren drohte.)


----------



## mf4nky (12. Feb 2008)

Hallo mimo
Besten Dank für deine Antwort.

Hab mir eben auch gedacht, dass wohl zwei einzelne Modelle sinnvoller wären.
Naja, ich bin leider kein Java-Guru  und habe noch nicht so oft mit den Patterns gearbeitet.

Bis jetzt habe ich einfach immer wenn ich eine JTable verwendet habe, ein Model, welches von DefaultTableModel geerbt hat, erstellt.
Wie kann ich jetzt denn ein DefaultTableModel und das Observer-Pattern kombinieren?

Änderungen im Model werden den JTables ja per "_fire...()_"-Befehle mitgeteilt. Bei Observern sind es ja die Befehle "_setChanged()_" und "_notifyObservers(...)_".

Könntest du oder sonst jemand trotzdem ein kleines und einfaches Bsp. posten, damit ich so bisschen die Grundstruktur der einzelnen Klassen und deren Verknüpfungen sehe.
Irgendwie steh ich momentan ziemlich auf dem Schlauch und seh wohl vor lauter Bäume den Wald nicht mehr 

Vielen Dank für eure Hilfe!

Gruss aus der sonnigen Schweiz


----------



## Marco13 (12. Feb 2008)

Observer war ein etwas unpräziser Begriff. Es gibt für JTables (wenn man das so sehen will) "spezielle Observer" - nämlich Listener   Und DIE werden (indirekt) mit den "fire...()"-Methoden benachrichtigt.

Holen kann man sich das "SelectionModel" mit
http://java.sun.com/javase/6/docs/api/javax/swing/JTable.html#getSelectionModel()
(nicht irritieren lassen, *List*SelectionModel ist schon richtig :wink: )

Wie man das dann anwendet steht für JTables angedeutet hier
http://java.sun.com/docs/books/tutorial/uiswing/components/table.html#selection

und ausführlicher (allgemeiner) nochmal hier
http://java.sun.com/docs/books/tutorial/uiswing/events/listselectionlistener.html

(einschließlich der Datei http://java.sun.com/docs/books/tuto...roject/src/events/TableListSelectionDemo.java wo man ein komplettes, compilerbares Beispiel hat, das du bestimmt leicht auf dein Problem übertragen kannst)


----------



## mf4nky (12. Feb 2008)

Hey Marco13

Ahh, ok! Ich hatte mal so für mich ein kleines Beispiel mit Observern erstellt und für mich war vorhin klar, dass das diese sein müssten 

Besten Dank für deine Ausführungen und die Links.

Werde mich in dem Fall mal bisschen durchlesen und mich schlau machen.
Melde mich dann später wieder.


----------



## mf4nky (13. Feb 2008)

Hallo zusammen
Aufgrund der Tipps habe ich jetzt mal ein komplettes Beispiel erstellt.

*Grobbeschreibung*
Das GUI besteht aus einem JFrame, welcher zwei JTables "Mitarbeiter" und "Login" beinhaltet. Beim Start des Tools werden alle erfassten Mitarbeiter aus der DB gelesen und via Model in die JTable abgefüllt.
Beim Klick auf einen Mitarbeiter-Eintrag wird die Login-JTable aktualisiert und zeigt nur noch diejenigen Einträge an, welche dem markierten Mitarbeiter zugeordnet sind.

/edit: Hier noch drei Pics zu dem Tool:










*Bemerkungen*
Aus Platzgründen habe ich sämtliche Import-Befehle und Kommentare zu den einzelnen Methoden weggelassen.
Man könnte den Code noch in vielen Bereichen optimieren (z.B. noch viel mehr mit Gettern und Settern arbeiten).

Mich würde es interessieren, was ihr als Profis zum ganzen Aufbau (hinsichtlich MVC) und dem Code meint.

*Meine Fragen*

Ich liefere der View als Parameter die zwei Modelle und den Controller mit. Wird das so angewendet oder gäbe es da noch eine bessere Variante?
Würde man für den Aufbau der ganzen DB-Connection eine eigene Klasse erstellen (ohne dass es gleich zu kompliziert wird)?

Danke für euer Feedback 


*Main.java*

```
public class Main {
    public static void main(String[] args) {
        Controller ctrl = new Controller();
    }
}
```

*Controller.java*

```
public class Controller implements ListSelectionListener {

    private ModelMitarbeiter mdlMA = null;
    private ModelLogin mdlLogin = null;
    private View view = null;

    Controller() {
        mdlMA = new ModelMitarbeiter();
        mdlLogin = new ModelLogin();

        view = new View(this, mdlMA, mdlLogin);
        view.setVisible(true);
    }

    @Override
    public void valueChanged(ListSelectionEvent lstSelEv) {
        ListSelectionModel lsm = (ListSelectionModel) lstSelEv.getSource();

        if (!lsm.isSelectionEmpty() && lsm.getValueIsAdjusting()) {
            int minIdx = lsm.getMinSelectionIndex();
            String value = mdlMA.getValueAt(minIdx, 0).toString();
            String qryLogin = "SELECT l.login FROM tbl_login AS "
                    + "l INNER JOIN tbl_mitarbeiter AS m ON "
                    + "l.mitarbeiter = m.M_ID WHERE m.name ='" + value + "';";
            mdlLogin.setQryLogin(qryLogin);
            mdlLogin.readLogins();
        }
    }
}
```

*View.java*

```
public class View extends JFrame {

    private ModelMitarbeiter mdlMA = null;
    private ModelLogin mdlLogin = null;
    private Controller ctrl = null;
    private JTable tblMA = null;
    private JTable tblLogin = null;
    private JScrollPane scpMA = null;
    private JScrollPane scpLogin = null;

    View(Controller ctrl, ModelMitarbeiter mdlMA, ModelLogin mdlLogin) {
        super("Beispiel");
        setSize(450, 250);
        setLayout(new FlowLayout());
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        this.mdlMA = mdlMA;         // 
        this.mdlLogin = mdlLogin;     // besser: via setter
        this.ctrl = ctrl;             //

        initView();
    }

    /**
     * Dieser Teil ist aus Platzgründen nicht sauber strukturiert. Besser wäre:
     * Jedes einzelne Element über getters zu holen.
     */
    public void initView() {
        // JTable Mitarbeiter
        tblMA = new JTable(mdlMA);
        tblMA.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        tblMA.getSelectionModel().addListSelectionListener(ctrl);
        
        scpMA = new JScrollPane(tblMA);
        scpMA.setPreferredSize(new Dimension(200, 180));
        add(scpMA);

        // JTable Login
        tblLogin = new JTable(mdlLogin);
        tblLogin.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        
        scpLogin = new JScrollPane(tblLogin);
        scpLogin.setPreferredSize(new Dimension(200, 180));
        add(scpLogin);
    }
}
```

*ModelMitarbeiter.java*

```
public class ModelMitarbeiter extends DefaultTableModel {

    final private String dbPath = "H:/MALogin.mdb";
    final private String qryMitarbeiter = "SELECT * FROM tbl_mitarbeiter";
    final private String[] headers = { "Mitarbeiter" };
    private Vector<Mitarbeiter> mitarbeiter = null;

    ModelMitarbeiter() {
        initMitarbeiter();
    }

    public void initMitarbeiter() {
        readMitarbeiter();
    }

    @Override
    public int getColumnCount() {
        return 1;
    }

    @Override
    public String getColumnName(int col) {
        return headers[col];
    }

    @Override
    public int getRowCount() {
        return getMitarbeiter().size();
    }

    @Override
    public Object getValueAt(int row, int col) {
        Mitarbeiter m = getMitarbeiter().elementAt(row);

        if (col == 0) {
            return m.getName();
        } else {
            return null;
        }
    }

    /**
     * Der Vector musste mit einem getter geholt werden, da es sonst bei der
     * Methode "getRowCount()" einen "NullPointerException"-Fehler generiert
     * hätte.
     */
    public Vector<Mitarbeiter> getMitarbeiter() {
        if (mitarbeiter == null) {
            mitarbeiter = new Vector<Mitarbeiter>();
        }
        return mitarbeiter;
    }

    public void addMitarbeiter(Mitarbeiter mitarbeiter) {
        getMitarbeiter().add(mitarbeiter);
        this.fireTableRowsInserted(getRowCount() - 1, getRowCount() - 1);
    }

    public ResultSet openConnection() {

        try {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            Connection con = DriverManager
                    .getConnection("jdbc:odbc:DRIVER={Microsoft Access Driver (*.mdb)};DBQ="
                            + dbPath);
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery(qryMitarbeiter);

            return rs;
        } catch (Exception e) {
        }
        return null;
    }

    public void readMitarbeiter() {
        try {
            ResultSet rs = openConnection();

            while (rs.next()) {
                Mitarbeiter mitarbeiter = new Mitarbeiter();
                mitarbeiter.setName(rs.getString("name"));
                addMitarbeiter(mitarbeiter);
            }

            closeConnection(rs);
        } catch (Exception e) {
        }
    }

    public void closeConnection(ResultSet rs) {
        try {
            rs.close();
        } catch (Exception e) {
        }
    }
}
```

*ModelLogin.java*

```
public class ModelLogin extends DefaultTableModel {

    final private String dbPath = "H:/MALogin.mdb";
    final private String[] headers = { "Login" };
    private String qryLogin = "";
    private Vector<Login> logins = null;

    ModelLogin() {
        initModel();
    }
    
    public void initModel() {
        readLogins();
    }

    @Override
    public int getColumnCount() {
        return 1;
    }

    @Override
    public String getColumnName(int col) {
        return headers[col];
    }

    @Override
    public int getRowCount() {
        return getLogins().size();
    }

    @Override
    public Object getValueAt(int row, int col) {
        Login login = getLogins().elementAt(row);
        
        if (col == 0) {
            return login.getLogin();
        } else {
            return null;
        }
    }

    /**
     * Der Vector musste mit einem getter geholt werden, da es sonst bei der
     * Methode "getRowCount()" einen "NullPointerException"-Fehler generiert
     * hätte.
     */
    public Vector<Login> getLogins() {
        if (logins == null) {
            logins = new Vector<Login>();
        }
        return logins;
    }

    public void addLogin(Login login) {
        getLogins().add(login);
        this.fireTableRowsInserted(getRowCount() - 1, getRowCount() - 1);
    }
    
    public ResultSet openConnection() {

        try {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            Connection con = DriverManager
                    .getConnection("jdbc:odbc:DRIVER={Microsoft Access Driver (*.mdb)};DBQ="
                            + dbPath);
            Statement stmt = con.createStatement();
            System.out.println(getQryLogin());
            ResultSet rs = stmt.executeQuery(getQryLogin());

            return rs;
        } catch (Exception e) {
        }
        return null;
    }

    public void readLogins() {
        getLogins().removeAllElements();
        
        try {
            ResultSet rs = openConnection();

            while (rs.next()) {
                Login login = new Login();
                login.setLogin(rs.getString("login"));
                addLogin(login);
            }

            closeConnection(rs);
        } catch (Exception e) {
        }
    }

    public void closeConnection(ResultSet rs) {
        try {
            rs.close();
        } catch (Exception e) {
        }
    }

    public String getQryLogin() {
        if (qryLogin.equals("")) {
            qryLogin = "SELECT * FROM tbl_login";
        }
        return qryLogin;
    }

    public void setQryLogin(String qryLogin) {
        this.qryLogin = qryLogin;
    }
}
```

*Mitarbeiter.java*

```
public class Mitarbeiter {
    
    private String name = "";
    
    Mitarbeiter() {
        
    }
    
    Mitarbeiter(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

*Login.java*

```
public class Login {

    private String login = "";

    Login() {
        
    }
    
    Login(String login) {
        setLogin(login);
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }
}
```


----------

