Java 子对象不是'；t在Spring数据中使用父对象获取

我对Hibernate很陌生，我在父对象和子对象之间建立了@OneToMany双向关系，并期望在数据库中持久化所有内容时，将父对象设置为子对象（因为子对象是关系的所有者）当我用ORM获取父对象时，我希望也获取一个子对象，但作为回报，我看到零个子对象

就我在互联网上读到的内容所理解的，当我将子对象作为与父对象的关系的所有者持久化时，ORM应该根据预定义的关系映射将两个对象连接起来。这个信息正确吗

@Entity
@Table(name = "stream")
@SequenceGenerator(name = "sequence", sequenceName = "stream_id", allocationSize = 1)
public class StreamEntity extends EntityWithId {

    // @MappedSuperclass with ID 

    @Column(name = "request_id")
    @OneToMany(
            mappedBy = "streamEntity",
            fetch = FetchType.LAZY
    )
    private List<RequestEntity> requestEntities = new ArrayList<>();

    // getters setters
}

@Entity
@Table(name = "request")
@SequenceGenerator(name = "sequence", sequenceName = "request_id", allocationSize = 1, initialValue = 1)
public class RequestEntity extends EntityWithId {

    // @MappedSuperclass with ID 

    @JoinColumn(name = "stream_id")
    @ManyToOne(fetch = FetchType.LAZY)
    private StreamEntity streamEntity;

    // getters setters
}

@实体
@表（name=“stream”）
@SequenceGenerator（name=“sequence”，sequenceName=“stream\u id”，allocationSize=1）
公共类StreamEntity扩展了EntityWithId{
//@MappedSuperclass，ID为
@列（name=“request\u id”）
@独身癖(
mappedBy=“streamEntity”，
fetch=FetchType.LAZY
)
private List requestEntities=new ArrayList（）；
//吸气剂二传手
}
@实体
@表（name=“请求”）
@SequenceGenerator（name=“sequence”，sequenceName=“request\u id”，allocationSize=1，initialValue=1）
公共类RequestEntity扩展EntityWithId{
//@MappedSuperclass，ID为
@JoinColumn（name=“stream\u id”）
@manytone（fetch=FetchType.LAZY）
私人流动性流动性；
//吸气剂二传手
}

一些测试：

@Test
public void createStreamWithSeveralStreamTargetsAndDeleteStream() {
    List<StreamEntity> streamEntities = createStream(1); // stream object is persisted here

    List<RequestEntity> requestEntitySave = createRequest(1, streamEntityCheck);
    assertEquals(1, requestEntitySave.size()); // request entity is persisted with the stream object into the database

    List<StreamEntity> streamEntities = streamDao.findAll();
    assertEquals(1, streamEntities.size());
    StreamEntity streamEntity2 = streamEntities.get(0);
    streamEntity2.getRequestEntities(); - this collection shows 0
}

@测试
public void createstream with everalstreamtargets和deleteStream（）{
List streamEntities=createStream（1）；//流对象保存在此处
List requestEntitySave=createRequest（1，streamEntityCheck）；
assertEquals（1，requestEntitySave.size（））；//请求实体与流对象一起持久化到数据库中
List streamEntities=streamDao.findAll（）；
assertEquals（1，streamEntities.size（））；
StreamEntity streamEntity2=StreamEntitys.get（0）；
streamEntity2.getRequestEntities（）；-此集合显示0
}

我错过了什么

更新： 正如@Alan Hay所建议的，我已经在我的测试中添加了一个@Persistent上下文，现在看起来是这样的：

@PersistenceContext
    private EntityManager em;


@Test
    public void createStreamWithSeveralStreamTargetsAndDeleteStream() {
        List<StreamEntity> streamEntities = createStream(1); // stream object is persisted here

        List<RequestEntity> requestEntitySave = createRequest(1, streamEntityCheck);
        assertEquals(1, requestEntitySave.size()); // request entity is persisted with the stream object into the database

        em.clear();

List<RequestEntity> requestEntities = requestDao.findAll();
        assertEquals(1, requestEntities.size()); // retirns zero objects

        List<StreamEntity> streamEntities = streamDao.findAll();
        assertEquals(1, streamEntities.size());
        StreamEntity streamEntity2 = streamEntities.get(0);
        streamEntity2.getRequestEntities();// this collection shows 0
    }

@PersistenceContext
私人实体管理者；
@试验
public void createstream with everalstreamtargets和deleteStream（）{
List streamEntities=createStream（1）；//流对象保存在此处
List requestEntitySave=createRequest（1，streamEntityCheck）；
assertEquals（1，requestEntitySave.size（））；//请求实体与流对象一起持久化到数据库中
em.clear（）；
List requestEntities=requestDao.findAll（）；
assertEquals（1，requestEntities.size（））；//重设零个对象
List streamEntities=streamDao.findAll（）；
assertEquals（1，streamEntities.size（））；
StreamEntity streamEntity2=StreamEntitys.get（0）；
streamEntity2.getRequestEntities（）；//此集合显示0
}

---

在我做了这个之后，我在requestDao.findAll（）上得到了零个对象；步我已经在上一步中提交了这些更改，为什么我不能获取此实体？

由于一级缓存的概念，您创建和保存的初始对象与加载的对象是同一个实例。由于您没有将创建的请求实体添加到内存模型中，而只是将其持久化到数据库中，因此内存模型中不存在这种关系

要获得所需的结果，需要清除保存和重新加载之间的持久性上下文

@Test
    public void createStreamWithSeveralStreamTargetsAndDeleteStream() {
        List<StreamEntity> streamEntities = createStream(1); 

        List<RequestEntity> requestEntitySave = createRequest(1, streamEntityCheck);
        assertEquals(1, requestEntitySave.size()); 

        //you need to clear the persistence context here
        //now a db query should execute.
        //Inject the entitymanager to your test @PersistenceContext EntityManager em;
        em.clear();

        List<StreamEntity> streamEntities = streamDao.findAll();
        assertEquals(1, streamEntities.size());
        StreamEntity streamEntity2 = streamEntities.get(0);
        streamEntity2.getRequestEntities(); - this collection shows 0

   }

@测试
public void createstream with everalstreamtargets和deleteStream（）{
List streamEntities=createStream（1）；
List requestEntitySave=createRequest（1，streamEntityCheck）；
assertEquals（1，requestEntitySave.size（））；
//您需要在这里清除持久性上下文
//现在应该执行一个db查询。
//将entitymanager注入测试@PersistenceContext entitymanager em；
em.clear（）；
List streamEntities=streamDao.findAll（）；
assertEquals（1，streamEntities.size（））；
StreamEntity streamEntity2=StreamEntitys.get（0）；
streamEntity2.getRequestEntities（）；-此集合显示0
}

看看这里：谢谢你的回答，我已经阅读了关于FetchType的不同之处，就我对FetchType的理解而言。LAZY应该至少返回代理对象，但它什么也不返回。谢谢你的回答，我还有几个问题要问。我正在使用spring数据和这个奇特的模糊CRUD方法，我认为他们正在做所有这些事情，清除上下文等等，对吗？我是否需要对spring数据执行任何其他配置，以使其按预期工作？一级缓存由hibernate管理，无法绕过。通常你无论如何都会想要的。您有责任确保内存模型的一致性。