Le moyen le plus simple d'accéder à une base de données en JAVA

Feb 17 2023

Comparaison entre Hibernate, JPA, EclipseLink et Spring Data JPA Qu'est-ce que l'ORM en Java ? ORM signifie Object-Relational Mapping, et c'est une technique utilisée en Java et dans d'autres langages de programmation pour mapper les données stockées dans une base de données relationnelle à des objets dans un langage de programmation. L'idée est de fournir un moyen pratique d'accéder et de manipuler les données stockées dans la base de données, sans avoir à écrire de code SQL.

Comparaison entre Hibernate, JPA, EclipseLink et Spring Data JPA

Photo de Tobias Fischer sur Unsplash

Qu'est-ce que l'ORM en Java ?

ORM signifie Object-Relational Mapping , et c'est une technique utilisée en Java et dans d'autres langages de programmation pour mapper les données stockées dans une base de données relationnelle à des objets dans un langage de programmation. L'idée est de fournir un moyen pratique d'accéder et de manipuler les données stockées dans la base de données, sans avoir à écrire de code SQL.

Les frameworks JAVA ORM populaires incluent :

Hiberner
JPA de données de printemps
APP

Discutons-en plus en détail.

Présentation : API de persistance Java (JPA)

Fournit une spécification pour la persistance, la lecture et la gestion des données de votre objet Java vers les tables relationnelles de la base de données. Ce cadre fournit une API pratique et cohérente pour effectuer des opérations CRUD (créer, lire, mettre à jour, supprimer) sur la base de données et gérer les relations entre les objets. Cela peut aider à réduire la quantité de code à écrire et à rendre le code plus maintenable et plus facile à comprendre.

Hiberner contre JPA ?

Hibernate est une implémentation de JPA, tandis que JPA est une spécification pour ORM en Java. JPA définit un ensemble d'API standard pour la persistance des données dans une base de données à l'aide d'objets Java, tandis que Hibernate est une implémentation spécifique de ces API. Hibernate a une architecture plus puissante que JPA, car elle permet aux développeurs de personnaliser le processus ORM.

Voici un exemple simple de la manière dont vous pouvez persister un simple objet "Person" dans une base de données en utilisant à la fois JPA et Hibernate :

APP

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    private String firstName;

    private String lastName;

    // Getters and setters omitted for brevity
}

// Persisting an entity using JPA
EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistenceUnitName");
EntityManager em = emf.createEntityManager();

em.getTransaction().begin();
Person person = new Person();
person.setFirstName("John");
person.setLastName("Doe");
em.persist(person);
em.getTransaction().commit();

em.close();
emf.close();

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    private String firstName;

    private String lastName;

    // Getters and setters omitted for brevity
}

// Persisting an entity using Hibernate
SessionFactory sessionFactory = new Configuration()
                                .configure()
                                .buildSessionFactory();
Session session = sessionFactory.openSession();

session.beginTransaction();
Person person = new Person();
person.setFirstName("John");
person.setLastName("Doe");
session.save(person);
session.getTransaction().commit();

session.close();
sessionFactory.close();

Données de printemps JPA contre JPA ?

Spring Data JPA est un framework, tandis que JPA est une spécification. Spring Data JPA est une implémentation JPA par défaut appelée Hibernate avec la spécification fournie dans le cadre de Spring Framework.

Voici un exemple utilisant JPA :

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String firstName;
    private String lastName;

    // Getters and setters ...
}

public class PersonDao {
    private EntityManager em;

    public PersonDao(EntityManager em) {
        this.em = em;
    }

    public void save(Person person) {
        em.getTransaction().begin();
        em.persist(person);
        em.getTransaction().commit();
    }

    public Person findById(Long id) {
        return em.find(Person.class, id);
    }
}

public interface PersonRepository extends JpaRepository<Person, Long> {
}

Vous pouvez également utiliser le PersonRepositorypour effectuer des opérations plus complexes en déclarant simplement des méthodes avec des noms spécifiques et en suivant une convention de dénomination. Spring Data JPA générera automatiquement l'implémentation pour vous.

Comme vous pouvez le constater, le moyen le plus rapide de mapper une base de données en Java consiste à utiliser le framework Spring Data JPA.

Présentation : mise en veille prolongée

Hibernate est un framework de mappage objet-relationnel (ORM) open source pour le langage de programmation Java. Le but de ce cadre est de soulager les développeurs d'une quantité importante de données relationnelles, y compris la gestion des transactions et la conversion des données d'une représentation d'objet en une représentation relationnelle.

Hibernate peut être utilisé avec ou sans l'API Java Persistence (JPA), mais il est souvent utilisé conjointement avec JPA pour fournir une solution complète pour le mappage objet-relationnel et la persistance dans les applications Java.

Avantages

Ce cadre ORM simplifie le processus de stockage et de récupération des données d'une base de données.
Fournit plus de performances et de fonctionnalités d'optimisation, telles que le chargement différé qui peut augmenter les performances de votre application.
Fournit une solution évolutive pour la persistance et la gestion des données à grande échelle.

Hibernate peut être complexe à utiliser pour les relations complexes, telles que l'héritage ou les collections, ce qui peut entraîner des difficultés pour mapper le modèle objet au modèle relationnel.
Il peut être verbeux, en particulier lorsqu'il s'agit d'écrire des requêtes, ce qui peut rendre le code difficile à lire et à maintenir.

Ce cadre introduit le concept de référentiels JPA, un ensemble d' interfaces qui définit les méthodes de requête . Vous n'avez plus besoin d'écrire trop de requêtes. Spring Boot implémentera automatiquement vos interfaces de référentiel, y compris les méthodes de recherche personnalisées, au fur et à mesure que vous les écrivez.

Ce que vous pouvez créer avec Spring Data JPA :

Prise en charge du référentiel : Spring Data JPA fournit une approche d'accès aux données basée sur l'interface. Vous pouvez simplement déclarer une interface qui s'étend JpaRepositoryet obtenir les opérations CRUD de base (Créer, Lire, Mettre à jour, Supprimer)
Création de requête : fournit un mécanisme de création de requêtes personnalisées
Pagination et tri
Transactions : Spring Data JPA fournit une gestion automatique des transactions, facile à réaliser avec une simple annotation @Transaction

Présentation : EclipseLink

EclipseLink est un puissant outil de mappage objet-relationnel (ORM) qui fait partie de l'outillage Java d'entreprise de la Fondation Eclipse. C'est une source ouverte et un bon moyen de commencer à apprendre Java. Ce n'est pas aussi simple que Spring Data JPA mais vous pourrez mieux comprendre ce qui se passe à l'intérieur d'une application.

Prend en charge de nombreuses bases de données que vous pouvez choisir, telles que Postgres, MySQL et MariaDB. Offre des fonctionnalités utiles telles que le chargement différé et un niveau de performance élevé et garantit l'évolutivité de votre application.

L'inconvénient est qu'ils peuvent nécessiter plus d'installation et de configuration que les autres outils ORM.

Exemple d'implémentation simple d'EclipseLink :

EntityManagerFactory emf = Persistence.createEntityManagerFactory("default");
        EntityManager em = emf.createEntityManager();

        //  clear
        em.getTransaction()
                        .begin();
        em.createQuery("DELETE FROM Employee ").executeUpdate();
        em.getTransaction()
                       .commit();

        Employee e1 = new Employee("Costel", "Daniel", "0742929245", 21, Departament.Marketing, 2100.0);
        Employee e2 = new Employee("Daniel", "Costin", "0742929345", 26, Departament.IT, 4100.0);
        Employee e3 = new Employee("Codrin", "Daniel", "0742929245", 41, Departament.HumanResource, 3100.0);
   
        em.getTransaction()
                        .begin();
        System.out.println("Saving your new employees");
        em.persist(e1);
        em.persist(e2);
        em.persist(e3);
      
        em.getTransaction()
                    .commit();

        System.out.println("End");
    }

Si vous utilisez JPA , vous devrez écrire vous-même le code nécessaire pour implémenter la logique de persistance. Mais avec Spring Data JPA , une grande partie de la logique de persistance est automatiquement implémentée pour vous, vous pouvez donc vous concentrer sur l'écriture de la logique métier de l'application. C'est pourquoi Spring Data JPA est plus populaire parmi les développeurs car ils peuvent se concentrer sur la logique métier et ne pas écrire beaucoup de requêtes.

En conclusion, lorsque vous choisissez un outil ORM, il est important de considérer les besoins spécifiques de votre projet, notamment le type de base de données que vous souhaitez utiliser et la complexité de votre modèle de données.