嵌入式数据库neo4j中按长度排序的路径

我们如何检索图中两个节点之间的所有简单路径，路径按长度排序。在Cypher查询中有一个ORDERBY子句，但我无法在用于嵌入式数据库的JavaAPI中找到任何类似的内容

---

有没有一种方法，或者在检索路径后，我必须自己对它们进行排序？

Neo4j有一个Java API包，用于图形算法，以完全执行您要求的操作。请参阅下面的代码片段以了解其工作原理

有关详细信息，请参阅和。下面的代码段是用groovy编写的，可以使用：

@Grab（group=“org.neo4j”，module=“neo4j-cypher”，version=“2.1.3”）
@Grab（group=“org.neo4j”，module=“neo4j lucene index”，version=“2.1.3”）
@Grab（group='org.neo4j'，module='neo4j-graph-algo'，version='2.1.3'）
导入org.neo4j.graphdb.factory.GraphDatabaseFactory
导入org.neo4j.graphdb.PathExpander
导入org.neo4j.graphdb.PathExpanders
导入org.neo4j.graphdb.Path
导入org.neo4j.graphdb.Label
导入org.neo4j.graphdb.Node
导入org.neo4j.graphdb.DynamicLabel
导入org.neo4j.graphalgo.graphalgo工厂
导入org.neo4j.graphalgo.PathFinder
导入org.neo4j.helpers.collection.IteratorUtil
导入org.neo4j.cypher.javacompat.ExecutionEngine
def db=新GraphDatabaseFactory（）
.newEmbeddedDatabaseBuilder（“graph.db”）
.newGraphDatabase（）
def ee=新执行引擎（db）
ee.执行（“”）
创建（a:myLabel{myprop:'a'}），
（b:myLabel{myprop:'b'}），
（c:myLabel{myprop:'c'}），
（d:myLabel{myprop:'d'}），
（a） -[：知道]->（b），
（a） -[：知道]->（c），
（c） -[：知道]->（b），
（c） -[：知道]->（e），
（d） -[：知道]->（b）
""")
def tx=db.beginTx（）
试一试{
//查找开始和结束节点
Label Label=DynamicLabel.Label（“myLabel”）
Node startNode=IteratorUtil.single（db.findNodesByLabelAndProperty（标签“myprop”、“a”））
Node endNode=IteratorUtil.single（db.findNodesByLabelAndProperty（标签“myprop”、“b”））
PathExpander PathExpander=PathExpanders.allTypesAndDirections（）//根据需要采用
def maxDepth=5//根据您的需要采用
PathFinder PathFinder=GraphAlgoFactory.AllSimplePath（pathExpander，maxDepth）
Iterable result=pathFinder.findAllPaths（startNode，endNode）
//对结果进行排序，在java中这需要更多的努力；-）
List sortedResult=result.sort{it.length（）}
用于（路径p:sortedResult）{
println p
}
tx.成功（）
}最后{
完成
}
db.shutdown（）

您始终可以直接从java代码运行cypher查询。感谢Sumeet，这是一个选项。在使用Cypher方法之前，我想确定Java中是否有该功能。感谢Stefan，我使用Java中的类似方法对路径长度进行排序。

@Grab(group="org.neo4j", module="neo4j-cypher", version="2.1.3")
@Grab(group="org.neo4j", module="neo4j-lucene-index", version="2.1.3")
@Grab(group='org.neo4j', module='neo4j-graph-algo', version='2.1.3')

import org.neo4j.graphdb.factory.GraphDatabaseFactory
import org.neo4j.graphdb.PathExpander
import org.neo4j.graphdb.PathExpanders
import org.neo4j.graphdb.Path
import org.neo4j.graphdb.Label
import org.neo4j.graphdb.Node
import org.neo4j.graphdb.DynamicLabel
import org.neo4j.graphalgo.GraphAlgoFactory
import org.neo4j.graphalgo.PathFinder
import org.neo4j.helpers.collection.IteratorUtil
import org.neo4j.cypher.javacompat.ExecutionEngine

def db = new GraphDatabaseFactory()
  .newEmbeddedDatabaseBuilder("graph.db")
  .newGraphDatabase()

def ee = new ExecutionEngine(db)
ee.execute("""
create (a:myLabel {myprop:'a'}),
(b:myLabel {myprop:'b'}),
(c:myLabel {myprop:'c'}),
(d:myLabel {myprop:'d'}),
(a)-[:KNOWS]->(b),
(a)-[:KNOWS]->(c),
(c)-[:KNOWS]->(b),
(c)-[:KNOWS]->(e),
(d)-[:KNOWS]->(b)
""")

def tx = db.beginTx()
try {

  // lookup start and end node
  Label label = DynamicLabel.label("myLabel")
  Node startNode = IteratorUtil.single(db.findNodesByLabelAndProperty(label, "myprop", "a"))
  Node endNode = IteratorUtil.single(db.findNodesByLabelAndProperty(label, "myprop", "b"))

  PathExpander pathExpander = PathExpanders.allTypesAndDirections() // adopt to your needs
  def maxDepth = 5 // adopt to your needs

  PathFinder<Path> pathFinder = GraphAlgoFactory.allSimplePaths(pathExpander, maxDepth)
  Iterable<Path> result = pathFinder.findAllPaths(startNode, endNode)

  // sort the results, in java this is more effort ;-)
  List<Path> sortedResult = result.sort { it.length() }

  for (Path p: sortedResult) {
      println p
  }
  tx.success()
} finally {
   tx.finish()
}

db.shutdown()