Comment puis-je utiliser JPA persister une Carte (java.util.Carte) objet à l'intérieur d'une entité et de s'assurer de la persistance des cascades?

J'ai récemment commencé à jouer avec le Jeu! Cadre pour Java, la version 1.2.3 (la dernière). Tout en testant le cadre, je suis tombé sur un étrange problème lorsque vous essayez de conserver un Map objet à l'intérieur d'une Hibernate entité appelée FooSystem. L'objet Map cartes d'un long Hibernate entity j'ai appelé Foo, avec la déclaration Map<Long, Foo> fooMap;

Mon problème est comme suit: corriger les tables sont créées comme je l'ai annoté. Toutefois, lorsque le FooSystem objet fs est persistant, les données fs.fooMap ne l'est pas!

Voici le code que j'utilise pour les entités. La première est Foo:

package models.test;

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

@Entity
public class Foo extends Model
{
    @ManyToOne
    private FooSystem foosystem;

    public Foo(FooSystem foosystem)
    {
        this.foosystem = foosystem;
    }
}

Et voici FooSystem:

package models.test;

import java.util.HashMap;
import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import play.db.jpa.Model;

@Entity
public class FooSystem extends Model
{
    @ManyToMany(cascade = {CascadeType.ALL, CascadeType.PERSIST})
    @JoinTable(
        name = "fooMap",
        joinColumns = @JoinColumn(name = "foosystem"),
        inverseJoinColumns = @JoinColumn(name = "foo")
    )
    private Map<Long, Foo> fooMap = new HashMap<Long, Foo>();

    public FooSystem()
    {
        Foo f1 = new Foo(this);
        Foo f2 = new Foo(this);
        fooMap.put(f1.getId(), f1);
        fooMap.put(f2.getId(), f2);
    }

    public Map<Long, Foo> getFooMap()
    {
        return fooMap;
    }
}

Ici est la Controller classe j'utilise pour tester mon set-up:

package controllers;

import javax.persistence.EntityManager;
import models.test.FooSystem;
import play.db.jpa.JPA;
import play.mvc.Controller;

public class TestController extends Controller
{
    public static void index() {
        EntityManager em = JPA.em();
        FooSystem fs = new FooSystem();
        em.persist(fs);
        render();
    }
}

Le Jeu! cadre créé automatiquement une transaction pour la requête HTTP. Bien que les données sont insérées dans la foo et foosystem tables, rien n'est jamais inséré dans le foomap la table, qui est le résultat souhaité. Que puis-je faire à ce sujet? Ce qui me manque?

quelle est la version de JPA êtes-vous à l'aide.JPA2 a '@pour valeur elementcollection " qui ne ce download.oracle.com/javaee/6/api/javax/persistence/...
Je suis à l'aide de JPA2 comme une question de fait. J'ai essayé ta suggestion et il a travaillé, après j'ai fait quelques ajustements à l'ordre dans lequel j'ai sauvé ma entités! Je vais poster la solution complète dans les prochaines 24 heures! Il est très tard dans la nuit où j'habite, et j'ai besoin de dormir. Merci pour votre aide! J'ai vu le @ElementCollection annotation ailleurs sur Internet lors de la recherche pour mon problème, mais à l'aide de @ElementCollection ne fonctionne pas la première fois que j'ai essayé. J'avais écrit jusqu'à ce que maintenant. Merci!

OriginalL'auteur fruchtose | 2011-09-22

  1. 4

    J'ai réussi à résoudre ce problème en utilisant les conseils de Java Ka Bébé. La question n'était pas dans mon Model classes; le problème réside dans le Controller. Plus précisément, j'essayais de sauver les entités dans le mauvais ordre. Une fois que j'ai réalisé que l'utilisation de la @ElementCollection annotation sur le Map<Long, Foo> produit les mêmes effets que la table de jointure, j'ai été spécifiant manuellement, j'ai essayé j'ai pensé expérience où j'ai re-réfléchi à la manière dont je gardais mes entités.

    Dans le code que j'ai posté ci-dessus, vous pouvez voir dans le FooSystem constructeur que deux Foo objets, f1 et f2, sont mis en fooMap avant la Foo objets sont conservées. J'ai réalisé que si f1 n'est pas dans la base de données lorsqu'il est mis dans la map, comment est JPA capable d'utiliser son ID comme clé étrangère dans la table de jointure?

    Si vous pouvez voir où je vais avec cette ligne de raisonnement, on peut voir que la réponse évidente est que JPA est pas en mesure d'accomplir ce tour de force incroyable de l'aide d'une clé étrangère pour faire référence à une clé inexistante. La chose bizarre est que le Jeu! la console n'a pas de noter toutes les erreurs à tous pour le code d'origine que j'ai posté, même si ce n'était pas correct du tout. Le cadre avalé chaque Exception levée pendant le processus, ou j'ai écrit le code qui devrait produire un Exception.

    Afin de résoudre le problème, j'ai conservé le Foo entités avant tout les opérations ont été effectuées sur eux. Alors seulement je les ai mis dans fooMap. Enfin, une fois fooMap a été remplie, j'ai conservé le FooSystem entité.

    Voici le corrigé TestController classe:

    package controllers;

import javax.persistence.EntityManager;
import models.test.Foo;
import models.test.FooSystem;
import play.db.jpa.JPA;
import play.mvc.Controller;

public class TestController extends Controller
{
    public static void index() {
        EntityManager em = JPA.em();
        FooSystem fs = new FooSystem();
        Foo f1 = new Foo(fs);
        Foo f2 = new Foo(fs);
        f1.save();
        f2.save();
        fs.put(f1.getId(), f1);
        fs.put(f2.getId(), f2);
        fs.save();
        render();
    }
}

    Et, depuis que j'ai changé FooSystem, voici le code final pour la classe:

    package models.test;

import java.util.HashMap;
import java.util.Map;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import play.db.jpa.Model;

@Entity
public class FooSystem extends Model
{
    @ElementCollection
    private Map<Long, Foo> fooMap = new HashMap<Long, Foo>();

    public FooSystem()
    {
    }

    public Map<Long, Foo> getFooMap()
    {
        return fooMap;
    }

    public void put(Long l, Foo f)
    {
        fooMap.put(l, f);
    }
}

    OriginalL'auteur fruchtose