# Hibernate Datensätze finden



## casi91 (30. Nov 2011)

Hallo Community
ich habe mal wieder eine Frage zu Hibernate und hoffe ihr könnt mir weiterhelfen 

Ich habe folgende Tabellen in meiner DB: Unternehmen und Filiale
Ein Unternehmen kann mehrere Filialen haben [1:n]

Mein Vorhaben ist nun, wenn ein Unternehmen ausgewählt wurde, alle zugehörigen Filialen zu laden.
Mein Unternehmenobjekt habe ich. Nur weiß ich nicht, wie ich nun alle Filialen bekomme.

Hier meine Unternehmen.java:

```
@Entity
@Table (name = "UNTERNEHMEN")
public class Unternehmen {
	private Integer ID;
	private String  Name;
	private Set <Filiale> filiale = new HashSet<Filiale>();
	
	public Unternehmen()
	{
	}

	public Unternehmen(String sName)
	{
		this.Name = sName;
	}
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")
	public Integer getID() {
		return ID;
	}

	public void setID(Integer iD) {
		ID = iD;
	}

	@Column(name = "NAME")
	public String getName() {
		return Name;
	}

	public void setName(String name) {
		Name = name;
	}
	
	
	@OneToMany
	public Set <Filiale> getFiliale()
	{
		return filiale;
	}
	
	public void setFiliale (Set <Filiale> filiale) {
		this.filiale = filiale;
	}		
}
```

und hier meine Filiale.java:

```
@Entity
@Table(name="FILIALE")
public class Filiale {

	private Integer ID;
	private Standort MyOrt;
	private String Name;
	
	private Unternehmen MyUnternehmen;
	
	public Filiale() {
	}

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")	
	public Integer getFiliale_ID() {
		return ID;
	}


	public void setFiliale_ID(Integer filiale_ID) {
		ID = filiale_ID;
	}

	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "OrtID", insertable=true, updatable=true)	
	public Standort getMyOrt() {
		return MyOrt;
	}

	public void setMyOrt(Standort myOrt) {
		MyOrt = myOrt;
	}

	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "UnternehmenID", insertable=true, updatable=true)		
	public Unternehmen getMyUnternehmen() {
		return MyUnternehmen;
	}

	public void setMyUnternehmen(Unternehmen myUnternehmen) {
		MyUnternehmen = myUnternehmen;
	}		

	@Column(name = "Name")	
	public String getName() {
		return Name;
	}

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

Ich dachte, dass ich über die "getFiliale" irgendwie meine Filialen bekomme.
Bei einem Anderen Konstrukt bekomme ich auch meine Daten.

(Ein Ort kann zu einem Land gehören, ein Land kann mehrere Orte haben)
Wenn ich hier ein Ortobjekt habe, bekomme ich durch getLand genau das Landobjekt das zu diesem Ort gehört)
Ja ich weiß, dass das genau umgekehrt ist ^.^


Hoffe ihr könnt mir helfen


----------



## casi91 (30. Nov 2011)

Kurz als Beispiel:
So würde das zugehörige SQL aussehen:


```
Select * from FILIALE
INNER JOIN UNTERNEHMEN
ON FILIALE.UNTERNEHMENID = UNTERNEHMEN.ID
```


----------



## casi91 (30. Nov 2011)

Niemand eine Lösungsidee oder einen Vorschlag der das Problem löst?
Das muss doch irgendwie gehen.. ;(


----------



## SlaterB (30. Nov 2011)

was ist denn deine Frage? geht es dir um eine HQL-Anfrage oder um korrektes Mapping so dass getFiliale() zu jeder Zeit korrekt befüllt ist?
um letzteres doch wohl 

hast du je ein Tutorial mit korrekten Beispiel für Liste/ Set angeschaut/ zum Laufen gebracht?
ich selber verwende Annotations nicht, wenn ich 
Hibernate Annotations
anschaue dann soll man da noch mappedBy oder JoinColumn oder ähnlich komisches angeben?

nebenbei sprichst du verwirrenderweise auch noch von Orten und Ländern,
funktioniert es dort? ist dort das Mapping anders?

--------

äußerst dringend solltest du dir korrekte Schreibweise angewöhnen:
Variablen beginnen mit Kleinbuchstaben, in CamelCase maximal ab und zu ein Großbuchstabe, nie zwei hintereinander,
und auf keinen Fall _ in Variablen oder Methodennamen,

außerdem heißen die getter und setter genau wie die Variablen, nur mit Großbuchstaben,
also entweder

```
public Integer getId() {
    return id;
}
```
oder

```
public Integer getFilialeId() {
    return filialeId;
}
```

statt

```
public Integer getFiliale_ID() {
    return ID;
}
```
oder sonstiger unmöglicher Varianten


----------



## casi91 (1. Dez 2011)

Erst mal danke für die Antwort.
Mit der Schreibweise hast du recht, das kommt davon, wenn man sich nen teil generieren lässt dann was ändert aber nicht mehr alles Kontrolliert.
Sorry, wenn das Probleme beim lesen macht.

Und das mit Ort und Land habe ich nur angefügt, um zu sagen das diese Richtung klappt.
Ort zu Land:
Ein Ort kann genau zu einem Land gehören, ein Land kann mehrere Orte haben [1:n]
Bei dieser Konztelation, möchte ich zu meinem Ort, das dazugehörige Land haben (wie erwähnt, funktioniert)
Hier mal der Quelltext dazu:

(Ort

```
@Entity
@Table( name = "STANDORT")
public class Standort {

	private Integer ID;
	private Integer PLZ;
	private String  Ort;

	private Land myLand;
	
	public Standort() 
	{
	}
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")	
	public Integer getID() {
		return ID;
	}

	public void setID(Integer iD) {
		ID = iD;
	}

	@Column(name = "PLZ")
	public Integer getPLZ() {
		return PLZ;
	}

	public void setPLZ(Integer iPLZ) {
		PLZ = iPLZ;
	}


	@Column(name = "BEZEICHNUNG",insertable=true, updatable=true)
	public String getOrt() {
		return Ort;
	}


	public void setOrt(String iOrt) {
		this.Ort = iOrt;
	}
	

	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "LANDID", insertable=true, updatable=true)
	public Land getMyLand() {
		return myLand;
	}

	public void setMyLand(Land myLand) {
		this.myLand = myLand;
	}	
}
```

(und Land

```
@Entity
@Table( name = "LAND")
public class Land {
	
	private Integer ID;
	private String Bezeichnung;
	private Set <Standort> standort = new HashSet<Standort>();
	
	public Land()
	{
	}
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")
	public Integer getID() {
		return ID;
	}
	public void setID(Integer iD) {
		ID = iD;
	}
	
	@Column(name = "BEZEICHNUNG", insertable=true, updatable=true)
	public String getBezeichnung() {
		return Bezeichnung;
	}
	public void setBezeichnung(String bezeichnung) {
		Bezeichnung = bezeichnung;
	}

	
	@OneToMany
	public Set <Standort> getStandort() {
		return standort;
	}

	public void setStandort(Set <Standort> standort) {
		this.standort = standort;
	}	
}
```

So mein Problem (wie oben beschrieben) ist nun, dass ich zu einem Unternehmen alle Filialen finden möchte.

(Im Beispiel Ort und Land wäre es also: finde alle Orte die zu diesem Land gehören)

Diese richtung funktioniert nicht!
Das mit mappedBy muss ich mir mal noch genauer ansehen. Danke schonmal für den Hinweis.

Darf man Nachfragen warum zu keine Annotations verwendest?
Einfach weil du diese nicht magst, oder haben die einen schwerwiegenden Nachteil?

Nochmal Entschuldigung, wenn meine Anfrage nicht deutlich war.
Ich hoffe ich konnte meine Frage jetzt deutlicher machen


----------



## SlaterB (1. Dez 2011)

- ich finde, die Mapping-Variante ist besser dokumentiert
Hibernate – One-to-Many example (XML Mapping)
ok, wenn man sucht findet man dasselbe vielleicht auch für Annotations:
Hibernate Mapping One-to-Many using Annotations Example
von 'inverseJoinColumns' habe beim Mapping aber noch nie gehört

- ich kann mich kaum oder nur selten an Problem-Threads wie diese hier fürs Mapping erinnern, aber das mag subjektiv gefärbt sein,
und vielleicht nutzt nur niemand mehr Mappings 

- und ich finde es grundsätzlich schöner wenn die Bean-Klassen nahezu frei von fremden Code sind, 
theoretisch gleichzeitig auch mit einer anderen Mapping-Datei in einem anderen DB-Framework gespeichert werden könnten,
ein Bean hat eine Id und Eigenschaften zu haben, das ist universelle Grundlage, selbst ohne SQL-Datenbank nicht falsch, 
Hibernate-spezifisches hat darin nichts zu suchen

- außerdem mag ich Annotations generell nicht , stehen außerhalb aller OO-Konzepte, aber das gilt für XML-Dateien auch kaum besser


----------



## casi91 (1. Dez 2011)

Vielen Dank für den Link 

werde mir das direkt ansehen und hoffe, dass es mir auch weiterhilft 
(Frage mich, wie mir diese Seite, bzw. dieses Beispiel bei meiner bisherigen Suche durch die Lappen gehen konnte...aber ok ^.^)

Das mit dem fremden Code stimmt, andererseits ist dann aber auch alles an einer Stelle.
Ich hatte ganz am Anfang als ich mich in Hibernate angefangen habe, die Mapping-Variante genutzt.
Und damit ich beide Varianten gesehen habe, auch die Annotations versucht.
Die mir dann irgendwie (aus oben genanntem Grund) besser gefallen haben und ich hatte das Gefühl, dass der Trend auch zu Annotations geht (kann mich auch irren)

Aber das muss jeder für sich entscheiden 
Und wer weiß, vielleicht stell ich das ganze irgendwann auch auf mapping um

Aber das werden wir sehen, wenn ich mal ans richtige Programmieren komme und nicht mehr "rumspiele und teste"

Nochmals Danke und sobald ich rausgefunden habe wie ich das Problem löse (hoffentlich durch den Link) schreib ich es natürlich hier rein


----------



## casi91 (1. Dez 2011)

Was mich nur grad bei dem Beispiel (Link) wundert.
Bei einer 1:n Relation, brauche ich doch keine Zwischentabelle!?

Also Ich würde da den Student in der Tabelle Phone hinterlegen.
Oder sehe ich das falsch?

War nur kurz ne Anmerkung, ich versuchs weiterhin zum laufen zu bekommen


----------



## casi91 (1. Dez 2011)

Sooo
ich komme der Sache näher.
Ich finde nun alle Filialen zu einem Unternehmen :applaus:

Jedoch bekomm ich an manch einer Stelle zu viele Daten, oder auch mal Daten doppelt.
Da muss ich jetzt noch rausfinden, woran das liegt.

Sobald ich mal eine lauffähige Version dieses Beispiels habe. Werde ich die Lösung posten, damit evtl später suchende was zu lesen haben :-D

Danke nochmal für die Links
hatte letztendlich aber noch einen anderen Link gefunden der mir geholfen hat:
@OneToMany Relationship with Java, Hibernate and Annotations | united-coders.com


----------



## casi91 (2. Dez 2011)

So, hier bin ich wieder.
Folgend nun mein Beispiel zu einer 1:n relation mit Hibernate und Annotations.

Nochmal zum auffrischen: 
Ein Unternehmen kann mehrere Filialen haben, eine Filiale kann zu genau einem Unternehmen gehören.

Unternehmen.java:

```
@Entity
@Table (name = "UNTERNEHMEN")
public class Unternehmen implements Serializable {

	private Integer ID;
	private String  Name;
	
	
	private Set <Filiale> filiale = new HashSet<Filiale>();
	
	public Unternehmen()
	{
	}

	public Unternehmen(String sName)
	{
		this.Name = sName;
	}
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")
	public Integer getID() {
		return this.ID;
	}

	public void setID(Integer iID) {
		this.ID = iID;
	}

	@Column(name = "NAME")
	public String getName() {
		return this.Name;
	}

	public void setName(String sName) {
		this.Name = sName;
	}
	
	@OneToMany(fetch=FetchType.EAGER, cascade = CascadeType.ALL, mappedBy="myUnternehmen")
	public Set <Filiale> getFiliale()
	{
		return filiale;
	}
	
	public void setFiliale (Set <Filiale> filiale) {
		this.filiale = filiale;
	}
}
```

Filiale.java

```
@Entity
@Table(name="FILIALE")
public class Filiale implements Serializable {

	private Unternehmen myUnternehmen;
	
	private Integer ID;
	
	public Filiale() {
		// TODO Auto-generated constructor stub
	}

	
	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = "UnternehmenID", insertable=true, updatable=true)
	public Unternehmen getMyUnternehmen() {
		return this.myUnternehmen;
	}

	public void setMyUnternehmen(Unternehmen myUnternehmen) {
		this.myUnternehmen = myUnternehmen;
	}		
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY) 
	@Column(name = "ID")	
	public Integer getID() {
		return this.ID;
	}

	public void setID(Integer iID) {
		this.ID = iID;
	}
}
```

Es ist darauf zu achten, dass die zu mappende Variable (myUnternehmen) *AUF JEDEN FALL* mit einem Kleinbuchstaben beginnt.
Andernfalls hat Hibernate probleme und kann es nicht richtig verbinden.

Eine m:n relation funktioniert wie in diesem Link beschrieben (danke an SlaterB)
Hibernate Mapping One-to-Many using Annotations Example

Hoffe es Hilft jemandem, der an einer ähnlichen Stelle steht wie ich.

Ps.:
@SlaterB 
Habe meine Schreibweise nun mal der angepasst, wie ich sie in meiner Ausbildung gelernt habe.
Sprich, eine Variable beginnt mit einem Kleinbuchstaben, der Kennzeichnet von welchem Typ die Variable ist (Beispiel: Integer iID)

Finde das recht praktisch, weil man so im Quellcode nie die Übersicht verliert.
Aber das ist meine Meinung 
Hoffe es ist annehmbar ;-)


----------



## SlaterB (2. Dez 2011)

> (Beispiel: Integer iID)
sehe ich in deinem Code nicht so (edit: also in Filiale  ),

wie du damit andere Leser mehr oder weniger quälst ist eine Sache,
ich rate dir das vor allem zur Vermeidung von echten Java-Problemen, 
mag sein dass mit Hibernate alles funktioniert, 
ein anderes interessantes Gebiet, welches ich kenne sind dann noch Web-Frameworks mit speziellen Skriptsprachen, JSP, JSTL, JSF, falls dir davon was sagt,
xut="{beanX.id}" usw.
ob die auch mit abweichenden Standard zurechtkommen ist dann die Frage..

edit:
ein weiterer Punkt wäre übrigens, dass der zweite Buchstabe kein Großbuchstabe sein sollte,
denn selbst vermeintlich gutes iId würde zu getIId() mit zwei Großbuchstaben hintereinander führen,
ich bin da wohl überparanoid, aber einfach komplett unnötig, solche Anomalien einzubauen,


----------



## maki (2. Dez 2011)

Die sog. "Hungarian Notation", also dass der Typ im Variablennamen vorkommt, zB. [c]iId[/c], ist nicht annehmbar 

Halte dich an die Javakonventionen, dazu gehören auch die JavaBean Konventionen.

Anstatt [c]ID[/c] -> [c]id[/c] usw.
Anstatt 

```
public void setID(Integer iID) {
        this.ID = iID;
    }
```
besser:

```
public void setId(final Integer id) {
        this.id = id;
   }
```

Ist für dich als Anfägner noch am besten geeignet 

Ausserdem wird empfohlen, die Annotationen an das Attribut zu machen anstatt an die Getter.


----------



## casi91 (2. Dez 2011)

Wusste garnicht, dass die Notation "Hungarian Notation" heißt.
Wieder was gelernt :toll:

Wie erwähnt, in meiner Ausbildung wurde mir diese Notation beigebracht (war aber auch die Programmiersprache "Visual Dataflex") und ich fand das auch irgendwie praktisch.

Aber ok,
wenn diese Notation in JAVA nichts zu suchen hat, werde ich das ändern und mich an die von euch geschilderte JAVA Notation halten.
(schließlich möchte ich andere JAVA-Entwickler nicht quälen, vorallem die nicht, die mir helfen)

Und das die Annotationen über das Attribut sollen, kommt mir sehr gelegen.
Da ich es bisher nur anders gesehen habe, dachte ich, dass macht man so. :bahnhof:

Werde ich dann natürlich auch umgehend ändern.
Danke für die Hilfe.

Edit:
@maki
kann es sein, dass du in deinem Post was vertauscht hast?
Weil du stellst meine Variante als die bessere da, wenn ich mich nicht verlesen


----------



## maki (2. Dez 2011)

Ja hab ich vertauscht, korrigiere gleich...


----------



## casi91 (2. Dez 2011)

kurze Frage noch zur Namenskonvention.

Wenn ich eine Ansicht habe, die mehrere permanente Objekte (Buttons, Textfelder, Labels etc.) beinhaltet.
Wie benennt man diese am besten?

gelernt habe ich (Beispiel: Label): oLbl_Objekt

sehe ich das richtig, dass ich ein solches Objekt dann: lblObjekt nennen würde?


----------



## maki (2. Dez 2011)

Keine Präfixe, keine Underscroes 

objectLabel wenn es denn als Label erkennbar sein soll, sowie objectButton etc. pp.
Ist zwar auch ein bisschen Hungarian Notation, aber i.O. IME.

Code Conventions for the Java(TM) Programming Language: Contents
JavaBean - Wikipedia, the free encyclopedia


----------



## casi91 (2. Dez 2011)

So da mein Problem ja gelöst ist und ich die Lösung (auch wenn mit falscher Namenskonvetion) gepostet habe, schließe ich das Thema, da es denke ich sonst zu sehr um andere Sachen geht und ich dafür wohl besser ein neues Thema erstellen würde.


----------



## SlaterB (2. Dez 2011)

Suffixe sind auch nichts anderes als Präfixe,
gerade bei GUI-Komponenten durchaus denkbar,
buttonStart;
buttonStop;
usw.


----------

