annotation
L'annotation Hibernate est une dernière méthode qui n'utilise pas de fichiers XML pour définir les mappages. Les annotations peuvent être utilisées dans les métadonnées de cartographie XML qui sont séparées ou remplacées.
Les annotations d'Hibernate sont un moyen puissant de fournir des mappages d'objets de métadonnées et de tables relationnelles. Toutes les métadonnées sont paniquées avec le fichier Pojo Java. Cela peut aider les utilisateurs à comprendre la structure de la table et du POJO pendant le processus de développement.
Si vous avez l'intention de porter l'application vers d'autres applications ORM spécifiques à EJB3, vous devez utiliser des annotations pour représenter les informations de mappage, mais si vous voulez une plus grande flexibilité, vous devez utiliser le mappage basé sur XML.
En définissant d'abord l'annotation hibernate dans l'environnement, vous devez vous assurer que vous utilisez JDK5.0, sinon, vous devez mettre à niveau JDK vers la prise en charge native JDK5.0 avec annotations.
Deuxièmement, vous devez installer le package de distribution d'annotation 3.x de Hibernate, vous pouvez utiliser Sourceforge: (télécharger Hibernate Annotation) et copier Hibernate-Annotations.jar, lib / hibernate-comons-annotations.jar et lib / ejb3-persistence.jar pour attribuer des annotations Hibernate à Classpathes de Hibernate Annotations.
Instance de classe commentée:
Comme mentionné, toutes les métadonnées qui fonctionnent avec l'annotation Hibernate fonctionnent dans le fichier Pojo Java ci-dessus peuvent aider les utilisateurs à comprendre à la fois la structure du tableau et le POJO pendant le développement.
Considérez l'objet qui sera stocké à l'aide du tableau des employés suivants:
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 null, clé primaire (id));
Ce qui suit est la cartographie de la classe des employés de l'objet avec des annotations pour mapper avec la table des employés définis:
Importer javax.persistence. *; @ entité @ table (name = "employee") classe publique Employee {@id @generatedValue @Column (name = "id") private int id; @Column (name = "First_name") String privé FirstName; @Column (name = "last_name") String privé LastName; @Column (name = "salaire") Salaire privé int; Public Employee () {} 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; }}Hibernate détecte que l'annotation @ID est contre un champ et suppose qu'il doit accéder aux propriétés d'un objet directement via le domaine d'exécution. Si @Id est annoté avec la méthode getID (), la propriété sera accessible par défaut via Getter et Methods Setter. Par conséquent, tous les autres commentaires sont également placés dans le champ ou la méthode Getter, tel que sélectionné sous la politique. La section suivante explique les commentaires utilisés dans la classe ci-dessus.
@Entity Annotation:
La description de la spécification EJB3 est incluse dans le package Javax.Persistence, nous importons donc ce package comme première étape. Deuxièmement, nous avons utilisé l'annotation @entity pour marquer cette classe en tant que classe d'employée de bean d'entité, il doit donc avoir un constructeur sans paramètre, qui est enfin visible avec la protection.
@Table Annotation:
L'annotation @Table permet à la table spécifiée d'être utilisée pour contenir des informations détaillées sur l'entité dans la base de données.
L'annotation @Table fournit quatre propriétés qui permettent de remplacer le nom de la table, son répertoire, son schéma et l'exécution de contraintes uniques sur les colonnes du tableau. Maintenant, nous utilisons le nom de la table des employés tout à l'heure.
@ID et @GeneratedValue Annotations:
Chaque haricot d'entité aura une clé primaire annotée dans l'annotation @ID de la classe. La clé primaire peut être un champ unique ou une combinaison de plusieurs champs en fonction de la structure du tableau.
Par défaut, l'annotation @ID détermine automatiquement la stratégie de génération de clés principale la plus appropriée à utiliser, mais elle peut être utilisée en appliquant l'annotation @GeneratedValue, qui accepte deux paramètres, stratégie et générateur, à ne pas discuter ici, utilisez simplement la stratégie de génération par défaut de clé par défaut. Laissez Hibernate déterminer le type de générateur à utiliser pour faire la portabilité du code entre les différentes bases de données.
@Column Annotation:
L'annotation @Column est utilisée pour spécifier les détails de la colonne sur un champ ou une propriété qui sera mappé. Les propriétés les plus couramment utilisées peuvent être annotées à l'aide de colonnes:
L'attribut de nom permet de spécifier explicitement le nom de la colonne.
La propriété de longueur permet de cartographier la taille d'une colonne qui est spécialement pour une valeur de chaîne.
La propriété nullable permet à la colonne d'être marquée non lors de la génération du schéma.
La propriété unique permet des colonnes marquées comme contenant uniquement des valeurs uniques.
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 enregistrements des employés, puis nous demanderons des dossiers sur les opérations CRUD.
Importer java.util.list; import java.util.date; import java.util.iterator; import org.hibernate.hibernateException; import org.hibernate.Session; import org.hibernate.transaction; import org.hibernate.cfg.annotationConfiguration; import org.hibernate.essionfactory; import org.hibernate.cfg.configuration; classe publique managemployee {factory privé static sessionfactory; public static void main (String [] args) {try {factory = new annotationConfiguration (). configure (). //addpackage("com.xyz ") // ajouter un package si utilisé. AddannotedClass (employee.class). 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 (); / * Ajouter quelques enregistrements d'employés dans la base de données * / Integer empid1 = me.addemployee ("zara", "ali", 1000); Integer Empid2 = me.addemployee ("Daisy", "Das", 5000); Integer Empid3 = me.addemployee ("John", "Paul", 10000); / * Énumérez tous les employés * / me.listEmployee (); / * Mettre à jour les enregistrements de l'employé * / me.updateEmployee (EMPID1, 5000); / * Supprimer un employé de la base de données * / me.DeleteEmployee (EMPID2); / * Énumérez la nouvelle liste des employés * / me.listEmployee (); } / * Méthode pour créer un employé dans la base de données * / entier public addEmployee (String fname, String lname, int salaire) {session session = factory.opencession (); Transaction tx = null; EmployeeId entier = null; try {tx = session.begintransaction (); Employé employé employé = nouvel employé (); employee.setFirstName (fName); Employee.SetLastName (LNAME); Employee.SetSalary (salaire); EmployeeId = (entier) Session.Save (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); } return EmployeeId; } / * Méthode pour lire tous les employés * / public void lisTemployees () {session session = factory.opencession (); 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 ()); } 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 (); }}} Configuration de la base de données:
Maintenant, créons un fichier de configuration hibernate.cfg.xml pour définir les paramètres pertinents de la base de données.
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Configuration System "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate "> org.hibernate.dialect.mysqldialect </ propriété> <propriété name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </ propriété> <! - Supposons que les étudiants soient le nom de la base de données -> <propriété name = "Hibernate.connection.url"> jdbc: mysql: // localhost / test </prewet> <frout name = "hibernate.connection.username"> root </ propriété> <propriété name = "hibernate.connection.password"> cohondob </ propriété> </ session-factory> </ hibernate-configuration>
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.
Supprimez le fichier de mappage employee.hbm.xml du chemin.
Créez le fichier source employee.java comme indiqué dans l'image ci-dessus et compilez-le.
Créez le fichier source ManageMloyee.Java comme indiqué dans l'image ci-dessus et compilez-le.
Exécutez le fichier binaire ManageMloyee pour exécuter le programme.
Les résultats suivants seront obtenus et les dossiers seront dans le tableau des employés.
$ Java Managemployee ......... Divers messages de journal s'affichent ici ......... Prénom: Zara Nom de famille: Ali Salaire: 1000 Nom de Daisy Nom de famille: DAS Salaire: 5000 Nom de John: Nom de famille: Paul Nom: 10000 Nom Paul: 10000 Nom: Ali Salaire: 5000
Si vous vérifiez le tableau des employés, il devrait avoir les enregistrements suivants:
MySQL> Sélectionner * dans l'employé; + ---- + ------------ + ----------- + -------- + | ID | First_name | Last_name | Salaire | + ---- + ------------ + ----------- + -------- + | 29 | Zara | Ali | 5000 || 31 | John | Paul | 10000 | + ---- + ------------ + ----------- + -------- + 2 lignes en jeu (0,00 secmysql>
cache
La mise en cache est une question d'optimisation des performances de l'application et elle est située entre l'application et la base de données pour éviter plusieurs accès de base de données et permettre aux applications critiques de performances de mieux fonctionner.
La mise en cache est importante pour l'hibernate, et il adopte un schéma de mise en cache à plusieurs niveaux décrit ci-dessous:
Cache de niveau 1:
Le premier cache de niveau est le cache de session, qui est un cache obligatoire, et toutes les demandes à travers elle doivent être réalisées. Les objets de session sont constamment alimentés par des objets avant de les soumettre à la base de données.
Si plusieurs mises à jour sont émises, Hibernate tente de retarder les mises à jour aussi longtemps que possible pour réduire le nombre d'instructions SQL émises. Si vous fermez la session, tous les objets mis en cache seront perdus, persistants ou mis à jour dans la base de données.
Cache de niveau 2:
Le cache de niveau 2 est facultatif et le cache de niveau 1 qui sera toujours recherché avant toute tentative de trouver le cache de niveau 2 d'un objet. Le cache de deuxième niveau peut être configuré sur une base par classe et par catégorie, principalement responsable des objets mis en cache en session.
Tout cache tiers peut utiliser Hibernate. L'interface org.hibernate.cache.cacheprovider fournit, et il est nécessaire d'implémenter une implémentation de cache de poignée pour fournir Hibernate.
Cache de niveau de requête:
Hibernate implémente également l'intégration serrée du cache de jeu de résultats de requête et du cache de niveau 2.
Il s'agit d'une fonctionnalité facultative qui nécessite deux caches physiques supplémentaires pour enregistrer les résultats et les régions de la requête en cache lors de la dernière mise à jour d'un tableau. Ceci est tout simplement très utile pour les requêtes qui s'exécutent souvent avec les mêmes paramètres.
Cache de niveau 2:
Hibernate utilise le cache de niveau 1, par défaut, vous ne faites rien avec le cache de niveau 1. Passons directement au cache de deuxième niveau en option. Toutes les classes ne bénéficient pas de la mise en cache, il est donc important de désactiver le cache de niveau 2.
Le cache Hibernate Level 2 est défini sur deux étapes. Tout d'abord, vous devez décider quelle stratégie de concurrence utiliser. Après cela, vous pouvez configurer l'expiration du cache et utiliser le cache pour fournir des attributs de cache physiques.
Stratégie de concurrence:
Une politique de concurrence est un médiateur responsable du stockage des éléments de données dans le cache et de leur récupération du cache. Si vous souhaitez activer la mise en cache de niveau 2, vous devrez décider quelle politique de concurrence de cache utiliser pour chaque classe et collection persistantes.
Transactionnel: l'utilisation de cette stratégie pour lire principalement les données pour empêcher les transactions simultanées de données obsolètes est essentielle dans de rares cas de mises à jour.
Lecture-écriture: En utilisant à nouveau cette stratégie, la lecture principale des données est essentielle pour empêcher les transactions simultanées de données périmées dans de rares cas de mises à jour.
Non-lecture-lecture-écriture: cette stratégie ne garantit pas la cohérence entre le cache et la base de données. Avec cette stratégie, la clé n'est pas de prêter attention si les données sont rarement modifiées et que la possibilité de données périmées doit être périmée.
En lecture seule: la politique concurrencée convient aux données et ne changera jamais. Les données utilisées sont uniquement pour référence.
Si nous voulons utiliser le cache de deuxième niveau comme classe d'employés, ajoutons les éléments de cartographie requis pour indiquer à Hibernate d'utiliser une politique de cache lisible et écrite pour les instances des employés.
<? 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> <cache usage = "read-write" /> <id name = "id" type = "int" colonnen = "id"> <générateur /> </ id> <propriété name = "firstname" chronn = "first_name" type = "string" /> <propriété name = "lastName" chronn type = "int" /> </ class> </ hibernate-mapping>
La propriété usage = "read-write" indique à Hibernate d'utiliser un cache défini par une politique de concurrence en lecture-écriture.
Fournisseur de cache:
Après avoir envisagé la politique concurrencée de votre classe de candidats Cache, l'étape suivante consiste à sélectionner un fournisseur de cache. Hibernate Forces Sélection d'un cache pour servir l'ensemble de l'application.
Cache fourni dans le fichier de configuration Hibernate.cfg.xml spécifié. Sélectionnez Ehcache comme fournisseur de cache de deuxième niveau:
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Configuration System "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate "> org.hibernate.dialect.mysqldialect </ propriété> <propriété name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </ propriété> <! - Supposons que les étudiants soient le nom de la base de données -> <propriété name = "Hibernate.connection.url"> jdbc: mysql: // localhost / test </prewet> <frout name = "hibernate.connection.username"> root </ propriété> <propriété name = "hibernate.connection.password"> root123 </ propriété> <propriété name = "hibernate.cache.provider_class"> org.hibernate.cache.ehcacheprovider </ propriété> <! ressource = "employee.hbm.xml" /> </ session-factory> </ hibernate-configuration>
Maintenant, vous devez spécifier les propriétés de la zone de cache. Ehcache a son propre fichier de configuration ehcache.xml, dans l'application dans ClassPath. Dans ehcache.xml, la configuration du cache de classe des employés peut ressembler à ceci:
<diskstore path = "java.io.tmpdir" /> <defaultCacheMaMELelementsInMemory = "1000" Eternal = "false" TimeToidleSonds = "120" TimetolivesEconds = "120" overflowtodisk = "true" /> <cache name = "employee" maxElementsInMemory = "500" eternal = "true" timetoidleconds = "0" timetoliveseconds = "0" overflowtodisk = "false" />
C'est tout, activez maintenant le cache secondaire de la classe des employés et Hibernate a maintenant le cache secondaire, chaque fois que vous parcourez un employé ou lorsque l'employé est chargé par un identifiant.
Vous devez analyser toutes vos classes et sélectionner la stratégie de mise en cache appropriée pour chaque classe. Parfois, le cache secondaire peut dégrader les performances de l'application. Il est donc recommandé à l'application de référence qui ne permet pas la mise en cache pour la première fois, ce qui est très adapté à la mise en cache et à la vérification des performances. Si le cache n'améliore pas les performances du système, il est dénué de signification de faire n'importe quel type de cache.
Cache de niveau de requête:
En utilisant le cache de requête, il doit être activé d'abord dans le fichier de configuration de la propriété hibernate.cache.use_query_cache = "true". Si cette propriété est définie sur true, laissez Hibernate créer le cache requis en mémoire pour enregistrer l'ensemble de requête et d'identifiant.
Ensuite, en utilisant le cache de requête, vous pouvez utiliser la méthode SetCacheable (booléenne) de la classe de requête. Par exemple:
Hibernate prend également en charge le support de cache très fin à travers le concept d'une zone de cache. Le cache fait partie du cache donné un nom.
Ce code utilise une méthode pour indiquer Hibernate pour stocker et trouver des requêtes sur les employés du cache.