# JTree Daten in DB schreiben am besten SQL



## TJava (2. Feb 2011)

Hallo wie kann man einen JTree mit einer Datenbank synchron halten?
Es sollen dort objekte ausgelesen und im Jtree angezeigt werden. 
Ebenso sollen die veränderungen z.b. Knotenhinzufügen etc. in die Datenbank aufgenommen werden.

Also das auslesen ist erstmal nicht so wichtig. 
Hat jemand ein Beispiel wie ich das in eine DB schreibe oder einen vorschlag wie ich dabei vorgehen soll?

Das ganze soll beliebig erweiterbar sein.

Projekt
---->Ordner 1
           ---------->Subordner1
                                  --------->Datei1.xml
           ---------->Subordner2
                                  --------->Datei2.xml
---->Ordner 2


----------



## XHelp (2. Feb 2011)

Du kannst dir ja für Projekte und Ordner Tabellen anlegen. Ein Projekt hat eine ID. Ordner hat u.a. "parent"-Eintrag. Dieser zeigt entweder auf ein Projekt oder auf einen anderen Ordner. Auf diese Weise kannst du recht einfach so eine Ordnerstruktur speichern.


----------



## TJava (2. Feb 2011)

Du kannst dir ja für Projekte und Ordner Tabellen anlegen. Ein Projekt hat eine ID. Ordner hat u.a. "parent"-Eintrag. Dieser zeigt entweder auf ein Projekt oder auf einen anderen Ordner. Auf diese Weise kannst du recht einfach so eine Ordnerstruktur speichern. 



und wie mache ich das es beliebig vom user weitergeführt werden kann?
Root
----------> Projekt //hat einen parent und child
------------------->Ornder1 //hat parent 
------------------->Ornder2 //hat parent
--------------------------->Kind1 // hat parent kein child

 kann leider nicht mehr denken, bin seit heute morgen dabei :-D
mache mir morgen gedanken.

Vielleicht kannst du mir noch ein bisschen input geben für morgen früh
Es sollen auch Dateien in der DB liegen und die soll synchron sein mit dem baum.

Danke für deine Hilfe.


----------



## XHelp (2. Feb 2011)

Sollen *Dateien* in der Datenbank liegen, oder nur Pfadangaben? Ganze Dateien da abzulegen ist hmmm.... nicht schön.
So die einfachste Möglichkeit ist 4 Tabellen:

```
-----------------------------
| Projects                  |
-----------------------------
| project_id | project_name |
-----------------------------

----------------------------------------
| Folders                              |
----------------------------------------
| folder_id | project_id | folder_name |
----------------------------------------

---------------------------------------------
| Subfolders                                |
---------------------------------------------
| subfolder_id | parent_id | subfolder_name |
---------------------------------------------

-----------------------------------
| Files                           |
-----------------------------------
| file_id | parent_id | file_path |
-----------------------------------
```
Damit kannst du beliebige Verzeichnisstrukturen darstellen. Folders und Subfolders kannst du auch noch bei bedarf zusammenführen.


----------



## TJava (3. Feb 2011)

Guten morgen wieso ist es nicht schön Dateien in die Datenbank zu legen?


----------



## TJava (3. Feb 2011)

Wie kann man das mit der parent_id verstehen? Also Ordner haben eine zugehörige Project_ID.
Das verstehe ich noch. Aber wie weiß ein Unterordner wozu ergehört? Wie ordnet man die zu?


----------



## TJava (3. Feb 2011)

Kann mir jemand erklären was hier genau passiert?

```
nodeSpecifier instanceof Object[]
```
Hier wird geprüft ob nodeSpecifier in Object castbar ist?

Wenn dem so ist 

```
child = processHierarchy((Object[]) nodeSpecifier);
```
Wird hier die Funktion processHierarchy nochmal aufgerufen und nodeSpecifier als Object gecastet

Dann weiß ich nicht wie diese rekursion abläuft.
Kann das jemand erklären?


```
private DefaultMutableTreeNode processHierarchy(Object[] hierarchy) {
    DefaultMutableTreeNode node = new DefaultMutableTreeNode(hierarchy[0]);
    DefaultMutableTreeNode child;
    for (int i = 1; i < hierarchy.length; i++) {
      Object nodeSpecifier = hierarchy[i];
      if (nodeSpecifier instanceof Object[]) // Ie node with children
      {
        child = processHierarchy((Object[]) nodeSpecifier);
      } else {
        child = new DefaultMutableTreeNode(nodeSpecifier); // Ie Leaf
      }
      node.add(child);
    }
    return (node);
```


----------



## TJava (3. Feb 2011)

Bitte! ich verzweifele:-(


----------



## XHelp (3. Feb 2011)

Mensch, das ist doch ein Forum und kein Chat...
parent_id gibt an, wozu der Subfolder gehört. Und generell in der Denkrichtung falsch. Du musst ja nicht wissen wozu ein Subfolder gehört, sondern welche Subfolder zu dem Ordner gehören.

Die rekursive Funktion läuft eigentlich genau so wie jede andere rekursive Funktion ab. Es wird solange aufgerufen, bis es sich um das letzte Objekt handelt und nicht um eine Menge von Objekten. Was *genau* verstehst du denn nicht an dem Algo?


----------



## TJava (3. Feb 2011)

Also der erste durchlauf

1.es wird das Object übergeben
  Der erste Eintrag aus dem Object wird zum Root
  Der zweite Eintrag aus dem Object wird zum Child


```
if (nodeSpecifier instanceof Object[]) // Ie node with children
      {
        child = processHierarchy((Object[]) nodeSpecifier);
      } else {
        child = new DefaultMutableTreeNode(nodeSpecifier); // Ie Leaf
      }
```
Verstehe den auf Aufruf nicht würde es nciht immer im Kreis laufen. Weil  Object 
	
	
	
	





```
nodeSpecifier = hierarchy[i];
```
 ist ja immer true

Also was passiert hier  Object nodeSpecifier = hierarchy_;

Und das hier fragt ist nodeSpecifier überführbar in Object[]?
 if (nodeSpecifier instanceof Object[])

Wenn ja 
child = processHierarchy((Object[]) nodeSpecifier);
Aber das ist doch immer der Fall.
Also ich weiß einfach nicht wie der verlauf ist.
Einseits geht er ja nur eine Runde wenn er wieder bei 
processHierarchy(Object[] hierarchy) aber in hierachie ja nur ein Objekt drin ist.
Kannst du vielleicht mal einfach den Ablauf beschreiben._


----------



## XHelp (3. Feb 2011)

TJava hat gesagt.:


> Weil  Object
> 
> 
> 
> ...



Das ist eine Zuweisung und kein boolischer Ausdruck. Das kann nicht true oder false sein.

Es wird eben geguckt ob es sich bei dem *"kind"-*Objekt wieder um ein Array handelt (also um mehrere Einträge), wenn ja wird die Methode rekursiv aufgerufen, sonst einfach ein Blatt erstellt.
Du kannst ja in dem Object-Array wieder Object-Array als Element haben.
Vllt hast du generell Probleme mit der Rekursion, aber da kannst du am besten in einem Buch nach einer Erklärung schauen.


----------



## TJava (6. Feb 2011)

Hallo, wie kann ich eine instanzvariable 
weiterlaufen lassen?

Also ca. so
k=1;

DefaultMutableTreeNode k = new DefaultMutableTreeNode("Testtool");

k=2;

DefaultMutableTreeNode k = new DefaultMutableTreeNode("Testtool2");

???

MFG


----------



## XHelp (6. Feb 2011)

"weiterlaufen lassen"?? Du kannst ja nicht der Variable 
	
	
	
	





```
k
```
 mal ein Zahlenwert zuweisen, mal ein Object.


----------



## TJava (6. Feb 2011)

wie erstellt man denn dann eine Objectliste?

for(int i = 0 ; i <= indexmax ; i++ )

DefaultMutableTreeNode i = new DefaultMutableTreeNode ("i")


Kannst du mir nicht noch irgendwie helfen?
Ich bekomme den Baum immer noch nicht hin.


----------



## XHelp (6. Feb 2011)

Du darf dir für deine Fragen mehr Zeit als 5 Sekunden nehmen. Dann ergeben die Fragen auch hoffentlich einen Sinn. Für mich ist es jedenfalls ein Rätsel, was du in den lezten 2 Posts fragen willst.


----------



## TJava (6. Feb 2011)

Also ok :-D
mein Plan war es die Datenbank auszulesen jeder Datensatz hat eine parent_ID
NAME Parent_ID
Test1          0
Test2          0
Test3          1
Test4          2
....


```
//Es wird als erstes die max_Parent_ID ermittelt 
int k=1;

for ( int i =0 ; i<= max_Parent_ID; i++)
{
  // Hier kommt dann eine SQL Select Anweisung hin. Select Name from Tabelle where Parent_ID = i;
 node = i ;

        for(int j = k; rs.next(); j++){
            DefaultMutableTreeNode j = new DefaultMutableTreeNode("rs.getString(1)");
           node.add( j );
           k= j;
           }
```

Ich hoffe du verstehst wie ich das meine.


Ich möchte einfach die Tabelle als Baumstruktur abbilden.
Gibt es da eine andere möglichkeit? Die Tabelle kann immer verschieden aussehen.
Also immer unterschiedliche Tiefe haben mal 5 Knoten, mal 10 Knoten.

Ich hoffe es ist verständlicher, wenn nicht darf ich dich bei ICQ adden?


----------



## XHelp (6. Feb 2011)

Der Code macht so kein Sinn. Du hast in der Schleife eine Zählvariable *j* und dann versuchst du noch ein Knoten *j* zu erstellen. Das geht natürlich nichts. Nimm einfach eine andere Variable für den Knoten.
Du kannst auch nicht einem Knoten *node* einfach mal ein Int-Wert zuweisen.
Außerdem erstellst du kein Knoten mit dem *Wert* aus der Datenbank, sondern nur einen Knoten mit dem Wort *"rs.getString(1)"*.
Bevor du weiter machst lohnt es sich vllt mal ein paar Grundlagen zu Objekten und Variablen zu lesen.


----------



## TJava (6. Feb 2011)

rs.getString(1) Das natürlich so...

Ok ich probiere das nochmal mit einer anderen Variable.
 DefaultMutableTreeNode node = new DefaultMutableTreeNode("rs.getString(1)");

Was sagst du denn zu der Vorgehensweise insgesamt? Wie macht man denn sonst so einen Baum?


----------



## XHelp (6. Feb 2011)

Ich würde es auch rekursiv machen. Ein Beispiel dafür hast du ja schon selber gebracht.


----------



## TJava (6. Feb 2011)

Und wie lege ich dafür die Datenstruktur an, damit Sie rekursiv gelesen werden kann?
Kannst du dafür ein paar Beispiele geben?
Am besten für meine Beispieltabelle.


----------



## XHelp (6. Feb 2011)

Fang doch mal klein an und lass dir nur die Projekte ausgeben. Wenn es wirklich läuft, dann versuchst du zu dem jeweiligen Projekt die Ordner rauszulesen usw.


----------



## TJava (6. Feb 2011)

Es geht ja nur bekomme ich keine weiteren Hierachiestufen hin.

Weil immer alles an einen Knotengehängt werden muss.
Dieser ist aber immer statisch.

es sei denn man könnte irgenwie

nodealt.add(node) machen
aber hier ist es immer der root
wie kann man diesen knoten immer auf einen bestimmten setzen?
Das war auch der Grund warum ich die Instanzen laufen lassen wollten


```
for (int i = 0; i <= 3; i++) {
			try {
				String sql = " Select Name from student where parent_id=" + i;
				st = con.createStatement();
				rs = st.executeQuery(sql);

				for (int j = 0; rs.next(); j++) {
					DefaultMutableTreeNode node = new DefaultMutableTreeNode(
							rs.getString(1));
					root.add(node);

				}
```

Das war auch der Grund warum ich die Instanzen laufen lassen wollten

```
DefaultMutableTreeNode 0 = new DefaultMutableTreeNode("Testtool");
		int q = 4;
		for (int i = 0; i <= 3; i++) {
			try {
				String sql = " Select Name from student where parent_id=" + i;
				st = con.createStatement();
				rs = st.executeQuery(sql);

				for (int j = 0; rs.next(); j++) {
					DefaultMutableTreeNode node = new DefaultMutableTreeNode(
							rs.getString(1));
					dieser knoten muss immer der i.te Knotensein.add(node);

				}
```



Verstehst du wo das problem liegt?


----------

