Supprimé : examen Spécialiste certifié Red Hat en Persistence

Description de l'examen

Remarque : cet examen et la certification correspondante ne sont plus proposés.

L'examen Spécialiste certifié Red Hat en Persistence teste la capacité des candidats à créer des applications Java™ basées sur le composant JPA (Java Persistence API) et à assurer leur maintenance en situation réelle, à l'aide de JBoss® Hibernate®.

La certification obtenue suite à l'examen Spécialiste certifié Red Hat en Persistence prouve l'aptitude à exécuter des tâches concrètes associées à l'utilisation de JPA avec JBoss Hibernate. JPA est une structure de langage de programmation Java pour la gestion des données relationnelles. Elle est mise en œuvre par Hibernate, un service hautes performances de requête et de persistance des objets en base de données relationnelle.

Familiarisez-vous avec les outils, l'environnement et les exigences de l'examen Développeur JBoss certifié Red Hat.

Public ciblé

L'examen Spécialiste certifié Red Hat en Persistence s'adresse aux personnes suivantes :

• Architectes et développeurs d'applications Java expérimentés
• Développeurs de bases de données et de composants métier

Prérequis pour cet examen

• Savoir travailler dans un environnement Red Hat Enterprise Linux
• Consulter les objectifs de l'examen Spécialiste certifié Red Hat en Persistence (EX297)

Red Hat recommande aux candidats d'obtenir la certification RHCJD (Développeur JBoss certifié Red Hat) avant de passer cet examen, sans aucune obligation.

Points à étudier pour l'examen

Pour vous aider à vous préparer, les objectifs de l'examen répertorient les types de tâches que vous serez amené à effectuer au cours de l'examen. Red Hat se réserve le droit d'ajouter, de modifier ou de supprimer des objectifs pour tout examen. Ces modifications seront publiées à l'avance.

Tâches de l'examen

Les candidats à l'examen Spécialiste certifié Red Hat en Persistence doivent être capables d'effectuer les tâches suivantes à l'aide de JPA avec Hibernate. Pour les aider dans leur préparation, nous avons également inclus une liste de références recommandées pour ces activités.

Mise en correspondance d'une table ou d'un objet unique

• Comprendre le comportement des générateurs d'ID, notamment comment et quand la valeur est générée
• Comprendre comment mettre en correspondance une clé primaire, notamment :
  • Mettre en correspondance des clés générées
  • Mettre en correspondance des clés métier simples
  • Mettre en correspondance des clés composées
• Comprendre l'identité des objets et l'équivalence métier
• Configurer des informations propres à la base de données, comme le nom de table, le nom de colonne, la largeur de colonne et les attributs de colonne (nullable, unique, type, etc.)
  
• Convertir un objet Java existant en objet persistant à l'aide de JPA/Hibernate
• Mettre en correspondance des types de données JPA de base sur les types de bases de données correspondants
• À partir d'une table de base de données existante, créer un objet Java persistant sur lequel mettre en correspondance cette table
• Comprendre comment et quand utiliser les chargements différé et immédiat
• Comprendre et utiliser les stratégies de mise en correspondance optimales pour les collections et les types de valeurs
• Gérer les comportements et propriétés propres aux modèles objet/Java dans un objet persistant ; par exemple :
  • La sérialisation
  • Les propriétés transitoires
  • Les propriétés générées et calculées
  • Les propriétés immuables
  • Les types de valeurs
  • Les propriétés codépendantes (c'est-à-dire, dans le cas où les valeurs valides d'une propriété dépendent de la valeur d'une autre propriété)
    

Mise en correspondance de relations d'objets avec JPA/Hibernate

• Comprendre comment mettre en correspondance des relations, notamment (liste non exhaustive) :
  • Les relations de valeurs (par ex., « a un objet details »)
  • Les relations parent/enfant
  • Les relations un-à-un (à la fois unidirectionnelles et bidirectionnelles)
  • Les relations plusieurs-à-un et un-à-plusieurs (à la fois unidirectionnelles et bidirectionnelles)
  • Les relations plusieurs-à-plusieurs (à la fois unidirectionnelles et bidirectionnelles)
• Comprendre les comportements de mise en correspondance par défaut, notamment (liste non exhaustive) :
  • Les noms de clés étrangères
  • Les noms de tables d'associations
• Comprendre l'utilisation des clés étrangères et des tables de jointure lors de la création de relations
• Comprendre comment mettre en correspondance une clé primaire composée en fonction de la relation
• Comprendre les collections JPA/Hibernate (sets, maps, lists et bags) et la façon dont elles sont mises en correspondance sur les relations d'objets et de tables
  
• Comprendre l'impact des différentes collections sur les performances
• Comprendre comment et quand utiliser les chargements différé et immédiat, ainsi que l'impact de ces deux solutions sur les performances et le code
  
• À partir d'un ensemble de tables et de relations existantes, créer un objet Java persistant correspondant à la base de données
  
• Mettre en correspondance un modèle objet existant, y compris plusieurs associations, sur un magasin de persistance
• Déterminer les stratégies de chargement optimales pour un processus métier donné

Mise en correspondance de relations d'objets hiérarchiques avec JPA/Hibernate

• Comprendre comment représenter différentes hiérarchies d'objets à l'aide de JPA/Hibernate
• Convertir une hiérarchie d'objets Java existante en objets persistants à l'aide de JPA/Hibernate
• Représenter un ensemble existant de relations de table en tant que hiérarchie d'objets (par ex., compte d'épargne, carte de crédit et compte de prêt)
  
• Comprendre les associations et requêtes polymorphiques
• Comprendre les avantages et les limites des différentes stratégies d'héritage
• Analyser et déterminer les représentations de bases de données optimales pour différentes hiérarchies d'objets

Compréhension du comportement transactionnel (ACID)

• Acquérir et utiliser un contexte transactionnel sous :
  • Java EE/CMT
  • Java EE/BMT
  • Java SE avec les API JPA
• Comprendre comment le contexte de persistance est lié à la transaction dans Java EE
• Comprendre la propagation du contexte transactionnel avec EJB3
• Comprendre les conséquences d'une restauration transactionnelle au niveau du contexte de persistance
• Comprendre les risques de simultanéité transactionnelle
• Évaluer la perte de données/corruption par rapport aux compromis en matière de performances

Récupération d'objets persistants

• Comprendre les stratégies de chargement JPA/Hibernate :
  • Le chargement différé
  • Le chargement par sous-select
  • Le chargement par lot
• Comprendre et utiliser les options de requêtes avancées :
  • HQL/JPA QL
  • API Criteria
  • Requêtes natives (SQL)
• Utiliser la fonction de récupération immédiate d'exécution
• Utiliser des paramètres nommés
• Anticiper et éviter les exceptions de type LazyInitializationException
• Analyser et améliorer les performances de JPA/Hibernate
• Comprendre et utiliser les fonctions étendues de verrouillage optimiste JPA et de verrouillage pessimiste Hibernate

Manipulation d'objets persistants

• Comprendre les différents états d'entité, notamment :
  • éphémère
  • persistante
  • attachée
  • détachée
  • supprimée
• Comprendre comment modifier l'état d'une entité/d'un graphe d'entités à l'aide des API JPA
• Comprendre le cycle de vie du contexte de persistance et son impact sur les entités gérées
• Appliquer les fonctions de création de lots JPA/Hibernate :
  • Schémas d'utilisation d'API
  • Requêtes DML
• Déterminer et appliquer les paramètres optimaux de mise en œuvre et de cascade pour manipuler un graphe d'objets
• Apprendre à identifier les cas adaptés à la création de lots

Documentation et formation

Au cours de l'examen, vous n'aurez accès qu'à la documentation officielle JBoss Enterprise Application Platform de la version sur laquelle vous êtes évalué, ainsi qu'aux exemples de fichiers ou à la documentation supplémentaire fournis avec le produit. Nous ne retirerons rien qui soit normalement fourni.

Veuillez noter que vous n'aurez pas accès aux wikis jboss.org et hibernate.org. Bien que ces ressources soient utiles et incluent du contenu pertinent pour l'examen, leur format ne permet pas d'y accéder au cours d'un examen. Nous souhaitons vous examiner vous, pas les personnes qui lisent et mettent à jour le wiki.

Vous ne serez pas autorisé à apporter de copie papier ni de documentation électronique en salle d'examen. Les notes personnelles, livres et autres documents sont aussi interdits. L'accès à Internet sera strictement contrôlé. Gardez toutes ces restrictions à l'esprit au cours de votre préparation.

Environnement

Au cours de l'examen, vous travaillerez sur un système Red Hat Enterprise Linux® 5.4. Par conséquent, toute expérience préalable d'utilisation de Linux ou UNIX sera utile. En revanche, aucune expérience approfondie de Linux n'est requise, car l'objectif de cet examen est de tester vos compétences JPA avec Hibernate, pas vos compétences sur un système d'exploitation. Vous disposerez d'un environnement de travail complet et d'une liste de commandes de base, fournie par nos soins, pour référence, en plus des pages de manuel et de toute autre documentation fournie avec Red Hat Enterprise Linux.

Fedora est un système d'exploitation Linux gratuit sur lequel vous pouvez vous entraîner. Une version live CD vous permet de travailler sur Fedora sans avoir à l'installer sur votre ordinateur. Bien que ce système d'exploitation ne corresponde pas exactement à l'environnement de Red Hat Enterprise Linux, il est suffisamment proche pour le niveau de connaissances requis.

Format de l'examen

L'examen Spécialiste certifié Red Hat en Persistence est entièrement basé sur les performances. Les candidats prouvent leurs connaissances et compétences en effectuant des tâches pratiques plutôt qu'en récitant de la théorie. La plupart des examens de certification informatique posent une série de questions auxquelles vous devez répondre par A, B, C ou D, ou sont proposés sous la forme de questions à choix multiples. Ce n'est pas le cas de l'examen Spécialiste certifié Red Hat en Persistence. D'ailleurs, aucune question ne vous sera posée. Vous aurez face à vous un environnement bien réel dans lequel vous devrez effectuer une liste de tâches concrètes. Par exemple, plutôt que de vous poser des questions sur les annotations de mise en correspondance JPA, nous pourrons vous demander de créer une association persistante et d'en assurer la maintenance. Aussi, nous conseillons aux candidats d'éviter le « bourrage de crâne » en ligne et autres formations de ce type. La seule et unique source d'informations fiable concernant cet examen est le présent document.

L'examen Spécialiste certifié Red Hat en Persistence dure quatre heures. Il est important que vous arriviez quelques minutes avant le début de l'examen pour que nous puissions procéder aux vérifications d'identité et rassembler les informations utiles.

Environnement de l'examen

Outils de développement

Outre l'environnement de travail, nous vous fournirons une copie installée et configurée de JBoss CodeReady Studio 3. L'examen ne porte pas sur CodeReady Studio et il ne vous sera pas demandé de le connaître ni de l'utiliser pour effectuer les tâches de l'examen. Toutefois, il s'agit d'un excellent outil de développement et de maintenance des applications JPA/Hibernate, et quelques compétences en la matière seront certainement utiles au cours de l'examen. Si vous n'avez pas accès à une copie prise en charge de cet outil, vous pouvez télécharger une version gratuite. Si vous n'êtes pas encore inscrit auprès de Red Hat, vous devrez créer un compte Red Hat gratuit. Si vous ne souhaitez pas vous inscrire auprès de Red Hat pour bénéficier du téléchargement gratuit, une distribution Eclipse standard avec le plug-in JBoss Tools 4 conviendra pour vous préparer à l'examen.

Les projets de l'examen ont été créés avec Maven. Si vous n'utilisez pas JBoss CodeReady Studio, vous pouvez utiliser un éditeur de texte standard (comme gedit ou vi), l'outil de ligne de commande et Maven. Notez que l'examen se déroule à huis clos et que Maven s'exécute en mode hors connexion. Vous ne pouvez pas utiliser d'autres référentiels ou plug-ins Maven que ceux qui sont déjà importés dans l'environnement local.

Répertoire de travail

Lorsque vous commencerez l'examen, l'espace de travail JBoss CodeReady Studio par défaut contiendra un ou plusieurs répertoires de projet à utiliser. Vous n'avez pas à utiliser JBoss CodeReady Studio pour votre développement, mais vous devez utiliser le répertoire de l'espace de travail par défaut et les répertoires de projet fournis pour toutes les tâches. Nous insistons sur le fait que l'ensemble du code et des ressources doit être développé dans la structure des répertoires fournis et être cohérent avec cette dernière.

Normes de rédaction du code

Cet examen est un examen pratique et vous devrez écrire du code afin d'effectuer les tâches demandées. Selon les entreprises, les normes de rédaction du code diffèrent. Ici, comme dans tout environnement réel, vous devrez suivre les normes de rédaction locales. Vous trouverez ci-dessous, pour vous aider à vous préparer, quelques informations sur les normes de rédaction du code à suivre lors de l'examen. Ces informations seront également fournies pendant l'examen. Le jour de l'examen, pour mieux vous mettre en condition, imaginez que vous venez d'être recruté comme développeur JPA/Hibernate afin de mener à bien un projet précis. Malheureusement, le développeur initial du projet a dû l'abandonner en cours de route et n'est plus joignable. Vous devez déterminer où il s'est arrêté dans le code et en écrire autant que vous le pouvez dans le temps imparti.

Le code est plutôt bien documenté et vous trouverez de nombreuses tâches à exécuter pour vous permettre de savoir ce que vous devez faire. Notez toutefois que la documentation Javadoc et les tâches à exécuter sont insuffisantes ; vous devez lire les descriptions des tâches et comprendre ce qui doit être fait avant d'effectuer une tâche. Si vous voyez des incohérences entre le texte de la tâche, les diagrammes UML/PDM et la documentation Javadoc/les tâches à exécuter, suivez toujours les indications données dans la description de la tâche.

Lorsque vous travaillerez, gardez les points suivants à l'esprit :

• Le format du code n'est pas important. Le fait que vous utilisiez des tabulations ou des espaces et le positionnement de vos accolades n'auront aucun impact sur l'évaluation de votre travail.
• Vous pouvez mettre en correspondance vos classes à l'aide de fichiers XML, d'annotations de champs ou d'annotations de propriétés, peu importe. Le code existant utilise quelques annotations de champs, mais vous pouvez facilement passer à votre style de mise en correspondance préféré.
• De nombreuses classes sont organisées de façon inhabituelle ; les champs et méthodes connexes sont regroupés. Cette pratique est très inhabituelle et n'est pas recommandée. Nous avons procédé de la sorte afin de vous faciliter le travail sur un seul élément sans avoir à rechercher dans le code les champs et méthodes connexes. Vous pouvez trier les membres de classes si vous préférez utiliser une structure de code plus habituelle. Astuce : dans CodeReady Studio, les gouttes bleues indiquant des tâches, situées à droite de la fenêtre d'édition, et la liste de propriétés de la vue Outline sont utiles pour naviguer rapidement dans ces classes.
• Contrairement à ce qui se passe dans le monde réel, les commentaires et messages d'exception ne sont pas importants. L'examen est noté par une machine, donc les commentaires et les messages sont totalement ignorés.
• La qualité du code et l'application des bonnes pratiques sont importantes. Vous devez appliquer les bonnes pratiques à tout moment, en sachant que des pratiques médiocres et inefficaces feront baisser votre note. Par exemple, l'une des bonnes pratiques Java consiste à ne jamais exposer publiquement les membres de type champ. Vous devez donc toujours utiliser des méthodes d'obtention et de réglage JavaBeans standard pour vos propriétés d'objets.
• Le projet du scénario de l'examen a été conçu avec d'autres applications provenant d'autres services. Sauf instruction explicite contraire provenant d'une description de tâche ou d'une tâche à exécuter du code, vous ne devez pas modifier la signature d'une méthode existante. Une seule exception à cette règle : lorsque c'est nécessaire, vous devez donner plus de détails sur la signature, c'est-à-dire, utiliser une sous-classe et/ou une classe générique spécifique. Par exemple, vous devez remplacer Collection{cke_protected}{C}%3C!%2D%2D%3F%2D%2D%3E par List lorsque cela est nécessaire.
• Vous pouvez ajouter des champs, des propriétés et des méthodes, si besoin.
• Étant donné que le projet porte sur les entités persistantes et que vous n'avez pas d'entrée dans la couche contrôleur/service, vous êtes censé coder les entités persistantes de manière défensive. Autrement dit, vos méthodes d'entité doivent essayer d'empêcher la logique métier de détruire la cohérence des objets. Par exemple, un réglage pour une propriété nullable doit lever une exception NullPointerException si une valeur « null » lui est transmise.
• Sauf indication contraire, toutes les entités doivent utiliser les clés primaires de base de données qui sont automatiquement générées par le moteur de persistance.
• Si une méthode doit lever une exception à cause d'un problème interne, utilisez toujours une exception RuntimeException ; ne créez pas d'exception propre à l'activité. Par exemple, vous pourriez utiliser IllegalArgumentException si le problème concerne un argument non valable pour une méthode. Vous pourriez utiliser IllegalStateException si le problème concerne une incohérence au niveau de l'état du modèle objet ou du magasin de persistance. Et, bien entendu, vous pourriez utiliser NullPointerException lorsque cela est approprié. Sauf si vous y êtes explicitement invité, n'utilisez pas les fonctions de persistance transitive JPA pour propager des modifications de manière automatique vers des entités associées dans un graphe d'objets. Notre expérience nous a montré que bon nombre de développeurs métier sont déroutés par cette fonction et que cette dernière peut entraîner des problèmes de performances et de fiabilité si elle n'est pas utilisée correctement. Dernier avertissement : nous ne pourrons pas évaluer votre travail s'il ne se compile pas ou s'il ne s'exécute pas correctement. En particulier, une association persistante qui ne fonctionne pas peut entraîner l'échec de toutes les actions de persistance. Il vaut mieux mettre en commentaire une association difficile plutôt que de risquer qu'elle interfère avec d'autres associations qui fonctionnent. Les projets tests incluent une bonne sélection de tests JUnit et nous vous recommandons d'exécuter toute la série de tests après avoir effectué une tâche. Notez toutefois que les tests JUnit inclus ne représentent pas l'examen en lui-même. Donc ce n'est pas parce que votre code passe ces tests que votre travail recevra forcément la meilleure note.

Résultats et communication des notes

Les notes officielles attribuées pour les examens proviennent exclusivement du Centre de certification Red Hat. Red Hat n'autorise pas les examinateurs ou les partenaires de formation à donner directement leurs résultats aux candidats. Les notes d'examen sont généralement communiquées sous trois (3) jours ouvrables (aux États-Unis) après l'examen.

Les résultats d'examen sont communiqués sous forme de notes pour chaque partie. Red Hat ne communique pas les résultats sur des points particuliers et ne fournit pas non plus d'informations complémentaires sur demande.