Question

我遇到的问题是Hibernate在一个懒惰的关系的另一边查询一个类。

对top_players的查询，取决于缓存设置，通过映射表进行查询，以获取QHPlayer表的ID。

执行主查询后，它会查询QHPlayer表的每个实例。

但是，它在两种不同的情况下做错了。

如果我打开了缓存，它将查询QHPlayer的实例，然后它将查询到inventory_item表。如果我关闭了缓存，则会通过加入inventory_item向QHPlayer发出查询。

问题是无论我怎么做，它都坚持查询inventory_item表。这是我不想要的。我不需要数据目前在inventory_item中。

我假设QHPlayer和PlayerInventoryItem之间的onetoone声明有问题。

有什么想法吗？

相关代码如下：

    Query query = entityManager.createQuery( "SELECT c FROM top_players c WHERE c.teamId=:teamId ORDER BY c.level DESC, c.adjustedFantasyPointsTotal DESC, c.id ASC" );
    query.setParameter( "teamId", teamId );
    List<TopPlayers> results = query.getResultList();



    @XmlAccessorType( XmlAccessType.PROPERTY)
@Entity( name="player_template")
@Table( name="player_template" )
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class QhPlayer implements Serializable {

    @Id
    public Integer getPlayerTemplateId() {
        return playerTemplateId;
    }

    @OneToOne( mappedBy ="playerTemplate", fetch = FetchType.LAZY)
    @XmlTransient
    public PlayerInventoryItem getInventoryItem() {
        return inventoryItem;
    }

}


@Entity( name = "qhplayer_inventory_item" )
@DiscriminatorValue("PLAYER")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class PlayerInventoryItem extends InventoryItem {
    private QhPlayer playerTemplate;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="player_template_id")
    @XmlTransient
    public QhPlayer getPlayerTemplate() {
        return playerTemplate;
    }
}



@Entity( name="inventory_item" )
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
        name = "inventory_item_type",
        discriminatorType = DiscriminatorType.STRING
)
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public abstract class InventoryItem {
    private int inventoryItemId;
}



@Entity( name = "top_players")
@XmlRootElement(name = "top_player")
@Table(name="player")
@SecondaryTables({
        @SecondaryTable(name="player_stats", pkJoinColumns={
                @PrimaryKeyJoinColumn(name="playerId", referencedColumnName="id")
        }),
        @SecondaryTable(name="player_mapping", pkJoinColumns={
                @PrimaryKeyJoinColumn(name="playerId", referencedColumnName="id")
        })       
})
@XmlAccessorType( XmlAccessType.PROPERTY )
public class TopPlayers {

    private QhPlayer playerTemplate;

    @XmlTransient
    @ManyToOne
    @JoinColumn( table="player_mapping", name = "player_template_id", nullable = true )
    public QhPlayer getPlayerTemplate() {
        return playerTemplate;
    }
}

Answer 1

我找到了答案。

这是因为一对一可以为空。然后它无法实现延迟加载对象。所以我通过多对一的关系来解决它，只是寻找一个对象的集合。

这是一个很好的参考 http://community.jboss.org/wiki/Someexplanationsonlazyloadingone-to-one

同时感谢任何阅读此内容的人。

尽管使用了Lazy Fetch，Hibernate JPA OneToOne仍在查询

1 个答案: