Hibernate et Scala

Question

Je me suis amusé avec Scala et je me demandais si quelqu'un avait une expérience de l'utilisation d'Hibernate et de MySQL comme magasin persistant pour les objets Scala ? Est-ce que ça marche tout de suite ou est-ce qu'il y a beaucoup à faire ?

Answer 1

La plupart du temps, Scala + Hibernate fonctionne assez bien, avec quelques petites difficultés qui peuvent être surmontées facilement. Par exemple, lorsqu'il s'agit de collections, Hibernate exige l'utilisation des interfaces java.util. Mais vous pouvez importer scala.collection.jcl.Conversions._ si vous souhaitez exploiter la bibliothèque plus puissante de Scala.

Vous pouvez consulter Frank Sommers pour plus d'informations.

Answer 2

Ce n'est certainement pas un gros travail. Un simple exemple hibernate + scala peut être défini en quelques dizaines de lignes. Scala et Java peuvent être mélangés dans un même projet. En particulier, la combinaison hibernate-scala permet de combiner le framework JPA, et une couche orm très flexible avec l'élégance des structures immuables et de la programmation fonctionnelle telle que fournie par scala.

La façon la plus simple d'expérimenter avec hibernate et scala est d'utiliser une base de données hsqldb en mémoire via hibernate/jpa. Tout d'abord, définissons le modèle de domaine. Dans ce cas, une classe scala annotée selon le style hibernate, sur mes copains.

package nl.busa.jpa
import javax.persistence._

@Entity
@Table(name = "buddy")
class Buddy(first: String, last: String) {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    var id: Int = _

    var firstName: String = first
    var lastName: String  = last

    def this() = this (null, null)

    override def toString = id + " = " + firstName + " " + lastName
}

Notez que la classe scala est beaucoup plus compacte que la classe java, puisque nous n'avons pas besoin du code passe-partout typique getter/setter. Maintenant, assurons-nous que les modules jpa et le modèle de base de données sont chargés. Selon les spécifications d'Hibernate, ajoutons le fichier de configuration bien connu d'Hibernate : resources/META-INF/persistence.xml :

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
        version="2.0">
    <persistence-unit name="nl.busa.jpa.HibernateJpaScalaTutorial">
        <description>
        Persistence unit for the JPA tutorial of the Hibernate Getting Started Guide
        </description>
        <class>nl.busa.jpa.HibernateJpaScalaTutorial</class>
        <properties>
            <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:mem:JpaScala"/>
            <property name="hibernate.show_sql" value="false"/>
            <property name="hibernate.hbm2ddl.auto" value="create"/>
        </properties>
    </persistence-unit>
</persistence>

Après avoir défini la configuration de la persistance, passons au fichier scala principal :

package nl.busa.jpa

import javax.persistence.EntityManager
import javax.persistence.EntityManagerFactory
import javax.persistence.Persistence

import scala.collection.JavaConversions._

object HibernateJpaScalaTutorial      {

  var entityManagerFactory: EntityManagerFactory = Persistence.createEntityManagerFactory( "nl.busa.jpa.HibernateJpaScalaTutorial" )
  var entityManager: EntityManager = entityManagerFactory.createEntityManager()

  def main( args : Array[String]) {

    entityManager.getTransaction().begin()
    entityManager.persist( new Buddy( "Natalino", "Busa" ) )
    entityManager.persist( new Buddy( "Angelina", "Jolie" ) )
    entityManager.persist( new Buddy( "Kate", "Moss" ) )
    entityManager.getTransaction().commit()

    entityManager.getTransaction().begin();
    val allBuddies = entityManager.createQuery("From Buddy", classOf[Buddy]).getResultList.toList
    entityManager.getTransaction().commit();

    allBuddies foreach println 

    entityManager.close();

  }
}

Le code est assez simple. Une fois l'EntityManager JPA créé via la factory, le modèle de données est disponible pour l'insertion, la suppression, l'interrogation, en utilisant les méthodes définies dans la documentation de hibernate et jpa.

Cet exemple a été mis en place en utilisant sbt. Après avoir récupéré les paquets nécessaires et compilé les sources, l'exécution du tutoriel produira le journal suivant :

HibernateJpaScalaTutorial:-:1.0.0> run
[info] Running nl.busa.jpa.HibernateJpaScalaTutorial 
1 = Natalino Busa
2 = Angelina Jolie
3 = Kate Moss
[success] Total time: 4 s, completed Dec 9, 2012 4:18:00 PM

Answer 3

Scala Query n'est pas Hibernate mais peut être intéressant.

• http://github.com/szeiger/scala-query
• http://szeiger.de/blog/category/scala/scala-query/
• www.cs.uwm.edu/~dspiewak/papers/scalaql.pdf

Answer 4

Voir l'exemple de mapping Option dans hibernate : http://snippets.dzone.com/posts/show/10025

Answer 5

Il y a des problèmes. Comme certaines fonctionnalités de JPA utilisent des annotations imbriquées, par exemple les collections, vous êtes en difficulté car Scala ne prend pas encore en charge les annotations imbriquées. Cela disparaîtra avec la sortie de la version 2.8.

Ver Blog de Wille Faler pour en savoir plus sur ce sujet et sur d'autres incompatibilités.