Java Hibernate-使用唯一键映射多个联接表

我有表用户、角色、组和联接表GroupRoles。一个用户可以有许多角色（其中一些不是特定于组的），一个组可以有许多角色。由于角色可以与组相关，我需要将一个groupID与它们关联，因此GroupRoles有一个唯一的键userID、groupID和roleID。我需要userID作为密钥的一部分，因为我需要知道与用户关联的角色。在hibernate中，映射一个这样的唯一键与映射一个复合键是一样的，在这个复合键中，我可以使用

@Embeddable
public class GroupRoleKey implements Serializable {

    @Column(name="userID")
    private Long userID;

    @Column(name="groupID")
    private Long groupID;

    @Column(name="roleID")
    private Long roleID;

    protected GroupRoleKey(){}

    public GroupRoleKey(Long userID, Long roleID, Long groupID) {
        this.userID = userID;
        this.roleID = roleID;
        this.groupID = groupID
    }

老实说，我不确定这是否是表示用户-角色-组关系的最佳方式，任何建议都将不胜感激。我需要显示用户在他们所属的每个组中的角色，例如，我可能希望显示Bob在组1中的角色Admin和Teacher，在组2中的角色group Admin。我需要知道哪些角色对应于哪个组，哪些角色对应于哪个用户

编辑：

集团实体：

@Table(name="FocusGroups")
@Entity
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "groupID")
public class Group {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long groupID;
    private String groupName;

    @ManyToMany
    @JoinTable(name = "GroupMembers",
            joinColumns = @JoinColumn(
                    name = "groupID"),
            inverseJoinColumns = @JoinColumn(
                    name = "userID"))
    private Set<User> groupMembers = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "GroupRoles",
            joinColumns =
                @JoinColumn(
                name = "groupID"),
            inverseJoinColumns = @JoinColumn(
                    name = "roleID"))
    private Set<Role> roles = new HashSet<>();

    @ManyToOne(fetch = FetchType.EAGER, optional = true)
    @JoinColumn(name="frameworkID", nullable = true)
    private Framework framework;

    public Group(){}

    public Group(String groupName, Set<User> groupMembers, Framework framework) {
        this.groupName = groupName;
        this.groupMembers = groupMembers;
        this.framework = framework;
    }

    public Long getGroupID() {
        return groupID;
    }

    public void setGroupID(Long groupID) {
        this.groupID = groupID;
    }

    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }

    public Set<User> getGroupMembers() {
        return groupMembers;
    }

    public void setGroupMembers(Set<User> groupMembers) {
        this.groupMembers = groupMembers;
    }

    public void addMembers(Set<User> groupMembers){
        this.groupMembers.addAll(groupMembers);
    }

    public void addMember(User groupMember){
        this.groupMembers.add(groupMember);
    }

    public String groupMembersToString(){
        String out = "";
        int count = 0;
        if(groupMembers.size() > 0){
            for(User user: groupMembers){
                if(count >= 1){
                    out += ", ";
                }
                out += user.getUsername();
                count++;
            }
        }else{
            out = "No members";
        }
        return out;
    }

    public boolean hasMember(String groupMemberName) {
        for (User member : this.groupMembers) {
            if (member.getUsername().equals(groupMemberName)) {
                return true;
            }
        }
        return false;
    }

    public User getGroupMember(String groupMemberName){
        for(User member: this.groupMembers){
            if(member.getUsername().equals(groupMemberName)){
                return member;
            }
        }
        return null;
    }

    public Framework getFramework() {
        return framework;
    }

    public void setFramework(Framework framework) {
        this.framework = framework;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}

@Table（name=“FocusGroups”）
@实体
@JsonIdentityInfo（生成器=ObjectedGenerators.PropertyGenerator.class，
property=“groupID”）
公共课组{
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
私有长groupID；
私有字符串组名；
@许多
@JoinTable（name=“GroupMembers”，
joinColumns=@JoinColumn(
name=“groupID”），
inverseJoinColumns=@JoinColumn(
name=“userID”））
private Set groupMembers=new HashSet（）；
@许多
@JoinTable（name=“GroupRoles”，
连接柱=
@连接柱(
name=“groupID”），
inverseJoinColumns=@JoinColumn(
name=“roleID”））
私有集角色=新HashSet（）；
@manytone（fetch=FetchType.EAGER，可选=true）
@JoinColumn（name=“frameworkID”，nullable=true）
私有框架；
公共组（）{}
公共组（字符串组名、集合组成员、框架）{
this.groupName=groupName；
this.groupMembers=groupMembers；
这个框架=框架；
}
公共长getGroupID（）{
返回groupID；
}
public void setGroupID（长groupID）{
this.groupID=groupID；
}
公共字符串getGroupName（）{
返回groupName；
}
public void setGroupName（字符串groupName）{
this.groupName=groupName；
}
公共集getGroupMembers（）{
返回组成员；
}
公共无效setGroupMembers（集合groupMembers）{
this.groupMembers=groupMembers；
}
public void addMembers（设置组成员）{
this.groupMembers.addAll（groupMembers）；
}
public void addMember（用户组成员）{
this.groupMembers.add（groupMember）；
}
公共字符串groupMembersToString（）{
串出“”；
整数计数=0；
如果（groupMembers.size（）>0）{
用于（用户：groupMembers）{
如果（计数>=1）{
out+=“，”；
}
out+=user.getUsername（）；
计数++；
}
}否则{
out=“无成员”；
}
返回；
}
公共布尔hasMember（字符串groupMemberName）{
for（用户成员：this.groupMembers）{
if（member.getUsername（）.equals（groupMemberName））{
返回true；
}
}
返回false；
}
公共用户getGroupMember（字符串groupMemberName）{
for（用户成员：this.groupMembers）{
if（member.getUsername（）.equals（groupMemberName））{
返回成员；
}
}
返回null；
}
公共框架getFramework（）{
回报框架；
}
公共框架（框架）{
这个框架=框架；
}
公共集getRoles（）{
返回角色；
}
公共无效集合角色（集合角色）{
this.roles=角色；
}
}

角色：

@实体
@表（name=“Roles”）
公共阶级角色{
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
私人长罗莱德；
私有字符串roleName；
@许多
@JoinTable（name=“GroupRoles”，
连接柱=
@连接柱(
name=“roleID”），
inverseJoinColumns=@JoinColumn(
name=“groupID”，nullable=true）
私有集组=新HashSet（）；
受保护的角色（）{}
公共角色（字符串角色名）{
this.roleName=roleName；
}
公共长getId（）{
返回roleID；
}
公共无效集合id（长id）{
this.roleID=id；
}
公共字符串getName（）{
返回roleName；
}
public void setName（字符串roleName）{
this.roleName=roleName；
}
}

用户：

@Table（name=“Users”）
@实体
@名称存储过程请求({
@名称存储过程(
name=“userRating”，
procedureName=“CalculateUserRating”，
参数={
@存储过程参数(
name=“userID”，
类型=Long.class，
模式=ParameterMode.IN），
@存储过程参数(
name=“focusID”，
类型=Long.class，
模式=ParameterMode.IN），
@存储过程参数(
name=“userRating”，
type=BigDecimal.class，
模式=参数模式（输出）
})
})
//存储基本评级？
公共类用户{
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
私有长用户ID；
@列（name=“userHashedPassword”）
脉波重复间隔
@Entity
@Table(name = "Roles")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long roleID;

    private String roleName;

    @ManyToMany
    @JoinTable(name = "GroupRoles",
            joinColumns =
            @JoinColumn(
                    name = "roleID"),
            inverseJoinColumns = @JoinColumn(
                    name = "groupID", nullable = true))
    private Set<Group> groups = new HashSet<>();

    protected Role(){}

    public Role(String roleName){
        this.roleName = roleName;
    }

    public Long getId() {
        return roleID;
    }

    public void setId(Long id) {
        this.roleID = id;
    }

    public String getName() {
        return roleName;
    }

    public void setName(String roleName) {
        this.roleName = roleName;
    }
}

@Table(name="Users")
@Entity
@NamedStoredProcedureQueries({
        @NamedStoredProcedureQuery(
                name = "userRating",
                procedureName = "CalculateUserRating",
                parameters = {
                        @StoredProcedureParameter(
                                name = "userID",
                                type = Long.class,
                                mode = ParameterMode.IN),
                        @StoredProcedureParameter(
                                name = "focusID",
                                type = Long.class,
                                mode = ParameterMode.IN),
                        @StoredProcedureParameter(
                                name = "userRating",
                                type = BigDecimal.class,
                                mode = ParameterMode.OUT)
                })
})
//store a base rating?
public class User {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long userID;

    @Column(name = "userHashedPassword")
    private String password;

    @Column(name = "userName")
    private String userName;
    @Column(name = "userEmail")
    private String email;

    @ManyToMany
    @JoinTable(name = "GroupMembers",
            joinColumns = @JoinColumn(
                    name = "userID"),
            inverseJoinColumns = @JoinColumn(
                    name = "groupID"))
    private Set<Group> usersGroups = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "UserRoles",
        joinColumns = @JoinColumn(
                name = "userID"),
            inverseJoinColumns = @JoinColumn(
                    name = "roleID"))
    private Set<Role> roles = new HashSet<>();

    @OneToMany(mappedBy = "user")
    private Set<Rating> ratings;

    protected User(){}

    public User(String userHashedPassword, String userName, String email, Set<Role> roles){
        this.password = userHashedPassword;
        this.userName = userName;
        this.email = email;
        this.roles = roles;
    }

    public User(String userName, String userHashedPassword){
        this.userName = userName;
        this.password = userHashedPassword;
    }

    public Long getUserId() {
        return userID;
    }

    public void setId(Long userID) {
        this.userID = userID;
    }

    public String getPassword(){
        return password;
    }

    public void setPassword(String password){
        this.password = password;
    }

    public String getUsername() {
        return userName;
    }

    public void setUsername(String name) {
        this.userName = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

    public Set<Rating> getRatings() {
        return ratings;
    }

    public void setRatings(Set<Rating> ratings) {
        this.ratings = ratings;
    }

    public String rolesToString(){
        String outputRoles = "";
        int count = 0;
        for(Role role: roles){
            if(count >= 1){
                outputRoles += ", ";
            }
            outputRoles += role.getName();
            count++;
        }
        return outputRoles;
    }

    public void removeRole(Role role){
        this.roles.remove(role);
    }

    public Set<Group> getGroups() {
        return usersGroups;
    }

    public void addGroup(Group group) {
        this.usersGroups.add(group);
    }

    public void addGroups(Set<Group> groups) {
        this.usersGroups.addAll(groups);
    }

    public Set<Group> getUsersGroups() {
        return usersGroups;
    }

    public void setUsersGroups(Set<Group> usersGroups) {
        this.usersGroups = usersGroups;
    }

    public String groupsToString(){
        String outputGroups = "";
        int count = 0;
        if(usersGroups.size() > 0){
            for(Group group: usersGroups){
                if(count >= 1){
                    outputGroups += ", ";
                }
                outputGroups += group.getGroupName();
                count++;
            }
        }else{
            outputGroups = "None";
        }
        return outputGroups;
    }
}