Como criar modelos e um controlador JPA

Criar uma forma de persistência própria é bom, porém é algo bastante massivo e tem que ser repetido em diversas situações, portanto, um modelo e controlador JPA pode facilitar (e muito) sua vida. Além disso, é muito comum erros de sintaxe no SQL e falhas de segurança da aplicação pela utilização de SQL injection. Para mitigar estes problemas foram criados os mapeadores objeto-relacional. A função deste framework é criar uma forma do usuário trabalhar com objetos e não se preocupar com “tabelas” na base de dados. Nessa aula iremos compreender como estes mapeadores funcionam e como utiliza-los na prática.  

Esse artigo faz parte de um conjunto de artigos sobre programação web em Java. Veja mais sobre esse assunto aqui.

Compreendendo o que é o Hibernate

O objetivo do Hibernate é diminuir a complexidade entre os programas Java, baseado no modelo orientado a objeto, que precisam trabalhar com um banco de dados do modelo relacional (presente na maioria dos SGBDs). Em especial, no desenvolvimento de consultas e atualizações dos dados.   Sua principal característica é a transformação das classes em Java para tabelas de dados (e dos tipos de dados Java para os da SQL).

O Hibernate gera as chamadas SQL e libera o desenvolvedor do trabalho manual da conversão dos dados resultante, mantendo o programa portável para quaisquer bancos de dados SQL, porém causando um pequeno aumento no tempo de execução.   Nas questões relacionadas para o gerenciamento de transações e na tecnologia de acesso à base de dados são de responsabilidade de outros elementos na infraestrutura do programa. Apesar de existirem API no Hibernate para possuir operações de controle transacional, ele simplesmente delegará estas funções para a infraestrutura na qual foi instalada.  

No caso de aplicações construídas para serem executadas em servidores de aplicação, o gerenciamento das transações é realizado segundo o padrão JTA. Já nas aplicações standalone, o programa delega o tratamento transacional ao driver JDBC.   Hibernate pode ser utilizado em aplicações Java standalone ou em aplicações Java EE, utilizando servlet ou sessões Enterprise Java Beans.  

O que é o JPA

  Java Persistence API (ou simplesmente JPA) é uma API padrão da linguagem Java que descreve uma interface comum para frameworks de persistência de dados. A JPA define um meio de mapeamento objeto-relacional para objetos Java simples e comuns (POJOs), denominados beans de entidade. Diversos frameworks de mapeamento objeto/relacional como o Hibernate implementam a JPA. Também gerencia o desenvolvimento de entidades do Modelo Relacional usando a plataforma nativa Java SE e Java EE.   Originou-se num projeto comum entre os desenvolvedores para se criar o padrão[1]. Fortemente baseado nas ideias trazidas pelo Hibernate, tanto que o líder da primeira versão dessa especificação é o criador do framework.  

Inicializando um projeto

O primeiro passo é criar um novo projeto web em sua IDE e criar os pacotes comuns do MVC. No pacote de Models irão ficar todas as classes que representam tabelas no banco de dados. No pacote de Controlers ficarão todos os controladores JPA que realizarão as 4 operações básicas (CRUD). Por fim, no pacote de Views ficarão todos as classes denominadas “managed beans” que respondem por uma interface (XHTML).      

Criando o primeiro model

O primeiro passo para criar um modelo é adicionar ao seu projeto a biblioteca do JPA 2.1. Clique com o botão direito em bibliotecas e adicione, veja a imagem:  

Após adicionar a biblioteca estamos preparados para criar a classe Pessoa dentro do pacote Models. Na classe pessoas iremos definir algumas propriedades e anota-las.  

package Models;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Pessoa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    public Pessoa(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Pessoa() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Pessoa{" + "id=" + id + ", name=" + name + '}';
    }
}

A anotação @Entity indica que esta classe representa uma entidade no banco de dados. O JPA em conjunto com a implementação (hibernate) irá cuidar da criação da tabela e gerenciamento da mesma. A anotação @id indica que o campo anotado é a chave primária da tabela que será criada. Além disso, ele vem acompanhado com a anotação @GeneratedValue(strategy = generationType.IDENTITY.) que realizará o auto-incremento desta tabela.

Criando um controlador JPA

Os controladores podem ser criados manualmente ou automaticamente a partir das entidades já definidas. Se você optar por criar um controlador simples e escrever todo o código, você precisará criar:

public void criar(Pessoa p);
public void deletar(Pessoa p);
public void alterar(Pessoa p);
public void buscarPorId(int id);
public void buscarTodas();

Porém, o netbeans pode te ajudar a realizar esta tarefa utilizando a criação automática de controladores. 

1- Clique sobre o pacote de controlers > novo > Classes do controlador JPA de classes de entidade. Caso esta opção não esteja sendo exibida, clique em outros e localize-a na lista.

2- Selecione o model que deseja criar um controler e clique em “próximo”:

3- Dê um nome a sua nova unidade de persistência e realize uma nova conexão com o banco de dados:

3.1 – selecione o driver que deseja usar:

3.2 – preencha os dados do banco de dados (previamente criado em seu SGBD)

  4 – Finalize  

7- Unidade de persistência

As unidades de persistência foram criadas para indicar a conexão com uma base de dados. Ela é definida pelo arquivo persistence.xml localizado no seu projeto. O código fonte mostra quais as informações essenciais para que o JPA consiga realizar a conexão com a base de dados.  

8- Gerenciando conexões com o banco de dados

Um dos maiores problemas de uma aplicação é a conexão e comunicação com o banco de dados. Esta conexão é muito “cara” para o sistemas, visto que consome muito processamento e requisições ao servidor. Logo, é necessário pensar muito bem em uma estratégia para gerenciar de forma eficiente as conexões.   Se você está desenvolvendo uma aplicação de grande porte, é muito interessante que você entenda como funciona os servidores de aplicação (Wildfly, Glassfish, Weblogic). Porém, para o nosso exemplo utilizaremos uma forma simples de gerenciar essas conexões utilizando o uma fábrica de conexões.    Esta fábrica de conexões foi chamada de EmProvider:

package View;
import java.util.Date;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class EmProvider {
    private static final String DB_PU = "NOME DA SUA UNIDADE DE PERSISTENCIA";
    public static final boolean DEBUG = true;
    private static final EmProvider singleton = new EmProvider();
    private EntityManagerFactory emf;
    private EmProvider() {}
    
    public static EmProvider getInstance() {
        return singleton;
    }

    public EntityManagerFactory getEntityManagerFactory() {

        if(emf == null) {
            emf = Persistence.createEntityManagerFactory(DB_PU);
        }
        if(DEBUG) {
            System.out.println("factory created on: " + new Date());
        }
    return emf;
    }

    public void closeEmf() {
        if(emf.isOpen() || emf != null) {
            emf.close();
        }

        emf = null;
        if(DEBUG) {
            System.out.println("EMF closed at: " + new Date());
        }
    }
}

Observação: não se esqueça de alterar o nome da sua unidade de persistência

9- Testando

Para testar nossa persistência (modelo e controlador JPA), utilizaremos uma classe de teste básica contendo apenas o método main(). Nesta classe instanciaremos uma nova pessoa e o controler, a seguir, invocamos o método create do controler. Veja o exemplo:      

package testandoJPA;
import controlers.PessoaJpaController;
import Models.Pessoa;
import Views.EmProvider;

public class TestandoJPA {
    public static void main(String[] args) {
        Pessoa p = new Pessoa(Long.MIN_VALUE, "vinicius");
        PessoaJpaController control = 
                new PessoaJpaController(EmProvider
                        .getInstance()
                        .getEntityManagerFactory());
        control.create(p);
    }
}

Observação: Não se esqueça de adicionar o driver do mysql ao projeto

10- Resultado

Confira o resultado do código na seção 9 no seu SGBD:  

Veja o código completo no github