//通过构造方法创建节点
    @Test
    public void createUser() {
//        Person person = new Person("代晓涛",1999);
//        personRepository.save(person);
        Movie movie = new Movie("红楼梦", 123, "nice Movie");
        movieRepository.save(movie);
    }

    //通过节点Id删除节点
    @Test
    public void deleteUser() {
        personRepository.deleteById(2440L);
    }

    //通过查找名字删除节点以及节点相邻的关系
    @Test
    public void delete() {
//        personRepository.deleteRelationAndPersonByName("代晓涛");
        personRepository.SaveNode("嘉兴学院");
    }


    //多个不存在的节点创建关系
    @Test
    public void createRelation() {
        Person person = new Person("六小龄童", 1988);
        Person person1 = new Person("猪八戒", 1988);
        Movie movie = new Movie("西游记", 5, "这部电视剧也");
        List<Movie> list = new ArrayList<>();
        list.add(movie);
        movieRepository.save(movie);
        person.setDirected(list);
        person1.setDirected(list);
        personRepository.save(person);
        personRepository.save(person1);
    }

    //已存在的两个节点创建关系,失败了，好像只能通过单独写语句创建
    @Test
    public void createRelationBy() {
//        Person person = personRepository.getPersonByName("猪八戒");
//        Movie movie = movieRepository.getMovieByTitle("我和我的祖国");
//        List<Movie>list = new ArrayList<>();
//        list.add(movie);
//        person.setActedIn(list);

        personRepository.createDIRECTEDRelationWithExistPerson("代涛涛", "喜欢", "我和我的祖国");//这个可以
    }

    //通过关系名删除两个节点之间的关系
    @Test
    public void deleteByRelationName() {
        personRepository.deleteDIRECTEDRelationWithExistPerson("六小龄童", "DDDDDD", "我和我的祖国");//这个可以

    }

    //查询一个节点所有关系
    //刚开始失败的原因一直是Stack Flow Over
    //后来才发现原来是对象A中的属性中包含对象B，而对象B中的属性又包含对象A，造成无限循环执行对象的toString()函数，才会栈溢出
    @Test
    public void findRelationByPerson() {
//        System.out.println(personRepository.getPersonsWhoActAndDirect());
        List<Person> list = new ArrayList<>();
        list = personRepository.findRelationByPerson("Joney");
//        System.out.println(list);
        for (Person person : list) {
            System.out.println(person.toStringq());
        }
    }
    //至此终于实现了数据的增删改查

    @Test
    public void saveNode(){
        personRepository.SaveNode("daixiaotaoaaa");
    }

@Repository
public interface PersonRepository extends Neo4jRepository<Person, Long> {

    Person getPersonByName(String name);

    Iterable<Person> findPersonByNameLike(String name);

    @Query("MATCH (am:Movie)<-[ai:ACTED_IN]-(p:Person)-[d:DIRECTED]->(dm:Movie) return p, collect(ai), collect(d), collect(am), collect(dm)")
    List<Person> getPersonsWhoActAndDirect();

    //@Query("Match (n:User{name:{0}})-[r]-() delete n,r")
    @Query("Match (n:Person{name:{0}})-[r]->() delete n,r")
    void deleteRelationAndPersonByName(String name);

    //MATCH (a:LabeofNode1), (b:LabeofNode2)
    //WHERE a.name = "nameofnode1" AND b.name = " nameofnode2"
    //CREATE (a)-[: Relation]->(b)
    //Match (a:Person{name:"六小龄童"}),(b:Movie{title:"长津湖"}) create (a)-[r:DIRECTED]->(b)
    @Query("Match (a:Person{name:{0}}),(b:Movie{title:{2}}) merge (a)-[r:DIRECTED{name:{1}}]->(b)")
    void createDIRECTEDRelationWithExistPerson(String from,String relation,String to);
    @Query("Match (a:Person{name:{0}})-[r:DIRECTED{name:{1}}]->(b:Movie{title:{2}}) delete r")
    void deleteDIRECTEDRelationWithExistPerson(String from,String relation,String to);


    //查询一个节点所有关系
    //    @Query("Match (a:Person{name:{0}})-[r]->(m) return a,r,m")//失败
    @Query("Match (a:Person{name:{0}})-[r]->(m) return a,r,m")
    List<Person> findRelationByPerson(String name);

    @Query("Match (a:Person{name:{0}})-[r]->(m) or (a:Movie{title:{0}}-[r]->(m)) return a,r,m")
    List<Person> findAllRelation(String name);

    @Query("Merge (n:Person{name:$name})")//新语法
    void SaveNode(String name);
}