golang快速构建应用程序基础框架插件库gobase的使用

GoBase - Golang快速构建应用程序基础框架插件库

概述

GoBase是一个简单的Golang应用程序骨架框架,灵感来源于开发经验,并参考了golang-standards/project-layout项目布局标准。

如何使用?

  1. 克隆仓库(使用git客户端 git clone github.com/wajox/gobase [project_name] 或直接在GitHub上使用它作为模板创建新项目)
  2. 将所有文件中的 github.com/wajox/gobase 替换为 [your_pkg_name]

项目结构

  • /api - OpenAPI规范,由swag生成的文档
  • /cmd - 应用程序入口
  • /db - 数据库迁移和种子数据
  • /docs - 文档
  • /internal - 内部使用的应用程序源代码
  • /pkg - 外部使用的应用程序源代码(SDK和库)
  • /test - 测试相关的内容

常用命令

# 安装开发工具(wire, golangci-lint, swag, ginkgo)
make install-tools

# 从docker-compose-test.yml启动测试环境
make start-docker-compose-test

# 停止docker-compose-test.yml中的测试环境
make stop-docker-compose-test

# 构建应用程序
make build

# 运行所有测试
make test-all

# 运行go generate
make gen

# 使用swag生成OpenAPI文档
make swagger

# 从.proto文件生成源代码
make proto

# 使用wire生成依赖项
make deps

创建新项目示例

# 安装clonegopkg
go install github.com/wajox/clonegopkg@latest

# 创建你的项目
clonegopkg clone git@github.com:wajox/gobase.git github.com/wajox/newproject

# 推送到你的git仓库
cd ~/go/src/github.com/wajox/newproject
git add .
git commit -m "init project from gobase template"
git remote add origin git@github.com:wajox/newproject.git
git push origin master

主要工具和包

  • gin-gonic
  • ginkgo with gomega
  • spf13/viper
  • spf13/cobra
  • envy
  • zerolog
  • golangci-lint
  • wire
  • swag
  • migrate
  • protoc
  • jsonapi
  • docker with docker-compose

基础示例代码

以下是一个使用GoBase框架的简单HTTP服务示例:

package main

import (
	"github.com/gin-gonic/gin"
	"github.com/wajox/gobase/internal/app/build"
	"github.com/wajox/gobase/internal/app/initializers"
	"github.com/wajox/gobase/internal/lib/logger"
)

func main() {
	// 初始化配置
	cfg := initializers.InitConfig()
	
	// 初始化日志
	log := logger.NewLogger(cfg.LogLevel, cfg.LogFormat)
	
	// 构建应用
	application, err := build.BuildApplication(cfg, log)
	if err != nil {
		log.Fatal().Err(err).Msg("failed to build application")
	}
	
	// 设置路由
	r := gin.Default()
	r.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Welcome to GoBase application",
		})
	})
	
	// 启动服务
	if err := r.Run(":8080"); err != nil {
		log.Fatal().Err(err).Msg("failed to start server")
	}
}

依赖注入示例

GoBase使用wire进行依赖注入,以下是一个简单的wire配置示例:

// internal/app/build/wire.go
package build

import (
	"github.com/google/wire"
	"github.com/wajox/gobase/internal/app/config"
	"github.com/wajox/gobase/internal/lib/logger"
)

var ApplicationSet = wire.NewSet(
	config.NewConfig,
	logger.NewLogger,
	wire.Struct(new(Application), "*",
)

// Application 包含所有应用依赖
type Application struct {
	Config *config.Config
	Logger *logger.Logger
}

配置管理示例

使用viper进行配置管理的示例:

package config

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

type Config struct {
	AppName  string
	LogLevel string
	LogFormat string
}

func NewConfig() (*Config, error) {
	v := viper.New()
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath(".")
	
	if err := v.ReadInConfig(); err != nil {
		return nil, err
	}
	
	var cfg Config
	if err := v.Unmarshal(&cfg); err != nil {
		return nil, err
	}
	
	return &cfg, nil
}

这个框架提供了快速启动Golang项目所需的基础设施,包括配置管理、日志记录、依赖注入等常用功能。


更多关于golang快速构建应用程序基础框架插件库gobase的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang快速构建应用程序基础框架插件库gobase的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


gobase - Golang快速构建应用程序基础框架插件库

gobase 是一个用于快速构建 Golang 应用程序的基础框架插件库,它提供了一系列常用功能和组件,帮助开发者快速搭建项目基础架构。

主要特性

  1. 配置管理
  2. 日志系统
  3. 数据库集成
  4. HTTP服务
  5. 中间件支持
  6. 工具函数集合

安装

go get github.com/yourusername/gobase

基本使用示例

1. 初始化应用

package main

import (
	"github.com/yourusername/gobase"
	"github.com/yourusername/gobase/config"
	"github.com/yourusername/gobase/logger"
)

func main() {
	// 初始化配置
	cfg, err := config.Load("./config.yaml")
	if err != nil {
		panic(err)
	}

	// 初始化日志
	logger.Init(cfg.Log)

	// 创建应用
	app := gobase.NewApplication(cfg)

	// 运行应用
	if err := app.Run(); err != nil {
		logger.Fatal("application run failed", "error", err)
	}
}

2. 配置管理

// config.yaml 示例
app:
  name: "myapp"
  env: "dev"
  port: 8080

log:
  level: "info"
  path: "./logs"

database:
  driver: "mysql"
  dsn: "user:password@tcp(localhost:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"

3. HTTP服务

package main

import (
	"github.com/yourusername/gobase"
	"github.com/yourusername/gobase/server"
	"net/http"
)

func main() {
	app := gobase.NewDefaultApplication()
	
	// 创建HTTP服务器
	srv := server.NewHTTPServer(app.Config.Server)
	
	// 注册路由
	srv.Router().GET("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello, gobase!"))
	})
	
	// 添加服务器到应用
	app.AddServer("http", srv)
	
	// 运行应用
	app.Run()
}

4. 数据库集成

package main

import (
	"github.com/yourusername/gobase"
	"github.com/yourusername/gobase/database"
)

type User struct {
	ID   uint   `gorm:"primaryKey"`
	Name string `gorm:"size:255"`
	Age  int
}

func main() {
	app := gobase.NewDefaultApplication()
	
	// 初始化数据库
	db, err := database.New(app.Config.Database)
	if err != nil {
		panic(err)
	}
	
	// 自动迁移
	db.AutoMigrate(&User{})
	
	// 使用示例
	user := User{Name: "John", Age: 30}
	db.Create(&user)
	
	app.Run()
}

5. 中间件支持

package main

import (
	"github.com/yourusername/gobase"
	"github.com/yourusername/gobase/server"
	"github.com/yourusername/gobase/server/middleware"
	"net/http"
)

func main() {
	app := gobase.NewDefaultApplication()
	srv := server.NewHTTPServer(app.Config.Server)
	
	// 使用日志中间件
	srv.Use(middleware.Logger())
	
	// 使用恢复中间件
	srv.Use(middleware.Recovery())
	
	srv.Router().GET("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello with middleware!"))
	})
	
	app.AddServer("http", srv)
	app.Run()
}

高级功能

自定义插件

package myplugin

import (
	"github.com/yourusername/gobase"
	"github.com/yourusername/gobase/plugin"
)

type MyPlugin struct {
	plugin.BasePlugin
}

func (p *MyPlugin) Init() error {
	// 初始化逻辑
	return nil
}

func (p *MyPlugin) Start() error {
	// 启动逻辑
	return nil
}

func (p *MyPlugin) Stop() error {
	// 停止逻辑
	return nil
}

// 注册插件
func init() {
	gobase.RegisterPlugin("myplugin", func() gobase.Plugin {
		return &MyPlugin{}
	})
}

使用自定义插件

package main

import (
	_ "path/to/myplugin" // 导入插件包以注册插件
	"github.com/yourusername/gobase"
)

func main() {
	app := gobase.NewDefaultApplication()
	
	// 加载插件
	app.LoadPlugin("myplugin")
	
	app.Run()
}

最佳实践

  1. 将业务逻辑与基础设施分离
  2. 使用依赖注入管理组件
  3. 合理使用中间件处理横切关注点
  4. 通过插件机制扩展功能

gobase 提供了构建 Golang 应用程序所需的基础设施,开发者可以专注于业务逻辑的实现,快速构建高质量的应用程序。

回到顶部