Hibernate的标准显示意想不到的效果

我有一个标准的，看起来像这样：Hibernate的标准显示意想不到的效果

public List<role> searchByFormStatus(boolean status) { 
    Criteria criteria = this.getSession().createCriteria(this.getPersistentClass()); 
    List<role> result = (List<role>) criteria        
         .setFetchMode("role", FetchMode.JOIN) 
         .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY) 
         .createAlias("formApprovals", "f") 
         .add(Restrictions. eq("f.latestApproval", true)) 
         .list(); 
    return result;       
}

起初看起来这应该是工作，但无论我是否在参数发送true或false值时，结果总是

[{ 
    "roleIsActive": true, 
    "roleName": "role1", 
    "roleNotes": "note", 
    "formApprovals": [ 
     { 
      "approvalNotes": "good", 
      "approvedDate": 1449900000000, 
      "fkapprovedBy": 1, 
      "idformApproval": 1, 
      "latestApproval": true 
     }, 
     { 
      "approvalNotes": "bad", 
      "approvedDate": 1449900000000, 
      "fkapprovedBy": 1, 
      "idformApproval": 2, 
      "latestApproval": false 
     } 
}]

正如你所看到的，“formApprovals”带来的所有寄存器在数据库中，即使我创建限制为latestApproval财产

ŧ他在父对象财产申报（角色）是：

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
public Set<FormApproval> getFormApprovals() { 
    return this.formApprovals; 
} 

public void setFormApprovals(Set<FormApproval> formApprovals) { 
    this.formApprovals = formApprovals; 
}

检查控制台，我可以看到，在正在生成条款恰当地休眠，但是，我可以看到，后面还有其他疑问，有可能这些查询（我不知道他们为什么在那里）会覆盖我的标准吗？

任何想法？

EDIT

FormApproval类

@Entity 
@Table(name="FormApproval" 
    ,catalog="catalog" 
) 
public class FormApproval implements java.io.Serializable { 

    private static final long serialVersionUID = 8L; 
    private int idformApproval; 
    private role role; 
    private Integer fkapprovedBy; 
    private Date approvedDate; 
    private String approvalNotes; 
    private boolean latestApproval; 

    public FormApproval() { 
    } 


    public FormApproval(int idformApproval, role role) { 
     this.idformApproval = idformApproval; 
     this.role = role; 
    } 
    public FormApproval(int idformApproval, role role, Integer fkapprovedBy, Date approvedDate, String approvalNotes, boolean latestApproval) { 
     this.idformApproval = idformApproval; 
     this.role = role; 
     this.fkapprovedBy = fkapprovedBy; 
     this.approvedDate = approvedDate; 
     this.approvalNotes = approvalNotes; 
     this.latestApproval = latestApproval; 
    } 

    @Id @GeneratedValue(strategy = IDENTITY) 

    @Column(name="IDFormApproval", unique=true, nullable=false) 
    public int getIdformApproval() { 
     return this.idformApproval; 
    } 

    public void setIdformApproval(int idformApproval) { 
     this.idformApproval = idformApproval; 
    } 

@JsonIgnore 
@ManyToOne(fetch=FetchType.EAGER) 
    @JoinColumn(name="FKRole", nullable=false) 
    public role getrole() { 
     return this.role; 
    } 

    public void setrole(role role) { 
     this.role = role; 
    } 


    @Column(name="LatestApproval") 
    public boolean getLatestApproval() { 
     return this.latestApproval; 
    } 

    public void setLatestApproval(boolean latestApproval) { 
     this.latestApproval = latestApproval; 
    } 

    @Column(name="FKApprovedBy") 
    public Integer getFkapprovedBy() { 
     return this.fkapprovedBy; 
    } 

    public void setFkapprovedBy(Integer fkapprovedBy) { 
     this.fkapprovedBy = fkapprovedBy; 
    } 
    @Temporal(TemporalType.DATE) 
    @Column(name="ApprovedDate", length=10) 
    public Date getApprovedDate() { 
     return this.approvedDate; 
    } 

    public void setApprovedDate(Date approvedDate) { 
     this.approvedDate = approvedDate; 
    } 

    @Column(name="ApprovalNotes") 
    public String getApprovalNotes() { 
     return this.approvalNotes; 
    } 

    public void setApprovalNotes(String approvalNotes) { 
     this.approvalNotes = approvalNotes; 
    } 
}

角色类

@Entity 
@Table(name="Role" 
    ,catalog="catalog" 
)  
public class Role implements java.io.Serializable { 

    private static final long serialVersionUID = 1L; 
    private int idRole; 
    private WorkType workType; 
    private String roleName; 
    private String roleNotes; 
    private boolean roleIsActive; 
    private Set<FormApproval> formApprovals = new HashSet<FormApproval>(0); 
    private Set<Topicrole> topicRoles = new HashSet<TopicRole>(0); 
    private Set<FormFeedBack> formFeedBacks = new HashSet<FormFeedBack>(0); 
    private Set<UserRole> userRoles = new HashSet<UserRrole>(0); 
    private Set<Interview> interviews = new HashSet<Interview>(0); 

    public Role() { 
    } 


    public Role(int idRole, WorkType workType, String roleName, boolean roleIsActive) { 
     this.idRole = idRole; 
     this.workType = workType; 
     this.RoleName = RoleName; 
     this.roleIsActive = roleIsActive; 
    } 
    public Role(int idRole, WorkType workType, String roleName, String roleNotes, boolean roleIsActive, Set<FormApproval> formApprovals, Set<TopicRole> topicRoles, Set<FormFeedBack> formFeedBacks, Set<UserRole> userRoles, Set<Interview> interviews) { 
     this.idRole = idRole; 
     this.workType = workType; 
     this.RoleName = RoleName; 
     this.roleNotes = roleNotes; 
     this.roleIsActive = roleIsActive; 
     this.formApprovals = formApprovals; 
     this.topicRoles = topicRoles; 
     this.formFeedBacks = formFeedBacks; 
     this.userRoles = userRoles; 
     this.interviews = interviews; 
    } 

    @Id @GeneratedValue(strategy = IDENTITY) 

    @Column(name="IDRole", unique=true, nullable=false) 
    public int getIdrole() { 
     return this.idRole; 
    } 

    public void setIdrole(int idRole) { 
     this.idRole = idRole; 
    } 
@ManyToOne(fetch=FetchType.EAGER) 
    @JoinColumn(name="FKWorkType", nullable=false) 
    public WorkType getWorkType() { 
     return this.workType; 
    } 

    public void setWorkType(WorkType workType) { 
     this.workType = workType; 
    } 

    @Column(name="RoleName", nullable=false) 
    public String getRoleName() { 
     return this.roleName; 
    } 

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

    @Column(name="RoleNotes") 
    public String getRoleNotes() { 
     return this.roleNotes; 
    } 

    public void setRoleNotes(String roleNotes) { 
     this.roleNotes = roleNotes; 
    } 

    @Column(name="RoleIsActive", nullable=false) 
    public boolean isRoleIsActive() { 
     return this.roleIsActive; 
    } 

    public void setRoleIsActive(boolean roleIsActive) { 
     this.roleIsActive = roleIsActive; 
    } 

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
    public Set<FormApproval> getFormApprovals() { 
     return this.formApprovals; 
    } 

    public void setFormApprovals(Set<FormApproval> formApprovals) { 
     this.formApprovals = formApprovals; 
    } 

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
    public Set<TopicRole> getTopicRoles() { 
     return this.topicRoles; 
    } 

    public void setTopicRoles(Set<TopicRole> topicRoles) { 
     this.topicRoles = topicRoles; 
    } 

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
@JsonManagedReference 
    public Set<FormFeedBack> getFormFeedBacks() { 
     return this.formFeedBacks; 
    } 

    public void setFormFeedBacks(Set<FormFeedBack> formFeedBacks) { 
     this.formFeedBacks = formFeedBacks; 
    } 

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
    public Set<UserRole> getUserRoles() { 
     return this.userRoles; 
    } 

    public void setUserRoles(Set<UserRole> userRoles) { 
     this.userRoles = userRoles; 
    } 

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="acnrole") 
    public Set<Interview> getInterviews() { 
     return this.interviews; 
    } 

    public void setInterviews(Set<Interview> interviews) { 
     this.interviews = interviews; 
    }

}

来源

2015-12-23 rhernandez

你能与注释的问题添加FormApproval场左外连接？为什么你需要设置获取模式和结果转换器？ –

@JohnScattergood完成！ fetchmode和resulttransformer在那里，因为我在使用Inner Join生成的查询时遇到问题，但我需要左外连接，并且解决了问题 – rhernandez

您需要左外连接，因为role.formApprovals可能为null？您是否尝试将获取模式添加为createAlias（）的一部分？ –

使用固定

.createCriteria("formApprovals","f",1,Restrictions.eq("f.latestApproval", status))

1强制查询

来源

2015-12-24 14:22:47 rhernandez

随着预先抓取类型，嵌套标准应为这种情况下的工作：

public List<role> searchByFormStatus(boolean status) { 
    Criteria criteria = this.getSession().createCriteria(this.getPersistentClass()); 
    List<role> result = (List<role>) criteria        
         .createCriteria("formApprovals") 
          .add(Restrictions.eq("latestApproval", true)) 
         .list(); 
    return result;       
}

来源

2015-12-23 18:58:41

它一直检索所有formApprovals数据 – rhernandez

即使是带有latestApproval！= true的 –

yes，就像条件正在被覆盖某处 – rhernandez

您可以尝试在关联顶部使用限制作为ON子句的一部分。

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role") 
@Where(clause=" latestApproval='true' ") 
public Set<FormApproval> getFormApprovals() { 
    return this.formApprovals; 
}

您也可以消除设定FetchMode.JOIN使用方法org.hibernate.Criteria.createAlias(String associationPath, String alias, JoinType joinType)

public List<role> searchByFormStatus(boolean status) { 
    Criteria criteria = this.getSession().createCriteria(Role.class, "role") 
      .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY) 
      .createAlias("role.formApprovals", "formApprovals", JoinType.LEFT_OUTER_JOIN); 
    return criteria.list(); 
}

更新指向关联路径获取：

对于Hibernate老的版本，使用下面的其它方法。其中joinType的值将为LEFT_OUTER_JOIN的1，并且连接子句可以作为第四个参数传递。

public Criteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException;

来源

2015-12-23 20:10:34

当我将JoinType.LEFT_OUTER_JOIN添加到createAlias，我得到一个参数无效的错误，好像JoinType发送一个整数。 @Where（clause =“latestApproval ='true'”）是否有动态值？ – rhernandez

它应该只用'JoinType'作为参数，你看到的例外是什么？ –

类型Criteria中的方法createAlias（String，String，int）不适用于参数（String，String，JoinType） – rhernandez

Hibernate的标准显示意想不到的效果

回答

相关问题