# GO语言基本增删改查业务实现（对比Java）

原创已于 2025-07-14 15:32:22 修改 · 308 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #mvc #go

于 2025-07-14 15:31:41 首次发布

GO 同时被 2 个专栏收录

1 篇文章

订阅专栏

Java

1 篇文章

订阅专栏

Exchangeapp_backend/
├── cmd/
│   └── server/
│       └── main.go              # 程序入口：启动 Gin、加载配置、优雅停服
├── config/
│   └── config.go                # 配置初始化（MySQL、Redis、环境变量）
├── internal/
│   ├── router/
│   │   └── router.go           # 路由注册
│   ├── controller/
│   │   └── exchange_controller.go
│   ├── service/
│   │   └── exchange_service.go
│   ├── repository/
│   │   └── exchange_repo.go    # MySQL 操作
│   └── model/
│       └── exchange.go         # GORM 模型
└── go.mod

go.sum和go.mod

go.mod

作用：记录项目的模块名/Go版本/直接依赖的包及其版本。

类似于Java的maven的pom.xml

go.sum

作用：记录所有依赖的版本和哈希值，用于校验依赖包的完整性和安全性，防止依赖被篡改。

类似于Java的go.mod 和 go.sum 是 Go Modules 的两个核心文件，它们的作用可以类比为 Java 项目中的Maven 的 dependency:go-offline 下载的 .sha1 校验文件

数据库（MySQL，Redis）连接

1.在config里定义数据库配置。

app:
  port: 8080

database:
  dsn: "root:123456@tcp(127.0.0.1:3306)/mysql_backend?charset=utf8mb4&parseTime=True&loc=Local"
  maxIdleConns: 10
  maxOpenConns: 100

redis:
  addr: "localhost:6379"
  DB: 0
  Password: ""

2.在config.go里利用viper读取配置文件并映射到到自定义的结构config类型的AppConfig中

package config

import (
    "log"
    "github.com/spf13/viper"

)

type Config struct {
    App struct {
        Name string
        Port string
    }
    Database struct {
        Dsn          string
        MaxIdleConns int
        MaxOpenConns int
    }
    Redis struct {
        Addr     string
        DB       int
        Password string
    }
}

var AppConfig *Config


func InitConfig(){
    viper.SetConfigName("config")
    viper.SetConfigType("yml")
    viper.AddConfigPath("./config")

    //读取并解析配置文件（config.yaml），把文件内容加载到viper的内存中
    //如果读取配置文件失败，程序会终止并输出错误信息
    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("Error reading config file: %v", err)
    }
    AppConfig = &Config{}

    //将viper中的配置内容解码到AppConfig结构体中
    //如果解码失败，程序会终止并输出错误信息
    if err := viper.Unmarshal(AppConfig); err != nil {
        log.Fatalf("Unable to decode into struct: %v", err)
    }

    initDB()
    initRedis()
}

3.分别创建database.go文件和redis.go文件并实现initDB()和initRedis()方法

package config

import (
	"log"
	"time"
	"myselfbackend/global"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	
)

func initDB() {
	dsn := AppConfig.Database.Dsn
	//使用gorm.Open连接数据库
	//dsn格式为"username:password@tcp(host:port)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	//其中username为数据库用户名，password为数据库密码，host为数据库主机地址，port为数据库端口号，dbname为数据库名称
	//charset=utf8mb4表示使用utf8mb4字符集，parseTime=True表示将时间类型解析为Go的time.Time类型，loc=Local表示使用本地时区
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})

	if err != nil {
		log.Fatalf("Failed to initialize database, got error: %v", err)
	}

	sqlDB, err := db.DB()
	if err != nil {
		log.Fatalf("Failed to get database instance, got error: %v", err)
	}

	sqlDB.SetMaxIdleConns(AppConfig.Database.MaxIdleConns)
	sqlDB.SetMaxOpenConns(AppConfig.Database.MaxOpenConns)
	sqlDB.SetConnMaxLifetime(time.Hour)

	if err != nil {
		log.Fatalf("Failed to configure database, got error: %v", err)
	}
	global.Db = db
}

package config

import (
	"myselfbackend/global"
	"log"

	"github.com/go-redis/redis"

)

func initRedis() {
	addr := AppConfig.Redis.Addr
	db := AppConfig.Redis.DB
	password := AppConfig.Redis.Password

	RedisClient := redis.NewClient(&redis.Options{
		Addr:     addr,
		DB:       db,
		Password: password,
	})
	_, err := RedisClient.Ping().Result()
	if err != nil {
		log.Fatalf("Failed to connect to Redis, got error: %v", err)
	}
	global.RedisDB = RedisClient
}

4.这两个配置里都用到了global.go文件，它的作用是定义全局变量，用于在项目的各个包之间共享重要的资源对象。

这样做的好处是只需要初始化一次数据库和redis连接，后续所有需要用到它们的地方都可以直接通过global.Db和global.RedisDB访问，避免重复创建和管理连接，方便统一维护。

package global

import (
	"github.com/go-redis/redis"
	"gorm.io/gorm"
)

var(
	Db *gorm.DB
	RedisDB *redis.Client
)

CRUD的实现

先结构，后存取，再服务，后接口

model → repository → service → controller → router

1.model层

package model

import (
	"gorm.io/gorm"
)

type Article struct {
	gorm.Model
	Title   string `json:"title" binding:"required"`
	Content string `json:"content" binding:"required"`
	Preview string `json:"preview" binding:"required"`
}

gorm.model内容如下：

type Model struct {
	ID        uint `gorm:"primarykey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt DeletedAt `gorm:"index"`
}

2.repository层

package repository

import (
	"myselfbackend/global"
	"myselfbackend/internal/model"
)


//负责封装对数据库的所有直接操作，隔离上层业务逻辑
type ArticleRepository struct {}

// NewArticleRepository 创建一个新的 ArticleRepository 实例
// 该函数用于初始化 ArticleRepository 的实例，便于在其他地方使用
// 返回一个指向 ArticleRepository 的指针
// 这样可以在需要时创建新的文章仓库实例
func NewArticleRepository() *ArticleRepository {
	return &ArticleRepository{}
}
// Create 方法用于在数据库中创建一篇新的文章
// 接受一个指向 model.Article 的指针作为参数
// 如果创建成功，返回 nil；如果发生错误，返回错误信息
// 该方法将文章数据插入到数据库中
// 使用 global.Db 进行数据库操作，这个 Db 是在 global 包中定义的 gorm.DB 实例
func (repo *ArticleRepository) Create(article *model.Article) error {
	return global.Db.Create(article).Error
}

3.service层

package service

import (
	"myselfbackend/internal/model"
	"myselfbackend/internal/repository"
)

// ArticleService 负责处理文章相关的业务逻辑
type ArticleService struct {
	articleRepo *repository.ArticleRepository
}

// NewArticleService 创建一个新的 ArticleService 实例
// 该函数用于初始化 ArticleService 的实例，便于在其他地方使用
// 返回一个指向 ArticleService 的指针
// 这样可以在需要时创建新的文章服务实例
func NewArticleService(repo *repository.ArticleRepository) *ArticleService {
	return &ArticleService{
		articleRepo: repo,
	}
}

// CreateArticle 方法用于创建一篇新的文章
func (s *ArticleService) CreateArticle(article *model.Article) error {
	return s.articleRepo.Create(article)
}

4.contorller层

package service

import (
	"myselfbackend/internal/model"
	"myselfbackend/internal/repository"
)

// ArticleService 负责处理文章相关的业务逻辑
type ArticleService struct {
	articleRepo *repository.ArticleRepository
}

// NewArticleService 创建一个新的 ArticleService 实例
// 该函数用于初始化 ArticleService 的实例，便于在其他地方使用
// 返回一个指向 ArticleService 的指针
// 这样可以在需要时创建新的文章服务实例
func NewArticleService(repo *repository.ArticleRepository) *ArticleService {
	return &ArticleService{
		articleRepo: repo,
	}
}

// CreateArticle 方法用于创建一篇新的文章
func (s *ArticleService) CreateArticle(article *model.Article) error {
	return s.articleRepo.Create(article)
}

5.router层

package router

import (
	"github.com/gin-gonic/gin"
	"myselfbackend/internal/controller"
)

//初始化路由
func SetupRouter() *gin.Engine {
	r := gin.Default()
	// 设置路由组	
	article := r.Group("/article")
	{
		// 创建文章
		article.POST("/create", controller.CreateArticle)
	}

	return r
}