# Java objekt in MYSQL auslesen



## sence (24. Aug 2009)

Hallo,

ich würde gerne Objecte in der Mysql Datenbank speichern, und habe folgendes bis jetzt:


```
java.sql.PreparedStatement pstmt= connect.prepareStatement("INSERT INTO user produkte VALUES (?) where user='" user + '");
		                 
		         adminTool.produkt produkt = new adminTool.produkt();
		         produkt.initProdukt("AMD Duron", "254", "30", "Dedicated", "randompw");
		         
		                
		         
		            pstmt.setObject(1, produkt);		            
		            pstmt.executeQuery();

 // Hatte hier auch pstmt.updateQuery(); // aber auch erfolglos
		            
		            pstmt.close();
		           
					String encodedUrl = response.encodeRedirectURL("./showCustomer?kdn='" + kunde +"'");
					response.sendRedirect(encodedUrl);
```

das ist jetzt etwas, was ich mir aus diesem Forum zusammen gebaut habe.
Habe dies in einem Servlet untergebracht, jedoch beginnt mein Problem ab hier


```
pstmt.setObject(1, produkt);		            
		            pstmt.executeQuery();
```

ab dort macht er nicht weiter, bekomme auch keinen Fehler.


dann meine 2. Frage,
was hat es eigentlich mit den Serialisierten objecten aufsich ?
und wieso muss mann ein PreStatement nehmen, ok habe gelesen ist leistungsfähiger, aber wenn ich das auser acht lasse, wie wäre es noch zu realisieren ?

bin ein freund der wenigen codezeilen :- )

Vielen Dank!


----------



## The_S (25. Aug 2009)

Uff, wa soll denn das für ein SQL-Statement sein? "INSERT INTO ... WHERE"? Meinst du nicht eher "UPDATE"? Ich denke viele deiner Fragen lassen sich beantworten, wenn du dir das Kapitel über Datenbankprogrammierung in deinem Einsteigerbuch ansiehst. Oder alternativ: Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 23 Datenbankmanagement mit JDBC .

Auch die SQL-Syntax solltest du dir mal ansehen.


----------



## sence (25. Aug 2009)

hm hab mir eben das ganze nochmal durch gelesen, ändert nicht meine Ansicht zu meiner Programmierung.

Statement stimmt, jedoch sehe ich nichts, wie es mit dem Objecten funktionieren soll :/
im Forum steht dies auch als Lösung, um Objekte zu speichern, aber bei GalileoComputing steht nichts dazu, somit ist der Thread weiter offen :/

please help


//// wieso meinst du update, statt insert, wenn es noch kein Object zum updaten gibt ? oO


----------



## The_S (25. Aug 2009)

sorry, doppelpost, bitte löschen.


----------



## The_S (25. Aug 2009)

sence hat gesagt.:


> jedoch sehe ich nichts, wie es mit dem Objecten funktionieren soll :/



Die könntest du Bspw. als Byte-Array (BLOB bzw. CLOB) in die DB schreiben.



sence hat gesagt.:


> //// wieso meinst du update, statt insert, wenn es noch kein Object zum updaten gibt ? oO



Weil ich nicht weiß, ob du updaten oder inserten willst. Bei einem INSERT gibt es keine WHERE Bedingung, bei einem UPDATE schon. Daher dachte ich, dass du evtl. UDPATEN möchtest - anosnsten macht das WHERE keinen Sinn.

Außerdem ist dein INSERT-Statement generell falsch (INSERT INTO user produkte VALUES ... hä?) und du verwendest das PreparedStatement falsch (bitte doch noch einmal nachlesen)

Wenn du ein Update machen möchtest, dann executeUpdate und nicht executeQuery - solltest du auch gelesen haben.


----------



## sence (25. Aug 2009)

schau mal, habe mich an den Thread angelehnt:

http://www.java-forum.org/datenbankprogrammierung/86312-objekte-datenbank-speichern.html

habe es nun wie folgt:


```
try {
        
       
       java.sql.PreparedStatement pstmt= verbindung.prepareStatement("INSERT INTO user produkte VALUES (?)");
       
       class test implements Serializable {
		private static final long serialVersionUID = 1L;
		
		String name;
		String hdd;
		test(String n, String h) {
			this.name = n;
			this.hdd = h;
		}
    	   
       }
             	test t = new test("amd", "80GB");	                
       
          pstmt.setObject(1, t);	

          pstmt.executeUpdate();

          pstmt.close();
    }
    catch (Exception e) {
       e.printStackTrace();
    }
```

der aufbau sollte richtig sein, aber es will nicht :/

komme gerade irgendwie nicht klar das mit Byte[] hinzubekommen

bei meinem Oben angegebenem Code bekomme ich den Fehler:

com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'produkte VALUES (_binary'¬í\0sr\0CDatenbank$1test\0\0\0\0\0\0\0\0L\0hddt\0' at line 1
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
	at java.lang.reflect.Constructor.newInstance(Unknown Source)
	at com.mysql.jdbc.Util.handleNewInstance(Util.java:406)
	at com.mysql.jdbc.Util.getInstance(Util.java:381)
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1030)
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3515)
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3447)
	at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1951)
	at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2101)
	at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2554)
	at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1761)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2046)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1964)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1949)
	at CDatenbank.main(CDatenbank.java:57)

:/

dank33333


----------



## The_S (25. Aug 2009)

Du hast das WHERE zwar im INSERT behoben, aber du hast noch immer eine falsche Syntax (wie bereits mehrfach erwähnt):

was soll "user produkte" sein? Ein Tabellenname mit Leerzeichen?

Das Object direkt zu setzen ist scheinbar auch eine Alternative, ich habs bis jetzt allerdings eher mit nem Byte-Array gemacht.


----------



## sence (25. Aug 2009)

Danke erstmal für die Antworten,

habe ne fertige Tabelle, dort habe ich noch eine Spalte hinzugefügt, (produkte)

nun würde ich gerne sagen:
wo kundennummer = xxxx dort soll er in die Spalte produkte bei dem User das Object hinzufügen.

ist nen Produktobject, welches ich den Benutzer zuweisen möchte :rtfm:

deswegen hatte ich auch die Where clausel drin :/


----------



## The_S (25. Aug 2009)

Dann musst du doch ein update Statement verwenden.


----------



## sence (25. Aug 2009)

Ok, soweit funktionert alles jedoch hab ich nun nur noch ein Problem:


```
java.sql.PreparedStatement st = verbindung.prepareStatement("SELECT produkt FROM user WHERE kdn=10104");
		ResultSet rs = st.executeQuery();
		produkt p = null;
			rs.next();
				Object obj = rs.getObject(1);
				p = (produkt) obj;
		
			System.out.println("name:" + p.ServerName);
    	}catch (Exception e) {
       e.printStackTrace();
    }
```

wenn ich nun das Object auslesen will erhalte ich den Fehler:

java.lang.ClassCastException: [B cannot be cast to produkt
	at CDatenbank.main(CDatenbank.java:36)

Das object wurde aber richtig in der DB gesetzt

das wäre es dann für erstmal *hoff*

Vielen Dank bis dato!


----------



## sparrow (25. Aug 2009)

1. Beschäftige dich mit den Richtlinien für das Programmieren in Java: Klassennamen haben einen großen Anfangsbuchstaben, Instanzvariablen werden klein geschrieben.

```
Produkt produkt = new Produk();
```

2. Beschäftigt dich mit SQL. Lerne die Ausdrücke. Lerne was Relationen, Tupel und Normalisierung sind.

3. Brauchen wir den Code vom Schreiben und vom Lesen des Datensatzes um den Fehler zu finden.


----------



## sence (25. Aug 2009)

sparrow hat gesagt.:


> 1. Beschäftige dich mit den Richtlinien für das Programmieren in Java: Klassennamen haben einen großen Anfangsbuchstaben, Instanzvariablen werden klein geschrieben.
> 
> ```
> Produkt produkt = new Produkt();
> ...


--------------------------------------
Stehen doch alle oben im Thread oO

aber hier  nochmal:

Object einfügen !!!FUNKTIONIERT!!!

```
java.sql.PreparedStatement pstmt= connect.prepareStatement("UPDATE user SET produkt = (?) where kdn=(?)");
		                 
		         adminTool.produkt produkt = new adminTool.produkt();
		         produkt.initProdukt("AMD Duron", "254", "30", "Dedicated", "randompw");
		         		                
		         
		            pstmt.setObject(1, produkt);
		            pstmt.setString(2, kunde);
		            pstmt.executeUpdate();		            
		            pstmt.close();
```

Auslesen !!!kann nicht gecasted werden!!!! (MYSQL)

java.lang.ClassCastException: [B cannot be cast to produkt
	at CDatenbank.main(CDatenbank.java:36)


```
java.sql.PreparedStatement st = verbindung.prepareStatement("SELECT produkt FROM user WHERE kdn=104");
		ResultSet rs = st.executeQuery();
		produkt p = null;
			rs.next();
				Object obj = (Object) rs.getObject(1);
				p = (produkt) obj;
```


----------



## tfa (25. Aug 2009)

Bist du sicher, dass du wirklich serialisierte Objekte in eine SQL-Datenbank speichern willst? Es mag Fälle geben, wo man das machen will, aber üblich ist das ganz und gar nicht. Normalerweise speichert man den Inhalt der Objekte Attribut-weise in eine normale Tabelle, also die Strings in VARCHAR-Spalten, die ints in Integer-Spalten etc. Das kannst mit normalem JDBC "von Hand" machen (für den Anfang ist das einfacher), oder du verwendest ein ORM-Framework wie Hibernate.


----------



## sparrow (25. Aug 2009)

Entschuldige meine Ehrlichkeit, aber das was du da tust ist Blödsinn.
Und ich meine nicht den Java-Code sondern die Art wie du die Datenbank nutzt.

Bitte beschäftige dich damit warum es Relationale Datenbanken gibt und wie man sie benutzt.

Mir ist es gerade zu mühselig aufzuzählen warum deine Vorgehensweise ganz einfach falsch ist.
Und dann erstmal Datenbankmodell entwerfen.

Edit: tfa war schneller und hat es netter formuliert


----------



## sence (25. Aug 2009)

sagen wir es so:

Jeder kunde bestellt z.b einen Server, dies stellt ein Object dar, in welchem alle einzelheiten des Servers auszulesen sind.
Würde ich dies wie beschrieben aufsplitten wäre dies nicht gerade Objektiv, und sehr umständlich wieder auszufragen.

A) gibt es eine Möglichkeit mein Object wieder herauszuholen und wieso streitet ihr euch bei meinem Thread, bei dem anderen hast du auch ohne zu fragen geholfen. oO 

B) wie würdet Ihr es denn Lösen, wenn Kunden z.b mehre Produkte haben, wo man jedesmal alle daten auslesen muss.
Z.B
ein Kunde hat 5 Server, willst du für jeden Kunden eine Tabelle anlegen oder woot, ok übertrieben geht auch anders aber ich wollte nur meinen Sinn mal nieder schreiben 


Das gescheiteste wäre natürlich mit JDO dies zu realisieren und dme PersistenceManager, nur um das gerade zu erlernen fehlt mit die Zeit :/

deswegen fixiere ich die Möglichkeit von dir, aus dem anderem Thread.

Aber nun die Goldene Frage:
Wieso wieder zurück in die Steinzeit gehen und wieder alles neu bauen, wenn man Objekte doch speichern kann, welche die Arbeit um ein vielfaches erleichtern ?

greetz

Achja P.S.

Um Persistenz für ein Objekt zu erreichen, kann es serialisiert werden. Hier wird der komplette Zustand des Objektes, inklusive aller referenzierten Objekte, in einen Datenstrom umgewandelt, der anschließend auf ein Speichermedium geschrieben wird.

jap das will ich!


----------



## tfa (25. Aug 2009)

sence hat gesagt.:


> B) wie würdet Ihr es denn Lösen, wenn Kunden z.b mehre Produkte haben, wo man jedesmal alle daten auslesen muss.
> Z.B
> ein Kunde hat 5 Server, willst du für jeden Kunden eine Tabelle anlegen oder woot, ok übertrieben geht auch anders aber ich wollte nur meinen Sinn mal nieder schreiben


Kapier ich nicht.
Du hast eine Tabelle mit Kunden und eine mit Produkten. Eine Abbildungstabelle ordnet die Produkte den Kunden zu. Wo ist das Problem?

Was machst du mit deiner Lösung, wenn 100 Kunden das selbe Produkt haben? 100 mal das gleiche Objekt serialisiert in die DB schreiben? 
Was passiert, wenn im Produktdatensatz was geändert werden muss? Alle Objekte deserialisieren, anpassen und wieder zurück schreiben?
Was machst du, wenn du alle Kunden finden willst, die Produkt xyz bestellt haben?



sence hat gesagt.:


> Das gescheiteste wäre natürlich mit JDO dies zu realisieren und dme PersistenceManager, nur um das gerade zu erlernen fehlt mit die Zeit :/


Wenn du eine vernünftige Lösung willst, wirst du dir die Zeit nehmen müssen.


----------



## sence (25. Aug 2009)

ja mir fehlen noch 5 Kapitel @ j2ee SRY, jedoch frage ich nochmal, habt ihr ein Problem für meine Lösung, das ich das Object nicht heraus bekomme oder nicht. 

ja es führen tausend wege nach rom, und ja dann wäre meine Lösung nicht gut, wenn ich etwas ändern müsste, jedoch würde ich dies gerne nun so fertig bekommen.
zumal ich dann auch etwas gelernt habe, und werde es dann ggf umschreiben sobald zeit da ist.

Nur das problem ist wenn man arbeitet, studiert und nebenher noch programmiert ist die zeit eng, deshalb please wie kann ich den Cast fehler beheben


----------



## sparrow (25. Aug 2009)

sence hat gesagt.:


> Jeder kunde bestellt z.b einen Server, dies stellt ein Object dar, in welchem alle einzelheiten des Servers auszulesen sind.
> Würde ich dies wie beschrieben aufsplitten wäre dies nicht gerade Objektiv, und sehr umständlich wieder auszufragen.


Ein KUNDE hat SERVER die KOMPONENTEN enthalten.
Das heißt du brauchst eine Tabelle für Kunden, eine für die Server und eine für Komponenten. Jede einzelne stellt eine Relation dar.



sence hat gesagt.:


> A) gibt es eine Möglichkeit mein Object wieder herauszuholen und wieso streitet ihr euch bei meinem Thread, bei dem anderen hast du auch ohne zu fragen geholfen. oO


Falls du mich meinst: Ich helfe dir hier gerade auch.
Ich zieh mal einen Vergleich zu Realität: Normalerweise steigt man in ein Auto, lässt die Zündung an und gibt Gas um vorwärts zu kommen. Du versuchst gerade das Auto durch Schieben vorwärts zu bekommen. Ich könnte dir natürlich dabei helfen, ich könnte dich aber darauf hinweisen, dass das was du mit dem Auto machst nicht Sinn des Autos ist.
Oder anders: Das was du da versuchst ist nicht Sinn einer Relationalen Datenbank.
Erklär mir mal wie du alle Server heraus finden willst die einen Opteron-Prozessor haben. ALLE Datensätze holen, deserialisieren und dann durchsuchen? Nein nein, das willst du nicht!




sence hat gesagt.:


> B) wie würdet Ihr es denn Lösen, wenn Kunden z.b mehre Produkte haben, wo man jedesmal alle daten auslesen muss.
> Z.B
> ein Kunde hat 5 Server, willst du für jeden Kunden eine Tabelle anlegen oder woot, ok übertrieben geht auch anders aber ich wollte nur meinen Sinn mal nieder schreiben


Nein, natürlich nicht.
Wie gesagt: Beschäftige dich mit Relationalen Datenbanken. Die gibt es nicht umsonst.




sence hat gesagt.:


> deswegen fixiere ich die Möglichkeit von dir, aus dem anderem Thread.


Die ist aber nicht für das gedacht was du hier machst.



sence hat gesagt.:


> Aber nun die Goldene Frage:
> Wieso wieder zurück in die Steinzeit gehen und wieder alles neu bauen, wenn man Objekte doch speichern kann, welche die Arbeit um ein vielfaches erleichtern ?


Dann reden wir über eine Objektorientierte Datenbank. Darin kann man tatsächlich Objekte speichern. Dann bist du bei mySQL aber falsch, denn mySQL ist eine relationale Datenbank. Du kannst aber einen O/R-Mapper wie Hibernate verwenden um eine entsprechende Funktionalität zu erhalten.



sence hat gesagt.:


> Um Persistenz für ein Objekt zu erreichen, kann es serialisiert werden. Hier wird der komplette Zustand des Objektes, inklusive aller referenzierten Objekte, in einen Datenstrom umgewandelt, der anschließend auf ein Speichermedium geschrieben wird.
> 
> jap das will ich!


Nein, willst du nicht.
Du willst eine Datenbank, keinesfalls Serialisierung.
Auch Objektorientierte Datenbanken arbeiten nicht mit Serialisierung sondern bilden Variablen auf Feldern ab.




Nur damit wir uns richtig verstehen:
Angenommen du willst Kunden mit den Angaben: ID, Name, Straße, PLZ, Ort speichern sieht die Relation so aus, dass du eine Tabelle mit den Feldern ID, Name, Straße, PLZ und Ort hast. NICHT eine Tabelle mit ID und einem BLOB mit einer serialisierten Java-Klasse darin.


----------



## tfa (25. Aug 2009)

sence hat gesagt.:


> deshalb please wie kann ich den Cast fehler beheben


Offensichtlich versuchst du ein byte-Array in ein "produkt"-Objekt zu casten. Das funktioniert nicht, da ein byte[] kein produkt ist. Das Array enthält die serialisierten Daten des Objekts. Das musst du erst deserialisieren, und zwar mit einem ObjectInputStream.


----------



## sence (25. Aug 2009)

ok ok ich gebe mich geschlagen ihr habt recht, aber das Angebot dass du mir hilfst mein Auto schieben, nehme ich gerne an, aber zum glück brauch ich das nicht -.-

gut dann werde ich nun mich damit auseinander setzten ,)

Aber trotzdem, nur aus intresse:
wieso ist der Cast fehlgeschlagen ?

falls ich mal dies dann wirklich benötigen sollte, und den selben Fehler habe, dass ich dann an diesen Threadzurück denken kann 

Dann sag ich mal vielen dank! und baue mir etwas, damit ich dies abbilden kann.
ja mit den Kunden habe ich es so realisiert, nein nicht mit der id und dem Object -.-


----------



## sparrow (25. Aug 2009)

Wenn du Auto fahren willst kannst du hier auch gerne fragen was du abbilden möchtest.
Wir helfen gerne ein Datenbankmodell zu erstellen bzw. dir Tipps zu geben.


----------



## sence (25. Aug 2009)

ok, du hast natürlich recht, es ist besser zu verwalten.

Könntet Ihr mir nen Tip geben, wie ich das Model aufbauen sollte, um die Produkte für jeden kunden in der Datenbank zu hinterlegen.

Mache mir gerade nen paar Zeichnungen wie ich es am besten realisieren könnte, jedoch weiß ich gerade nicht, wie ich mehrere produkte einem Kunden zu weißen kann und jedoch, jedes einzelne editieren kann :rtfm:

Vielen dank!


----------



## sparrow (25. Aug 2009)

Ich bin mir nicht ganz sicher was du vorhast, aber ich gehe mal von folgendem aus:
Es gibt einen Hardwarehersteller der PC-Systeme baut.

Was wollen wir Abbilden:
Wir wollen Komponenten in Servern verbauen.

Zuerst brauchen wir eine Tabelle KOMPONENTEN die alle Komponenten enthält die verbaut werden können. Eine weitere Tabelle SERVER die die Server darstellt indem Sie auf die Komponenten verweist.

Mal folgendes für Komponenten:
	
	
	
	





```
postgres=# SELECT * FROM komponenten;
 id |               name               
----+----------------------------------
  1 | 50 GB Seagate
  2 | Athlon XP+ 2500 Prozesso 123 FSB
  3 | Intel Mainboard
```

Dann brauchen wir die Datenbank SERVER_REL in etwa wie folgt:

```
postgres=# SELECT * FROM server_rel;
 id | komponente 
----+------------
  1 |          1
  1 |          2
  2 |          3
```

Du siehst, unsere Servertabelle ist eigentlich nur eine Verbindungstabelle zwischen Komponenten und Server. Eigentlich müsste es noch eine Tabelle geben die die IDs für die Server erstellt. Dort wo man quasi auch Notizen oder Namen für die Server hinterlegen kann:
	
	
	
	





```
postgres=# SELECT * FROM server;
 id | name 
----+------------
  1 |    Erster Server
  2 |    Zweiter Server
```



Was hat der Server 1 für Komponenten (Name)?:

```
postgres=# SELECT komponenten.name FROM server_rel LEFT JOIN komponenten ON (server_rel.komponente = komponenten.id) WHERE server_rel.id = 1;
               name               
----------------------------------
 50 GB Seagate
 Athlon XP+ 2500 Prozesso 123 FSB
(2 rows)
```

Vorteil: für jeden Artikel gibt es einen Eintrag in der Datenbank. Er wird dann nur dem entsprechenden Servern zugeordnet.


----------



## sence (25. Aug 2009)

schonmal vielen dank, solangsam kann ich mir damit was bauen, ohje dass wird eine Denkerei 

Das System welches ich gerade schreibe soll folgende funktionalität bieten:

Ich biete Hosting diensleitungen an, (Web, mail, ftp) und Dedicated (root) server
dazu kommen noch zusatzdienstleistungen wie Clustering, dann ggf noch zuzätzliche Hardware und co.

Nun kam ich deswegen auf die Idee mit Objekten zu arbeiten, da jeder Server z.B:
- Servername
- Server Adresse (IP)
- Recusiver DNS eintrag 
- cpu gesch.
- vorhandener Ram
- Festplatten anzahl und größe beinhaltet
- OS (Betriebssystem)

und wenn ein Kunde nun 2 oder Server oder sonstige Produkte bestellt, müssen diese 2 Produkte bei ihm abgebildet werden.

dafür dachte ich Objekte, nun sehe ich es ein, dass es ein Rießiger verwaltungsaufwand ist dies mit Objekten zu realisieren, wenn sich etwas ändert.

von der erschaffung finde ich es mit Objekten leichter, aber im nachhinein ist es mit der bearbeitung natürlich leichter Ohne Objekte.

Mit freundlichen Grüßen

Sence


----------



## sparrow (25. Aug 2009)

An sich hast du ja recht. Aus diesem Grund gibt es ja Hibernate das dir hilft Objekte direkt in der Datenbank abzubilden und dir das abzunehmen. Das braucht natürlich ein wenig Einarbeitungszeit.

Ansonsten kannst du dir merken: jedes Objekt muss auch in einer Relationalen Datenbank ebenso abgebildet werden wie als Objekt. So geht Hibernate ja auch vor. Das was man mit getter/setter ändertr bekommt ein Feld in der Datenbank.


----------



## sence (25. Aug 2009)

erstmal danke danke danke!!

sry wegen vorhin, jedoch wollte ich nicht alles preisgeben ,)

was würdest du nun vorschlagen, doch mit objekten zu arbeiten, oder mit der relationalen db

mein Gebiet ist eigentlich Linux und Systemadministration, mache Java nur nebenher.
habe bis jetzt J2SE komplett abgeschlossen und bin in der hälfte von J2EE, aber nun kommt das was mir noch fehlt, aber da ich gerade einiges an Servern zu arbeiten habe, habe ich nicht viel Zeit mich durch zu lesen, da ich noch das Studium nebenher mache 

deswegen war ich zimmlich fixiert :/

Mit freundlichen Grüßen

Sence


----------



## sparrow (25. Aug 2009)

Kein Grund sich zu entschuldigen, dass ist schon ok. Ich bin nur im Moment ein Freund klarer Worte.
Falls du irgend etwas studierst was mit -nformatik aufhört musst du dich früher oder später eh mit Datenbanken auseinander setzen.
Ich würde vorschlagen, dass du dich kurz in relationale Datenbanken einarbeitest. Der Schritt zu Hibernate ist dann nur noch ein kleiner.

Um ehrlich zu sein weiß ich gar nicht womit ich mal die Anfänge gemacht habe. Vertieft habe ich das Ganze aber im Studium.


----------



## sence (25. Aug 2009)

ne, Studiere gerade Linux Systemadministration, Lpic 1,2 und demnächst 3

mache es als Studium, da ich nebenher noch Netzwerkadministration mache, bleibt leider nicht als sooviel zeit für Java ,)

deswegen habe ich nur das gelernt, was in den Büchern darüber Stand, die Basics habe ich soweit intus, aber wenn es dann mit Join und co los geht, bin ich shcon wieder zu weit entfernt.
Netzwerk, und Linux :O
und durch den bestehenden aufbau der Unternehmung, ist nun noch weniger Zeit da, aber ich muss alles alleine Programmieren .....
da mein Kollege sich gerade in nem asp Studium befindet :O

Also würdest du mir Hibernate an herz legen dafür ?

oder eher mit den Tabellen realisieren (ich bin zwar kein Freund davon da ich viel dafür lernen muss und meine Zeit ....... naja) aber ohne bestehendes Portal geht es natürlich auch nicht!

greets


----------



## sparrow (25. Aug 2009)

Relationale Datenbanken. Danach erst Hibernate.
Falls du daran keinen Spaß hast, gib es den Kollegen 
Nein ernsthaft: das mit den Joins brauchst du auch mit Hibernate, daher solltest du dir das mit den Relationalen Datenbanken einfach anschauen. Das ist gar nicht schwer und gar nicht viel. Und die Grundlagen kannst du auch als Sysadmin gut gebrauchen.


----------



## sence (26. Aug 2009)

Hallo nochmal :- )

Also arbeite mich nun wie du sagtest nochmal von Grund auf in sql hinein, und erst dann mach ich mit hibernate weiter :- )

jedoch eine kurze frage, auch wenn ich dies mit Hibernate bald realisiere oder einem anderem System wie Hibernate (muss mich erstmal hinein arbeiten)

stell ich mir trotzdem immer noch die Frage, wie bekomme ich auf die "einfache" art das Object aus der Datenbank wieder heraus.

Habe es mit dem Input Stream versucht aber bekomme jedoch nen fehler dass der byte nicht zu object casten kann. ( brauche dafür noch ein erfolgserlebnis *g*)

der Type ist Blob, mache auch gerne Byte oder etwas anderes draus, (soweit bin ich noch nicht erst 4 Kapitel @ sql  )
kannst du mir nur sagen bitttte wie ich dies auf die 'unschöne' art auslesen kann.

hatte es so versucht:

```
java.sql.PreparedStatement st = connect.prepareStatement("SELECT produkt FROM user WHERE kdn='" + kdn + "'");
		ResultSet rs = st.executeQuery();
		produkt p = null;
		while(rs.next()) {
		Object object = rs.getObject(1);
		p = (produkt) object;
```
aber das ging nicht, da er sagt b cannot be cast to object, wie ich nun herausgefunden habe heißt b -> Byte.

und mit den Input stream komme ich nicht klar, würde nur gerne dies noch erleben, dass es klappt, und ich dies für irgendwann mal weiß 

Vielen Dank für deine Infos und Argumentationen!

Lg Marco


----------



## sence (27. Aug 2009)

Ok, brauchst nicht mehr, habe es nun...

für jeden den es Interresiert das Object wieder in seinen alten Zustand zu bekommen ist die Lösung wie folgt:

                            rs.next;
			    InputStream is = rs.getBlob(1).getBinaryStream();
			    ObjectInputStream ois = new ObjectInputStream(is);
			    Object x = ois.readObject(); 
                            DeineKlasse DKName = (DeineKlasse) x;
                            DKName.funktion;


----------



## tfa (27. Aug 2009)

Siehe auch Antwort #19


----------



## sence (27. Aug 2009)

jo, hatte es gelesen gehabt, hatte aber den Weg gesucht, nun hab ich ihn, und poste den kompletten weg. :- )


----------

