使用 Go 通过 REST API 查询 Neo4j 节点：完整教程-Golang-PHP中文网

使用 Go 通过 REST API 查询 Neo4j 节点：完整教程

心靈之曲

发布： 2025-10-07 11:53:24

原创

794人浏览过

使用 go 通过 rest api 查询 neo4j 节点：完整教程

本文档详细介绍了如何使用 Go 语言通过 Neo4j 的 REST API 查询节点，重点在于正确配置和使用 Lucene 查询。我们将通过一个完整的示例，演示如何创建节点索引、添加节点到索引，并最终使用正确的 Lucene 查询来检索节点。本文将帮助开发者避免常见的查询错误，并提供清晰的代码示例和注意事项。

前提条件

安装 Go 语言环境
安装 Neo4j 数据库
安装 Neo4j Go 驱动 (例如：github.com/neo4j/neo4j-go-driver/v4)

步骤详解

以下是一个完整的示例，演示了如何创建节点索引、添加节点到索引，并使用 Lucene 查询检索节点。

1. 创建节点索引

首先，我们需要创建一个节点索引。索引类型通常选择 fulltext，提供者选择 lucene。

func CreateNodeIndex(session *neo4j.Session, indexName string) error {
    query := fmt.Sprintf(`CREATE FULLTEXT INDEX %s FOR (n:Node) ON EACH [n.name, n.key01]`, indexName)
    _, err := (*session).Run(query, map[string]interface{}{})
    return err
}

登录后复制

2. 创建节点

接下来，创建一些节点，这些节点将被添加到索引中。

func CreateNode(session *neo4j.Session, data map[string]interface{}) (neo4j.Result, error) {
    query := `CREATE (n:Node $props) RETURN n`
    params := map[string]interface{}{
        "props": data,
    }
    result, err := (*session).Run(query, params)
    return result, err
}

登录后复制

3. 将节点添加到索引

将创建的节点添加到索引中。注意，indexKey 应该与节点属性名一致，indexValue 应该与节点属性值一致。

造点AI

夸克 · 造点AI

325

查看详情

func AddNodeToIndex(session *neo4j.Session, indexName string, nodeID int64, indexKey string, indexValue string) error {
    query := fmt.Sprintf(`CALL db.index.fulltext.addNode('%s', {Node}, ['%s'])`, indexName, indexKey)
    params := map[string]interface{}{
        "nodeId":    nodeID,
        "indexKey":  indexKey,
        "indexValue": indexValue,
    }

    _, err := (*session).Run(query, params)
    return err
}

登录后复制

4. 使用 Lucene 查询节点

这是最关键的部分。要使用 Lucene 查询，必须使用正确的索引键。如果存储数据时使用的 indexKey 是 "some_key"，那么 Lucene 查询也必须使用 "some_key"。

func FindNodeByQuery(session *neo4j.Session, indexName string, luceneQuery string) (neo4j.Result, error) {
    query := fmt.Sprintf(`CALL db.index.fulltext.queryNodes('%s', '%s') YIELD node, score RETURN node`, indexName, luceneQuery)
    result, err := (*session).Run(query, map[string]interface{}{})
    return result, err
}

登录后复制

完整示例代码

package main

import (
    "fmt"
    "log"
    "testing"

    "github.com/neo4j/neo4j-go-driver/v4/neo4j"
)

// Replace with your Neo4j connection details
const (
    uri      = "bolt://localhost:7687"
    username = "neo4j"
    password = "your_password"
)

func TestFindNodeByQuery(t *testing.T) {
    log.Println("Start testing FindNodeByQuery")

    driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""))
    if err != nil {
        t.Fatal(err)
    }
    defer driver.Close()

    sessionConfig := neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite}
    session := driver.NewSession(sessionConfig)
    defer session.Close()

    log.Println("Create Index,type lucene")
    indexName := "testIndex"
    indexType := "fulltext"
    indexProvider := "lucene"
    err = CreateNodeIndex(&session, indexName)
    if err != nil {
        t.Error(err)
    }
    log.Println("create two nodes")
    data := map[string]interface{}{
        "name":  "test01",
        "key01": "value01",
    }
    result1, err := CreateNode(&session, data)
    if err != nil {
        t.Error(err)
    }
    record1, err := result1.Single()
    if err != nil {
        t.Error(err)
    }
    node1 := record1.Values[0].(neo4j.Node)

    data["name"] = "test02"
    result2, err := CreateNode(&session, data)
    if err != nil {
        t.Error(err)
    }
    record2, err := result2.Single()
    if err != nil {
        t.Error(err)
    }
    node2 := record2.Values[0].(neo4j.Node)

    indexKey := "name"
    indexValue := "test"
    err = AddNodeToIndex(&session, indexName, node1.Id, indexKey, indexValue)
    if err != nil {
        t.Error(err)
    }
    err = AddNodeToIndex(&session, indexName, node2.Id, indexKey, indexValue)
    if err != nil {
        t.Error(err)
    }
    luceneQuery := "name:test*" // Corrected query
    results, err := FindNodeByQuery(&session, indexName, luceneQuery)
    if err != nil {
        t.Error(err)
    }

    count := 0
    for results.Next() {
        count++
        record := results.Record()
        node := record.Values[0].(neo4j.Node)
        log.Println(node.Props)

    }
    log.Printf("Found %d nodes\n", count)
    // results, err := session.FindNodeByMatch(indexName, indexKey, indexValue)
    // log.Println(len(results))
    // for _, result := range results {
    //  log.Println(result)
    // }
    log.Println("Clean data...")
    deleteNodeQuery := `MATCH (n) WHERE id(n) = $nodeId DELETE n`
    _, err = session.Run(deleteNodeQuery, map[string]interface{}{"nodeId": node1.Id})
    if err != nil {
        t.Error(err)
    }
    _, err = session.Run(deleteNodeQuery, map[string]interface{}{"nodeId": node2.Id})
    if err != nil {
        t.Error(err)
    }
    dropIndexQuery := fmt.Sprintf(`DROP INDEX %s`, indexName)
    _, err = session.Run(dropIndexQuery, map[string]interface{}{})

    if err != nil {
        t.Error(err)
    }
    log.Println("data cleaned")
    log.Println("FindNodeByQuery test finished!")

}

func CreateNodeIndex(session *neo4j.Session, indexName string) error {
    query := fmt.Sprintf(`CREATE FULLTEXT INDEX %s FOR (n:Node) ON EACH [n.name, n.key01]`, indexName)
    _, err := (*session).Run(query, map[string]interface{}{})
    return err
}

func CreateNode(session *neo4j.Session, data map[string]interface{}) (neo4j.Result, error) {
    query := `CREATE (n:Node $props) RETURN n`
    params := map[string]interface{}{
        "props": data,
    }
    result, err := (*session).Run(query, params)
    return result, err
}

func AddNodeToIndex(session *neo4j.Session, indexName string, nodeID int64, indexKey string, indexValue string) error {
    query := fmt.Sprintf(`CALL db.index.fulltext.addNode('%s', {Node}, ['%s'])`, indexName, indexKey)
    params := map[string]interface{}{
        "nodeId":    nodeID,
        "indexKey":  indexKey,
        "indexValue": indexValue,
    }

    _, err := (*session).Run(query, params)
    return err
}

func FindNodeByQuery(session *neo4j.Session, indexName string, luceneQuery string) (neo4j.Result, error) {
    query := fmt.Sprintf(`CALL db.index.fulltext.queryNodes('%s', '%s') YIELD node, score RETURN node`, indexName, luceneQuery)
    result, err := (*session).Run(query, map[string]interface{}{})
    return result, err
}

func main() {
    testing.Main(nil, nil, nil)
}

登录后复制

注意事项