Swing jTree + MySql Befüllungsproblem

[Oldboii]

Also hi erstmal,

das ist das erste mal für mich in diesem Forum. Und ich komme auch nur aus purer
Verzweiflung hier angekrochen. Ich würde mich immer noch als Java Anfänger bezeichnen,
auch nach 3 Jahren Programmieren in meinem Studium.

Also ich habe folgendes Problem, welches ich auch schon in sämtlichen Varianten etc. mit
google gesucht habe, und habe auch einige Tutorials etc. gefunden die aber alle leider nicht
bei meinem gedanklichen Problem helfen.

So endlich zum Problem:
Ich hatte am Anfang meines Projekts die Idee nen schönen einfachen jTree zum navigieren
einzubauen, und wusste leider nicht was da auf mich zukommt.
Im Hintergrund befindet sich jetzt eine kleine aber evlt. bald riesige DB mit z.B. Geräten;
meine Geräte haben Kategorien und wiederrum Typen, alles hat auch schön nochmal ne eigene
ID etc. Hier ne BeispielAbfrage:
Select Kategorie.KategorieID, Kategorie.Kategorie, Typ From Kategorie JOIN Typ ON KategorieID = Typ.Kategorie
Ergebnis:
KategorieID: Kategorie: Typ:
1 Allgemeine Geräte Drucker
1 Allgemeine Geräte Mehrkopfwaage
3 Produktion Tiefziehmaschine

So und jetzt will ich nen Tree mit Hilfe z.B. dieser Abfrage gestalten. Die Schranke in meinem Gehirn
liegt jetzt an folgendem Punkt. Anfangs wollte ich die Abfrage ohne KategorieID in eine ArrayList packen die ArrayList dann in das Object hierarchy packen und daraus die gesamte Baumhierarchie
gestalten... eigentlich ganz schön, aber hätte mir klar sein müssen, dass ich jetzt doppelte Knoten erhalten:
root
Allgemeine Geräte
Drucker
Allgemeine Geräte
Mehrkopfwaage

usw.
Dann hatte ich vor die ArrayList irgendwie mit nem iterated HashSet von doppelten Werten zu bereinigen, die Idee hab ich aber gar nicht erst fertig probiert, weil dann sicher die Beziehung von Kategorie und Typ verloren gegangen wäre und ich nur Müll bekommen hätte.
Meine nächste Idee die eigentlich klappen könnte ist folgende, das ich die Hauptstruktur fülle indem ich nur die Kategorien abfrage welche dann die Parentnodes darstellen und vorerst keine Kinder haben, sondern die Kinder extra durch einen WillExpandListener und eine entsprechende extra neue Abfrage "... Where '"getselectedTreePath"' = Kategorie.." oder so ähnlich. Allerdings macht mir
hier zu Anfang gleich mal der DefaultMutableTreeNode einen Strich durch die Rechnung, weil die
nodes ohne childs schonmal gar nicht mehr expandeble sind.
Hier z.B. ist eine extrem kranke Lösung, die für meinen JTree aber auch nicht klappt und zu übertrieben ist (Drag n Drop etc.) http://sites.google.com/site/uhilger/artikel_index/boundtree

Ich hoffe irgendjemand findet die Zeit meinen riesen Thread durchzulesen und auch alles zu verstehen, was ich nicht hinbekomme.
Übrigens wer sich jetzt unbedingt einbilden will, das ich meine Arbeit gemacht haben will etc. etc., der soll doch bitte einfach gehen.. ich möchte lediglich einen anständigen Denkanstoß und jemand der mich vom Schlauch schubst auf dem ich gerade stehe. Thx

 

[Michael...]

Da gibt's diverse Möglichkeiten z.B.:
1) Man schreibt ein eigenes TableModel, das mit der ArrayList umgehen kann
2) man sortiert im SQL nach der ID und überprüft beim erzeugen des Baums, ob die Kategorie des aktuellen Typs noch der des Vorgängers entspricht. Wenn nicht fügt man einen neuen Knoten mit der neuen Kategorie in den Baum ein und fügt darin, die alle darauffolgenden Typen ein, bis wieder eine neue Kategorie in der List kommt
3) man erfragt per Statement erst einmal nur die Kategorien und während man den Baum mit den Kategorien befüllt, erfragt man in einem zweiten Statement die Typ der jeweiligen Kategorie
4) man befüllt den Baum erst einmal nur mit den Kategorien und lädt die Typen im Bedarfsfall nach, damit Kategorieknoten vom Anwender expandiert werden können bzw. als expandierbar erkannt werden fügt man zunächst einen Dummyknoten ein oder markiert sie mit einem speziellen Icon

Ich persönlich würde in dem Fall Variante 2 und 3 bevorzugen, danach Variante 1 und im äussersten Notfall Variante 4

 

[Oldboii]

Danke für die schnelle Antwort Michael. Ich weiß jetzt zwar spontan noch nicht wie ich deine Vorschläge Codetechnisch angehen soll (weil ichn boon bin), aber ich find die Varianten 2 und 3 auch sehr plausibel. Ich werd mich jetzt erstmal mit Variante 3 beschäftigen... Variante 4 ist ja ungefähr so wie ich es schonmal vor hatte (WillExpandListener); gut zu wissen das die nur für den äussersten Notfall gut wäre.
Ich glaub mein neues Experiment was ich gerade angefangen habe, ähnelt der Variante 3.

package test;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;
import java.util.List;

public class Test extends JFrame {
    public Test() {
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	Container content = getContentPane();
	JTree jt = new JTree(new RefTreeNode());
	content.add(new JScrollPane(jt));
	setSize(200,200);
	show();
    }
    public static void main(String[] args) { new Test(); }
}
class RefTreeNode extends DBZugriff implements TreeNode{
	   List<RefTreeNode> children = new ArrayList<RefTreeNode>();
	   String displayName = null;
	   RefTreeNode parent = null;
	   transient int parentid = -1;
	   
	   public TreeNode getParent() { return parent;}
	   public Enumeration<RefTreeNode> children() {
	      return Collections.enumeration(children);
	   }
	   public boolean isLeaf() {
	       return children.size()==0;
	   }
	   public boolean getAllowsChildren() {
	       return !isLeaf();
	   }
	   public int getChildCount() {return children.size();}
	   public int getIndex(TreeNode tn) {
	       return children.indexOf(tn);
	   }
	   public TreeNode getChildAt(int index) {
	       return (TreeNode)children.get(index);
	   }
	   // used by the default renderer
	   public String toString() {
	       return displayName;
	   }
	   // use this method to create the root node
	   // from a result set;
	   // assumption: first: id, second: display name, third: parent id
	   public static RefTreeNode createRootFor(ResultSet rs) 
	       throws SQLException
	   {
	       // preserves insertion order
	       Map<Integer, RefTreeNode> nodes = new LinkedHashMap<Integer, RefTreeNode>();
	       RefTreeNode root = null;
	       while(rs.next()) {
	    	   String sql = "Select Kategorietyp.ID, Kategorie.Kategorie, TypID From Kategorietyp " +
	    	   		"JOIN Kategorie ON Kategorietyp.KategorieID = Kategorie.KategorieID";
	    	   Statement st = con.createStatement();
	    	   rs = st.executeQuery(sql);
	    	   
	           RefTreeNode tmp = new RefTreeNode();
	           tmp.displayName = rs.getString(2);
	           tmp.parentid = rs.getInt(3);
	           nodes.put(new Integer(rs.getInt(1)), tmp);
	           if(tmp.parentid==rs.getInt(1)) root = tmp;
	       }
	       // important!
	       rs.close();
	       for(Iterator<RefTreeNode> iter = nodes.values().iterator(); iter.hasNext();){
	          RefTreeNode n = (RefTreeNode)iter.next();
	          if(n!=root) {
	             Integer i = new Integer(n.parentid);
	             RefTreeNode parent = (RefTreeNode)nodes.get(i);
	             parent.children.add(n);
	             n.parent = parent;
	          }
	       }
	       return root;
	   }
}

 

[Oldboii]

peinlich peinlich .. aber jetzt nach insgesamt fast einer Woche hab ichs doch endlich so wie ich es haben wollte.
Aber mein Bauchgefühl sagt mir das der jTree noch so einiges auf Lager hat um mich fertig zu machen.
Als nächstes werd ich mich jetzt ran hocken und den jTree mit nem Table verbinden.
Meine Lösung übrigens:
- Abfrage schicken/empfangen
- (ID) Kategorie, Typ jeweils in nen String packen (rs.getString(1).. usw.)
- diese in nen String[] baum z.B.
- und ner ArrayList<String[]> den String[]baum adden
- in der DefaultMutableTreeNode mit zwei Schleifen (for (String[] : blubb)) die Hierarchie festlegen
- fertig

Wer das hier liest und auch schon seit Stunden/Tagen oder länger vor dem jTree sitzt und nen Knoten im Hirn bekommt.. ich schätze ich kann inzwischen gute Hilfe leisten.