JPA Eficaz: As melhores práticas de persistência de dados em Java

Sumário

Sobre o autor

Agradecimentos

Sobre o livro

1. Introdução

2. Como escolher uma implementação e as configurações da JPA

3. Aprenda os detalhes dos mapeamentos de entidades

4. Entenda e mapeie corretamente os relacionamentos

5. Aprenda os truques da JPQL e domine as consultas da JPA

6. Alternativas às consultas: Named Queries e Queries nativas

7. Entenda as queries programáticas com Criteria

8. Recursos avançados com a JPA

9. Finalizando

Sobre o autor

Hébert Coelho de Oliveira é analista desenvolvedor sênior, pós-graduado em Engenharia de Software, professor em faculdade e escritor nas horas vagas. Trabalha há mais de 10 anos com desenvolvimento de softwares, e possui as certificações SCJP, SCWCD, OCBCD, OCJPAD.

É autor do livro JSF Eficaz, publicado pela editora Casa do Código, que dá dicas e melhores práticas para os desenvolvedores que utilizam o JSF em seus projetos. É também criador do blog http://uaiHebert.com, visualizado por 180 países, totalizando mais de 800 mil visualizações em seus 3 anos de vida. É ainda autor do framework EasyCriteria (http://easycriteria.uaihebert.com) que ajuda na utilização da Criteria da JPA, sendo testado com Hibernate, OpenJPA e EclipseLink e com 100% de cobertura nos testes.

Foi revisor de um livro específico sobre Primefaces, e criador de posts em seu blog com aplicações completas utilizando JSF. Escreveu dois posts sobre JPA com diversas dicas que já passaram de 55 mil visualizações, e que também foi o ponto de partida deste livro.

Pós-graduado em MIT Engenharia de Software — desenvolvimento em Java pela Infnet RJ. Atualmente, atua como professor para o curso de pós-graduação, ensinando o conteúdo de Java Web (JSP, Servlet, JSF e Struts) e tópicos avançados, como EJB, Spring e WebServices.

Agradecimentos

Agradeço a Deus pela sabedoria, força de vontade e inteligência para conseguir finalizar o livro.

Dedico este livro àquela que é o maior presente que Deus poderia me dar, minha esposa Daiane. Seu sorriso único, seu olhar que encanta e sua voz que traz alegria ao meu coração. Companheira fiel e única, que está sempre ao meu lado em todas as situações.

Dedico também o livro à minha família, que está lá no interior de Minas Gerais, juntamente com minha linda sobrinha Louanne e sua irmã e minha afilhada Fernanda.

Segue um agradecimento sem medidas aqui ao Rodrigo Sasaki (http://cv.rodrigosasaki.com), que me ajudou no decorrer deste livro com revisões em textos e códigos. Ter um profissional de alto calibre como ele ajudando na produção de um livro é de incomensurável alegria. Sou grato a Deus por ter colocado em meu caminho pessoa tão boa, sábia e sempre disposta a ajudar.

E, por último, mas não menos importante, dedico este livro à minha querida irmã Louise, que sempre briga comigo. [=

Sobre o livro

A JPA é um framework que vem ganhando mais espaço no mercado a cada dia que se passa. Veremos neste livro diversos conceitos e dicas de utilizações de diversos recursos que a JPA oferece. Este livro é ideal para quem já entende o conceito do framework e já sabe fazer um hello world.

Ao final deste livro, um desenvolvedor JPA já estará apto a modelar, desenvolver e resolver diversos problemas que podem acontecer ao se trabalhar com JPA.

Você pode discutir sobre este livro no Fórum da Casa do Código: http://forum.casadocodigo.com.br/.

Caso você deseje submeter alguma errata ou sugestão, acesse http://erratas.casadocodigo.com.br.

Capítulo 1

Introdução

Diversas vezes, ao trabalhar com JDBC, nos deparamos com rotinas chatas e entediantes ao escrever comandos SQL. Como fazer diversos whiles para popular um objeto, erro de sintaxes ao escrever um insert, e até mesmo problemas de relacionamento de chaves ao fazer um delete.

Veja o código de JDBC a seguir:

private Usuario buscaUsuario(int id) throws SQLException {

    Connection conexaoComBanco = null;

    PreparedStatement preparedStatement = null;

    Usuario usuarioEncontrado = null;

    String consulta = "SELECT

                            EMAIL,

                            NOME

                        FROM

                            USUARIO

                        WHERE

                            ID = ?";

    try {

        // busca a conexão de algum lugar válido

        conexaoComBanco = getConexaoComBanco();

        // prepara o objeto da conexão

        preparedStatement =

            conexaoComBanco.prepareStatement(consulta);

        preparedStatement.setInt(1, id);

        // executa a consulta

        ResultSet rs = preparedStatement.executeQuery();

        usuarioEncontrado = new Usuario();

        while (rs.next()) {

            String email = rs.getString(EMAIL);

            String nome = rs.getString(NOME);

            usuarioEncontrado.setNome(nome);

            usuarioEncontrado.setId(id);

            usuarioEncontrado.setEmail(email);

        }

    } finally {

        if (preparedStatement != null) {

            preparedStatement.close();

        }

        if (conexaoComBanco != null) {

            conexaoComBanco.close();

        }

    }

    return usuarioEncontrado;

}

O código que acabamos de ver usa o JDBC puro para realizar a conexão com o banco de dados e realizar uma consulta. Note como é verboso, e como necessita de diversas ações para realizar apenas a consulta que volta, ou um, ou nenhum resultado. Caso fosse uma lista, teríamos de ter o cuidado de criar uma lista e populá-la.

Imagine também se cada usuário tivesse um log de atividades. Seria necessário fazer outra consulta para trazer essa informação, ou utilizar um JOIN, complicando ainda mais a simples tarefa de buscar uma informação no banco de dados.

Para evitar toda essa verbosidade do JDBC, surgiu a JPA, uma ferramenta muito poderosa que pode aumentar consideravelmente o tempo de desenvolvimento da equipe, além de facilitar muito a implementação do código que manipula o banco de dados. Quando corretamente aplicado, a JPA se torna uma ferramenta que ajuda em todas as funções de um CRUD (Create, Read, Update e Delete), além de contribuir com diversas otimizações de performance e consistência de dados.

É nesse exato momento que podemos entender por que as siglas ORM são tão faladas. Object Relational Mapping (ORM) quer dizer basicamente: transformar as informações de um banco de dados, que estão no modelo relacional para classes Java, no paradigma Orientado a Objetos de um modo fácil.

Um framework ORM vai ajudá-lo na hora de realizar consultas, manipular dados e até mesmo a retirar relatórios complexos. A verbosidade de um SQL com JDBC não será necessária, nem mesmo os incansáveis loops que fazemos para popular objetos. Tudo isso já está pronto. Só precisamos saber usar.

Outra vantagem que veremos é a portabilidade da aplicação entre banco de dados, tratamento de acesso simultâneo, acesso às funções, dentre outras mais.

O código de busca do usuário pelo id que acabamos de ver poderia ser resumido para:

private Usuario buscaUsuario(int id)

{

    EntityManager entityManager = getEntityManager();

    Usuario usuario = entityManager.find(Usuario.class, id);

    entityManager.close();

}

Note quão simples e prático ficou nosso código. E para salvar uma informação no banco de dados? Será que teremos de fazer muito código? Na prática, não é necessário criar queries longas e tediosas. Bastaria fazer:

private void salvarUsuario(Usuario usuario)

{

    EntityManager entityManager = getEntityManager();

    entityManager.getTransaction().begin();

    entityManager.persist(usuario);

    entityManager.getTransaction().commit();

    entityManager.close();

}

É possível perceber que o contato com o banco de dados ficou mais simples e de fácil utilização. Rotinas que incluíam escrever tediosos e verbosos comandos SQL agora viraram apenas chamadas a uma API simples. É claro que a vantagem não fica só aí. Vai muito mais além e vamos explorar essas funcionalidades durante o livro.

Veremos desde os conceitos básicos da JPA até os avançados, falando de diversos detalhes e boas práticas, em capítulos curtos, cada um focado em um recurso específico. Dessa forma, você pode ler os capítulos de forma isolada e usá-lo como um guia de referência quando precisar.

Capítulo 2

Como escolher uma implementação e as configurações da JPA

2.1 Escolha uma implementação

A JPA nada mais é do que um conjunto de regras, normas e interfaces para definir um comportamento também conhecido como especificação. No mundo Java, temos diversas outras como JSF, EJB, JAAS e muito mais. Toda especificação precisa de uma implementação para que possa ser usada em um projeto. No caso da JPA, a implementação mais famosa e utilizada no mercado é o Hibernate, mas existem mais no mercado como OpenJPA, EclipseLink, Batoo e outras. Cada implementação tem suas vantagens e desvantagens na hora do uso.

O Hibernate contém diversas funcionalidades, como Engenharia Reversa, Exportação de Schema facilitado e anotações próprias para simplificar a utilização da API. Por outro lado, ao usar o Hibernate, será necessário adicionar diversas dependências para o seu correto funcionamento.

A ideia do Batoo, por exemplo, é o foco na performance. Ele tem um número reduzido de dependências, mas tem um desempenho otimizado. Já da OpenJPA é possível dizer que sua simplicidade e facilidade de usar a faz bem próxima da API da JPA; ao estudar a JPA, facilmente poderia se entender a OpenJPA e suas anotações extras.

Uma implementação da JPA deve satisfazer todas as interfaces determinadas pela especificação. Pode acontecer de uma implementação ter 80% de todas as interfaces implementadas e, ainda assim, lançar uma versão para utilização. Fica a critério de cada uma garantir que tudo esteja corretamente implementado. Caso não esteja, usuários escolherão não utilizar.

Para implementar