J’avais évoqué il y a quelques temps déjà Play!, et j’avais même traduit le tutoriel officiel en français montrant les capacités de ce framework.

Ayant eu l’occasion de me remettre sur Play! ces derniers jours, je ne peux m’empêcher de vous faire partager le plaisir que j’ai eu à l’utiliser en vous parlant d’un aspect sympathique de ce framework : la gestion des entités.

Si vous avez déjà eu l’occasion de vous faire la main sur Play!, vous ne devriez rien apprendre ici. Il s’agit surtout de donner envie à ceux qui hésitent à se lancer dans l’aventure Play!.

L’entité User

Commençons par écrire notre entité, que nous appellerons User. Voici le code :

package models;

import javax.persistence.Entity;
import play.db.jpa.Model;

@Entity
public class User extends Model {

    public String name;
    public String email;
    public boolean isAdmin;

    public User() {
    }

    public User(String name, String email, boolean isAdmin) {
        this.name = name;
        this.email = email;
        this.isAdmin = isAdmin;
    }

}

Nous notons déjà deux choses importantes :

  • Les propriétés de notre entité sont publiques, et nous ne polluons plus notre classe avec des getters et setters (en attendant les property de Java 8 ;) ).
  • L’entité étend la classe play.db.jpa.Model. C’est ce point que nous allons voir en détail juste après.

La super-classe Model

Cette super-classe Model (et ses parents) vont nous simplifier grandement la vie, car elle nous évitera l’écriture d’un DAO. En effet, nous disposons, simplement grâce à notre entité, des principales méthodes de CRUD (Create, Read, Update, Delete):

  • count() pour compter le nombre d’entités, en fournissant éventuellement des paramètres pour affiner la requête ;
  • save() pour sauver notre entité ;

Voyons quelques exemples basiques avec un test unitaire :

public class UserTest extends UnitTest {

    @Before
    public void clean() {
        Fixtures.deleteDatabase();
    }

    @Test
    public void testAddition() {
        assertEquals(0, User.count());
        new User("romain linsolas", "romain@example.com", true).save();
        assertEquals(1, User.count());
    }

}

On notera que nous nettoyons la base de données en mémoire avant chaque test, afin de ne pas fausser nos résultats. De plus, notre classe JUnit étendant la classe play.test.UnitTest afin de profiter de l'environnement de Play! : création de la base de données en mémoire et la structure des tables, par exemple.

    private void insertUsers() {
        new User("romain linsolas", "admin@example.com", true).save();
        new User("romain linsolas", "romain@example.com", false).save();
        new User("bob l'eponge", "bob.leponge@example.com", false).save();
        new User("romain gary", "romain.gary@example.com", false).save();
    }

    @Test
    public void testFindAll() {
        insertUsers();
        assertEquals(4, User.findAll().size());
    }

    @Test
    public void testFindOneArg() {
        insertUsers();
        List<User> list = User.find("byName", "romain linsolas").fetch();
        assertEquals(2, list.size());
        assertEquals("romain linsolas", list.get(0).name);
    }

    @Test
    public void testFindTwoArgs() {
        insertUsers();
        List<User> list = User.find("byNameAndIsAdmin", "romain linsolas", true).fetch();
        assertEquals(1, list.size());
        assertTrue(list.get(0).isAdmin);
    }

Dans le code précédent, nous insérons quatre utilisateurs, et nous vérifions que la méthode findAll() nous retourne le nombre correct d'éléments. Nous faisons également une autre vérification, où nous recherchons tous les utilisateurs selon la valeur d'une propriété, ici name. Le dernier test permet de montrer une utilisation un peu plus poussée de la méthode find("…"), où nous cherchons tous les utilisateurs ayant un nom donné et dont l'attribut isAdmin vaut true.

Nous pouvons encore améliorer les choses en fournissant encore plus de détails sur la recherche, par exemple comme ceci :

    @Test
    public void testFindAndOrder() {
        insertUsers();
        List<User> list = User.find("name = ? order by email desc", "romain linsolas").fetch();
        assertEquals(2, list.size());
        assertFalse(list.get(0).isAdmin);
    }

où nous cherchons les utilisateurs selon un nom donné, puis en les triant selon l'adresse mail. Nous aurions pu encore corsé les choses en mettant en place des jointures avec d'autres entités...

Bien entendu, cette fonctionnalité ne marche pas seulement avec les méthodes de comptage ou de recherche, on pourra l'utiliser avec la méthode delete() :

    @Test
    public void testDelete() {
        insertUsers();
        User.delete("name = ?", "romain linsolas");
        assertEquals(2, User.count());
    }

Ce ne sont là que quelques possibilités, la classe Model offre d'autres fonctionnalités permettant les opérations de CRUD.

Conclusion

Au final, il n'y rien de révolutionnaire ici, mais que de temps gagné grâce à ces méthodes si utiles ! C'est sans doute ça la force première de Play! : nous offrir un retour rafraichissant à la simplicité. Et ça, c'est bon !

Pour aller plus loin :

Start Slide Show with PicLens Lite PicLens