EX297

Descrição do exame

Observação: este exame e a respectiva credencial não estão mais disponíveis.

Com o Red Hat Certified Specialist in Persistence exam, os candidatos testam se estão prontos para as responsabilidades reais da criação e manutenção de aplicações Java™ que utilizam o Java Persistence API (JPA) com o JBoss® Hibernate®.

A credencial Red Hat Certified Specialist in Persistence exam comprova a capacidade de um indivíduo de realizar tarefas reais associadas ao uso do Java™ Persistence API (JPA) com o JBoss Hibernate. O JPA é um framework de linguagem de programação Java para gerenciamento de dados relacionais, e o Hibernate é um serviço de consulta e persistência relacional de objetos de alto desempenho que implementa o JPA.

Familiarize-se com as ferramentas, o ambiente e os requisitos de um Red Hat JBoss Certified Developer exam.

Público para este exame

O Red Hat Certified Specialist in Persistence foi projetado para:

• Desenvolvedores e arquitetos experientes em aplicações Java.
• Desenvolvedores de componentes e bancos de dados corporativos.

Pré-requisitos do exame

• Estar familiarizado com o trabalho em um ambiente do Red Hat Enterprise Linux
• Revisar os objetivos do Red Hat Certified Specialist in Persistence exam (EX297)

A Red Hat recomenda aos candidatos a aprovação no Red Hat Certified JBoss Developer (RHCJD) antes de realizar este exame, mas isso não é obrigatório.

Tópicos de estudo para o exame

Para ajudar você a se preparar, os objetivos do exame realçam as áreas de atuação que podem ser incluídas. A Red Hat se reserva o direito de incluir, modificar e remover objetivos do exame. Essas alterações serão divulgadas com antecedência.

Tarefas do exame

Os candidatos do Red Hat Certified Specialist in Persistence exam precisam estar aptos a executar as tarefas a seguir usando o JPA com o Hibernate. Para auxiliar no estudo, incluímos uma lista de referências recomendadas dessas atividades.

Mapear uma tabela ou objeto

• Entender o comportamento dos geradores de ID, incluindo como e quando o valor é gerado
• Entender o mapeamento de uma chave primária, incluindo:
  • Usar chaves geradas
  • Mapear chaves corporativas simples
  • Mapear chaves compostas
• Entender a identidade do objeto e a equivalência corporativa
• Configurar informações específicas do banco de dados, como nomes de tabela e de coluna, largura da coluna e
  atributos dela (nullable, unique, type e assim por diante)
• Converter um objeto Java atual em um objeto persistente usando o JPA/Hibernate
• Mapear tipos de dados JPA básicos para os tipos de bancos de dados correspondentes
• Criar um novo objeto persistente do Java para mapear uma tabela de banco de dados atual
• Entender como e quando usar lazy ou eager loads
• Entender e usar as melhores estratégias de mapeamento em coleções e tipos de valores
• Trabalhar com propriedades específicas do modelo de objetos/Java e comportamentos em um objeto persistente Isso inclui:
  • Serialização
  • Propriedades temporárias
  • Propriedades geradas e calculadas
  • Propriedades imutáveis
  • Tipos de valor
  • Propriedades codependentes (ou seja, quando os valores válidos da propriedade dependem do valor de
    outra)

Mapear relacionamentos de objetos com o JPA/Hibernate

• Entender como mapear relacionamentos, incluindo:
  • Relacionamentos de valor (por exemplo, objeto de detalhes "has-a")
  • Relacionamentos pai/filho
  • Relacionamentos um para um (unidirecional e bidirecional)
  • Relacionamentos um para muitos ou muitos para um (unidirecional e bidirecional)
  • Relacionamentos muitos para muitos (unidirecional e bidirecional)
• Entender os comportamentos padrão de mapeamento, incluindo:
  • Nomes de chaves externas
  • Nomes de tabelas de associação
• Entender o uso das chaves externas e tabelas conjuntas ao criar relacionamentos
• Entender como mapear uma chave primária composta com base no relacionamento
• Entender as coleções do JPA/Hibernate (conjuntos, listas de mapas e recipientes) e como mapeá-las para relacionamentos de
  objetos e tabelas
• Entender o impacto do desempenho nas diferentes coleções.
• Entender como e quando usar lazy e eager loads, incluindo o impacto do desempenho e do código
  desses recursos
• Com um conjunto de tabelas e relacionamentos atuais, criar um gráfico de objetos persistente do Java
  correspondente ao banco de dados
• Mapear um modelo de objetos atual, incluindo diversas associações, em um repositório de persistência
• Determinar as melhores estratégias de carregamento de determinado processo de negócios

Mapear relacionamentos de objetos hierárquicos com o JPA/Hibernate

• Entender como representar diferentes hierarquias de objetos usando o JPA/Hibernate
• Converter um objeto de hierarquia Java atual em um persistente usando o JPA/Hibernate
• Representar um conjunto atual de relacionamentos de tabela como uma hierarquia de objetos (por exemplo,
  conta-poupança, cartão de crédito e empréstimo)
• Entender as consultas e associações polimórficas
• Entender os benefícios e as limitações das diferentes estratégias de herança
• Analisar e determinar as melhores representações de bancos de dados para diferentes hierarquias de objeto

Entender o comportamento transacional (ACID)

• Adquirir e usar um contexto de transação em:
  • Java EE/CMT
  • Java EE/BMT
  • Java SE usando APIs JPA
• Entender como o contexto de persistência é ligado à transação no Java EE
• Entender a propagação do contexto transacional com EJB3
• Entender as consequências de uma reversão transacional no contexto da persistência
• Entender os riscos da concomitância transacional
• Avaliar a perda/corrupção dos dados em relação às compensações do desempenho

Recuperar objetos persistentes

• Entender as estratégias de carregamento do JPA/Hibernate:
  • Lazy load
  • Subselect load
  • Batch load
• Entender e usar opções de consulta avançadas:
  • HQL/JPA QL
  • APIs de critérios
  • Consultas nativas (SQL)
• Usar a funcionalidade runtime eager fetching
• Usar parâmetros nomeados
• Antecipar e evitar LazyInitializationException
• Analisar e melhorar o desempenho do JPA/Hibernate
• Entender e usar as funcionalidades estendidas de bloqueio otimista do JPA e pessimista do Hibernate

Gerenciar objetos persistentes

• Entender estados das entidades, como:
  • temporário
  • persistente
  • conectado
  • desconectado
  • removido
• Entender como alterar o estado de uma entidade/gráfico de entidades usando APIs JPA
• Entender o ciclo de vida do contexto de persistência e seu impacto sobre as entidades gerenciadas
• Aplicar funcionalidades de lote do JPA/Hibernate:
  • Padrões de uso da API
  • Consultas DML
• Determinar e aplicar as configurações corretas de implementação e cascata para gerenciar um gráfico de objetos
• Avaliar quando usar lotes

Documentação e treinamento

Você só poderá consultar a documentação oficial do JBoss Enterprise Application Platform da versão usada no teste e arquivos de exemplo ou outros documentos fornecidos com a solução. Não vamos proibir nada que seja fornecido normalmente.

Você não terá acesso ao sites wiki jboss.org ou hibernate.org. Embora sejam recursos úteis e possam conter muito material pertinente ao exame, eles acabam sendo inadequados devido a seu formato. Queremos testar você, e não as pessoas que estão lendo e atualizando o wiki.

Não é permitida a entrada de documentos impressos ou eletrônicos no exame, incluindo cadernos, livros ou quaisquer outros materiais. O acesso à Internet será rigorosamente controlado. Lembre-se dessas restrições ao se preparar para o exame.

Ambiente

Você trabalhará em um sistema Red Hat® Enterprise Linux® 5.4 durante o exame. Portanto, é útil ter experiência em Linux ou UNIX. Não é necessária tanta experiência em Linux, já que a finalidade do exame é testar seu conhecimento em JPA com Hibernate, e não suas habilidades com sistemas operacionais específicos. Você terá um ambiente de desktop completo para trabalhar, bem como a lista de comandos básicos para consulta, páginas de manual e outros documentos fornecidos com o Red Hat Enterprise Linux.

O Fedora é uma alternativa disponibilizada gratuitamente para você praticar suas habilidades em Linux. Há uma versão Live CD disponível para você trabalhar no Fedora sem precisar instalá-lo no seu computador. Ele não é exatamente igual ao ambiente do Red Hat Enterprise Linux, mas é parecido o suficiente para você ter o nível de familiaridade necessário.

Formato do exame

O Red Hat Certified Specialist in Persistence exam é totalmente baseado em desempenho: os candidatos comprovam seus conhecimentos e habilidades realizando tarefas, em vez responder a perguntas sobre teorias. A maioria dos exames de certificação de TI tem perguntas de múltipla escolha, incluindo Escolha todas as respostas corretas. Perguntas desse tipo não aparecem no Red Hat Certified Specialist in Persistence exam. Na verdade, não há pergunta alguma. Na verdade, você usará um ambiente real para executar tarefas reais. Por exemplo, podemos pedir que você crie e mantenha uma associação persistente, em vez de fazer uma série de perguntas sobre as anotações de mapeamento do JPA. Portanto, aconselhamos os candidatos a desconfiar dos sites de dicas rápidas (os “brain dumps”) e afins. A melhor e única fonte de informações sobre esse exame é este documento.

O Red Hat Certified Specialist in Persistence exam tem a duração de quatro horas. É preciso um tempo antes do horário de início do exame para confirmação de identificação e coleta de informações.

Ambiente do exame

Ferramentas de desenvolvimento

Além do ambiente de desktop, forneceremos uma cópia instalada e configurada do Developer Studio 3. Não se trata de um exame para o Developer Studio, e não esperamos que você o conheça ou use para realizar as tarefas do exame. No entanto, ele é uma excelente ferramenta para desenvolvimento e manutenção de aplicações JPA/Hibernate. Assim, ter alguma experiência e qualificação no uso do Developer Studio, certamente, será útil na hora do exame. Se você não tem acesso a uma cópia com suporte da solução, faça o download de uma versão gratuita. Se você ainda não é cadastrado na Red Hat, é necessário criar uma conta gratuita. Se não quiser se cadastrar na Red Hat para fazer o download gratuito, uma distribuição Eclipse padrão com o plug-in JBoss Tools 4 é suficiente para praticar para o exame.

Os projetos do exame foram criados com o Maven. Se não quiser usar o Developer Studio, utilize um editor de textos comum, como gedit ou vi, a linha de comando e o Maven. O exame é feito em ambiente fechado, e o Maven é executado off-line. Não é possível usar repositórios ou plug-ins do Maven que já não tenham sido importados para o ambiente local.

Diretório de trabalho

Quando você começar o exame, o espaço de trabalho padrão do Developer Studio terá um ou mais diretórios de projeto que precisam ser usados durante o exame. Você não precisa usá-lo para desenvolvimento, mas deve utilizar o diretório do espaço de trabalho padrão e os diretórios de projetos fornecidos em todas as tarefas. Ou seja, todos os códigos e recursos devem ser desenvolvidos na estrutura dos diretórios fornecidos e serem coerentes com ela.

Padrões de codificação

Este é um exame prático hands-on, e você terá que escrever o código para concluir as tarefas. Empresas diferentes têm padrões de codificação distintos e, como no ambiente real, você precisará seguir os padrões de codificação locais. Veja abaixo algumas informações sobre os padrões de codificação do exame que podem ajudar na sua preparação. Essas informações também são fornecidas durante o exame. Para o exame, será mais fácil se você imaginar que é um desenvolvedor de JPA/Hibernate que acabou de ser contratado e foi designado para concluir um projeto. Infelizmente, o desenvolvedor original precisou abandonar o projeto, e não há como contatá-lo. Você precisa retomar de onde ele parou o código e concluir o máximo que conseguir no tempo disponível.

Há documentação suficiente sobre o código e várias tarefas "TODO" relacionadas que dão uma indicação do que precisa ser feito. O Javadoc e as TODO não são suficientes: você precisa ler as descrições das tarefas e entender o que deve ser feito antes de trabalhar nelas. Se você acha que existe alguma discordância entre o texto da tarefa, os diagramas de UML/PDM e o Javadoc/TODO, sempre siga a descrição da tarefa.

Veja alguns pontos a lembrar enquanto você estiver trabalhando:

• A formatação do código não é importante. Se você usa tabulações ou espaços e a forma como posiciona chaves não afetarão a avaliação do seu trabalho.
• Você precisa mapear classes usando arquivos XML, anotações dos campos ou anotações de propriedades, independentemente do que usar. O código atual usa um pequeno número de anotações de campo, mas é possível mudar para o estilo de mapeamento que quiser.
• Muitas classes estão organizadas de forma incomum: campos e métodos relacionados estão agrupados. Isso não é algo muito corriqueiro nem é uma prática recomendada. Na verdade, é para facilitar seu trabalho em um item único sem ter que ficar procurando no código inteiro os campos e métodos relacionados. Sinta-se à vontade para ordenar os membros das classes se quiser usar uma estrutura de código mais comum. Dica: no Developer Studio, o marcador azul "TODO" que aparece à direita da janela do editor e a lista de propriedades no modo de exibição "Outline" são muito úteis para uma rápida navegação nessas classes.
• Diferente do mundo real, comentários e mensagens de exceção não são importantes. O exame é marcado para computador, de modo que comentários e mensagens são completamente ignorados.
• A qualidade do código e as práticas recomendadas são importantes. Você precisa sempre aplicar as práticas recomendadas, bem como trabalhar considerando que práticas ruins ou ineficientes serão penalizadas. Por exemplo, é considerada uma prática recomendada do Java jamais expor publicamente membros de campo. Portanto, você deve sempre usar os getters e setters padrão do JavaBeans nas propriedades de objeto.
• O projeto do cenário do exame foi criado em conjunto com outras aplicações de outros departamentos. Salvo quando indicado explicitamente na descrição da tarefa ou em um "TODO" no código, não altere a assinatura de qualquer método atual. A única exceção a essa regra é que você pode e deve tornar a assinatura mais específica (ou seja, usar uma subclasse e/ou genérico específico) se apropriado. Por exemplo, você precisa substituir Collection{cke_protected}{C}%3C!%2D%2D%3F%2D%2D%3E por List se fizer sentido.
• É possível adicionar campos, propriedades e métodos conforme a necessidade.
• Já que o projeto é voltado para as entidades persistentes, e você não tem informação sobre a camada de controlador/serviço, é necessário codificar as entidades persistentes de maneira defensiva. Ou seja, seus métodos de entidade devem tentar impedir que a lógica corporativa destrua a consistência dos objetos. Por exemplo, um setter de uma propriedade nullable precisará executar um NullPointerException se um valor nulo for transmitido.
• A menos que informado de outra forma, todas as entidades devem usar as chaves primárias do banco de dados, que são automaticamente geradas pelo mecanismo de persistência.
• Se um método precisar executar uma exceção devido a algum problema interno, sempre use um RuntimeException: não crie uma exceção específica para a empresa. Por exemplo, você pode ainda usar IllegalArgumentException se o problema for um argumento inválido para um método. Use IllegalStateException se o problema for uma inconsistência no estado do modelo do objeto ou repositório de persistência. E, é claro, use NullPointerException sempre que apropriado. A menos que informado explicitamente, não use as funcionalidades de persistência transitiva do JPA para propagar alterações automaticamente nas entidades associadas em um gráfico de objetos. Por experiência, sabemos que muitos desenvolvedores corporativos se confundem com essa funcionalidade, além de que ela pode causar problemas de desempenho e confiabilidade quando usado indevidamente. Um aviso final: não será possível avaliar seu trabalho se ele não for compilado ou não for executado corretamente. Particularmente, uma associação persistente inválida pode fazer com que as ações de persistência falhem. É melhor comentar sobre uma associação difícil do que correr o risco de fazê-la interferir em outras que funcionam. Os projetos de teste incluem boas opções de testes JUnit. Recomendamos que você execute todo o conjunto depois de concluir uma tarefa. No entanto, os testes JUnit inclusos não são o exame, e fazer com que seu código seja aprovado não necessariamente significa que seu trabalho ganhará crédito total.

Pontuações e resultados

As pontuações oficiais dos exames são provenientes exclusivamente da Central de Certificação Red Hat. A Red Hat não autoriza os examinadores ou os parceiros de treinamento a informarem os resultados diretamente aos candidatos. Os resultados do exame são divulgados em até três dias úteis (EUA).

Os resultados do exame são informados como pontuações por seção. A Red Hat não divulga o desempenho em itens individuais nem fornece informações adicionais mediante solicitação.