Neo4j OGM学习和体验

Neo4j OGM

• Neo4j OGM（Object-Graph Mapping）是一个用于在Java应用程序中与Neo4j图数据库交互的库。它能够将对象模型与图数据模型之间进行映射，使得开发者可以更加方便地对图数据进行操作，而无需编写大量的Cypher查询语句。
• Neo4j OGM 提供了一个简洁的API，帮助开发者通过对象的方式来处理图数据，这样能够使代码更加清晰和易于维护。

核心概念

1. 对象映射：Neo4j OGM 提供了将数据库中的节点和关系映射到Java对象的能力。开发者可以通过简单的注释来定义对象之间的映射关系。例如，可以使用 @NodeEntity 注解来表示一个节点实体，使用 @Relationship 注解来表示关系。
2. 会话管理：Neo4j OGM 使用会话来管理数据的读取和写入。每个会话可以看作是一个与数据库的连接，开发者通过会话来执行CRUD操作（创建、读取、更新和删除），并处理对象的生命周期。
3. 查询：虽然 OGM 封装了大部分操作，但它依然支持使用 Cypher 查询来进行复杂的数据操作。开发者可以直接通过 OGM 的接口来执行 Cypher 查询，返回对象。

Neo4j OGM体验

项目地址

• neo4jAPILearn

Neo4j数据准备

• 使用Neo4j官方电影案例
  
  

1. 添加Maven依赖，在 pom.xml 中添加如下依赖：

<dependencies>
    <dependency>
        <groupId>org.neo4j</groupId>
        <artifactId>neo4j-ogm-core</artifactId>
        <version>4.0.15</version>
    </dependency>

    <dependency>
        <groupId>org.neo4j</groupId>
        <artifactId>neo4j-ogm-bolt-driver</artifactId>
        <version>4.0.15</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 配置：创建SessionFactoryUtils类

import lombok.Getter;
import org.neo4j.ogm.config.Configuration;
import org.neo4j.ogm.session.SessionFactory;

public class SessionFactoryUtils {

    private static final Configuration configuration=new Configuration.Builder()
            .uri("bolt://neo4j:neo4jneo4j@192.168.1.21:7687")
            .connectionPoolSize(150)
            .connectionLivenessCheckTimeout(100)
            .build();

    @Getter
    private static SessionFactory sessionFactory=new SessionFactory(configuration,"com.yang.ogm.pojo");
}

3. 创建实体:Movie，MyPerson，ActedIn

• Movie

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.neo4j.ogm.annotation.*;

import java.util.List;

@NodeEntity
@Setter
@Getter
@NoArgsConstructor
@ToString
public class Movie {
    @Id
    @GeneratedValue
    private Long id;

    private String title;

    private Long released;

    @Property("tagline")
    private String tagLine;

    //设置关系并且指定方向
    @Relationship(type = "ACTED_IN",direction = Relationship.Direction.INCOMING)
    private List<ActedIn> actedIns;
}

• MyPerson

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.neo4j.ogm.annotation.*;

import java.util.List;

@NodeEntity(label="Person")
@Setter
@Getter
@NoArgsConstructor
@ToString
public class MyPerson {
    @Id
    @GeneratedValue
    private Long id;

    private String name;

    private Long born;

    //指定关系
    //@Relationship(type = "ACTED_IN",direction = Relationship.Direction.OUTGOING)
    //private List<Movie> movies;

    @Relationship(type = "ACTED_IN")
    private List<ActedIn> actedIns;
    //导演关系
    @Relationship(type = "DIRECTED")
    private List<Movie> directedMovies;

    //出品关系
    @Relationship(type = "PRODUCED")
    private List<Movie> producedMovies;

    //写作关系
    @Relationship(type = "WROTE")
    private List<Movie> wroteMovies;
}

• ActedIn

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.neo4j.ogm.annotation.*;

@RelationshipEntity(type = "ACTED_IN")
@Setter
@Getter
@ToString(exclude = {"person","movie"})
@NoArgsConstructor
public class ActedIn {
    @Id
    @GeneratedValue
    private Long id;

    @StartNode //关系中的开始节点
    private MyPerson person;

    @EndNode  //关系中的结束节点
    private Movie movie;

    private String[] roles;
}

4. Person操作的服务层PersonService

import com.yang.ogm.pojo.MyPerson;
import com.yang.ogm.session.SessionFactoryUtils;
import org.neo4j.ogm.cypher.ComparisonOperator;
import org.neo4j.ogm.cypher.Filter;
import org.neo4j.ogm.model.Result;
import org.neo4j.ogm.session.Session;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


public class PersonService {
    private Session session;

    public PersonService() {
        this.session = SessionFactoryUtils.getSessionFactory().openSession();
    }

    /**
     * 根据id查询用户数据
     * @param id
     * @return
     */
    public MyPerson queryPersonById(Long id) {
        return this.session.load(MyPerson.class, id);
    }


    public void savePerson(MyPerson person) {
        this.session.save(person);
    }
    public void deletePerson(MyPerson person) {
        this.session.delete(person);
    }

    public ArrayList<Long> deletePersonByName(String name) {
        Filter filter = new Filter("name", ComparisonOperator.EQUALS,name);
        return (ArrayList<Long>) this.session.delete(MyPerson.class,List.of(filter),true);
    }

    // depth默认为1。 -1加载全部数据 0仅加载当前节点属性 1加载实例将映射该对象的简单属性及其直接相关的对象
    public MyPerson queryPersonById(Long id, int depth) {
        return this.session.load(MyPerson.class,id,depth);
    }

    public List<MyPerson> queryPersonByName(String name) {
        Filter filter = new Filter("name",ComparisonOperator.EQUALS,name);
        return (List<MyPerson>) this.session.loadAll(MyPerson.class, filter);
    }

    public Result queryAllShortestPathsByCypher(String personName1, String persoName2){
        String cypher=
                """
                match(n:Person {name:$personName1}),
                (m:Person {name:$personName2}),
                p=allShortestPaths((n)-[*]-(m))
                return p
                """;
        HashMap<String, String> params = new HashMap<>();
        params.put("personName1", personName1);
        params.put("personName2", persoName2);
        return this.session.query(cypher,params);
    }
}

5. CRUD 操作

import com.yang.ogm.pojo.Movie;
import com.yang.ogm.pojo.MyPerson;
import com.yang.ogm.service.PersonService;
import com.yang.ogm.session.SessionFactoryUtils;
import org.junit.Test;
import org.neo4j.driver.internal.InternalPath;
import org.neo4j.ogm.model.Result;
import org.neo4j.ogm.session.SessionFactory;

import java.util.List;

public class TestPersonService {
    private PersonService personService=new PersonService();

    @Test
    public void getSessionFactory(){
        SessionFactory sessionFactory = SessionFactoryUtils.getSessionFactory();
        System.out.println(sessionFactory);
    }

    @Test
    public void testQueryPersonById(){
        MyPerson myPerson = this.personService.queryPersonById(33L,2);
        System.out.println(myPerson);
    }

    @Test
    public void testQueryPersonByName(){
        List<MyPerson> list = this.personService.queryPersonByName("Tom Hanks");
        System.out.println(list);
    }

    @Test
    public void testQueryPersonByCypher(){
        Result result = this.personService.queryAllShortestPathsByCypher("Susan Sarandon", "Jessica Thompson");
        result.forEach(stringObjectMap -> {
            InternalPath.SelfContainedSegment[] arrays=(InternalPath.SelfContainedSegment[]) stringObjectMap.get("p");
            for (InternalPath.SelfContainedSegment segment : arrays) {
                System.out.println(segment);
            }
        });
    }

    @Test
    public void testSavePerson(){
        MyPerson myPerson = new MyPerson();
        myPerson.setName("沈腾");
        myPerson.setBorn(1970L);

        Movie movie = new Movie();
        movie.setTitle("飞驰人生");
        movie.setReleased(2019L);


        //添加关系 注意修改MyPerson类中的执行关系代码
        // myPerson.setMovies(List.of(movie));
        //
        // this.personService.savePerson(myPerson);
        // System.out.println(myPerson);
    }

    @Test
    public void testUpdate() {
        List<MyPerson> personList = personService.queryPersonByName("沈腾");
        MyPerson person = personList.get(0);
        person.setBorn(1980L);
        personService.savePerson(person);
    }

    @Test
    public void testDeletePersonByNmae() {
        Object result = personService.deletePersonByName("沈腾");
        System.out.println(result);
    }

}