O que é JPA (Java Persistence API)?

O JPA é uma especificação de API para a gestão da persistência de dados em aplicações Java. Ela fornece uma forma padrão de mapear objetos Java para bases de dados relacionais (ou outros armazenamentos de dados) e vice-versa. O JPA faz parte da plataforma Java EE (agora Jakarta EE) e também pode ser usado em aplicações standalone.

Componentes principais do JPA:

• Entidade: Classes Java normais (POJO), marcadas com a anotação @Entity, que representam dados na base de dados.
• EntityManager: Interface para interagir com o contexto de persistência. Usada para procurar, criar, atualizar e eliminar entidades.
• Contexto de Persistência: Conjunto de entidades geridas pelo EntityManager. Aqui são rastreadas as alterações nas entidades antes de serem sincronizadas com a base de dados.
• JPQL (Java Persistence Query Language): Linguagem de consulta orientada a objetos, semelhante ao SQL, mas que opera com entidades e suas relações em vez de tabelas e colunas.
• Criteria API: API orientada a objetos para executar consultas dinâmicas.
• persistence.xml: Ficheiro de configuração que descreve as unidades de persistência e as suas propriedades (por exemplo, informações de ligação à base de dados, estratégias de mapeamento).

O JPA não é uma implementação concreta de ORM (Object-Relational Mapping), mas sim que define contratos e API. Existem vários provedores de JPA que implementam esta especificação, sendo os mais populares:

• Hibernate
• EclipseLink
• Apache OpenJPA

Exemplo de definição de entidade:

// Entidade que representa uma linha na tabela `products`
@Entity
// Nome da tabela na base de dados
@Table(name = "products")
public class Product {

    // Chave primária
    @Id
    // Estratégia de geração da chave primária
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Coluna `name` na tabela
    private String name;

    // Coluna `price` na tabela
    private BigDecimal price;

    // Construtores, getters e setters
    // ...
}

Exemplo de uso de EntityManager:

// Obtenção de EntityManager a partir de EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Início de transação
    em.getTransaction().begin();

    // Criação de uma nova entidade
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Guardar a entidade na base de dados
    em.persist(newProduct);

    // Procurar uma entidade pela chave primária
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Produto encontrado: " + foundProduct.getName());

    // Executar consulta JPQL
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Confirmar transação
    em.getTransaction().commit();

} catch (Exception e) {
    // Reverter transação em caso de erro
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Fechar EntityManager
    em.close();
    // Fechar EntityManagerFactory
    emf.close();
}

O objetivo principal do JPA é simplificar o desenvolvimento de aplicações que trabalham com bases de dados, abstraindo os detalhes de baixo nível do trabalho com JDBC e SQL, fornecendo uma abordagem orientada a objetos para a persistência. Isto aumenta a portabilidade do código e reduz a sua dependência de uma base de dados específica.