Mappage de plusieurs à un
Les associations de plusieurs à un sont les relations d'association les plus courantes, où un objet peut être associé à plusieurs objets. Par exemple, un objet d'adresse identique peut être associé à des objets de plusieurs employés.
Définir le Tableau SGBDR:
Considérez une situation où nous avons besoin de dossiers des employés à stocker dans le tableau des employés, qui aura la structure suivante:
Créer un employé de table (id int not null auto_increment, first_name varchar (20) par défaut null, last_name varchar (20) par défaut null, salaire int défaut, adress int not null, clé primaire (id));
En outre, de nombreux employés peuvent avoir la même adresse, de sorte que cette association peut être présentée en utilisant de nombreuses associations individuelles. Nous stockons les informations liées à l'adresse dans un tableau séparé avec la structure suivante:
Créer une adresse de table (id int not null auto_increment, street_name varchar (40) par défaut null, city_name varchar (40) par défaut null, state_name varchar (40) par défaut null, zipcode varchar (10) null, clé primaire (id));
Créez des tables RBDMS en même temps et laissez-les se préparer à la prochaine implémentation.
Définir la classe Pojo:
Implémentons un employé de la classe Pojo qui sera utilisé pour contenir des variables de l'objet et son type d'adresse avec la table des employés.
import Java.util. *; Employé de classe publique {private int id; String privé FirstName; String privé LastName; Salaire int privé; adresse privée; Employee public () {} Public Employee (String fname, String lname, int salaire, adresse d'adresse) {this.firstName = fname; this.lastName = lname; this.salary = salaire; this.address = adresse; } public int getID () {return id; } public void setid (int id) {this.id = id; } public String getFirstName () {return firstName; } public void setFirstName (String first_name) {this.firstname = first_name; } public String getLastName () {return lastName; } public void setLastName (string last_name) {this.lastname = last_name; } public int getSalary () {return salaire; } public void setsalary (int salaire) {this.salary = salaire; } Adresse publique getAddress () {Adresse de retour; } public void setAddress (adresse d'adresse) {this.address = adresse; }}Nous devons définir la table d'adresse correspondante afin que l'objet d'adresse puisse stocker et récupérer une autre classe POJO dans la table d'adresse.
Importer Java.util. *; Adresse de classe publique {private int id; Street à chaîne privée; ville de cordes privée; État de chaîne privée; Private String Zipcode; Adresse publique () {} Adresse publique (String Street, String City, String State, String Zipcode) {this.Street = Street; this.city = ville; this.state = state; this.zipcode = zipcode; } public int getID () {return id; } public void setid (int id) {this.id = id; } public String getStreet () {return street; } public void SetStreet (String Street) {this.street = street; } public String getCity () {return City; } public void setCity (String City) {this.city = ville; } public String getState () {return State; } public void setState (String State) {this.state = state; } public String getzipcode () {return zipcode; } public void setzipcode (string zipcode) {this.zipcode = zipcode; }} Définissez le fichier de mappage Hibernate:
Développez notre fichier de mappage qui instruit Hibernate Comment définir la carte des classes sur les tables de base de données. Les éléments de traitement <plusieurs à un> seront utilisés pour définir des règles pour établir une relation plusieurs à un entre les employés et les entités d'adressage.
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd // en" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> table = "Employee"> <meta attribut = "class-description"> Cette classe contient le détail des employés. </ meta> <id name = "id" type = "int" chronn = "id"> <générateur /> </ id> <propriété name = "firstName" chronn = "first_name" type = "string" /> <propriété name = "lastName" chronny = "last_name" type = "int" intwe colonnes = "adresse" not-null = "true" /> </ class> <class name = "adresse" table = "adresse"> <meta attribut = "class-description"> Cette classe contient le détail d'adresse. </ meta> <id name = "id" type = "int" chronn = "id"> <générateur /> </ id> <propriété name = "street" colonnen = "street_name" type = "string" /> <propriété name = "city" column = "city_name" type = "String" colonnes = "zipcode" type = "string" /> </ class> </ hibernate-mapping>
Le format <classname> .hbm.xml dans le fichier de mappage qui doit être enregistré. Enregistrez le fichier employee.hbm.xml dans le fichier de mappage. Déjà familier avec la plupart des détails de cartographie, mais examinons à nouveau tous les éléments du fichier de mappage:
Un document mappé est un document XML avec <Hibernate-Mapping> en tant qu'élément racine correspondant à chaque classe contenant 2 <classe>.
L'élément <scons> est utilisé pour définir un mappage spécifique de la table de base de données à partir d'une classe Java. Le nom de la classe Java spécifie l'attribut de nom de l'élément de classe et la base de données d'attribut de table Nom de la table Spécifie.
L'élément <Meta> est un élément facultatif qui peut être utilisé pour créer une description de la classe.
L'élément <id> mappe l'attribut ID unique dans la classe à la clé principale de la table de base de données. L'attribut de nom de l'élément ID fait référence à la classe de l'attribut et l'attribut de colonne fait référence aux colonnes de la table de base de données. L'attribut de type enregistre le type de mappage Hibernate, qui sera converti de Java en type de données SQL.
La valeur de clé primaire dans l'élément <générateur> dans l'élément ID est utilisée pour générer automatiquement. Définissez l'attribut de classe de l'élément généré pour nativement, laissez Hibernate ramasser les algorithmes de savoir s'il s'agit d'identité, de séquence ou de Hilo pour créer des clés primaires en fonction des capacités de support de la base de données sous-jacente.
L'élément <propriété> est utilisé pour cartographier les propriétés d'une classe Java aux colonnes dans une table de base de données. L'attribut de nom d'un élément fait référence à la classe de l'attribut et l'attribut de colonne fait référence aux colonnes de la table de base de données. L'attribut de type enregistre le type de mappage Hibernate, qui sera converti de Java en type de données SQL.
L'élément de traitement <plusieurs à un> est utilisé pour définir la relation entre l'employé et l'entité qui adresse. L'attribut de nom est défini sur une variable définie dans la classe parent, dans notre cas, c'est l'adresse. L'attribut de colonne est utilisé pour les noms de colonne dans l'ensemble des employés de la table parent.
Enfin, nous créerons la méthode principale () de la classe d'application pour exécuter l'application. Nous utiliserons cette application pour sauver certains employés avec leur adresse pour enregistrer leur adresse, puis nous demanderons l'opération CUD sur le dossier.
import java.util. *; import org.hibernate.hibernateException; import org.hibernate.Session; import org.hibernate.transaction; import org.hibernate.essionfactory; import org.hibernate.cfg.configuration; classe publique managemployee {private static sessionfactory factory; public static void main (String [] args) {try {factory = new Configuration (). configure (). buildSessionFactory (); } catch (Throwable ex) {System.err.println ("Échec de la création de l'objet SessionFactory." + Ex); Jetez une nouvelle exceptionIninializizerError (ex); } ManageMloyee me = new ManageMloyee (); / * Ayons un objet d'adresse * / adresse d'adresse = me.addaddress ("kondapur", "hyderabad", "ap", "532"); / * Ajouter des enregistrements des employés dans la base de données * / Integer empid1 = me.addemployee ("manoj", "kumar", 4000, adresse); / * Ajouter un autre enregistrement des employés dans la base de données * / Integer Empid2 = me.addemployee ("dilip", "kumar", 3000, adresse); / * Énumérez tous les employés * / me.listEmployee (); / * Mettre à jour les dossiers salariaux de l'employé * / me.updateEmployee (EMPID1, 5000); / * Supprimer un employé de la base de données * / me.DeleteEmployee (EMPID2); / * Énumérez tous les employés * / me.ListEmployees (); }! Transaction tx = null; Integer Address = NULL; Adresse d'adresse = null; try {tx = session.begintransaction (); adresse = nouvelle adresse (rue, ville, état, code postal); AddressId = (entier) session.save (adresse); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); } Adresse de retour; } / * Méthode pour ajouter un enregistrement des employés dans la base de données * / public Integer addEmployee (String fname, String lname, int salaire, adresse d'adresse) {session session = factory.opencession (); Transaction tx = null; EmployeeId entier = null; try {tx = session.begintransaction (); Employé employé employé = nouvel employé (FNAME, LNAME, salaire, adresse); EmployeeId = (entier) Session.Save (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); } return EmployeeId; }! Transaction tx = null; try {tx = session.begintransaction (); Lister les employés = session.CreateeQuey ("From Employee"). List (); pour (iterator iterator = employés.iterator (); iterator.hasnext ();) {employee employé = (employé) iterator.next (); System.out.print ("prénom:" + employee.getFirstName ()); System.out.print ("nom de famille:" + employee.getLastName ()); System.out.println ("Salaire:" + employee.getsalary ()); Adresse add = employee.getAddress (); System.out.println ("adresse"); System.out.println ("Street:" + add.getStreet ()); System.out.println ("City:" + add.getCity ()); System.out.println ("State:" + add.getState ()); System.out.println ("Zipcode:" + add.getzipcode ()); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }} / * Méthode pour mettre à jour le salaire pour un employé * / public void updateEmployee (entier EmployeeId, int salaire) {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Employé employé employé = (employé) session.get (employee.class, employeeId); Employee.SetSalary (salaire); Session.Update (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }} / * Méthode pour supprimer un employé des dossiers * / public void DeleteEmployee (EmployeeId entier) {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Employé employé employé = (employé) session.get (employee.class, employeeId); session.delete (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }}} Compiler et exécuter:
Voici les étapes pour compiler et exécuter l'application ci-dessus. Assurez-vous que Path et ClassPath sont définis de manière appropriée avant de compiler et d'exécuter.
Obtenez les résultats suivants à l'écran et les enregistrements sont créés à la fois dans l'employé et les tables d'adresse.
$ java managemployee
..... Divers messages de journal s'affichera ici ......... Prénom: Manoj Nom de famille: Kumar Salaire: 4000Address Street: Kondapur Ville: Hyderabad State: AP Zipcode: 532 Nom de Dilip Nom de famille: Kumar SALARY: 3000Address Street Street: Kondapur Ville: Hyderabad State: AP Zipcode: 532
Si vous vérifiez l'employé et la table d'adresse, vous devez l'enregistrer:
MySQL> SELECT * à partir de l'employé;
+ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mysql> sélectionner * dans l'adresse;
+ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Cartographie un-à-plusieurs
Une cartographie un-à-plusieurs peut être implémentée à l'aide d'un ensemble de collections Java qui ne contiennent pas d'éléments en double. Nous avons vu comment définir des cartes dans Hibernate, donc si vous avez appris les mappages de définition, tous les paramètres peuvent être utilisés pour les mappages un-à-plusieurs.
L'ensemble est mappé à l'élément <Set> de la table de carte et est initialisé dans java.util.hashset. Vous pouvez utiliser des collections SET dans une classe, avec un élément de la collection qui ne nécessite pas de duplication.
Nous utilisons toujours la table RDBMS et les classes POJO définies dans l'exemple ci-dessus.
Définissez le fichier de mappage Hibernate:
Instruisons HiberNate comment définir une classe mappée dans le fichier de mappage d'une table de base de données.
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd // en" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> table = "Employee"> <meta attribut = "class-description"> Cette classe contient le détail des employés. </ meta> <id name = "id" type = "int" chronn = "id"> <générateur /> </ id> <set name = "certificats" cascade = "all"> <key column = "Employee_id" /> <one-to-that type = "string" /> <propriété name = "salaire" chronn = "salaire" type = "int" /> </ class> <class name = "Certificate" table = "Certificate"> <meta attribute = "class-description"> Cette classe contient les enregistrements de certificat. </ meta> <id name = "id" type = "int" chronn = "id"> <générateur /> </ id> <propriété name = "name" colonnen = "certificate_name" type = "string" /> </ class> </ hibernate-mapping>
Le format <classname> .hbm.xml dans le fichier de mappage qui doit être enregistré. Nous enregistrons le fichier employee.hbm.xml dans le fichier de mappage. Vous connaissez déjà la plupart des détails de cartographie, mais examinons à nouveau tous les éléments du fichier de mappage:
Un document mappé est un document XML avec <Hibernate-Mapping> en tant qu'élément racine correspondant à chaque classe contenant 2 <classe>.
L'élément <scons> est utilisé pour définir un mappage spécifique de la table de base de données à partir d'une classe Java. Le nom de la classe Java spécifie l'attribut de nom de l'élément de classe et la base de données d'attribut de table Nom de la table Spécifie.
L'élément <Meta> est un élément facultatif qui peut être utilisé pour créer une description de la classe.
L'élément <id> mappe l'attribut ID unique dans la classe à la clé principale de la table de base de données. L'attribut de nom de l'élément ID fait référence à la classe de l'attribut et l'attribut de colonne fait référence aux colonnes de la table de base de données. L'attribut de type enregistre le type de mappage Hibernate, qui sera converti de Java en type de données SQL.
L'élément <générateur> dans l'élément ID est utilisé pour générer automatiquement la valeur de clé primaire. Définissez l'attribut de classe de l'élément généré pour laisser nativement Hibernate ramasser l'identité, la séquence ou les algorithmes HILO pour créer des clés primaires en fonction des capacités de support de la base de données sous-jacente.
L'élément <propriété> est utilisé pour cartographier les propriétés d'une classe Java aux colonnes dans une table de base de données. L'attribut de nom d'un élément fait référence à la classe de l'attribut et l'attribut de colonne fait référence aux colonnes de la table de base de données. L'attribut de type enregistre le type de mappage Hibernate, qui sera converti de Java en type de données SQL.
L'élément <Set> définit la relation entre le certificat et la classe des employés. Nous utilisons l'élément <Set> dans l'attribut Cascade pour dire Hibernate pour enregistrer l'objet de certificat et être également l'objet employé. L'attribut de nom est défini sur l'ensemble des variables définies dans la classe parent, dans notre exemple est le certificat. Pour chaque ensemble de variables, nous devons définir un ensemble distinct d'éléments dans le fichier de mappage.
L'élément <yey> est l'objet parent contenant une clé étrangère, c'est-à-dire la colonne de la table de certificat. Employé de table.
L'élément <o-à-many> indique qu'un objet employé implique de nombreux certificats.
Créer une classe d'application:
Enfin, nous créerons la méthode principale () de la classe d'application pour exécuter l'application. Nous utiliserons cette application pour enregistrer certains employés avec le certificat d'enregistrement, puis nous appliquerons l'enregistrement de l'opération CRUD.
import java.util. *; import org.hibernate.hibernateException; import org.hibernate.Session; import org.hibernate.transaction; import org.hibernate.essionfactory; import org.hibernate.cfg.configuration; classe publique managemployee {private static sessionfactory factory; public static void main (String [] args) {try {factory = new Configuration (). configure (). buildSessionFactory (); } catch (Throwable ex) {System.err.println ("Échec de la création de l'objet SessionFactory." + Ex); Jetez une nouvelle exceptionIninializizerError (ex); } ManageMloyee me = new ManageMloyee (); / * Avons un ensemble de certificats pour le premier employé * / hashset set1 = new HashSet (); set1.add (nouveau certificat ("MCA")); set1.add (nouveau certificat ("MBA")); set1.add (nouveau certificat ("MBA")); set1.add (nouveau certificat ("PMP")); / * Ajouter des enregistrements des employés dans la base de données * / Integer empid1 = me.addemployee ("manoj", "kumar", 4000, set1); / * Un autre ensemble de certificats pour le deuxième employé * / hashset set2 = new HashSet (); set2.add (nouveau certificat ("BCA")); set2.add (nouveau certificat ("ba")); / * Ajouter un autre enregistrement des employés dans la base de données * / Integer Empid2 = me.addemployee ("dilip", "kumar", 3000, set2); / * Énumérez tous les employés * / me.listEmployee (); / * Mettre à jour les dossiers salariaux de l'employé * / me.updateEmployee (EMPID1, 5000); / * Supprimer un employé de la base de données * / me.DeleteEmployee (EMPID2); / * Énumérez tous les employés * / me.listEmployee (); } / * Méthode pour ajouter un enregistrement des employés dans la base de données * / public Integer addEmployee (String fname, String lname, int salaire, set Cert) {session session = factory.opencession (); Transaction tx = null; EmployeeId entier = null; try {tx = session.begintransaction (); Employé employé Employé = nouvel employé (FNAME, LNAME, SALAIRE); Employee.SetCertificates (CERT); EmployeeId = (entier) Session.Save (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); } return EmployeeId; }! Transaction tx = null; try {tx = session.begintransaction (); Lister les employés = session.CreateeQuey ("From Employee"). List (); pour (iterator iterator1 = employés.iterator (); iterator1.hasnext ();) {employee employé = (employé) iterator1.next (); System.out.print ("prénom:" + employee.getFirstName ()); System.out.print ("nom de famille:" + employee.getLastName ()); System.out.println ("Salaire:" + employee.getsalary ()); Set Certificates = Employee.GetCertificates (); for (iterator iterator2 = certificate.Itorator (); iterator2.hasnext ();) {Certificate Certname = (Certificate) iterator2.Next (); System.out.println ("Certificat:" + certname.getName ()); }} tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }} / * Méthode pour mettre à jour le salaire pour un employé * / public void updateEmployee (entier EmployeeId, int salaire) {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Employé employé employé = (employé) session.get (employee.class, employeeId); Employee.SetSalary (salaire); Session.Update (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }} / * Méthode pour supprimer un employé des dossiers * / public void DeleteEmployee (EmployeeId entier) {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Employé employé employé = (employé) session.get (employee.class, employeeId); session.delete (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }}} Compiler et exécuter:
$ java managemployee
..... Divers messages de journal s'affichera ici ......... Prénom: Manoj Nom de famille: Kumar Salaire: 4000Certificate: Mbacertificate: PMPCertificate: McAfirst Nom
Si vous vérifiez l'employé et le formulaire de certificat, vous devez l'enregistrer:
MySQL> SELECT * à partir de l'employé;
+ ---------------------------- + ---------- + | ID | First_name | Last_name | Salaire | + ------------------------------------ + ------------ + ---------- + | 1 | Manoj | Kumar | 5000 | + -------------------------------- + --------- + 1 ligne en jeu (0,00 sec)
mysql> sélectionner * dans le certificat;
+ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------