go項目實現(xiàn)mysql接入及web?api的操作方法

更新時間：2023年08月11日 08:43:25 作者：香吧香

這篇文章主要介紹了go項目實現(xiàn)mysql接入以及web api,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下

1.在idea中創(chuàng)建go項目
2.創(chuàng)建配置文件，并初始化數(shù)據(jù)庫
3.創(chuàng)建加載mysql，并創(chuàng)建數(shù)據(jù)庫連接的類
4.創(chuàng)建數(shù)據(jù)庫實體類 user 以及項目所需實體類ErrorResponse
5.編寫user表中數(shù)據(jù)庫交互的邏輯
6.編寫處理業(yè)務(wù)層的service
7.編寫兩個項目常用的util
8.編寫核心類：main.go
9.在服務(wù)器上部署和驗證

創(chuàng)建go項目，并在go項目中接入mysql，將mysql的配置項單獨整理放到一個胚子和文件中，支持項目啟動時，通過加載配置文件中的值，然后創(chuàng)建數(shù)據(jù)庫連接。

之后使用net/http相關(guān)的庫，創(chuàng)建路由，并在路由中通過不同的http方法，實現(xiàn)mysql連接的test數(shù)據(jù)庫中users表的增刪改查的 web api

1.在idea中創(chuàng)建go項目

　　其目錄文件結(jié)構(gòu)如下　　　　

2.創(chuàng)建配置文件，并初始化數(shù)據(jù)庫

　　在項目的根目錄下創(chuàng)建數(shù)據(jù)庫的配置文件：config.json

{
    "host": "192.168.118.46",
    "port": 3306,
    "user": "root",
    "password": "root",
    "dbname": "terra_no"
}

　　創(chuàng)建數(shù)據(jù)庫以及表，并插入數(shù)據(jù)

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(12) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `age` int(12) DEFAULT '18',
  PRIMARY KEY (`id`)
); 
insert into users value (1,"aa",12);
insert into users value (2,"bb",22);

3.創(chuàng)建加載mysql，并創(chuàng)建數(shù)據(jù)庫連接的類

　　在項目的根目錄下創(chuàng)建database目錄，之后創(chuàng)建 mysql.go 文件

package database
import (
    "database/sql"
    "encoding/json"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "io/ioutil"
    "log"
)
type MySQLConfig struct {
    Host     string `json:"host"`
    Port     int    `json:"port"`
    User     string `json:"user"`
    Password string `json:"password"`
    DBName   string `json:"dbname"`
}
func NewMySQLDB() (*sql.DB, error) {
    log.Println("coming NewMySQLDB ...")
    config, err := loadMySQLConfig()
    log.Println("coming NewMySQLDB config...", config.User, config.Password)
    if err != nil {
        log.Fatal(err)
        return nil, err
    }
    log.Println("coming NewMySQLDB config...", config)
    dbSource := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8", config.User, config.Password, config.Host, config.Port, config.DBName)
    log.Println("coming NewMySQLDB config dbSource is ...", dbSource)
    db, err := sql.Open("mysql", dbSource)
    if err != nil {
        log.Fatal(err)
        return nil, err
    }
    if err := db.Ping(); err != nil {
        log.Fatal(err)
        return nil, err
    }
    return db, nil
}
func loadMySQLConfig() (*MySQLConfig, error) {
    configFile, err := ioutil.ReadFile("config.json")
    if err != nil {
        log.Fatal("----------error-----------loadMySQLConfig err...", err)
        return nil, err
    }
    var config MySQLConfig
    err = json.Unmarshal(configFile, &config)
    log.Println("loadMySQLConfig Unmarshal err...", err)
    if err != nil {
        log.Fatal("---------error----------------loadMySQLConfig Unmarshal err...", config)
        return nil, err
    }
    return &config, nil
}

4.創(chuàng)建數(shù)據(jù)庫實體類 user 以及項目所需實體類ErrorResponse

　　user.go 的文件內(nèi)容如下：

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

ErrorResponse.go 中的文件內(nèi)容如下:

package models
type ErrorResponse struct {
    Message string `json:"message"`
}

5.編寫user表中數(shù)據(jù)庫交互的邏輯

package repositories
import (
    "database/sql"
    "go_test/models"
)
type UserRepository struct {
    DB *sql.DB
}
func (ur *UserRepository) CreateUser(user *models.User) error {
    query := "INSERT INTO users (name, age) VALUES (?, ?)"
    _, err := ur.DB.Exec(query, user.Name, user.Age)
    if err != nil {
        return err
    }
    return nil
}
func (ur *UserRepository) GetUserByID(id uint) (*models.User, error) {
    query := "SELECT id, name, age FROM users WHERE id = ?"
    row := ur.DB.QueryRow(query, id)
    user := new(models.User)
    err := row.Scan(&user.ID, &user.Name, &user.Age)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, nil // 用戶不存在
        }
        return nil, err
    }
    return user, nil
}
func (ur *UserRepository) GetUsers() ([]*models.User, error) {
    query := "SELECT id, name, age FROM "
    rows, err := ur.DB.Query(query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    users := []*models.User{}
    for rows.Next() {
        user := new(models.User)
        err := rows.Scan(&user.ID, &user.Name, &user.Age)
        if err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    return users, nil
}
func (ur *UserRepository) UpdateUser(user *models.User) error {
    query := "UPDATE users SET name = ?, age = ? WHERE id = ?"
    _, err := ur.DB.Exec(query, user.Name, user.Age, user.ID)
    if err != nil {
        return err
    }
    return nil
}
func (ur *UserRepository) DeleteUser(id uint) error {
    query := "DELETE FROM users WHERE id = ?"
    _, err := ur.DB.Exec(query, id)
    if err != nil {
        return err
    }
    return nil
}

6.編寫處理業(yè)務(wù)層的service

package services
import (
    "errors"
    "go_test/models"
    "go_test/repositories"
)
type UserService struct {
    UserRepository *repositories.UserRepository
}
func (us *UserService) CreateUser(user *models.User) error {
    if user.Name == "" {
        return errors.New("Name is required")
    }
    if user.Age <= 0 {
        return errors.New("Age should be greater than 0")
    }
    // ... 其他基礎(chǔ)業(yè)務(wù)校驗
    return us.UserRepository.CreateUser(user)
}
func (us *UserService) GetUserByID(id uint) (*models.User, error) {
    return us.UserRepository.GetUserByID(id)
}
func (us *UserService) GetUsers() ([]*models.User, error) {
    return us.UserRepository.GetUsers()
}
func (us *UserService) UpdateUser(user *models.User) error {
    if user.Name == "" {
        return errors.New("Name is required")
    }
    if user.Age <= 0 {
        return errors.New("Age should be greater than 0")
    }
    // ... 其他基礎(chǔ)業(yè)務(wù)校驗
    return us.UserRepository.UpdateUser(user)
}
func (us *UserService) DeleteUser(id uint) error {
    return us.UserRepository.DeleteUser(id)
}

7.編寫兩個項目常用的util

　　error_handler.go

package utils
import (
    "encoding/json"
    "go_test/models"
    _ "log"
    "net/http"
)
//
//type ErrorResponse struct {
//    Message string `json:"message"`
//}
func HandleError(w http.ResponseWriter, statusCode int, message string) {
    errResponse := models.ErrorResponse{Message: message}
    response, _ := json.Marshal(errResponse)
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    w.Write(response)
}
func ErrorHandlerString(w http.ResponseWriter, message string) {
    errResponse := models.ErrorResponse{Message: message}
    response, _ := json.Marshal(errResponse)
    w.Header().Set("Content-Type", "application/json")
    //w.WriteHeader(statusCode)
    w.Write(response)
}
func ErrorHandler(w http.ResponseWriter, err error) {
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        response := models.ErrorResponse{
            Message: err.Error(),
        }
        json.NewEncoder(w).Encode(response)
        return
    }
}

　　json_utils.go

package utils
import (
    "encoding/json"
    "net/http"
)
func RespondJSON(w http.ResponseWriter, data interface{}, statusCode int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    json.NewEncoder(w).Encode(data)
}

8.編寫核心類：main.go

package main
import (
    _ "database/sql"
    "encoding/json"
    "go_test/models"
    "go_test/utils"
    "log"
    "net/http"
    "go_test/database"
    "go_test/repositories"
    "go_test/services"
)
func main() {
    log.Println("coming main method ...")
    db, err := database.NewMySQLDB()
    if err != nil {
        log.Fatal(err)
    }
    userRepository := &repositories.UserRepository{
        DB: db,
    }
    userService := &services.UserService{
        UserRepository: userRepository,
    }
    http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            users, err := userService.GetUsers()
            if err != nil {
                utils.ErrorHandler(w, err)
                return
            }
            utils.RespondJSON(w, users, http.StatusOK)
        case http.MethodPost:
            var user models.User
            err := json.NewDecoder(r.Body).Decode(&user)
            if err != nil {
                utils.ErrorHandler(w, err)
                return
            }
            err = userService.CreateUser(&user)
            if err != nil {
                utils.ErrorHandler(w, err)
                return
            }
            utils.RespondJSON(w, user, http.StatusCreated)
        default:
            w.WriteHeader(http.StatusMethodNotAllowed)
            response := models.ErrorResponse{
                Message: "Method not allowed",
            }
            json.NewEncoder(w).Encode(response)
        }
    })
    log.Println("Server is running on port 8000")
    log.Fatal(http.ListenAndServe(":8000", nil))
}