1. Basic knowledge of form processing
Form processing includes obtaining user-submitted data from the client, binding the data to the structure, verifying its validity, and performing related operations based on the results. The main process is as follows:
-
User Submit Form: Through HTTP methods (usually
POST）。 - Analyze data: The server extracts data from the request.
- Data binding: Map the data into a predefined structure.
- Data Verification: Ensure that the submitted data meets business logic requirements.
2. Basic form processing example
2.1 Configuring routing and form pages
Form page (HTML file)
existtemplates/Create a simple form in:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>User registration</title>
</head>
<body>
<h1>User registration</h1>
<form action="/register" method="POST">
<label for="username">username：</label>
<input type="text" name="username"><br>
<label for="email">Mail：</label>
<input type="email" name="email"><br>
<label for="password">password：</label>
<input type="password" name="password"><br>
<button type="submit">register</button>
</form>
</body>
</html>
Server-side code
Load the form page through Gin route and set up the data receiving route:
package main
import (
"/gin-gonic/gin"
)
func main() {
r := ()
// Loading template ("templates/*")
// Form page ("/form", func(c *) {
(200, "", nil)
})
// Process form submission ("/register", func(c *) {
username := ("username")
email := ("email")
password := ("password")
(200, {
"username": username,
"email": email,
"password": password,
})
})
(":8080")
}
2.2 Test form function
Access after running the programhttp://localhost:8080/form, fill in the form and submit. The server will return data in JSON format:
{
"username": "Zhang San",
"email": "zhangsan@",
"password": "123456"
}
3. Data binding
Data binding is to map the form data in the request into the structure of Go, simplifying the process of field extraction and verification.
3.1 Basic data binding
Define structure
Define a structure for receiving form data:
type RegistrationForm struct {
Username string `form:"username"`
Email string `form:"email"`
Password string `form:"password"`
}
Modify form processing logic
useMethod to bind form data to structure:
("/register", func(c *) {
var form RegistrationForm
if err := (&form); err != nil {
(400, {"error": ()})
return
}
(200, {
"username": ,
"email": ,
"password": ,
})
})
3.2 Data Verification
Add on the structure fieldbindingTags for verification. Gin uses the go-playground/validator library to provide powerful verification functions.
Sample code
type RegistrationForm struct {
Username string `form:"username" binding:"required,min=3,max=20"`
Email string `form:"email" binding:"required,email"`
Password string `form:"password" binding:"required,min=6"`
}
Verification logic
When the submitted data does not meet the requirements,An error message will be returned:
if err := (&form); err != nil {
(400, {"error": ()})
return
}
3.3 Custom verification rules
Gin allows registration of custom validators. For example, verify that the username contains only letters:
package main
import (
"/gin-gonic/gin"
"/go-playground/validator/v10"
"regexp"
)
var validate *
func usernameValidator(fl ) bool {
return (`^[a-zA-Z]+$`).MatchString(().String())
}
func main() {
r := ()
// Register a custom validator validate = ()
("isalpha", usernameValidator)
//Route ("/register", func(c *) {
var form struct {
Username string `form:"username" binding:"required,isalpha"`
}
if err := (&form); err != nil {
(400, {"error": ()})
return
}
(200, {"username": })
})
(":8080")
}
4. File upload
Gin provides native support for file uploads, and can handle single and multi-file uploads.
4.1 Single file upload
Form page
<form action="/upload" method="POST" enctype="multipart/form-data">
<label for="file">Select a file：</label>
<input type="file" name="file">
<button type="submit">Upload</button>
</form>
Server-side code
("/upload", func(c *) {
file, _ := ("file")
(file, "./uploads/"+)
(200, {"message": "File upload successfully", "filename": })
})
4.2 Multi-file upload
Modify form page and routing logic:
Form page
<form action="/upload-multiple" method="POST" enctype="multipart/form-data">
<label for="files">Select a file：</label>
<input type="file" name="files" multiple>
<button type="submit">Upload</button>
</form>
Routing logic
("/upload-multiple", func(c *) {
form, _ := ()
files := ["files"]
for _, file := range files {
(file, "./uploads/"+)
}
(200, {"message": "All files uploaded successfully"})
})
5. Complete project examples for form processing
Combining form verification, file upload and data binding, a complete user registration project is built.
Project structure
├── ├── templates │ ├── │ └── ├── uploads
Complete code
package main
import (
"/gin-gonic/gin"
)
type User struct {
Username string `form:"username" binding:"required,min=3,max=20"`
Email string `form:"email" binding:"required,email"`
Password string `form:"password" binding:"required,min=6"`
}
func main() {
r := ()
("templates/*")
("/uploads", "./uploads")
("/form", func(c *) {
(200, "", nil)
})
("/register", func(c *) {
var user User
if err := (&user); err != nil {
(400, {"error": ()})
return
}
(200, "", {"user": user})
})
(":8080")
}
6. Summary
This blog introduces the functions of form processing and data binding in the Gin framework in detail, from basic form submission to complex data verification and file uploads, to complete project examples, covering common scenarios in actual development. In the next blog, we will learn how to handle API requests and JSON data binding to further expand your web development capabilities.
The above is the detailed operation steps for using the Gin framework to process form data. For more information about the Gin framework to process form data, please pay attention to my other related articles!