Hibernate JPA OneToOne查询

在Hibernate查询惰性onetoone关系另一端的类时，我遇到了一些问题

根据缓存设置，对顶级玩家的查询通过映射表进行查询，以获取QHPlayer表的ID

完成主查询后，它将查询QHPlayer表的每个实例

然而，它在两种不同的情况下做了错误的事情

如果启用了缓存，它将查询QHPlayer的实例，然后将查询到inventory_item表。 如果我关闭了缓存，它将查询到QHPlayer，并连接到inventory_项

问题是，无论我如何做，它都坚持查询inventory\u 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;
    }
}

Query Query=entityManager.createQuery（“从顶级玩家c中选择c，其中c.teamId=：按c.level DESC、c.adjusted fantasypointstotal DESC、c.id ASC排序的团队id”）；
query.setParameter（“teamId”，teamId）；
List results=query.getResultList（）；
@XmlAccessorType（XmlAccessType.PROPERTY）
@实体（name=“player\u模板”）
@表（name=“player\u模板”）
@缓存（用法=CacheConcurrencyStrategy.READ\u WRITE）
公共类QhPlayer实现了可序列化{
@身份证
公共整数getPlayerTemplateId（）{
返回playerTemplateId；
}
@OneToOne（mappedBy=“playerTemplate”，fetch=FetchType.LAZY）
@XmlTransient
public PlayerInventoryItem getInventoryItem（）{
退回存货项目；
}
}
@实体（名称=“qhplayer\U存货\U项目”）
@鉴别器值（“播放器”）
@缓存（用法=CacheConcurrencyStrategy.READ\u WRITE）
公共类PlayerInventoryItem扩展了InventoryItem{
专用QhPlayer playerTemplate；
@OneToOne（fetch=FetchType.LAZY）
@JoinColumn（name=“player\u template\u id”）
@XmlTransient
公共QhPlayer getPlayerTemplate（）{
返回playerTemplate；
}
}
@实体（名称=“库存项目”）
@继承（策略=InheritanceType.SINGLE_表）
@鉴别器柱(
name=“库存\项目\类型”，
discriminatorType=discriminatorType.STRING
)
@缓存（用法=CacheConcurrencyStrategy.READ\u WRITE）
公共抽象类InventoryItem{
私有int inventoryItemId；
}
@实体（名称=“顶级玩家”）
@XmlRootElement（name=“顶级玩家”）
@表（name=“player”）
@二级表({
@第二个表（name=“player\u stats”，第二列）={
@PrimaryKeyJoinColumn（name=“playerId”，referencedColumnName=“id”）
}),
@第二个表（name=“player\u mapping”，pkJoinColumns）={
@PrimaryKeyJoinColumn（name=“playerId”，referencedColumnName=“id”）
})       
})
@XmlAccessorType（XmlAccessType.PROPERTY）
公共类顶层{
专用QhPlayer playerTemplate；
@XmlTransient
@许多酮
@JoinColumn（table=“player\u mapping”，name=“player\u template\u id”，nullable=true）
公共QhPlayer getPlayerTemplate（）{
返回playerTemplate；
}
}

我找到了答案

这是因为一对一是可以为空的。那么它就不能实现延迟加载对象。所以我通过多对一关系解决了这个问题，只需要寻找一个对象的集合

这里有一个很好的参考资料。

同时感谢所有读过这篇文章的人