Oracle Hibernate复合表及其关键问题

我试图让hibernate使用复合表。基本上有一个users表、roles表和一个名为userroles的复合表，它将两者连接起来。我从一个拥有角色的用户那里得到的查询急切地输出了下面的内容。我不断收到stackoverflow错误或null异常。我的问题是，为什么列在Oracle中生成两个userid和roleid输出

 select
    this_.ID as ID0_1_,
    this_.DATECREATED as DATECREA2_0_1_,
    this_.EMAIL as EMAIL0_1_,
    this_.ENABLED as ENABLED0_1_,
    this_.FIRSTNAME as FIRSTNAME0_1_,
    this_.LASTNAME as LASTNAME0_1_,
    this_.PASSWORD as PASSWORD0_1_,
    this_.SALT as SALT0_1_,
    this_.USERNAME as USERNAME0_1_,
    userroles2_.USERID as USERID3_,
    userroles2_.ROLEID as ROLEID3_,
    userroles2_.ROLEID as ROLEID3_0_,
    userroles2_.USERID as USERID3_0_ 
from
    CISCO.USERS this_ 
inner  join
    CISCO.USERROLES userroles2_ 
        on this_.ID=userroles2_.USERID 
where
    this_.USERNAME='mike'

我的课在下面

User.java

@Entity
@Table(name = "USERS", schema = "CISCO")
@SuppressWarnings("serial")
public class User implements Serializable {

    /**
     * Attribute id.
     */
    private long id;

    /**
     * Attribute username.
     */
    private String username;

    /**
     * Attribute password.
     */
    private String password;

    /**
     * Attribute enabled.
     */
    private Long enabled;

    /**
     * Attribute salt.
     */
    private String salt;

    /**
     * Attribute first name.
     */
    private String firstName;

    /**
     * Attribute last name.
     */
    private String lastName;

    /**
     * Attribute email.
     */
    private String email;

    /**
     * Attribute email.
     */
    private Date dateCreated;

    /**
     * @return id
     */
    @Basic
    @Id
    @Column(name = "ID")
        public long getId() {
        return id;
    }

    /**
     * @param username new value for id 
     */
    public void setId(long id) {
        this.id = id;
    }

    /**
     * @return username
     */
    @Basic
    @Column(name = "USERNAME", length = 50)
        public String getUsername() {
        return username;
    }

    /**
     * @param username new value for username 
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * @return password
     */
    @Basic
    @Column(name = "PASSWORD", length = 50)
        public String getPassword() {
        return password;
    }

    /**
     * @param password new value for password 
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * @return enabled
     */
    @Basic
    @Column(name = "ENABLED")
        public Long getEnabled() {
        return enabled;
    }

    /**
     * @param enabled new value for enabled 
     */
    public void setEnabled(Long enabled) {
        this.enabled = enabled;
    }

    /**
     * @return salt
     */
    @Basic
    @Column(name = "SALT", length = 25)
        public String getSalt() {
        return salt;
    }

    /**
     * @param salt new value for salt 
     */
    public void setSalt(String salt) {
        this.salt = salt;
    }

    /**
     * @return first name
     */
    @Basic
    @Column(name = "FIRSTNAME", length = 100)
        public String getFirstName() {
        return firstName;
    }

    /**
     * @param first name new value for first name 
     */
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    /**
     * @return last name
     */
    @Basic
    @Column(name = "LASTNAME", length = 100)
        public String getLastName() {
        return lastName;
    }

    /**
     * @param last name new value for last name 
     */
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    /**
     * @return email
     */
    @Basic
    @Column(name = "EMAIL", length = 50)
        public String getEmail() {
        return email;
    }

    /**
     * @param email new value for email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * @return dateCreated
     */
    @Basic
    @Column(name = "DATECREATED")
        public Date getDateCreated() {
        return dateCreated;
    }

    /**
     * @param dateCreated new value for dateCreated
     */
    public void setDateCreated(Date dateCreated) {
        this.dateCreated = dateCreated;
    }

    private List<UserRole> userRoles;

    /**
     * Get the list of User Roles
     */
     @OneToMany(fetch=FetchType.EAGER, mappedBy="userRolePK.user")
     public List<UserRole> getUserRoles() {
         return this.userRoles;
     }

    /**
     * Set the list of User Roles
     */
     public void setUserRoles(List<UserRole> userRoles) {
         this.userRoles = userRoles;
     }
}

获取数据的调用是

 public List<T> findByCriteria(Criteria criteria, List<Criterion> criterions, IList list) {

        if(criterions != null)
        {
            for(Criterion c : criterions)
            {
                criteria.add(c);
            }
        }

        criteria.setProjection(Projections.rowCount());

        list.setTotal(((Integer)criteria.uniqueResult()).intValue());

        logger.debug("Count:" + list.getTotal());

        if(list.getTotal() > 0)
        {
            criteria.setProjection(null);
            criteria.setResultTransformer(Criteria.ROOT_ENTITY);
            criteria.setFirstResult((list.getPage() - 1) * list.getPageSize()).setMaxResults(list.getPageSize());

            if(list.getSortBy() != null && list.getSortBy().length() > 0) {

                Order order = null;

                if(list.getOrderBy().equalsIgnoreCase("asc"))
                    order = Order.asc(list.getSortBy());
                else
                    order = Order.desc(list.getSortBy());

                criteria.addOrder(order);
            }

            return criteria.list();
        }

        return new ArrayList<T>();

公共列表findByCriteria（标准、列表标准、IList列表）{
如果（标准！=null）
{
对于（标准c：标准）
{
标准.增加（c）；
}
}
criteria.setProjection（Projections.rowCount（））；
list.setTotal（（（整数）criteria.uniqueResult（））.intValue（））；
debug（“Count:+list.getTotal（））；
if（list.getTotal（）>0）
{
标准。设置投影（空）；
criteria.setResultTransformer（criteria.ROOT\u实体）；
条件.setFirstResult（（list.getPage（）-1）*list.getPageSize（））.setMaxResults（list.getPageSize（））；
if（list.getSortBy（）！=null&&list.getSortBy（）.length（）>0）{
订单=空；
if（list.getOrderBy（）.equalsIgnoreCase（“asc”））
order=order.asc（list.getSortBy（））；
其他的
order=order.desc（list.getSortBy（））；
标准。添加订单（订单）；
}
返回条件。list（）；
}
返回新的ArrayList（）；

---

}我不确定这个奇怪查询的原因，但我想知道为什么要将联接表映射为一个实体，而不是使用

@manytomy

@Entity 
@Table(name = "USERS", schema = "CISCO") 
@SuppressWarnings("serial") 
public class User implements Serializable {
    ...
    @ManyToMany
    @JoinTable(name = "USERROLES", 
        joinColumns = @JoinColumn(name = "USERID"),
        inverseJoinColumns = @JoinColumn(name = "ROLEID")
    )
    public List<Role> getRoles() { ... }
    public void setRoles(List<Role> roles) { ... }
} 

@Entity  
@Table(name = "ROLES", schema = "CISCO")
@SuppressWarnings("serial")
public class Role implements Serializable { 
    ...

    // I'm not sure if you need this relationship to be bidirectional, 
    // but if you actually need here is another side
    @ManyToMany(mappedBy = "roles")
    public List<User> getUsers() { ... }
    public void setUsers(List<User> users) { ... }
}

@实体
@表（name=“USERS”，schema=“CISCO”）
@抑制警告（“串行”）
公共类用户实现可序列化{
...
@许多
@JoinTable（name=“USERROLES”，
joinColumns=@JoinColumn（name=“USERID”），
inverseJoinColumns=@JoinColumn（name=“ROLEID”）
)
公共列表getRoles（）{…}
public void setRoles（列表角色）{…}
} 
@实体
@表（name=“ROLES”，schema=“CISCO”）
@抑制警告（“串行”）
公共类角色实现可序列化{
...
//我不确定你是否需要这种双向关系，
//但如果你真的需要，这里是另一面
@许多（mappedBy=“角色”）
公共列表getUsers（）{…}
public void setUsers（列表用户）{…}
}

另请参见：

---

我基本上就是走这条路的。我使用的是Spring所说的用于默认设置的默认模式。我继续创建了一个Users/Roles/UserRoles表，如您上面所说。下面是我的User.cs类中的内容，它正确地加入了它

 @OneToMany(fetch=FetchType.EAGER)
 @JoinTable(
        name="UserRoles",
        joinColumns = @JoinColumn( name="USERID"),
        inverseJoinColumns = @JoinColumn( name="ROLEID")
)
 public List<Role> getRoles() {
    return this.roles;
 }

@OneToMany（fetch=FetchType.EAGER）
@可接合(
name=“UserRoles”，
joinColumns=@JoinColumn（name=“USERID”），
inverseJoinColumns=@JoinColumn（name=“ROLEID”）
)
公共列表getRoles（）{
返回此.roles；
}

@Entity 
@Table(name = "USERS", schema = "CISCO") 
@SuppressWarnings("serial") 
public class User implements Serializable {
    ...
    @ManyToMany
    @JoinTable(name = "USERROLES", 
        joinColumns = @JoinColumn(name = "USERID"),
        inverseJoinColumns = @JoinColumn(name = "ROLEID")
    )
    public List<Role> getRoles() { ... }
    public void setRoles(List<Role> roles) { ... }
} 

@Entity  
@Table(name = "ROLES", schema = "CISCO")
@SuppressWarnings("serial")
public class Role implements Serializable { 
    ...

    // I'm not sure if you need this relationship to be bidirectional, 
    // but if you actually need here is another side
    @ManyToMany(mappedBy = "roles")
    public List<User> getUsers() { ... }
    public void setUsers(List<User> users) { ... }
}

 @OneToMany(fetch=FetchType.EAGER)
 @JoinTable(
        name="UserRoles",
        joinColumns = @JoinColumn( name="USERID"),
        inverseJoinColumns = @JoinColumn( name="ROLEID")
)
 public List<Role> getRoles() {
    return this.roles;
 }