使用Neo4J和Docker创建一个简单的GO应用程序-DEV365 开发者社区

大家好ð，今天我们将创建一个简单的GO应用程序，该应用程序使用Neo4jð¢（一个流行的图形数据库）和Dockerð¢演示基本的CRUD操作。本教程将指导您使用Docker设置本地NEO4J实例的步骤，使用Neo4J Go驱动程序从您的GO应用程序连接到它，并在示例数据集上执行CRUD操作。到本教程结束时，您将对如何将Neo4J与GO和Docker一起使用以构建可扩展和高效的基于图形的应用程序ð。所以，让我们开始！

neo4j是一个流行的图形数据库，允许用户使用基于图的查询ð存储，管理和检索数据。 GO是一种流行的编程语言，用于构建可扩展有效的应用程序ð。在本教程中，我们将学习如何创建一个使用Neo4J和Docker执行CRUD操作的简单GO项目。

先决条件

我们开始之前，请确保您在系统上安装了以下内容：

docker - �
GO（版本1.16或更高版本）
neo4j-go-driver软件包（版本4或更高版本）

使用Dockerð³设置Neo4J数据库

首先，我们需要使用Dockerð³设置NEO4J数据库。打开终端并执行以下命令：

docker run --name neo4j -p 7687:7687 -p 7474:7474 -e NEO4J_AUTH=neo4j/test1234 neo4j:latest
此命令将创建一个新的Docker容器，其NEO4J数据库在端口7687（用于螺栓）和7474（用于HTTP）ð上。我们还将neo4j_auth环境变量设置为neo4j/test1234，以指定Neo4J用户的初始密码。

创建一个新的GO项目

接下来，我们需要创建一个新的GO项目。为项目创建一个新目录并导航到其中：

mkdir my-neo4j-project
cd my-neo4j-project

为项目创建一个新的GO模块：

go mod init my-neo4j-project

这将在项目目录中创建一个新的go.mod文件。

现在，让我们看一下代码！ ð

导入语句

import (
    "fmt"
    "github.com/neo4j/neo4j-go-driver/v4/neo4j"
    "log"
)

导入语句包括与neo4j数据库交互的必要软件包和日志错误。

创建一个人结构

type Person struct {
    ID   int64
    Name string
    Age  int
}

人的结构代表neo4j数据库ð§中的“人”节点的结构。它具有ID，名称和年龄领域。

写主要功能

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

主要功能是应用程序的入口点。它通过提供螺栓URL和身份验证证书ð。

来创建一个新的Neo4J驱动程序实例。

创建一个人

让我们从创建一个新人开始。我们定义了一个createperson函数，该函数涉及neo4j驱动程序实例，该人的名称以及年龄为参数。在功能中，我们使用驱动程序创建一个新的会话，然后执行Cypher查询以创建具有给定名称和年龄的新人节点。然后，我们从结果中提取创建节点的ID，并返回具有ID，名称和年龄的新人结构。

func createPerson(driver neo4j.Driver, name string, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "CREATE (p:Person {name: $name, age: $age}) RETURN id(p)",
        map[string]interface{}{"name": name, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    return &Person{ID: id, Name: name, Age: age}, nil
}

命名

接下来，我们定义一个getPersonByName函数，该函数涉及neo4j驱动程序实例和一个人的名称作为参数。在函数内部，我们使用驱动程序创建一个新的会话，然后执行Cypher查询以找到带有给定名称的人节点。我们将结果限制为一个记录，然后从结果中提取节点的ID和年龄。然后，我们返回具有ID，名称和年龄的新人结构。

func getPersonByName(driver neo4j.Driver, name string) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE p.name = $name RETURN id(p), p.age LIMIT 1",
        map[string]interface{}{"name": name},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    age, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(age)}, nil
}

通过身份证找人

我们还定义了一个getPersonbyId函数，该函数将带有neo4j驱动程序实例和一个人的ID作为参数。在函数内部，我们使用驱动程序创建一个新的会话，然后执行Cypher查询以找到具有给定ID的人节点。我们从结果中提取节点的名称和年龄，并返回具有ID，名称和年龄的新人结构。

func getPersonByID(driver neo4j.Driver, id int64) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id RETURN p.name, p.age",
        map[string]interface{}{"id

更新人的年龄

更新的函数采用Neo4J驱动程序对象，需要更新年龄的人的ID和新时代。然后，它使用驱动程序创建一个新的会话，并执行一个密码查询，该查询根据提供的ID更新人的年龄。 Cypher查询从匹配关键字开始，该关键字可以找到具有给定ID的人节点。 SET关键字用于将人节点的年龄属性设置为提供的新时代。最后，返回关键字用于检索该人节点的名称和更新的年龄。

一旦Cypher查询成功执行，该函数将构造一个人结构，其中包含更新的ID，名称和年龄。然后，该人结构由功能返回。

func updatePersonAge(driver neo4j.Driver, id int64, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id SET p.age = $age RETURN p.name, p.age",
        map[string]interface{}{"id": id, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    name, ok := record.Values[0].(string)
    if !ok {
        return nil, fmt.Errorf("invalid name type")
    }

    newAge, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(newAge)}, nil
}

删除人

DELETEPERSON函数带有NEO4J驱动程序对象和要删除的人的ID。它使用驱动程序创建一个新的会话，并执行一个基于提供的ID删除人节点的密码查询。 Cypher查询从匹配关键字开始，该关键字可以找到具有给定ID的人节点。删除关键字用于删除人节点。

如果删除成功，则函数将返回零。否则，它会返回一个错误，表明删除不成功。

func deletePerson(driver neo4j.Driver, id int64) error {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    _, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id DELETE p",
        map[string]interface{}{"id": id},
    )
    if err != nil {
        return err
    }

    return nil
}

将所有这些放在一起

现在，我们已经定义了CRUD操作的必要功能，让我们将它们放在主要功能中。主函数演示了如何在neo4j数据库中创建，获取，更新和删除一个人节点。

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

    // create a new person
    person, err := createPerson(driver, "Alice", 30)
    if err != nil {
        log.Fatalf("Failed to create person: %v", err)
    }
    log.Printf("Created person: %+v\n", person)

    // get the person by name
    personByName, err := getPersonByName(driver, "Alice")
    if err != nil {
        log.Fatalf("Failed to get person by name: %v", err)
    }
    log.Printf("Found person by name: %+v\n", personByName)

    // get the person by ID
    personByID, err := getPersonByID(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to get person by ID: %v", err)
    }
    log.Printf("Found person by ID: %+v\n", personByID)

    // update the person's age
    updatedPerson, err := updatePersonAge(driver, person.ID, 35)
    if err != nil {
        log.Fatalf("Failed to update person's age: %v", err)
    }
    log.Printf("Updated person: %+v\n", updatedPerson)

    // delete the person
    err = deletePerson(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to delete person: %v", err)
    }
    log.Printf("Deleted person with ID %d\n", person.ID)
}

主函数首先创建一个新的Neo4J驱动程序实例，然后创建一个名称为“ Alice”和30岁的新人节点。然后，它按名称和ID检索人节点并打印结果。然后，该功能将人的年龄更新为35岁，并打印出更新的人。最后，它删除了该人节点并打印一条消息，表明该人已被删除。

结论

在本教程中，我们学会了如何创建一个简单的GO应用程序，该应用程序使用Neo4J和Docker在示例数据集上执行CRUD操作。我们首先使用Docker设置了一个NEO4J数据库，然后定义了在Neo4J数据库中创建，获取，更新和删除一个人节点的必要函数。然后，我们将这些功能放在主要功能中，以演示如何在示例数据集上执行CRUD操作。

在本教程结束时，您应该对如何将Neo4J与GO和Docker一起使用以构建可扩展和高效的基于图形的应用程序有深入的了解。希望您发现本教程有帮助，请随时在下面留下任何评论或问题！ ð