De multiples relations hasMany à même domaine classe dans Graal

Je suis en utilisant le Graal, et j'ai un modèle de domaine avec plusieurs hasMany attributs pour le même domaine de la classe, qui ressemble à ceci:

static hasMany = [ posts : Post, likes : Post, dislikes : Post ]

Le problème que je suis en cours d'exécution, c'est que lorsque je ajouter quelque chose à la liste des postes, il a également fait en quelque sorte dans les goûts et les dégoûts de listes. Au moins, c'est à quoi il ressemble quand je itérer sur chacune de ces listes.

Je pense que le problème est que j'ai aussi la relation suivante dans mon Post de domaine:

static belongsTo = [ contributer : Contributer ]

Quelle est la meilleure façon d'aller sur la configuration de ces relations pour rendre mon travail sur le modèle? Des suggestions?

@Wayne,

J'ai essayé à l'aide de votre test, et il est passé avec succès. Alors, la seule chose que je peux penser est qu'il ya quelque chose de mal avec ma méthode dans mon PostController. J'ai collé l'relavent code ci-dessous (je suis en utilisant le Printemps de Sécurité de Base du plugin, et mon Contributer classe étend la classe User qui est créé avec ce plugin):

@Secured(['IS_AUTHENTICATED_FULLY'])
def save = {
def props = [title:params.title, post:params.post,   category:Category.get(params.category.id)]

def user = Contributer.get(springSecurityService.principal.id)
def postInstance = new Post(props)

postInstance.contributer = user
if (postInstance.save(flush: true)) {
  flash.message = "${message(code: 'default.created.message', args: [message(code: 'post.label', default: 'Post'), postInstance.id])}"
  redirect(action: "show", id: postInstance.id)
}
else {
  render(view: "create", model: [postInstance: postInstance])
}
}

Il n'y a rien qui se démarque ici?

lorsque vous ajoutez un post à la contributer ne vous faites " myPost.contributer=myContributer " ou " myContributer.addToPosts(myPost)' ?
merci pour la réponse. J'ai essayé les deux façons, avec le même résultat.

OriginalL'auteur NickForrer | 2011-09-24

11

Le problème, c'est que vous avez un un-à-plusieurs entre la Poste et le Collaborateur (poste a un auteur, un auteur a de nombreux postes) ainsi que deux de nombreuses de nombreuses relations entre la Poste et le Collaborateur (poste a beaucoup de likers, likers, comme un grand nombre de postes) (post a de nombreux dislikers, dislikers n'aime pas beaucoup les posts). Le belongsTo à la Poste pour expliquer le comportement, mais l'élimination, il ne sera pas résoudre le problème, il suffit de créer différents. Le résultat final est que GORM conventions vont tomber à court de sorte que vous avez à dire GORM la façon de se comporter ou d'un modèle de choses differntly.

Il y a plusieurs options, mais la celui qui saute à l'esprit est de modèle de Voter séparément de la Poste, et faire en sorte qu'un Contributeur hasMany likeVotes et hasMany dislikeVotes
```
class Vote {

   //for illustration here, you need to think about the 
   //cascading behavior that makes sense and model it if you decide 
   //to go this route. 
  belongsTo = [post, contributor] 

}

class LikeVote extends Vote {
}

class DislikeVote extends Vote {
}
```
GORM servira de modèle cela comme un vote de la table avec une colonne discriminante pour séparer les goûts et les dégoûts; cela va vous permettre d'éliminer les conflits entre les aime, n'aime pas, et l'auteur de postes.

Puis dans le Contributeur
```
 hasMany = [likes:LikeVote, dislikes:DislikeVote, posts:Post]
```
Les relations sont désactivées jusqu'à maintenant:
1. Post a de nombreux likeVotes
2. Post a de nombreux dislikeVotes
3. Contributeur a beaucoup de likeVotes
4. Contributeur a beaucoup de dislikeVotes
5. Post a un contributeur
6. Contributeur dispose d'un grand nombre de postes
GORM peut comprendre ces relations et se comporter de manière appropriée.

Si vous n'aimez pas cette option, la prochaine étape serait de préciser les mappages personnalisés pour votre structure de base de données, puis utiliser mappedBy afin de différencier les diverses relations. C'est l'approche à adopter si vous voulez absolument avoir un Contributeur se rapportent directement au Poste de trois façons différentes.

Merci pour la réponse! Je pense que cela a dissipé beaucoup de confusion au sujet de GORM. Très instructif!
vraiment cool solution +1
Les types ne sont pas les même plus, alors qu'ils devraient être les mêmes. Cela peut avoir des effets secondaires indésirables.

OriginalL'auteur proflux

Utilisation statique mappedBy dans votre domaine classe

Par exemple:

Dans de nombreux côté de domaine objet (Contributer.groovy):

static hasMany = [ posts : Post, likes : Post, dislikes : Post ]
static mappedBy = [posts: "postsContributer", likes: "likesContributer", dislikes: "dislikesContributer"]

Dans un côté de domaine objet (Post.groovy):

Class Post {

       static belongsTo = [ contributer : Contributer ]

       Contributer postsContributer
       Contributer likesContributer
       Contributer dislikesContributer

   ... 
}

OriginalL'auteur Sherm273

4

Bien que, de manière standard pour le multi-M:M est d'utiliser joinTable, comme recommandé dans GRAAL-4884.

à mon humble avis c'est la bonne réponse

OriginalL'auteur Victor Sergienko

Pouvez-vous montrer le cas de test qui échoue? J'ai mis ce que je pense est votre cas dans un graal 1.3.7 projet, et le test passe:

class Post {
    String text ="postal"
    static belongsTo = [ contributor : Contributor ]
    static constraints = { }
}
class Contributor {
    String name = "Big C"
    static hasMany = [ posts : Post, likes : Post, dislikes : Post ]
    static constraints = { }
}

//integration test
void testMultipleRel() {
    Contributor c = new Contributor().save()
    assertNotNull c

    Post p1 = new Post(text:"neutral")
    Post p2 = new Post(text:"like")
    Post p3 = new Post(text:"dislike")
    [p1,p2,p3].each {c.addToPosts(it).save()}
    assertNotNull p1
    assertNotNull p2
    assertNotNull p3

    assertNull c.likes
    assertNull c.dislikes

    c.addToLikes(p2)
    c.addToDislikes(p3)

    assertEquals ([p1, p2, p3] as Set, c.posts as Set)
    assertEquals ([p2]         as Set, c.likes as Set)
    assertEquals ([p3]         as Set, c.dislikes as Set)

}

Veuillez consulter l'édition à la question. Merci de répondre.

OriginalL'auteur Wayne

1

Essayez de passer à un plusieurs-à-plusieurs relations et de définir une cartographie de domaine en classe. Dans ce domaine de la cartographie de la classe, vous pouvez spécifier le type de relation; aimer, ou de l'auteur.
```
class Contributor {
    static hasMany = [contributorPosts:ContributorPost]
}

class ContributorPost {
    Post post
    Contributor contributor
    Boolean like
    Boolean dislike
    Boolean author
}

class Post {
    static hasMany = [contributorPosts:ContributorPost]
}
```
Vous pouvez regarder ici http://www.grails.org/Many-to-Many+Cartographie+sans+Hibernate+XML pour plus d'information sur une plusieurs-à-plusieurs domaine de la cartographie de la classe.

OriginalL'auteur schmolly159

Cela devrait fonctionner:

static hasMany = [ posts : Post, likes : Post, dislikes : Post ]

static mapping = {
    posts joinTable: [name: 'contributor_posts']
    likes joinTable: [name: 'contributor_likes']
    dislikes joinTable: [name: 'contributor_dislikes']
}

OriginalL'auteur Thermech

Vous devez vous connecter pour publier un commentaire.