之前的后台都是用我写的代码生成器一键生成的（后端代码）两三天都写完了，但是最近笔记本坏了拿去修好久，这边催进度，为了应付只好赶一个出来，且我发现现在前后台交互有些问题，并且需求是上面提出的还不能改（不懂技术，纯属浪费口舌），前台后端和后台后端还是得分开，更可恶的是！我现在用的台式太垃圾IDEA跑不起来！！！用linux的时候可以，用windows就不行！就挺无语，但是咱什么都不好，会的多，打算用gin重写一遍，反正都是CRUD代码，写了两天发现，Go代码写起来还是挺有趣（隔了两三个月没写Go,期间都在写Spring,被恶心死了，无聊透顶）


![image.png](/static/img/221b3a5cafeb6a262f2edf0f6a16a5c3.image.webp)

完成后续的编码可能要几天时间，但是总体时间不会太长就是，而且Go的可执行文件确实小啊！！！今年上半年有两三个项目，后端几乎都我负责，一直在FastAPI,Spring之间横跳，FastAPI确实喜欢，恶心的就是运行环境打包出来无敌大！才二十个接口不到，把我服务器压垮了！穷啊，整了个三年的1C1G服务器，0.5带宽，一个博客将就用，自从部署一个用FastAPI写的资源服务器（个人存资源，数据，书籍等等），每一个月把我博客干崩了！

只有经历过才知道Go的好....再也不骂了


重构后台

2016.12阅读精读

每日日语小知识

```go
package main

import (
	"app/internal/config"
	"database/sql"
	"fmt"
	"log"
	"net/http"
	"path/filepath"
	"time"

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

// ReservoirBasicInfo 结构体映射数据库表
type ReservoirBasicInfo struct {
	ID                int          `json:"id"`
	Name              string       `json:"name"`
	Overview          string       `json:"overview"`
	Grade             string       `json:"grade"`
	TotalStorage      float64      `json:"total_storage"`
	UtilizableStorage float64      `json:"utilizable_storage"`
	CheckFloodLevel   float64      `json:"check_flood_level"`
	DesignFloodLevel  float64      `json:"design_flood_level"`
	FloodLimitedLevel float64      `json:"flood_limited_level"`
	ConstructionTime  time.Time    `json:"construction_time"`
	AcceptanceTime    time.Time    `json:"acceptance_time"`
	Certificate       string       `json:"certificate"`
	Image             string       `json:"image"`
	CreatedAt         time.Time    `json:"created_at"`
	UpdatedAt         time.Time    `json:"updated_at"`
	DeletedAt         sql.NullTime `json:"deleted_at"`
}

var db *sql.DB

func main() {

	// 加载配置
	cfg, err := config.LoadConfig()
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}
	fmt.Println(cfg.DatabaseURL)
	// // 初始化数据库连接
	// var err error
	// db, err = sql.Open("mysql", "root:123nit@tcp(111.229.7.180:3306)/reservoir_data?parseTime=true")
	// if err != nil {
	// 	log.Fatalf("Failed to connect to database: %v", err)
	// }
	// defer db.Close()

	// // 创建 uploads 文件夹
	// if err := os.MkdirAll("uploads", os.ModePerm); err != nil {
	// 	log.Fatalf("Failed to create uploads directory: %v", err)
	// }

	// // 创建 Gin 路由引擎
	// router := gin.Default()

	// // 配置 CORS
	// router.Use(cors.New(cors.Config{
	// 	AllowOrigins:     []string{"*"},
	// 	AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
	// 	AllowHeaders:     []string{"Origin", "Content-Type", "Accept", "Authorization"},
	// 	ExposeHeaders:    []string{"Content-Length"},
	// 	AllowCredentials: true,
	// 	MaxAge:           12 * time.Hour,
	// }))

	// // 静态文件服务
	// router.Static("/uploads", "./uploads")

	// // 定义路由
	// router.POST("/reservoir/add", createReservoir)
	// router.GET("/reservoir/get/:id", getReservoir)
	// router.PUT("/reservoir/up/:id", updateReservoir)
	// router.DELETE("/reservoir/del/:id", deleteReservoir)
	// router.POST("/reservoir/:id/certificate", uploadCertificate)
	// router.POST("/reservoir/:id/image", uploadImage)
	// router.GET("/reservoir/getAll", getAllReservoirs) // 新增获取所有水库信息的路由

	// // 启动 HTTP 服务器
	// router.Run(":8080")
}

// 创建水库信息
func createReservoir(c *gin.Context) {
	var reservoir ReservoirBasicInfo
	if err := c.ShouldBindJSON(&reservoir); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	query := `
		INSERT INTO reservoir_basic_info (name, overview, grade, total_storage, utilizable_storage, check_flood_level, design_flood_level, flood_limited_level, construction_time, acceptance_time, created_at, updated_at)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), NOW())
	`
	result, err := db.Exec(query, reservoir.Name, reservoir.Overview, reservoir.Grade, reservoir.TotalStorage, reservoir.UtilizableStorage, reservoir.CheckFloodLevel, reservoir.DesignFloodLevel, reservoir.FloodLimitedLevel, reservoir.ConstructionTime, reservoir.AcceptanceTime)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	id, _ := result.LastInsertId()
	reservoir.ID = int(id)
	c.JSON(http.StatusCreated, reservoir)
}

// 获取水库信息
func getReservoir(c *gin.Context) {
	id := c.Param("id")
	var reservoir ReservoirBasicInfo

	query := `
		SELECT id, name, overview, grade, total_storage, utilizable_storage, check_flood_level, design_flood_level, flood_limited_level, construction_time, acceptance_time, certificate, image, created_at, updated_at, deleted_at
		FROM reservoir_basic_info
		WHERE id = ?
	`
	err := db.QueryRow(query, id).Scan(&reservoir.ID, &reservoir.Name, &reservoir.Overview, &reservoir.Grade, &reservoir.TotalStorage, &reservoir.UtilizableStorage, &reservoir.CheckFloodLevel, &reservoir.DesignFloodLevel, &reservoir.FloodLimitedLevel, &reservoir.ConstructionTime, &reservoir.AcceptanceTime, &reservoir.Certificate, &reservoir.Image, &reservoir.CreatedAt, &reservoir.UpdatedAt, &reservoir.DeletedAt)
	if err != nil {
		if err == sql.ErrNoRows {
			c.JSON(http.StatusNotFound, gin.H{"error": "Reservoir not found"})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		}
		return
	}

	c.JSON(http.StatusOK, reservoir)
}

// 更新水库信息
func updateReservoir(c *gin.Context) {
	id := c.Param("id")
	var reservoir ReservoirBasicInfo
	if err := c.ShouldBindJSON(&reservoir); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	query := `
		UPDATE reservoir_basic_info
		SET name = ?, overview = ?, grade = ?, total_storage = ?, utilizable_storage = ?, check_flood_level = ?, design_flood_level = ?, flood_limited_level = ?, construction_time = ?, acceptance_time = ?, updated_at = NOW()
		WHERE id = ?
	`
	_, err := db.Exec(query, reservoir.Name, reservoir.Overview, reservoir.Grade, reservoir.TotalStorage, reservoir.UtilizableStorage, reservoir.CheckFloodLevel, reservoir.DesignFloodLevel, reservoir.FloodLimitedLevel, reservoir.ConstructionTime, reservoir.AcceptanceTime, id)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Reservoir updated successfully"})
}

// 删除水库信息
func deleteReservoir(c *gin.Context) {
	id := c.Param("id")

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

	c.JSON(http.StatusOK, gin.H{"message": "Reservoir deleted successfully"})
}

// 上传证书
func uploadCertificate(c *gin.Context) {
	id := c.Param("id")
	file, err := c.FormFile("file")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	filename := fmt.Sprintf("certificate_%s_%s", id, filepath.Base(file.Filename))
	filepath := filepath.Join("uploads", filename)

	if err := c.SaveUploadedFile(file, filepath); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	query := `
		UPDATE reservoir_basic_info
		SET certificate = ?
		WHERE id = ?
	`
	_, err = db.Exec(query, filename, id)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Certificate uploaded successfully", "filename": filename})
}

// 上传图片
func uploadImage(c *gin.Context) {
	id := c.Param("id")
	file, err := c.FormFile("file")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	filename := fmt.Sprintf("image_%s_%s", id, filepath.Base(file.Filename))
	filepath := filepath.Join("uploads", filename)

	if err := c.SaveUploadedFile(file, filepath); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	query := `
		UPDATE reservoir_basic_info
		SET image = ?
		WHERE id = ?
	`
	_, err = db.Exec(query, filename, id)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Image uploaded successfully", "filename": filename})
}

// 获取所有水库信息
func getAllReservoirs(c *gin.Context) {
	var reservoirs []ReservoirBasicInfo

	query := `
		SELECT id, name, overview, grade, total_storage, utilizable_storage, check_flood_level, design_flood_level, flood_limited_level, construction_time, acceptance_time, certificate, image, created_at, updated_at, deleted_at
		FROM reservoir_basic_info
	`
	rows, err := db.Query(query)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	defer rows.Close()

	for rows.Next() {
		var reservoir ReservoirBasicInfo
		err := rows.Scan(&reservoir.ID, &reservoir.Name, &reservoir.Overview, &reservoir.Grade, &reservoir.TotalStorage, &reservoir.UtilizableStorage, &reservoir.CheckFloodLevel, &reservoir.DesignFloodLevel, &reservoir.FloodLimitedLevel, &reservoir.ConstructionTime, &reservoir.AcceptanceTime, &reservoir.Certificate, &reservoir.Image, &reservoir.CreatedAt, &reservoir.UpdatedAt, &reservoir.DeletedAt)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
			return
		}
		reservoirs = append(reservoirs, reservoir)
	}

	c.JSON(http.StatusOK, reservoirs)
}


````

记录

最近在vscode写代码老是抽搐排查了好久觉得是插件的问题，但是写的太杂了装的插件很多，于是只能用本方法，把所有插件停掉最后开启需要的


![image.png](/static/img/62f1df3ee7f78399915c76898eb266c0.image.webp)


然后成功解决

短篇1

かといえば