Neo4j学习笔记-Embedded嵌入模式有向图寻找环路

原创已于 2023-02-02 13:48:08 修改 · 1.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#neo4j #embedded #有向图 #环路

于 2020-11-05 22:20:16 首次发布

Neo4j 专栏收录该内容

4 篇文章

订阅专栏

这篇博客介绍了在Java环境下使用Neo4j 3.5.22社区版进行有向图操作。通过示例代码展示了如何在嵌入模式下检测图中的环路，对理解Neo4j的图数据库操作具有实践指导意义。

Java版本：jdk1.8.0_121

Neo4j版本：neo4j-community-3.5.22

示例代码如下：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.neo4j.graphdb.*;
import org.platform.modules.bootstrap.BootstrapApplication;
import org.platform.modules.graph.utils.GraphUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = BootstrapApplication.class)
public class Neo4jEmbeddedApplicationCircleTest {

    private Logger LOG = LoggerFactory.getLogger(Neo4jEmbeddedApplicationCircleTest.class);

    @Test
    public void testGraphDatabaseServiceCreateNode() {
        GraphDatabaseService graphDatabaseService = GraphUtils.createGraphDatabaseService("C:/tmp/neo4j/pool1/graph.db");
        try (Transaction tx = graphDatabaseService.beginTx()) {
            Node node001 = graphDatabaseService.createNode(CLabel.USER);
            node001.setProperty("name", "zhang001");
            Node node002 = graphDatabaseService.createNode(CLabel.USER);
            node002.setProperty("name", "zhang002");
            Node node003 = graphDatabaseService.createNode(CLabel.USER);
            node003.setProperty("name", "zhang003");
            Node node004 = graphDatabaseService.createNode(CLabel.USER);
            node004.setProperty("name", "zhang004");
            Node node005 = graphDatabaseService.createNode(CLabel.USER);
            node005.setProperty("name", "zhang005");
            node001.createRelationshipTo(node002, CRelationshipType.IS_FRIEND_OF);
            node001.createRelationshipTo(node004, CRelationshipType.IS_FRIEND_OF);
            node002.createRelationshipTo(node001, CRelationshipType.IS_FRIEND_OF);
            node002.createRelationshipTo(node003, CRelationshipType.IS_FRIEND_OF);
            node003.createRelationshipTo(node001, CRelationshipType.IS_FRIEND_OF);
            node004.createRelationshipTo(node005, CRelationshipType.IS_FRIEND_OF);
            node005.createRelationshipTo(node001, CRelationshipType.IS_FRIEND_OF);
            tx.success();
        }
        GraphUtils.shutdownGraphDatabaseService(graphDatabaseService);
    }

    @Test
    public void testGraphDatabaseServiceCircleQuery1() {
        // 查询节点ID为0开始的3-10层环路
        String query = "match p=(n:USER)-[:IS_FRIEND_OF*3..10]->(n:USER) where id(n) = 0 return nodes(p) as ns";
        Map<String, Object> parameters = new HashMap<String, Object>();
        GraphUtils.query("C:/tmp/neo4j/pool1/graph.db", query, parameters, result -> {
            List<String> columns = result.columns();
            while (result.hasNext()) {
                Map<String, Object> row = result.next();
                LOG.info("row {}", row);
            }
        });
    }

    @Test
    public void testGraphDatabaseServiceCircleQuery2() {
        // 查询所有节点ID开始的3-10层环路
        String query = "match (u:USER) with id(u) as uid match p=(n:USER)-[:IS_FRIEND_OF*3..10]->(n:USER) where id(n) = uid return nodes(p) as ns";
        Map<String, Object> parameters = new HashMap<String, Object>();
        GraphUtils.query("C:/tmp/neo4j/pool1/graph.db", query, parameters, result -> {
            List<String> columns = result.columns();
            while (result.hasNext()) {
                Map<String, Object> row = result.next();
                LOG.info("row {}", row);
            }
        });
    }

    @Test
    public void testGraphDatabaseServiceCircleQuery3() {
        // 查询节点ID为0开始的3-10层环路，剔除掉重复循环环路
        String query = "match (u:USER) with id(u) as uid match p=(n:USER)-[:IS_FRIEND_OF*3..10]->(n:USER) where id(n) = uid " +
            "unwind nodes(p) as ps with p, size(nodes(p)) as pLen, size(collect(distinct ps)) as psLen where pLen = psLen + 1 return pLen, psLen, nodes(p)";
        Map<String, Object> parameters = new HashMap<String, Object>();
        GraphUtils.query("C:/tmp/neo4j/pool1/graph.db", query, parameters, result -> {
            List<String> columns = result.columns();
            while (result.hasNext()) {
                Map<String, Object> row = result.next();
                LOG.info("row {}", row);
            }
        });
    }

    public enum CLabel implements Label {
        USER;
    }

    public enum CRelationshipType implements RelationshipType {
        IS_FRIEND_OF;
    }

}