使用Java操作neo4j

本文使用的neo4j版本为3.1.0

一. 通过spring boot

1. 添加maven相关依赖

   	<dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-neo4j</artifactId>
               <version>2.1.3.RELEASE<verison>
           </dependency>
           <dependency>
               <groupId>org.neo4j</groupId>
               <artifactId>neo4j-ogm-http-driver</artifactId>
               <version>3.1.0</version>
           </dependency>
   

2. 配置文件

   spring:
     neo4j:
     uri: http://127.0.0.1:7474
     username: neo4j
     password: neo4j001
   

3. 构建neo4j标签节点

   import lombok.Data;
   import org.neo4j.ogm.annotation.*;
   
   @NodeEntity(label = "person")
   @Data
   public class  PersonNode {
       @Id
       @GeneratedValue
       private Long nodeId;
       @Property(name = "personId")
       private String personId;
       @Property(name = "name")
       private String name;
   }
   

4. 通过Neo4jRepository提供接口进行操作

   import org.jeecg.modules.analysis.entity.neoentity.AccountNode;
   import org.springframework.data.neo4j.annotation.Query;
   import org.springframework.data.neo4j.repository.Neo4jRepository;
   import org.springframework.data.repository.query.Param;
   
   public interface AccountRepository extends Neo4jRepository<AccountNode,Long> {
   
       @Query("match (n) where id(n)={id} return n")
       AccountNode accountNodeDetail(@Param("id") Long id);
   
       @Query("match (n:person)-[:是]->(b:account) where id(n)={id} return b")
       List<AccountNode> ListAccounts(@Param("id") Long id);
   }
   

5. 保存到neo4j

   FileInputStream inperson = new FileInputStream("persons.xlsx");
               Sheet sheetPerson = new Sheet(1, 1, PersonExcelBo.class);
               List<Object> personList = EasyExcelFactory.read(inperson, sheetPerson);
               List<PersonNode> personNodeList = new ArrayList<>();
               for (Object obj : personList) {
                   PersonExcelBo personExcel = (PersonExcelBo) obj;
                   PersonNode personNode = new PersonNode();
                   BeanUtils.copyProperties(personExcel, personNode);
                   personNodeList.add(personNode);
               }
               personRepository.saveAll(personNodeList);
   

二.通过自定义session的方式

1. 完成config配置类

   import org.neo4j.driver.v1.AuthTokens;
   import org.neo4j.driver.v1.Driver;
   import org.neo4j.driver.v1.GraphDatabase;
   import org.neo4j.driver.v1.Session;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   
   @Configuration
   public class Neo4jSourceConfig {
   
       @Bean(name = "sessionNeo")
       public Session neo4jSession() {
           Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "neo4j001"));
           return driver.session();
       }
   }
   

2. 通过session.run的方式执行cypherSql语句

   //查询某个指定节点与另一个带某种标签数据的关系集合
   public Result<?> searchRelation(String type, String nodeId) throws Exception{
   
           String cypherSql = String.format("match p=(n)-[r]-(b:%s) where id(n)=%d return p",
                   type, Long.valueOf(nodeId));
           //StatementResult result = session.run("match p=(n:person)-[r]-(b) where id(n)=1 return p");
       	//执行语句
           StatementResult result = session.run(cypherSql);
           List<RelationNeoResult> relationNeoResultList = new ArrayList<>();
           if (result.hasNext()) {
               List<Record> records = result.list();
               for (Record recordItem : records) {
                   List<Pair<String, Value>> f = recordItem.fields();
                   for (Pair<String, Value> pair : f) {
                       String typeName = pair.value().type().name();
                       if (typeName.equals("PATH")) {
                           //判断结果类型后获取
                           Path path = pair.value().asPath();
                           Iterator<Path.Segment> segmentIterator = path.iterator();
                           while (segmentIterator.hasNext()) {
                               RelationNeoResult relationNeo = new RelationNeoResult();
                               Path.Segment segment = segmentIterator.next();
                               //获取路径关系
                               Relationship relationship = segment.relationship();
                               RelationshipBo relationshipBo = RelationshipBo.builder().start(relationship.startNodeId())
                                       .end(relationship.endNodeId()).relationType(relationship.type()).build();
                               relationNeo.setRelationship(relationshipBo);
                               //
                               Node startNode = segment.start();
                               StringBuilder startLable = new StringBuilder("");
                               startNode.labels().forEach(e -> startLable.append(e));
                               Map<String, Object> startMap = startNode.asMap();
                               NodeDataBo startNodeBo = NodeDataBo.builder().nodeId(relationshipBo.getStart()).label(startLable.toString()).nodeMap(startMap).build();
                               relationNeo.setStartNode(startNodeBo);
   
                               Node endNode = segment.end();
                               StringBuilder endLable = new StringBuilder("");
                               endNode.labels().forEach(e -> endLable.append(e));
                               Map<String, Object> endMap = endNode.asMap();
                               NodeDataBo endtNodeBo = NodeDataBo.builder().nodeId(relationshipBo.getEnd()).label(endLable.toString()).nodeMap(endMap).build();
                               relationNeo.setEndNode(endtNodeBo);
                               relationNeoResultList.add(relationNeo);
                           }
                       }
                   }
               }
           }
           return Result.OK(relationNeoResultList);
       }
   

   //模糊搜索某个节点数据
   public Result<?> searchEntity(String type, String name)  throws Exception{
           Result respResult;
           List<SearchEntityRespVo> searchEntityRespVoList = new ArrayList<>();
               String cypherSql = String.format("match (p:person) where p.name =~'(?i)%s.*' return p", name);
               StatementResult result = session.run(cypherSql);
               if (result.hasNext()) {
                   List<Record> records = result.list();
                   for (Record recordItem : records) {
                       List<Pair<String, Value>> f = recordItem.fields();
                       for (Pair<String, Value> pair : f) {
                           String typeName = pair.value().type().name();
                           if (typeName.equals("NODE")) {
                               Node node = pair.value().asNode();
                               SearchEntityRespVo searchEntityRespVo = new SearchEntityRespVo();
                               searchEntityRespVo.setId(node.id());
                               searchEntityRespVo.setName(node.get("name").asString());
                               searchEntityRespVo.setType("person");
                               searchEntityRespVoList.add(searchEntityRespVo);
                           }
                       }
                   }
               }
               if (CollectionUtils.isEmpty(searchEntityRespVoList)) {
                   log.warn("并未找到相关数据，执行语句为:{}",  cypherSql);
                   return Result.error("并未找到相关数据");
               }
           
           return Result.OK(searchEntityRespVoList);
       }
   

   //根据excel中指定的关系在neo4j中创建关系
   FileInputStream inperorg= new FileInputStream("E:\\data\\person_org_all.xlsx");
               Sheet sheetperorg= new Sheet(1, 1, PersonOrgRelationExcelBo.class);
               List<Object> perorgList = EasyExcelFactory.read(inperorg, sheetperorg);
               for (Object obj : perorgList) {
                   PersonOrgRelationExcelBo relation = (PersonOrgRelationExcelBo) obj;
                   String cypherSql = String.format("match(a:person),(b:organization) where a.personId=\'%s\' and b.orgId=\'%s\' create (a)-[r:%s]->(b)",
                           relation.getPerId(),relation.getOrgId(),
                           relation.getRelationShip());
                   System.out.println(cypherSql);
                   session.run(cypherSql);
                   System.err.println("创建关系："+relation.getPerId()+ "|"+relation.getOrgId()+"|"+ relation.getRelationShip()+"成功！");
               }