具有 Grails 多对多关系的动态查找器 [英] Dynamic finders with Grails many-to-many relationship

问题描述

我有 2 个由多对多关系映射的域类.我遵循了 Grails 文档的说明，但是在处理这些域上的数据时仍然遇到一些问题.这是我的 2 个域类:

I have 2 domain classes which are mapped by many-to-many relationship. I followed the instruction of Grails documentation, but I still have some problem when processing data on those domains. Here are my 2 domain classes:

class User {
    String name
    int age
    String job
    static hasMany = [groups : Group]
    static belongsTo = [org : Organization]
}

class Group {
    String groupName
    String code
    static hasMany = [members : User]
}

我的问题是:
1. 上述关系要求一个类持有belongsTo 为关系的所有者".在这种情况下，User属于Group，但我不知道如何将belongsTo放到User类中，因为Grails建议的标准语法是静态belongsTo = [Group](只需指定所有者类名)，所以我不能:
- 像这样把它放到存在的所属对象中:静态所属对象 = [org : Organization, Group]
- 或者像这样定义另一个belongsTo:静态belongsTo = [Group]

My problems are:
1. The above relationship require one class hold belongsTo to be the "owner" of the relationship. In this context, the User belongs to the Group, but I do not know how to put the belongsTo to User class, because the standard syntax that Grails suggest is static belongsTo = [Group] (just specify the owner class name), so I cannot:
- put it into the exist belongsTo like this: static belongsTo = [org : Organization, Group]
- or define another belongsTo like this: static belongsTo = [Group]

1. 下面的例子是否正确:

1. Is below example right:

类书{字符串标题静态属于 = 作者静态 hasMany = [作者:作者]

class Book { String title static belongsTo = Author static hasMany = [authors:Author]

static mapping = {
    authors joinTable:[name:"mm_author_books", key:'mm_book_id' ]
}

}类作者{字符串名称静态 hasMany = [书籍:书籍]

} class Author { String name static hasMany = [books:Book]

static mapping = {
    books joinTable:[name:"mm_author_books", key:'mm_author_id']
}

}

(参考链接:多对多链接表在 grails (GORM)/休眠中)
我的意思是我们需要为每个类指定连接表的外键名称吗?

(Ref link: Many-to-Many link tables in grails (GORM) / hibernate)
I mean that do we need to specify the name of foreign key of the join table for each class?

1. 如果我想查找名称为ABC"的指定组的所有成员，我该如何使用 Grails 的 DynamicFinder?

非常感谢

推荐答案

m2m 关系很少有拥有方，所以我总是觉得必须指定一个方让 GORM 正常工作很奇怪.正因为如此，我不这样做.我将连接表创建为域.然后事情变得真的简单.

It is very rare that m2m relationships have an owning side, so I've always found it odd to have to specify one for GORM to work correctly. Because of this, I don't do it this way. I create the join table as a domain. Then things get really simple.

class UserGroup implements Serializable {

    User user
    Group group

    boolean equals(other) {
        if (!(other instanceof UserGroup)) {
            return false
        }

        other.user?.id == user?.id &&
            other.group?.id == group?.id
    }

    int hashCode() {
        def builder = new HashCodeBuilder()
        if (user) builder.append(user.id)
        if (group) builder.append(group.id)
        builder.toHashCode()
    }

    static UserGroup get(long userId, long groupId) {
        find 'from UserGroup where user.id=:userId and group.id=:groupId',
            [userId: userId, groupId: groupId]
    }

    static UserGroup create(User user, Group group, boolean flush = false) {
        new UserGroup(user: user, group: group).save(flush: flush, insert: true)
    }

    static boolean remove(User user, Group group, boolean flush = false) {
        UserGroup instance = UserGroup.findByUserAndGroup(user, group)
        instance ? instance.delete(flush: flush) : false
    }

    static void removeAll(User user) {
        executeUpdate 'DELETE FROM UserGroup WHERE user=:user', [user: user]
    }

    static void removeAll(Group group) {
        executeUpdate 'DELETE FROM UserGroup WHERE group=:group', [group: group]
    }

    static mapping = {
        id composite: ['group', 'user']
        version false
    }
}

然后你只需要在你的 User 和 Group 类中创建 getter.您不会在任何一个班级中拥有 User 用户或 Group 组.无需将它们与 hasMany/belongsTo 进行映射，因为只需创建连接表即可，您已通过创建 UserGroup 域完成此操作.

Then you just need to create the getters in your User and Group class. You won't have User user or Group group in either class. There is no need to map them with hasMany/belongsTo because all that will do is create the join table, which you've done by creating the UserGroup domain.

class User {
   Set<Group> getGroups() {
    UserGroup.findAllByUser(this).collect { it.group } as Set
  }
}

class Group {
  Set<User> getUsers() {
    UserGroup.findAllByGroup(this).collect { it.user } as Set
  }
}

一旦你有了这些，你就可以使用你在 UserGroup 域中创建的方法和/或你可以在它上面使用查找器...

Once you have these in place you can use the methods you created in the UserGroup domain and/or you can use finders on it...

def userGroupInstance = UserGroup.findByUserAndGroup(userInstance, groupInstance)
def userGroups = UserGroup.findAllByUser(userInstance)
def userGroupInstance = UserGroup.get(userId, groupId)

你懂的.这个 Burt Beckwith 的演讲 更详细地说明了为什么这是一个很好的方法以及其他一些方法提高性能的重要提示.

You get the idea. This presentation by Burt Beckwith sheds more light on why this is a good approach along with some other great tips for performance increases.

这篇关于具有 Grails 多对多关系的动态查找器的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！