Génération BD avec JPA

Version imprimable

Bonjour .

je suis entrain d'essayer de générer une BD grâce aux annotation jpa de hibernate je problème c'est les one to many , many to one :)

Je trouve pas d'exercice avec corrigé pour bien comprendre

j'essaye en ce moment de générer cette BD

http://img98.imageshack.us/img98/965...0110819091.png

j'ai pu faire cela mais je m'endort pas avec les relation entre table
Class Hotel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 
@Entity
@Table(name="Hotel")
public class Hotel {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="idHotel")
	private String idHotel;
 
 
	@Column(name="nomHotel")
	private String nomHotel;
 
 
	@Column(name="adressHotel")
	private String adressHotel;
 
 
	@Column(name="pays")
	private String pays;
 
	@Column(name="region")
	private String region;
 
	@Column(name="ville")
	private String ville;
 
	@Column(name="etoile")
	private Integer etoile;
 
 
	@OneToMany(mappedBy="Hotel")
	private List<Chambre> chambreList;
 
}

Class Client

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Entity
@Table(name="Client")
public class Client {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="numClient")
	private Integer numClient;
 
	@Column(name="nameClient")
	private String nameClient;
 
	@Column(name="adressClient")
	private String adressClient;
 
	@Column(name="phoneClient")
	private String phoneclient;
 
	@Column(name="dateNaissance")
	@Temporal(TemporalType.DATE)
	private Calendar dateNaissance;
 
	@Column(name="email")
	private String email;
 
	@Column(name="codePostale")
	private Integer codePostale;
 
	@Column(name="typeCard")
	private String typeCard;
 
	@Column(name="numCard")
	private String numCard;
 
	@Column(name="dateExpiration")
	@Temporal(TemporalType.DATE)
	private Calendar dateExpiration;
 
 
 
}

Class Reservation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Entity
@Table(name="Reservation")
public class Reservation {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="numReservation")
	private Integer numChambre;
 
	@Column(name="debutReservation")
	@Temporal(TemporalType.DATE)
	private Calendar debutReservation;
 
 
	@Column(name="finReservation")
	@Temporal(TemporalType.DATE)
	private Calendar finReservation;
 
	@Column(name="dateReservation")
	@Temporal(TemporalType.DATE)
	private Calendar datereservation;
 
 
	@Column(name="prix")
	private Double prix;
 
 
	@Column(name="libelleReservation")
	private String libelleReservation;
 
 
	@OneToMany(mappedBy="Reservation")
	private List<Client> ClientList;
 
}

Class chambre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Entity
@Table(name="Chambre")
public class Chambre {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="numChambre")
	private Integer numChambre;
 
	@Column(name="prixChambre")
	private Double prixChambre;
 
	@Column(name="nombreLit")
	private Integer nombreLit;
 
	@Column(name="disponible")
	private boolean disponible;
 
	@OneToMany(mappedBy="Chambre")
	private List<Reservation> reservationList;
 
}

Class ChaineHotel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
@Entity
@Table(name="ChaineHotel")
public class ChaineHotel {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="codeChaine")
	private Integer codeChaine;
 
	@Column(name="nomChaine")
	private String nomChaine;
 
}

Si c'est possible de m'éclairer sur les relation entre tables

Code:

1 2 @OneToMany(mappedBy="Hotel") private List<Chambre> chambreList;
mappedBy ne précisse pas quelle classe gère la relation mais "quelle propriété dans l'autre classe est utilisée pour gérer la relation. Ainsi tu devrais normalement avoir
Code:

1 2 3 4 5 6 7 8 9 public class Hotel { @OneToMany(mappedBy="hotel") private List<Chambre> chambreList; } public class Chambre { @ManyToOne private Hotel hotel; }
si tu ne veux pas de propriété Hotel dans Chambre (relation unidirectionelle), ca deviendrais
Code:

1 2 3 4 5 public class Hotel { @OneToMany(orphanRemoval=true) @JoinColumn(name="HOTEL_ID") // colonne HOTEL_ID dans table CHAMBRE private List<Chambre> chambreList; }

19/08/2011, 12h09
Fatemy

oula super compliquer tous ça :s ou bien ça vient su fait que j'ai pas fermer l'oeil depuis 48h

je vais essayer d'étudier cela merci et je me demandais si c'était possible de me procurez une petite correction que je pourrais utiliser pour comprendre :)
19/08/2011, 23h40
Fatemy

Personne ne sait résoudre cet éxércice ??? je déprime la !!
22/08/2011, 11h02
PhilippeGibault
Pour la relation Hotel-Client, il n'y a pas de lien (selon le schéma UML) entre ces deux entités. Ne ne comprend pas l'intérêt de ce bout de code dans la classe client:
Code:

1 2 3 @OneToMany(mappedBy="Hotel") private List<Chambre> chambreList;
Faisons le premier lien:
Lien Client-Réservation (si je comprend bien, à un client 0-N réservation mais à une réservation un client).

Dans la classe Client, tu vas avoir:
Code:

1 2 3 @OneToMany(fetch=FetchType.Eager,mappedBy="client") private Set<Reservation> reservations
OneToMany car à un client correspond plusieurs réservations.
mappedBy:voir plus loin.
Un Set est généralement préféré à une List.
Et fetch=FetchType.Eager signifie que quand tu chargera le client tu chargera en mémoire toutes ses réservations. Si tu ne le souhaite pas, tu remplace FetchType.Eager par FetchType.Lazy.

Ensuite, dans la classe Reservation, tu as:
Code:

1 2 3 4 @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="id_client",nullable=false) private Client client
Comme ça, tu mappes, la join column signifie que tu auras dans la table client de la BDD une colonne id_client correspondant à une clé secondaire.
nullable=false signifie que dans la BDD, cette colonne ne pourras pas être nulle.

Pour conclure, je pense qu'il faut voir Hibernate comme un framework ORM, qui va faire le lien entre le modèle objet côté Java et le modèle relationnel dans la base.

C'est pour ça que la meilleur façon d'aborder les chose est d'avoir le modèle objet, de faire parallèlement le modèle relationnel, et de voir si les deux sont optimisé et que le lien entre les deux est correct.

Je te laisse faire les autres relations.
23/08/2011, 03h58
Fatemy

Gros merci je commence a comprendre maintenant tous ça et ça marche !!!

je voudrais savoir l'intérêt d'utiliser JPA pour générer la base quél différence entre ça et la manière normal (SGBD)

encore merci
23/08/2011, 09h03
tchize_

tu t'emmerde pas à gérer les connexion, les SQL, les DAO et les objets de transfert.
23/08/2011, 14h15
PhilippeGibault

Le modèle de persistance évolue dans le magnifique mode objet java alors que la BDD évolue dans le monde relationnel.

Les deux mondes se détestes et fonctionnent différemment.

Par exemple, le monde objet a l'héritage...

Le monde relationnel a les tables de jointures...

JPA/Hibernate permet de faire le lien entre ces deux mondes.