Gin+Gorm implements CRUD actual combat

package main

import (
	"encoding/json"
	"net/http"

	"/gin-gonic/gin"
	"/thinkerou/favicon"
)

// Middleware (interceptor), functions: preprocessing, login authorization, verification, paging, time-consuming statistics...// func myHandler()  {
// 	return func(ctx *) {
// // By customizing the middleware and setting the value, you can get the parameters here as long as you call this middleware in the subsequent processing.// 		("usersesion", "userid-1")
// () // Release// 		() // Prevent// 	}
// }

func main() {
	// Create a service	ginServer := ()
	(("./")) // If you add something and run it again, there is no change, please restart the browser, the browser has a cache
	// Load static page	("templates/*") // One is global loading, the other is loading the specified file

	 // Load the resource file
	 ("/static", "./static")

	 // A corresponding page is given to the front end

	 ("/index", func(ctx *) {
		 (, "", {
			 "msg": "This data is come from Go background.",
		 })
	 })

	 // Can load static pages or test files

	 // Get the parameters in the request

	 // Traditional way: usl?userid=xxx&username=conqueror712
	 // Rustful method: /user/info/1/conqueror712

	 // Here are examples of traditional methods
	 ("/user/info", func(context *) { // This format is fixed
		 userid := ("userid")
		 username := ("username")
		 // Return to the front end after getting it
		 (, {
			 "userid": userid,
			 "username": username,
		 })
	 })
	 // After executing the code, you can enter http://localhost:8081/user/info?userid=111&username=666 in the browser
	 // You can see the data returned in JSON format

	 // Below is an example of the Rustful method
	 ("/user/info/:userid/:username", func(context *) {
		 userid := ("userid")
		 username := ("username")
		 // Still the same, return to the front end
		 (, {
			 "userid": userid,
			 "username": username,
		 })
	 })
	 // After specifying the code, you only need to http://localhost:8081/user/info/111/555 in the browser
	 // You can see that the JSON data is returned, which is very convenient and simple

	 // Serialization
	 // The front-end passes JSON to the back-end
	 ("/json", func(ctx *) {
		 //
		 data, _ := ()
		 var m map[string]interface{} // In Go language, object is generally represented by an empty interface, and can receive anything
		 // By the way, above 1.18, interface can be changed directly to any
		 _ = (data, &m)
		 (, m)
	 })
	 // Just use apipost or postman to write a json and pass it to localhost:8081/json
	 /*
		 json example:
		 {
			 "name": "Conqueror712",
			 "age": 666,
			 "address": "Mars"
		 }
	 */
	// Just see the data received in the real-time response of the backend
	// Handling form requests These support functional programming, Go language features, and can pass functions as parameters in	("/user/add", func(ctx *) {
		username := ("username")
		password := ("password")
		(, {
			"msg":      "ok",
			"username": username,
			"password": password,
		})
	})

	//Route	("/test", func(ctx *) {
		// Redirect -> 301		(301, "//")
	})
	// http://localhost:8081/test

	// 404
	(func(ctx *) {
		(404, "", nil)
	})

	// Routing group is temporarily omitted
	// Server port, use the server port to access the address	(":8081") // If you don't write it, the default is 8080, and it can also be changed.}

$ go build -tags=jsoniter .

go get -u /gorm
go get -u /driver/sqlite

package main

import (
	"fmt"
	"time"

	// "/driver/sqlite"
	"/gin-gonic/gin"
	"/driver/mysql"
	"/gorm"
)

func main() {
	// How to connect to the database? MySQL + Navicat	// What needs to be changed: username, password, database name	dsn := "root:BqV?eGcc_1o+@tcp(127.0.0.1:3306)/crud-list?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := ((dsn), &{})

	("db = ", db)
	("err = ", err)

	// Connection pool	sqlDB, err := ()
	// SetMaxIdleConns Set the maximum number of connections in the idle connection pool	(10)
	// SetMaxOpenConns Set the maximum number of open database connections.	(100)
	// SetConnMaxLifetime sets the maximum time for connection to be reusable.	(10 * ) // 10 seconds
	// Structure	type List struct {
		Name    string
		State   string
		Phone   string
		Email   string
		Address string
	}

	// Migrate	(&List{})

	// Interface	r := ()

	// Port number	PORT := "3001"
	(":" + PORT)
}

`gorm:"type:varchar(20); not null" json:"name" binding:"required"`

// test("/", func(c *) {
	(200, {
		"message": "Request succeeded",
	})
})

{
	"name" : "Zhang San",
    "state" : "On-job",
    "phone" : "13900000000",
    "email" : "6666@",
    "address" : "Erxian Bridge Chenghua Avenue"
}

{
    "code": "200",
    "data": {
        "ID": 1,
        "CreatedAt": "2023-01-24T09:27:36.73+08:00",
        "UpdatedAt": "2023-01-24T09:27:36.73+08:00",
        "DeletedAt": null,
        "name": "Zhang San",
        "state": "On-job",
        "phone": "13900000000",
        "email": "6666@",
        "address": "Erxian Bridge Chenghua Avenue"
    },
    "msg": "Added successfully"
}

{
    "code": 200,
    "msg": "Delete successfully"
}

{
    "code": 400,
    "msg": "id not found, deletion failed"
}

{
	"name" : "Zhang San",
    "state" : "Resignation",
    "phone" : "13900000000",
    "email" : "6666@",
    "address" : "Erxian Bridge Chenghua Avenue"
}

{
    "code": 200,
    "msg": "Modification was successful"
}

{
    "code": "200",
    "data": [
        {
            "ID": 3,
            "CreatedAt": "2023-01-24T10:06:25.305+08:00",
            "UpdatedAt": "2023-01-24T10:06:25.305+08:00",
            "DeletedAt": null,
            "name": "Wang Wu",
            "state": "On-job",
            "phone": "13100000000",
            "email": "8888@",
            "address": "Eight Immortal Bridge Chenghua Avenue"
        }
    ],
    "msg": "Query successful"
}

{
    "code": 200,
    "data": {
        "list": [
            {
                "ID": 3,
                "CreatedAt": "2023-01-24T10:06:25.305+08:00",
                "UpdatedAt": "2023-01-24T10:06:25.305+08:00",
                "DeletedAt": null,
                "name": "Wang Wu",
                "state": "On-job",
                "phone": "13100000000",
                "email": "8888@",
                "address": "Eight Immortal Bridge Chenghua Avenue"
            }
        ],
        "pageNum": 1,
        "pageSize": 2,
        "total": 2
    },
    "msg": "Query successful"
}

{
    "code": 200,
    "data": {
        "list": [
            {
                "ID": 1,
                "CreatedAt": "2023-01-24T09:27:36.73+08:00",
                "UpdatedAt": "2023-01-24T09:55:20.351+08:00",
                "DeletedAt": null,
                "name": "Zhang San",
                "state": "Resignation",
                "phone": "13900000000",
                "email": "6666@",
                "address": "Erxian Bridge Chenghua Avenue"
            },
            {
                "ID": 3,
                "CreatedAt": "2023-01-24T10:06:25.305+08:00",
                "UpdatedAt": "2023-01-24T10:06:25.305+08:00",
                "DeletedAt": null,
                "name": "Wang Wu",
                "state": "On-job",
                "phone": "13100000000",
                "email": "8888@",
                "address": "Eight Immortal Bridge Chenghua Avenue"
            }
        ],
        "pageNum": 0,
        "pageSize": 0,
        "total": 2
    },
    "msg": "Query successful"
}

package main

import (
	"fmt"
	"strconv"
	"time"

	// "/driver/sqlite"
	"/gin-gonic/gin"
	"/driver/mysql"
	"/gorm"
	"/gorm/schema"
)

func main() {
	// How to connect to the database? MySQL + Navicat	// What needs to be changed: username, password, database name	dsn := "root:password@tcp(127.0.0.1:3306)/database?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := ((dsn), &{
		NamingStrategy: {
			SingularTable: true,
		},
	})

	("db = ", db)
	("err = ", err)

	// Connection pool	sqlDB, err := ()
	// SetMaxIdleConns Set the maximum number of connections in the idle connection pool	(10)
	// SetMaxOpenConns Set the maximum number of open database connections.	(100)
	// SetConnMaxLifetime sets the maximum time for connection to be reusable.	(10 * ) // 10 seconds
	// Structure	type List struct {
		        // Primary key		Name       string `gorm:"type:varchar(20); not null" json:"name" binding:"required"`
		State      string `gorm:"type:varchar(20); not null" json:"state" binding:"required"`
		Phone      string `gorm:"type:varchar(20); not null" json:"phone" binding:"required"`
		Email      string `gorm:"type:varchar(40); not null" json:"email" binding:"required"`
		Address    string `gorm:"type:varchar(200); not null" json:"address" binding:"required"`
	}

	// Migrate	(&List{})

	// Interface	r := ()

	// test	// ("/", func(c *) {
	// 	(200, {
	// "message": "Request succeeded",	// 	})
	// })

	// Business code agreement: 200 correct, 400 error
	// Add	("/user/add", func(ctx *) {
		// Define a variable pointing to a structure		var data List
		// Binding method		err := (&data)
		// Determine whether there is any error in the binding		if err != nil {
			(200, {
				"msg":  "Add failed",
				"data": {},
				"code": "400",
			})
		} else {
			// Database operation			(&data) // Create a data			(200, {
				"msg":  "Added successfully",
				"data": data,
				"code": "200",
			})
		}
	})

	// Delete	// 1. Find the corresponding entry for the corresponding id	// 2. Determine whether the id exists	// 3. Delete or return id from the database
	// Restful encoding specification	("/user/delete/:id", func(ctx *) {
		var data []List
		// Receive id		id := ("id") // If there is a key-value pair form, use Query()		// Determine whether the id exists		("id = ? ", id).Find(&data)
		if len(data) == 0 {
			(200, {
				"msg":  "id not found, deletion failed",
				"code": 400,
			})
		} else {
			// Operation database deletion (the corresponding item to delete id)			// ("id = ? ", id).Delete(&data) <- Actually, it doesn't need to be written like this, because the data you found is the data to be deleted.			(&amp;data)

			(200, {
				"msg":  "Delete successfully",
				"code": 200,
			})
		}

	})

	// change	("/user/update/:id", func(ctx *) {
		// 1. Find the entry corresponding to the corresponding id		// 2. Determine whether the id exists		// 3. Modify the corresponding entry or return id not found		var data List
		id := ("id")
		// ("id = ?", id).Find(&data) can be written like this or as follows		// You can also add the Count function after Where to find out the number of digits corresponding to this condition		("id").Where("id = ? ", id).Find(&amp;data)
		if  == 0 {
			(200, {
				"msg":  "User ID not found",
				"code": 400,
			})
		} else {
			// Bind it			err := (&amp;data)
			if err != nil {
				(200, {
					"msg":  "Modification failed",
					"code": 400,
				})
			} else {
				// db modify database content				("id = ?", id).Updates(&amp;data)
				(200, {
					"msg":  "Modification was successful",
					"code": 200,
				})
			}
		}
	})

	// check	// The first type: conditional query,	("/user/list/:name", func(ctx *) {
		// Get path parameters		name := ("name")
		var dataList []List
		// Query the database		("name = ? ", name).Find(&amp;dataList)
		// Determine whether the data has been queried		if len(dataList) == 0 {
			(200, {
				"msg":  "No data was found",
				"code": "400",
				"data": {},
			})
		} else {
			(200, {
				"msg":  "Query successful",
				"code": "200",
				"data": dataList,
			})
		}
	})

	// The second type: all query / pagination query	("/user/list", func(ctx *) {
		var dataList []List
		// Query all data or query paginated data		pageSize, _ := (("pageSize"))
		pageNum, _ := (("pageNum"))

		// Determine whether paging is required		if pageSize == 0 {
			pageSize = -1
		}
		if pageNum == 0 {
			pageNum = -1
		}

		offsetVal := (pageNum - 1) * pageSize // Fixed writing method Just remember it		if pageNum == -1 &amp;&amp; pageSize == -1 {
			offsetVal = -1
		}

		// Return a total number		var total int64

		// Query the database		(dataList).Count(&amp;total).Limit(pageSize).Offset(offsetVal).Find(&amp;dataList)

		if len(dataList) == 0 {
			(200, {
				"msg":  "No data was found",
				"code": 400,
				"data": {},
			})
		} else {
			(200, {
				"msg":  "Query successful",
				"code": 200,
				"data": {
					"list":     dataList,
					"total":    total,
					"pageNum":  pageNum,
					"pageSize": pageSize,
				},
			})
		}

	})

	// Port number	PORT := "3001"
	(":" + PORT)
}