Τι είναι το JPA (Java Persistence API);

JPA is a specification of the API for managing data persistence in Java applications. It provides a standard way to map Java objects to relational databases (or other data stores) and vice versa. JPA is part of the Java EE (now Jakarta EE) platform and can also be used in standalone applications.

Key components of JPA:

• Entity: Ordinary Java classes (POJOs) annotated with @Entity, representing data in the database.
• EntityManager: Interface for interacting with the persistence context. Used for searching, creating, updating, and deleting entities.
• Persistence Context: A set of entities managed by EntityManager. It tracks changes to entities before synchronization with the database.
• JPQL (Java Persistence Query Language): An object-oriented query language similar to SQL but operates on entities and their relationships instead of tables and columns.
• Criteria API: An object-oriented API for executing dynamic queries.
• persistence.xml: Configuration file describing persistence units and their properties (e.g., database connection info, mapping strategies).

JPA does not specify a particular ORM (Object-Relational Mapping) implementation but defines contracts and APIs. Various providers implement this specification, the most popular of which are:

• Hibernate
• EclipseLink
• Apache OpenJPA

Example of defining an entity:

// Entity representing a record in the `products` table
@Entity
// Name of the table in the database
@Table(name = "products")
public class Product {

    // Primary key
    @Id
    // Strategy for generating the primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // `name` column in the table
    private String name;

    // `price` column in the table
    private BigDecimal price;

    // Constructors, getters, and setters
    // ...
}

Example of using EntityManager:

// Obtaining EntityManager from EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Beginning transaction
    em.getTransaction().begin();

    // Creating a new entity
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Saving the entity to the database
    em.persist(newProduct);

    // Finding an entity by primary key
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Found product: " + foundProduct.getName());

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

    // Committing the transaction
    em.getTransaction().commit();

} catch (Exception e) {
    // Rolling back the transaction in case of error
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Closing EntityManager
    em.close();
    // Closing EntityManagerFactory
    emf.close();
}

The main goal of JPA is to simplify the development of applications working with databases by abstracting low-level details of JDBC and SQL, providing an object-oriented approach to persistence. This increases code portability and reduces its dependency on a specific database.