Java 使用neo4j查询的Spring数据

见下文实体

个人实体

事件实体

我尝试了以下查询，但没有得到结果

List findByPersonPersonId（长personId）

那么如何通过查询实现这个结果呢

请引导，
谢谢。
@NodeEntity
公共阶层人士{
@长id；
私人字符串人形；
私有字符串名称；
私家姓；
@关系（type=“attents”，direction=Relationship.OUTGOING）
private Set attendedEvents=new HashSet（）；
}
@节点性
公开课活动{
@格拉希德
私人长id；
私有字符串eventId；
私有字符串eventName；
@关系（type=“attents”，direction=Relationship.INCOMING）
private List attendedEvents=new ArrayList（）；
}
@RelationshipEntity（type=“Attents”）
公开课上课{
@格拉希德
私人长id；
私家侦探做到了；
@StartNode
私人；
@端节点
私人活动；
私人日期出席日期；
}
@存储库
公共接口PersonRepository扩展了GraphRespository{
Person findByPersonId（字符串personId）；
}
公共类PersonServiceTest扩展了AbstractTest{
@自动连线
个人知识库；
@试验
公共作废保存（）{
Person=新人（）；
person.setName（“Person1”）；
person.setPersonId（UUID.randomUUID（）.toString（））；
个人姓名（“姓氏1”）；
event1=新事件（）；
event1.setEventId（UUID.randomUUID（）.toString（））；
event1.setEventName（“event1”）；
event2=新事件（）；
event2.setEventId（UUID.randomUUID（）.toString（））；
event2.setEventName（“event2”）；
Attents Attents 1=新的Attents（）；
attends1.setAttendId（UUID.randomUUID（）.toString（））；
attends1.设置AttendingDate（新日期（））；
出席1.集合人（人）；
出席1.设置事件（事件1）；
Attents Attents 2=新的Attents（）；
attends2.setAttendId（UUID.randomUUID（）.toString（））；
attends2.设置AttendingDate（新日期（））；
出席2.集合人（人）；
出席2.设置事件（事件2）；
person.getAttendedEvents（）.add（attendes1）；
person.getAttendedEvents（）.add（AttendedS2）；
personRepository.save（person）；
}
@试验
公开作废获取（）{
Person-Person=personRepository.findByPersonId（“ebc17b4b-2270-4e78-ac68-87BCE54444EF4”）；
person.getAttendedEvents（）.forEach（attendedEvent->{
System.out.println（attendedEvent.getEvent（））；
});
}
}
@NodeEntity
公共阶层人士{
@长id；
私人字符串人形；
私有字符串名称；
私家姓；
@关系（type=“attents”，direction=Relationship.OUTGOING）
private Set attendedEvents=new HashSet（）；
}
@节点性
公开课活动{
@格拉希德
私人长id；
私有字符串eventId；
私有字符串eventName；
@关系（type=“attents”，direction=Relationship.INCOMING）
private List attendedEvents=new ArrayList（）；
}
@RelationshipEntity（type=“Attents”）
公开课上课{
@格拉希德
私人长id；
私家侦探做到了；
@StartNode
私人；
@端节点
私人活动；
私人日期出席日期；
}
@存储库
公共接口PersonRepository扩展了GraphRespository{
Person findByPersonId（字符串personId）；
}
公共类PersonServiceTest扩展了AbstractTest{
@自动连线
个人知识库；
@试验
公共作废保存（）{
Person=新人（）；
person.setName（“Person1”）；
person.setPersonId（UUID.randomUUID（）.toString（））；
个人姓名（“姓氏1”）；
event1=新事件（）；
event1.setEventId（UUID.randomUUID（）.toString（））；
event1.setEventName（“event1”）；
event2=新事件（）；
event2.setEventId（UUID.randomUUID（）.toString（））；
event2.setEventName（“event2”）；
Attents Attents 1=新的Attents（）；
attends1.setAttendId（UUID.randomUUID（）.toString（））；
attends1.设置AttendingDate（新日期（））；
出席1.集合人（人）；
出席1.设置事件（事件1）；
Attents Attents 2=新的Attents（）；
attends2.setAttendId（UUID.randomUUID（）.toString（））；
attends2.设置AttendingDate（新日期（））；
出席2.集合人（人）；
出席2.设置事件（事件2）；
person.getAttendedEvents（）.add（attendes1）；
person.getAttendedEvents（）.add（AttendedS2）；
personRepository.save（person）；
}
@试验
公开作废获取（）{
Person-Person=personRepository.findByPersonId（“ebc17b4b-2270-4e78-ac68-87BCE54444EF4”）；
person.getAttendedEvents（）.forEach（attendedEvent->{
System.out.println（attendedEvent.getEvent（））；
});
}
}
不太确定您到底想要什么？
如果你想得到所有人的全部照顾，或者某个人的全部照顾

然而，我已经为这两个问题提供了答案

创建AttendsRepository并在其中添加findByPersonId（字符串personId）

公共接口AttendsRepository扩展了GraphRespository{
@查询（“匹配（p:Person{personId:{0}}）-[a:attents]->（e:Event）返回a”）
Iterable findByPersonId（字符串personId）；
}

然后，您可以通过以下方式获得所需的结果：

@Test
public void getAllAttends(){

    Iterable<Attends> allAttends = attendsRepository.findAll();
    allAttends.forEach(attend -> {
        System.out.println(attend);
    });

}

@Test
public void getAttendsByPerson(){

    String personId = "283f51e9-9ade-4f46-a005-7353b5211c8b";

    Iterable<Attends> allAttends = attendsRepository.findByPersonId(personId);
    allAttends.forEach(attend -> {
        System.out.println(attend);
    });

}

@测试
public void getAllAttends（）{
Iterable allAttends=attendsRepository.findAll（）；
所有与会者（出席->{
系统输出打印（参加）；
});
}
@试验
public void getAttendantByPerson（）{
字符串personId=“283f51e9-9ade-4f46-a005-7353b5211c8b”；
Iterable allAttends=attendsRepository.findByPersonId（personId）；
所有与会者（出席->{
系统输出打印（参加）；
});
}
不太确定您到底想要什么？
如果你想得到所有人的全部照顾，或者某个人的全部照顾@RelationshipEntity(type = "ATTENDS")
public class Attends {

    @GraphId
    private Long id;

    @StartNode
    private Person person;

    @EndNode
    private Event event;

    private Date attendingDate;

@NodeEntity
public class Event {

    @GraphId
    private Long eventId;

    private String eventName;

    @Relationship(type = "ATTENDS", direction = Relationship.INCOMING)
    private Set<Person> persons; 

[{
"attends":{
"attendsId":"1234",
"startDate":"98098098",
"endDate":"098098098",
event:{ "eventId":"1234", "name":"ComicCon" }
},
"attends":{
"attendsId":"1235",
"startDate":"984548098",
"endDate":"45454545",
event:{ "eventId":"1235", "name":"AWS Summit" }

}]

@NodeEntity
public class Person {

    @GraphId Long id; 

    private String personId;

    private String name; 

    private String surname;

    @Relationship(type = "ATTENDS", direction = Relationship.OUTGOING) 
    private Set<Attends> attendedEvents =new HashSet<Attends>();
}

@NodeEntity
public class Event {

    @GraphId
    private Long id;

    private String eventId;

    private String eventName;

    @Relationship(type = "ATTENDS", direction = Relationship.INCOMING)
    private List<Attends> attendedEvents = new ArrayList<Attends>();
}


@RelationshipEntity(type = "ATTENDS")
public class Attends {

    @GraphId
    private Long id;

    private String attendId;

    @StartNode
    private Person person;

    @EndNode
    private Event event;

    private Date attendingDate;
}

@Repository
public interface PersonRepository  extends GraphRepository<Person>{

     Person findByPersonId(String personId);

}


public class PersonServiceTest extends AbstractTest{

    @Autowired
    PersonRepository personRepository;

    @Test
    public void save(){

        Person person = new Person();
        person.setName("Person1");
        person.setPersonId(UUID.randomUUID().toString());
        person.setSurname("Surname1");

        Event event1 = new Event();
        event1.setEventId(UUID.randomUUID().toString());
        event1.setEventName("Event1");

        Event event2 = new Event();
        event2.setEventId(UUID.randomUUID().toString());
        event2.setEventName("Event2");

        Attends attends1 = new Attends();
        attends1.setAttendId(UUID.randomUUID().toString());
        attends1.setAttendingDate(new Date());
        attends1.setPerson(person);
        attends1.setEvent(event1);

        Attends attends2 = new Attends();
        attends2.setAttendId(UUID.randomUUID().toString());
        attends2.setAttendingDate(new Date());
        attends2.setPerson(person);
        attends2.setEvent(event2);

        person.getAttendedEvents().add(attends1);
        person.getAttendedEvents().add(attends2);

        personRepository.save(person);


    }

    @Test
    public void get(){
        Person person = personRepository.findByPersonId("ebc17b4b-2270-4e78-ac68-87bce5444ef4");

        person.getAttendedEvents().forEach(attendedEvent -> {
            System.out.println(attendedEvent.getEvent());
        });

    }


}

public interface AttendsRepository extends GraphRepository<Attends>{

    @Query("Match(p:Person {personId:{0}})-[a:ATTENDS]->(e:Event) return a")
    Iterable<Attends> findByPersonId(String personId);

}

@Test
public void getAllAttends(){

    Iterable<Attends> allAttends = attendsRepository.findAll();
    allAttends.forEach(attend -> {
        System.out.println(attend);
    });

}

@Test
public void getAttendsByPerson(){

    String personId = "283f51e9-9ade-4f46-a005-7353b5211c8b";

    Iterable<Attends> allAttends = attendsRepository.findByPersonId(personId);
    allAttends.forEach(attend -> {
        System.out.println(attend);
    });

}