Java 休眠多对多关系仅以一种方式可见

Java 8，Hibernate 4.3.8.Final，Play框架，SQL Server在其背后使用官方驱动程序，使用IntelliJ 14.1.2

基本上，我有一组用户和一组访问组。组有用户，用户有组，多对多

Persistent.java

package models;

import play.db.jpa.JPA;

import javax.persistence.*;
import java.io.Serializable;
import java.sql.Timestamp;


@MappedSuperclass
public class Persistent implements Serializable{

protected Persistent() {
    this.creationTime = new Timestamp(System.currentTimeMillis());
    this.modificationTime = new Timestamp(System.currentTimeMillis());
}

protected final static String DATE_FORMAT = "MM/dd/yyyy hh:mm a";

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

。。。etc（其他getter/setter、persist（）、update（）、remove（）方法等）

AccessGroup.java：

package models;

import javax.persistence.*;
import java.util.Collection;
import java.util.Set;

@Entity
@AttributeOverrides({@AttributeOverride(name = "id", column = @Column(name = "accessGroupId"))})
public class AccessGroup extends Persistent {

    @ManyToMany(        
        cascade = {CascadeType.PERSIST, CascadeType.MERGE}, 
        mappedBy = "accessGroups", 
        targetEntity = User.class)
    private Collection<User> users;

    public Collection<User> getUsers() {
        return users;
    }

    public void setUsers(Collection<User> users) {
        this.users = users;
    }

封装模型；
导入javax.persistence.*；
导入java.util.Collection；
导入java.util.Set；
@实体
@AttributeOverrides（{@AttributeOverride（name=“id”，column=@column（name=“accessGroupId”））}）
公共类AccessGroup扩展了持久性{
@许多（
cascade={CascadeType.PERSIST，CascadeType.MERGE}，
mappedBy=“accessGroups”，
targetEntity=User.class）
私人收藏用户；
公共集合getUsers（）{
返回用户；
}
公共void集合用户（集合用户）{
this.users=用户；
}

…等（与此关系无关的其他获取者和设置者）

User.java： 包装模型

import com.fasterxml.jackson.annotation.JsonIgnore;

import javax.persistence.*;
import java.util.Collection;



@Entity
@Table(name = "AppUsers")
@AttributeOverrides({@AttributeOverride(name = "id", column = @Column(name = "userId"))})
public class User extends Persistent{
    public User() {};

    public static UserFinder getFinder() {
        return new UserFinder();
    }

    public static class UserFinder extends Finder<User> {

        public UserFinder () {
            super(User.class);
        }

}
    @ManyToMany(fetch = FetchType.EAGER, 
            targetEntity = AccessGroup.class,        
            cascade={CascadeType.PERSIST, CascadeType.MERGE})
    @JoinTable(name="user_groups", joinColumns = {
            @JoinColumn(name="userId")},
            inverseJoinColumns = { @JoinColumn(name = "accessGroupId")
            })
    private Collection<AccessGroup> accessGroups;

    public Collection<AccessGroup> getAccessGroups() {
        return accessGroups;
    }

    public void setAccessGroups(Collection<AccessGroup> access_groups) {
        this.accessGroups = access_groups;
    }

import com.fasterxml.jackson.annotation.JsonIgnore；
导入javax.persistence.*；
导入java.util.Collection；
@实体
@表（name=“AppUsers”）
@AttributeOverrides（{@AttributeOverride（name=“id”，column=@column（name=“userId”））}）
公共类用户扩展持久性{
公共用户（）{}；
公共静态UserFinder getFinder（）{
返回新的UserFinder（）；
}
公共静态类UserFinder扩展了UserFinder{
公共用户查找器（）{
super（User.class）；
}
}
@ManyToMany（fetch=FetchType.EAGER，
targetEntity=AccessGroup.class，
cascade={CascadeType.PERSIST，CascadeType.MERGE}）
@JoinTable（name=“用户组”，JointColumns={
@JoinColumn（name=“userId”）}，
inverseJoinColumns={@JoinColumn（name=“accessGroupId”）
})
私人收藏组；
公共集合getAccessGroups（）{
返回访问组；
}
public void setAccessGroups（集合访问组）{
this.accessGroups=访问组；
}

……同样，其他方法也不相关

persistence.xml

 <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
             version="2.1">
    <persistence-unit name="liveDB" transaction-type="RESOURCE_LOCAL">
        <properties>

            <property name="hibernate.connection.url" value="jdbc:sqlserver://#############"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.SQLServerDialect"/>
            <property name="hibernate.connection.driver_class" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
            <property name="hibernate.connection.username" value="#############"/>
            <property name="hibernate.connection.password" value="#############"/>

            <property name="hibernate.archive.autodetection" value="class"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="hibernate.use_sql_comments" value="true"/>

        </properties>
    </persistence-unit>

</persistence>

下面是我用来从用户（所有者）方面创建测试、持久化和更新关系的代码

AccessGroup newGroup=newaccessgroup（）；
newGroup.setName（“集团”）；
newGroup.persist（）；
集合组列表=新的ArrayList（）；
groupList.add（newGroup）；
User newUser=新用户（）；
newUser.setFirstName（“测试”）；
newUser.setLastName（“用户”）；
newUser.setEmail（“test@user.com");
newUser.setAccessGroups（groupList）；
persist（）；

数据库被完美地识别和创建

如果我去运行一个查询来检索用户对象，我会得到一个正确的访问组列表（在其他变体中，我添加了多个组），但反过来，如果我查询访问组，“用户”列表是空的

表结构是按原样创建的，连接表名为user_groups，包含AccessGroup和AppUsers表中的ID。我在其他框架中运行过这方面的示例，从internet复制并粘贴了Hibernate m:m映射的其他示例，但我无法使它们中的任何一个正确运行

我做错了什么

AccessGroup newGroup = new AccessGroup();
newGroup.setName("The Group");
newGroup.persist();

Collection<AccessGroup> groupList = new ArrayList<AccessGroup>();
groupList.add(newGroup);

User newUser = new User();
newUser.setFirstName("Test");
newUser.setLastName("User");
newUser.setEmail("test@user.com");
newUser.setAccessGroups(groupList);
newUser.persist();