最简单的node-json搭建 建一个db.json 在命令行通过curl进行增删改查

1. 创建一个空的db.json文件
2. 安装json-server： `npm install -g json-server`
3. 启动json-server： `json-server db.json`
4. 在命令行中使用curl进行增删改查操作，例如：

- 查询所有数据： `curl localhost:3000`
- 查询id为1的数据： `curl localhost:3000/1`
- 添加一条数据： `curl -X POST -H "Content-Type: application/json" -d '{"name": "John", "age": 30}' localhost:3000`
- 更新id为1的数据： `curl -X PUT -H "Content-Type: application/json" -d '{"name": "John Doe", "age": 35}' localhost:3000/1`
- 删除id为1的数据： `curl -X DELETE localhost:3000/1`

注意：以上命令均在命令行中执行，需要保证json-server已经启动。

相关问题

最简单的node-json搭建 建一个db.json 通过curl进行增删改查

1. 首先需要安装Node.js和npm，具体安装方法可以参考官方文档。

2. 创建一个项目目录，进入该目录并执行以下命令初始化npm：

npm init -y

3. 安装json-server模块：

npm install json-server --save-dev

4. 在项目根目录下创建一个db.json文件，内容如下：

{
  "posts": [
    {
      "id": 1,
      "title": "Post 1",
      "body": "This is the first post"
    },
    {
      "id": 2,
      "title": "Post 2",
      "body": "This is the second post"
    },
    {
      "id": 3,
      "title": "Post 3",
      "body": "This is the third post"
    }
  ]
}

5. 在package.json文件中添加以下命令：

"scripts": {
  "start": "json-server --watch db.json"
}

6. 启动json-server：

npm start

此时json-server已经启动，可以通过curl命令进行增删改查操作了。

例如，获取所有posts：

curl http://localhost:3000/posts

新增一篇post：

curl -X POST -H "Content-Type: application/json" -d '{"title": "New Post", "body": "This is a new post"}' http://localhost:3000/posts

更新一篇post：

curl -X PUT -H "Content-Type: application/json" -d '{"title": "Updated Post", "body": "This post has been updated"}' http://localhost:3000/posts/1

删除一篇post：

curl -X DELETE http://localhost:3000/posts/1

以上就是最简单的node-json搭建，通过curl进行增删改查的方法。

用gin接受路由传递过来的json包并在数据库中增删改查值然后返回数据

好的，我可以给你一个简单的示例代码，使用Gin框架接收JSON请求，并对MySQL数据库进行增删改查操作，并返回相应的JSON数据。

首先，你需要确保你的环境中已经安装了Gin和MySQL的驱动程序。你可以使用以下命令来安装它们：

go get -u github.com/gin-gonic/gin
go get -u github.com/go-sql-driver/mysql

接下来，我们将创建一个名为main.go的文件，作为我们的入口文件。在这个文件中，我们将创建一个Gin路由，并定义一些处理程序，用于处理不同的请求。

package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // 连接 MySQL 数据库
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 测试数据库连接
    err = db.Ping()
    if err != nil {
        log.Fatal(err)
    }

    // 创建 Gin 路由
    r := gin.Default()

    // 添加处理程序
    r.POST("/users", addUser(db))
    r.GET("/users/:id", getUser(db))
    r.PUT("/users/:id", updateUser(db))
    r.DELETE("/users/:id", deleteUser(db))

    // 启动 HTTP 服务器
    err = r.Run(":8080")
    if err != nil {
        log.Fatal(err)
    }
}

// 处理添加用户请求
func addUser(db *sql.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        var user User
        err := c.BindJSON(&user)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        result, err := db.Exec("INSERT INTO users(name, age) VALUES(?, ?)", user.Name, user.Age)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        id, err := result.LastInsertId()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        user.ID = int(id)

        c.JSON(http.StatusOK, user)
    }
}

// 处理获取用户请求
func getUser(db *sql.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        id := c.Param("id")

        var user User
        err := db.QueryRow("SELECT id, name, age FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name, &user.Age)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        c.JSON(http.StatusOK, user)
    }
}

// 处理更新用户请求
func updateUser(db *sql.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        id := c.Param("id")

        var user User
        err := c.BindJSON(&user)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        _, err = db.Exec("UPDATE users SET name = ?, age = ? WHERE id = ?", user.Name, user.Age, id)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        c.JSON(http.StatusOK, user)
    }
}

// 处理删除用户请求
func deleteUser(db *sql.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        id := c.Param("id")

        _, err := db.Exec("DELETE FROM users WHERE id = ?", id)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        c.JSON(http.StatusOK, gin.H{"message": fmt.Sprintf("User %s deleted", id)})
    }
}

在这个示例代码中，我们创建了一个名为User的结构体，用于存储用户数据。我们还定义了四个处理程序，用于处理添加、获取、更新和删除用户的请求。这些处理程序都接受一个指向MySQL数据库的指针，以便它们可以对数据库进行操作。我们在每个处理程序中使用Gin的JSON绑定方法来解析请求的JSON数据，并使用MySQL的Exec和QueryRow方法来执行SQL语句。

最后，我们使用Gin的路由方法将这些处理程序添加到路由中，并使用Run方法启动HTTP服务器。你可以使用以下命令来编译和运行这个示例代码：

go build -o app main.go
./app

现在，你可以使用任何HTTP客户端向你的应用程序发送JSON请求，以进行增删改查操作。例如，你可以使用curl命令发送一个添加用户的请求：

curl -X POST -H "Content-Type: application/json" -d '{"name": "Alice", "age": 25}' http://localhost:8080/users

应用程序将返回一个包含新创建用户的JSON数据的响应。你还可以使用GET、PUT和DELETE方法来执行其他操作。