TOC

Guide pour Ebean ORM

Guide de l'ORM Ebean

1. introduction

Ebean est un outil de mappage objet-relationnel écrit en Java.

Il prend en charge les annotations JPA standard pour la déclaration d'entités. Cependant, il fournit une API beaucoup plus simple pour la persistance. En fait, l'un des points à noter à propos de l'architecture Ebean est qu'elle est sans session, ce qui signifie qu'elle ne gère pas entièrement les entités.

En plus de cela, il est également livré avec une API de requête et prend en charge l'écriture de requêtes en SQL natif. Ebean prend en charge tous les principaux fournisseurs de bases de données tels que Oracle, Postgres, MySql, H2, etc.

Dans ce didacticiel, nous allons voir comment nous pouvons créer, conserver et interroger des entités à l'aide d'Ebean et H2.

2. Installer

Pour commencer, voyons nos dépendances ainsi qu'une configuration de base.

2.1. Dépendances Maven

Avant de commencer, importons les dépendances requises: 


    io.ebean
    ebean
    11.22.4


    com.h2database
    h2
    1.4.196


    ch.qos.logback
    logback-classic
    1.2.3

Les dernières versions deEbean,H2 etLogback sont disponibles sur Maven Central.

2.2. Améliorations

Ebean doit modifier les beans entité afin qu'ils puissent être gérés par le serveur. Ainsi, nous allons ajouter un plugin Maven pour faire ce travail: 


    io.ebean
    ebean-maven-plugin
    11.11.2
    
        
            main
            process-classes
            
                debug=1
            
            
                enhance

Nous devons également fournir au plug-in Maven les noms des packages contenant les entités et les classes qui utilisent des transactions. Pour ce faire, nous créons le fichierebean.mf: 

entity-packages: com.example.ebean.model
transactional-packages: com.example.ebean.app

2.3. Enregistrement

Créons égalementlogback.xml et définissons les niveaux de journalisation de certains packages surTRACE afin que nous puissions voir les instructions en cours d'exécution:

3. Configurer un serveur

Nous devons créer une instanceEbeanServer pour enregistrer des entités ou exécuter des requêtes sur une base de données. Il existe deux manières de créer une instance de serveur: utiliser un fichier de propriétés par défaut ou le faire par programme.

3.1. Utilisation d'un fichier de propriétés par défaut

Le fichier de propriétés par défaut peut être de typeproperties ouyaml. Ebean recherchera la configuration dans les fichiers avec les nomsapplication.properties,ebean.properties ouapplication.yml.

Outre la fourniture des détails de connexion à la base de données, nous pouvons également demander à Ebean de créer et d'exécuter des instructions DDL.

Voyons maintenant un exemple de configuration: 

ebean.db.ddl.generate=true
ebean.db.ddl.run=true

datasource.db.username=sa
datasource.db.password=
datasource.db.databaseUrl=jdbc:h2:mem:customer
datasource.db.databaseDriver=org.h2.Driver

3.2. Utilisation de ServerConfig

Voyons ensuite comment nous pouvons créer le même serveur par programmation en utilisantEbeanServerFactory etServerConfig: 

ServerConfig cfg = new ServerConfig();

Properties properties = new Properties();
properties.put("ebean.db.ddl.generate", "true");
properties.put("ebean.db.ddl.run", "true");
properties.put("datasource.db.username", "sa");
properties.put("datasource.db.password", "");
properties.put("datasource.db.databaseUrl","jdbc:h2:mem:app2";
properties.put("datasource.db.databaseDriver", "org.h2.Driver");

cfg.loadFromProperties(properties);
EbeanServer server = EbeanServerFactory.create(cfg);

3.3. Instance de serveur par défaut

A single EbeanServer instance maps to a single database. En fonction de nos besoins, nous pourrions également créer plus d'une instance deEbeanServer.

Si une seule instance de serveur est créée, elle est enregistrée par défaut en tant qu'instance de serveur par défaut. Il est accessible n'importe où dans l'application en utilisant une méthode statique sur la classeEbean: 

EbeanServer server = Ebean.getDefaultServer();

S'il y a plusieurs bases de données, il est possible d'enregistrer l'une des instances de serveur comme instance par défaut: 

cfg.setDefaultServer(true);

4. Création d'entités

Ebean fournit un support complet pour les annotations JPA ainsi que des fonctionnalités supplémentaires en utilisant ses propres annotations.

Créons quelques entités à l'aide d'annotations JPA et Ebean. Tout d'abord, nous allons créer unBaseModel qui contient des propriétés communes aux entités: 

@MappedSuperclass
public abstract class BaseModel {

    @Id
    protected long id;

    @Version
    protected long version;

    @WhenCreated
    protected Instant createdOn;

    @WhenModified
    protected Instant modifiedOn;

    // getters and setters
}

Ici, nous avons utilisé l'annotation JPAMappedSuperClass pour définir les annotationsBaseModel. et deux annotations Ebeanio.ebean.annotation.WhenCreated etio.ebean.annotation.WhenModified à des fins d'audit.

Ensuite, nous allons créer deux entitésCustomer etAddress qui étendentBaseModel: 

@Entity
public class Customer extends BaseModel {

    public Customer(String name, Address address) {
        super();
        this.name = name;
        this.address = address;
    }

    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    Address address;

    // getters and setters
}
@Entity
public class Address extends BaseModel{

    public Address(String addressLine1, String addressLine2, String city) {
        super();
        this.addressLine1 = addressLine1;
        this.addressLine2 = addressLine2;
        this.city = city;
    }

    private String addressLine1;
    private String addressLine2;
    private String city;

    // getters and setters
}

DansCustomer, nous avons défini un mappage un à un avecAddress et ajouté un type de cascade défini àALL afin que les entités enfants soient également mises à jour avec les entités parentes.

5. Opérations CRUD de base

Nous avons vu précédemment comment configurer lesEbeanServer et créer deux entités. Maintenant,let’s carry out some basic CRUD operations dessus.

Nous utiliserons l'instance de serveur par défaut pour conserver et accéder aux données. La classeEbean fournit également des méthodes statiques pour conserver et accéder aux données qui transmettent la demande à l'instance de serveur par défaut: 

Address a1 = new Address("5, Wide Street", null, "New York");
Customer c1 = new Customer("John Wide", a1);

EbeanServer server = Ebean.getDefaultServer();
server.save(c1);

c1.setName("Jane Wide");
c1.setAddress(null);
server.save(c1);

Customer foundC1 = Ebean.find(Customer.class, c1.getId());

Ebean.delete(foundC1);

Tout d'abord, nous créons un objetCustomer et avons utilisé l'instance de serveur par défaut pour le sauvegarder en utilisantsave().

Ensuite, nous mettons à jour les détails du client et les enregistrons à nouveau à l'aide desave().

Enfin, nous utilisons la méthode statiquefind() surEbean pour récupérer le client et le supprimer à l'aide dedelete().

6. Des requêtes

Query APIs can also be used to create an object graph with filters and predicates. Nous pouvons utiliserEbean ouEbeanServer pour créer et exécuter des requêtes.

Examinons une requête qui trouve unCustomer par ville et renvoie un sobjectCustomer etAddress avec seulement quelques champs renseignés: 

Customer customer = Ebean.find(Customer.class)
            .select("name")
            .fetch("address", "city")
            .where()
            .eq("city", "San Jose")
            .findOne();

Ici, avecfind() nous indiquons que nous voulons trouver des entités de typeCustomer. Ensuite, nous utilisonsselect() pour spécifier les propriétés à remplir dans l'objetCustomer.

Plus tard, nous utilisonsfetch() pour indiquer que nous voulons récupérer l'objetAddress appartenant auxCustomer et que nous voulons récupérer le champcity.

Enfin, nous ajoutons un prédicat et limitons la taille du résultat à 1.

7. Transactions

Ebean exécute chaque instruction ou requête dans une nouvelle transaction par défaut.

Bien que cela puisse ne pas être un problème dans certains cas. Il peut arriver que nous souhaitions exécuter un ensemble d'instructions dans une seule transaction.

Dans de tels cas, si nous annotons la méthode avecio.ebean.annotations.Transactional, all, les instructions de la méthode seront exécutées dans la même transaction: 

@Transactional
public static void insertAndDeleteInsideTransaction() {
    Customer c1 = getCustomer();
    EbeanServer server = Ebean.getDefaultServer();
    server.save(c1);
    Customer foundC1 = server.find(Customer.class, c1.getId());
    server.delete(foundC1);
}

8. Construire le projet

Enfin, nous pouvons construire le projet Maven en utilisant la commande: 

compile io.ebean:ebean-maven-plugin:enhance

9. Conclusion

Pour résumer, nous avons examiné les fonctionnalités de base d'Ebean qui peuvent être utilisées pour conserver et interroger des entités dans une base de données relationnelle.

Enfin, ce code est disponible surGithub.

Related