Hibernate ORM est une bibliothèque offrant un support de mapping objet-relationnel (ORM) aux applications, bibliothèques et frameworks.

Elle fournit également une implémentation de la spécification JPA, qui est la spécification Java standard pour l'ORM.

Ceci est le dépôt de son code source : consultez Hibernate.org pour plus d'informations.

Construction à partir des sources

La construction nécessite un JDK Java 8 comme JAVA_HOME.

Vous aurez besoin de Git pour obtenir le code source.

Hibernate utilise Gradle comme outil de construction. Consultez la section Introduction à Gradle ci-dessous si vous débutez avec Gradle.

Les contributeurs devraient lire le Guide de contribution.

Consultez les guides pour configurer IntelliJ ou Eclipse comme environnement de développement.

Consultez la section Pour commencer dans CONTRIBUTING.md pour débuter le travail sur le code source d'Hibernate.

Intégration continue

Hibernate utilise Jenkins pour ses besoins en CI. Le projet est construit en continu à chaque push sur le dépôt amont. Dans l'ensemble, il y a plusieurs tâches différentes, toutes visibles sur http://ci.hibernate.org/view/ORM/

Introduction à Gradle

Cette section décrit certaines bases que les développeurs et contributeurs novices avec Gradle pourraient avoir besoin de connaître pour être rapidement productifs. La documentation de Gradle est très bien faite ; deux en particulier sont indispensables :

• Guide utilisateur Gradle est un guide utilisateur typique car il suit une approche thématique pour décrire toutes les capacités de Gradle.
• Guide DSL Gradle est unique et excellent pour se familiariser rapidement avec certains aspects de Gradle.

Utilisation du Wrapper Gradle

Pour les contributeurs qui n'utilisent pas autrement Gradle et ne souhaitent pas l'installer, Gradle offre une fonctionnalité très intéressante appelée le wrapper. Il permet d'exécuter des constructions Gradle sans avoir à installer préalablement une distribution Gradle, de manière zéro configuration. Hibernate configure le wrapper Gradle pour vous. Si vous préférez utiliser le wrapper plutôt que d'installer Gradle (ou pour vous assurer d'utiliser la version de Gradle prévue pour les anciennes constructions), vous utiliseriez simplement la commande gradlew (ou gradlew.bat) au lieu de gradle (ou gradle.bat) dans les discussions suivantes. Notez que gradlew n'est disponible que dans le répertoire racine du projet, donc selon votre répertoire de travail, vous devrez peut-être ajuster le chemin vers gradlew.

Les exemples utilisent la syntaxe gradle, mais remplacez simplement gradlew (avec le bon chemin relatif) par gradle si vous souhaitez utiliser le wrapper.

Une autre raison d'utiliser gradlew est qu'il utilise la version exacte de Gradle avec laquelle la construction est définie pour fonctionner.

Exécution de tâches

Gradle utilise le concept de tâches de construction (équivalent aux cibles Ant ou aux phases/objectifs Maven). Vous pouvez obtenir une liste des tâches disponibles via

gradle tasks

Pour exécuter une tâche sur tous les modules, effectuez simplement cette tâche depuis le répertoire racine. Gradle visitera chaque sous-projet et exécutera cette tâche si le sous-projet la définit. Pour exécuter une tâche dans un module spécifique, vous pouvez soit :

1. cd dans ce répertoire du module et exécutez la tâche
2. nommer le "chemin de la tâche". Par exemple, pour exécuter les tests du module hibernate-core depuis le répertoire racine, vous pouvez dire gradle hibernate-core:test

Tâches Java courantes

• build - Assemble (jars) et teste ce projet
• buildDependents - Assemble et teste ce projet ainsi que tous les projets qui en dépendent. Donc, si vous lancez ceci dans hibernate-core, Gradle assemblerait et testerait hibernate-core ainsi que hibernate-envers (car envers dépend de core)
• classes - Compile les classes principales
• testClasses - Compile les classes de test
• compile (Ajout Hibernate) - Effectue toutes les tâches de compilation, y compris le staging des ressources provenant à la fois de main et de test
• jar - Génère une archive jar avec toutes les classes compilées
• test - Exécute les tests
• publish - Pensez à Maven deploy
• publishToMavenLocal - Installe le jar du projet dans votre cache maven local (aka ~/.m2/repository). Notez que Gradle n'utilise jamais cela, mais cela peut être utile pour tester votre construction avec d'autres constructions locales basées sur Maven.
• eclipse - Génère un projet Eclipse
• idea - Génère un projet IntelliJ/IDEA (bien que l'approche préférée soit d'utiliser l'importation Gradle d'IntelliJ).
• clean - Nettoie le répertoire de construction

Tests et bases de données

Tester avec une base de données spécifique peut être réalisé de 2 manières différentes :

Utilisation du "Plugin de test matriciel" pour Gradle.

Bientôt disponible...

Utilisation des "profils"

La construction d'Hibernate définit plusieurs "profils" de test de base de données dans databases.gradle. Ces profils peuvent être activés par leur nom en utilisant la propriété de construction db qui peut être passée soit comme propriété système JVM (-D), soit comme propriété de projet Gradle (-P). Les exemples ci-dessous utilisent l'approche par propriété de projet Gradle.

gradle clean build -Pdb=pgsql

Pour exécuter un test depuis votre IDE, vous devez vous assurer que les expansions de propriétés ont lieu. Utilisez la commande suivante :

gradle clean compile -Pdb=pgsql

REMARQUE : Si vous exécutez des tests avec un pilote JDBC qui n'est pas disponible via Maven central, assurez-vous d'ajouter ces pilotes à votre cache de dépôt Maven local (~/.m2/repository) ou (mieux) de les ajouter à un serveur de dépôt Maven personnel

Exécution de tests spécifiques à une base de données depuis l'IDE en utilisant les "profils"

Vous pouvez exécuter n'importe quel test sur n'importe quelle base de données particulière configurée dans un profil databases.gradle.

Tout ce que vous avez à faire est d'exécuter la commande suivante :

gradlew setDataBase -Pdb=pgsql

ou vous pouvez utiliser la version raccourcie :

gradlew sDB -Pdb=pgsql

Vous pouvez faire cela depuis le module que vous souhaitez tester ou depuis le dossier racine hibernate-orm.

Ensuite, il suffit de choisir n'importe quel test depuis l'IDE et de l'exécuter comme d'habitude. Hibernate utilisera la configuration de base de données du fichier hibernate.properties qui a été configuré par la tâche Gradle setDataBase.