gone

README

gone

0. 框架定位

做一个对Spring程序员最友好的Golang框架

广告：长期寻觅一起完善和维护的框架的朋友："看你骨骼惊奇，就是你了🫵"

有意者请加微信👇，邀请你入群：

1. 这是什么？

• 一个类似 Java Spring 的 Golang 依赖注入 框架
• 一个不断完善的 微服务解决方案
• 更多信息，参考 Gone Story

2. 怎么使用？

所有的代码都应该封装到一个个叫 Goner 容器中，Goner 的概念可以类比 Spring 中的 Spring Bean

• Goner 是依赖注入的最小单位
• Goner 可以封装框架组件
• Goner 也可以是业务组件，比如一个 Service、一个 Controller、一个 Client、一个 Dao 等

下面是一个简单的例子，完整代码在这里

2.1. 编写一个 Goner

• 定一个 struct

• 组合 gone.Flag，将其标记为一个 Goner

• 定一个"构造函数"

• 如下：

  package user
  
  import "github.com/gone-io/gone"
  
  // 1. 定义 Goner：userService
  type userService struct {
      gone.Flag //2. 聚合 gone.Flag，使其实现gone.Goner接口成为一个Goner
  }
  
  //NewUserService 3. 定义构造函数
  func NewUserService() gone.Goner {
      return &userService{}
  }
  

2.2. 给 Goner 依赖的属性注入值

• 假设 user.userService 的一个方法依赖redis.Cache

  package user
  
  import (
      "fmt"
      "github.com/gone-io/examples/simple/interface/service"
      "github.com/gone-io/gone"
      "github.com/gone-io/gone/goner/redis"
  )
  
  // 1. 定义 Goner：userService
  type userService struct {
      gone.Flag             //2. 聚合 gone.Flag，使其实现gone.Goner接口成为一个Goner
      cache     redis.Cache `gone:"gone-redis-cache"` //4. 标记需要注入的依赖，这里表示在`cache`属性上注入一个ID=`gone-redis-cache`的 Goner 组件
  }
  
  func (s *userService) GetUserInfo(id int64) (*service.UserInfo, error) {
      info := new(service.UserInfo)
      key := fmt.Sprintf("user-%d", id)
      return info, s.cache.Get(key, info) //5.使用注入的依赖完成业务
  }
  
  // NewUserService 3. 定义 `userService` 构造函数
  func NewUserService() gone.Goner {
      return &userService{}
  }
  

• 假设 student.studentService 依赖 redis.userService

• 给 student.studentService 增加一个 AfterRevive() gone.AfterReviveError（Goner 上的AfterRevive在属性注入完后自动运行）

  package student
  
  import (
      "github.com/gone-io/examples/simple/interface/service"
      "github.com/gone-io/gone"
      "github.com/gone-io/gone/goner/logrus"
  )
  
  // 1. 定义 Goner：studentService
  type studentService struct {
      gone.Flag                  // 2.  聚合 gone.Flag，使其实现gone.Goner接口成为一个Goner
      service.User `gone:"*"`    //4. 聚合 service.User，这里的 `gone:"*"` 表示 `按类型注入` 一个Goner
      log          logrus.Logger `gone:"gone-logger"` //6. 注入一个用于日志打印的Goner
  }
  
  func (s *studentService) GetStudentInfo(id int64) (*service.UserInfo, error) {
      return s.GetUserInfo(id) //5. 调用 User 的 `GetUserInfo` 来实现 `GetStudentInfo`方法
  }
  
  // AfterRevive 6.该方法会在 studentService 属性被注入完成后自动运行
  func (s *studentService) AfterRevive() gone.AfterReviveError {
      info, err := s.GetUserInfo(100)
      if err != nil {
          s.log.Errorf("get info err:%v", err) //调用日志Goner，打印错误日志
      } else {
          s.log.Infof("student info:%v", info) //调用日志Goner，打印student info
      }
      return nil
  }
  
  // NewStudentService 3. 定义 `studentService` 构造函数
  func NewStudentService() gone.Goner {
      return &studentService{}
  }
  
  

2.3. 启动程序

• 增加 main 函数，调用 gone.Run

• 给 gone.Run 方法提供一个 Priest 函数（在 Gone 中，加载 Goner 的函数 叫 Priest———牧师；Goner 其实是逝者的意思）

• 在 Priest 函数 中 “安葬” Goner （Priest———牧师，对 Goner 的加载过程叫 Bury———安葬 ，更多概念）

  package main
  
  import (
      "github.com/gone-io/examples/simple/student"
      "github.com/gone-io/examples/simple/user"
      "github.com/gone-io/gone"
  )
  
  // 1. 增加 main 函数，调用 gone.Run
  func main() {
      //2. 给 gone.Run 方法提供一个 `Priest` 函数
      gone.Run(Priest)
  }
  
  func Priest(cemetery gone.Cemetery) error {
      // 3. "安葬" Goner
      cemetery.Bury(user.NewUserService()) // 3.1 在 `Priest` 函数中 "安葬" `user.NewUserService()`构造出来的 Goner
      cemetery.Bury(student.NewStudentService()) // 3.2 在 `Priest` 函数中 "安葬" `user.NewStudentService()`构造出来的 Goner
      return nil
  }
  

3. 🌰 更多例子：

在example目录可以找到详细的例子，后续会补充完成的帮忙手册。

4. 🔣 组件库（👉🏻 更多组件正在开发中...，💪🏻 ヾ(◍°∇°◍)ﾉﾞ，🖖🏻）

• goner/cumx， 对 github.com/soheilhy/cmux 的封装，用于复用同一个端口实现多种协议；
• goner/config，用于实现对 Gone-App 配置
• goner/gin，对 github.com/gin-gonic/gin封装，提供 web 服务
• goner/logrus， 对 github.com/sirupsen/logrus封装，提供日志服务
• goner/tracer， 提供日志追踪，可以给同一条请求链路提供统一的 tracerId
• goner/xorm， 封装 xorm.io/xorm，用于数据库的访问；使用时，按需引用数据库驱动；
• goner/redis， 封装 github.com/gomodule/redigo，用于操作 redis
• goner/schedule， 封装 github.com/robfig/cron/v3，用于设置定时器
• emitter，封装事件处理，可以用于 DDD 的 事件风暴

5. ⚙️ TODO LIST

• grpc，封装 github.com/grpc/grpc
• 完善文档
• 完善英文文档
• 完善测试用例

6. ⚠️ 注意

• 尽量不用使用 struct（结构体）作为 gone 标记的字段，由于 struct 在 golang 中是值拷贝，可能导致相关依赖注入失败的情况
• 下面这些 Goner 上的方法都不应该是阻塞的
  • AfterRevive(Cemetery, Tomb) ReviveAfterError
  • Start(Cemetery) error
  • Stop(Cemetery) error
  • Suck(conf string, v reflect.Value) SuckError

---

入群交流吧？添加微信👇︎，邀你入群！🤟

Documentation

Index

• Constants
• Variables
• func GetFuncName(f any) string
• func GetInterfaceType[T any](t *T) reflect.Type
• func NewSimpleLogger() (Goner, GonerId)
• func PanicTrace(kb int) []byte
• func Run(priests ...Priest)
• func Serve(priests ...Priest)
• func Test[T Goner](fn func(T), priests ...Priest)
• func TestAt[T Goner](id GonerId, fn func(T), priests ...Priest)
• type AfterReviveError
• type Angel
• type Cemetery
• type DefaultLoggerUser
• type Error
  • func CannotFoundGonerByIdError(id GonerId) Error
  • func CannotFoundGonerByTypeError(t reflect.Type) Error
  • func GonerIdIsExistedError(id GonerId) Error
  • func NewError(code int, msg string) Error
  • func NewInnerError(code int, msg string) Error
  • func NotCompatibleError(a reflect.Type, b reflect.Type) Error
  • func ReplaceBuryIdParamEmptyError() Error
• type Flag
• type Goner
• type GonerId
  • func GetGoneDefaultId(goner Goner) GonerId
• type Heaven
  • func New(priests ...Priest) Heaven
• type InnerError
• type Logger
• type Priest
• type Process
• type Prophet
• type SetLoggerError
• type SuckError
• type TestHeaven
  • func TestKit[T Goner](fn func(T)) TestHeaven[T]
• type Tomb
  • func NewTomb(goner Goner) Tomb
• type Tombs
  • func (tombs Tombs) GetTomByType(t reflect.Type) (filterTombs []Tomb)
• type Vampire

Constants

const (
	// GonerIdIsExisted GonerId 不存在
	GonerIdIsExisted = 1001 + iota

	// CannotFoundGonerById 通过GonerId查找Goner失败
	CannotFoundGonerById

	// CannotFoundGonerByType 通过类型查找Goner失败
	CannotFoundGonerByType

	//NotCompatible 类型不兼容
	NotCompatible

	//ReplaceBuryIdParamEmpty 替换性下葬，GonerId不能为空
	ReplaceBuryIdParamEmpty
)

错误代码：gone框架内部错误代码编码空间:1001~1999

const (
	// IdGoneHeaven 天堂组件的ID，代码了程序本身，Gone程序启动时默认注入
	IdGoneHeaven = "gone-heaven"

	// IdGoneCemetery 坟墓组件的ID，是完成依赖注入的关键组件，Gone程序启动时默认注入
	IdGoneCemetery = "gone-cemetery"

	//IdGoneTestKit 测试箱，调用 gone.Test 或者 gone.TestAt 时，会将测试箱注入到程序；非测试代码中不应该注入该组件
	IdGoneTestKit = "gone-test-kit"

	//IdConfig 配置 Goner 的ID，提过能配置能力
	IdConfig = "config"
	//IdGoneConfigure 配置器 Goner 的ID
	IdGoneConfigure = "gone-configure"
	// IdGoneTracer Tracer Goner 的ID，提供日志追踪能力
	IdGoneTracer = "gone-tracer"
	// IdGoneLogger 日志 Goner 的ID，用于日志打印
	IdGoneLogger = "gone-logger"

	//IdGoneCumx [cmux Goner](/goner/cmux#Server) ID
	IdGoneCumx = "gone-cumx"

	//IdGoneGin Gin相关的组件ID，可以使用 [goner.GinPriest](goner#GinPriest) 牧师函数批量安葬
	IdGoneGin          = "gone-gin"
	IdGoneGinRouter    = "gone-gin-router"
	IdGoneGinProcessor = "gone-gin-processor"
	IdGoneGinProxy     = "gone-gin-proxy"
	IdGoneGinResponser = "gone-gin-responser"

	//IdGoneXorm Xorm Goner 的ID，封装了xorm，用于操作数据库；使用 [goner.XormPriest](goner#XormPriest) 牧师函数安葬
	IdGoneXorm = "gone-xorm"

	//IdGoneRedisPool redis pool goner; redis 相关 Goner，使用 [goner.RedisPriest](goner#RedisPriest) 牧师函数安葬
	IdGoneRedisPool     = "gone-redis-pool"
	IdGoneRedisCache    = "gone-redis-cache"
	IdGoneRedisKey      = "gone-redis-key"
	IdGoneRedisLocker   = "gone-redis-locker"
	IdGoneRedisProvider = "gone-redis-provider"

	// IdGoneSchedule 定时器Goner；使用 [goner.SchedulePriest](goner#SchedulePriest) 牧师函数安葬
	IdGoneSchedule = "gone-schedule"
)

Gone框架中的内置组件ID

Variables

var AfterStopSignalWaitSecond = 10

AfterStopSignalWaitSecond 收到停机信号后，退出程序等待的时间

Functions

func GetFuncName

func GetFuncName(f any) string

GetFuncName 获取某个函数的名字

func GetInterfaceType

func GetInterfaceType[T any](t *T) reflect.Type

GetInterfaceType 获取接口的类型

func NewSimpleLogger

func NewSimpleLogger() (Goner, GonerId)

func PanicTrace

func PanicTrace(kb int) []byte

PanicTrace 用于获取调用者的堆栈信息

func Run

func Run(priests ...Priest)

Run 开始运行一个Gone程序；`gone.Run` 和 `gone.Serve` 的区别是： 1. gone.Serve启动的程序，主协程会调用 Heaven.WaitEnd 挂起等待停机信号，可以用于服务程序的开发 2. gone.Run启动的程序，主协程则不会挂起，运行完就结束，适合开发一致性运行的代码

    // 定义加载服务的Priest函数
	func LoadServer(c Cemetery) error {
		c.Bury(goneXorm.New())
		c.Bury(goneGin.New())
		return nil
	}

    // 加载组件的Priest函数
	func LoadComponent(c Cemetery) error {
		c.Bury(componentA.New())
		c.Bury(componentB.New())
	}

	gone.Run(LoadServer, LoadComponent)//开始运行

func Serve

func Serve(priests ...Priest)

Serve 开始服务，参考[Run](#Run)

func Test

func Test[T Goner](fn func(T), priests ...Priest)

Test 用于编写测试用例，参考[示例](https://github.com/gone-io/gone/blob/main/example/test/goner_test.go)

func TestAt

func TestAt[T Goner](id GonerId, fn func(T), priests ...Priest)

TestAt 用于编写测试用例，测试某个特定ID的Goner

Types

type AfterReviveError

type AfterReviveError error

type Angel

type Angel interface {
	Goner
	Start(Cemetery) error
	Stop(Cemetery) error
}

type Cemetery

type Cemetery interface {
	DefaultLoggerUser
	Goner

	Bury(Goner, ...GonerId) Cemetery  // 埋葬，将逝者埋葬到墓园
	ReplaceBury(Goner, GonerId) error // 替换性埋葬

	GetTomById(GonerId) Tomb
	GetTomByType(reflect.Type) []Tomb
	// contains filtered or unexported methods
}

Cemetery 墓园

type DefaultLoggerUser

type DefaultLoggerUser interface {
	SetLogger(logger Logger) SetLoggerError
}

type Error

type Error interface {
	error
	Msg() string
	Code() int
}

Error 普通错误

func CannotFoundGonerByIdError

func CannotFoundGonerByIdError(id GonerId) Error

func CannotFoundGonerByTypeError

func CannotFoundGonerByTypeError(t reflect.Type) Error

func GonerIdIsExistedError

func GonerIdIsExistedError(id GonerId) Error

func NewError

func NewError(code int, msg string) Error

func NewInnerError

func NewInnerError(code int, msg string) Error

func NotCompatibleError

func NotCompatibleError(a reflect.Type, b reflect.Type) Error

func ReplaceBuryIdParamEmptyError

func ReplaceBuryIdParamEmptyError() Error

type Flag

type Flag struct{}

type Goner

type Goner interface {
	// contains filtered or unexported methods
}

Goner 逝者

type GonerId

type GonerId string

GonerId 逝者ID

func GetGoneDefaultId

func GetGoneDefaultId(goner Goner) GonerId

type Heaven

type Heaven interface {
	Install() Heaven
	WaitEnd() Heaven
	End() Heaven

	Start() Heaven
	Stop() Heaven

	GetHeavenStopSignal() <-chan struct{}

	BeforeStart(Process) Heaven
	AfterStart(Process) Heaven

	BeforeStop(Process) Heaven
	AfterStop(Process) Heaven
	DefaultLoggerUser
}

func New

func New(priests ...Priest) Heaven

New 新建Heaven; Heaven 代表了一个应用程序；

type InnerError

type InnerError interface {
	Error
	Stack() []byte
}

InnerError 内部错误

type Logger

type Logger interface {
	Tracef(format string, args ...any)
	Errorf(format string, args ...any)
	Warnf(format string, args ...any)
	Infof(format string, args ...any)
}

type Priest

type Priest func(cemetery Cemetery) error

Priest 神父，负责给Goner下葬

type Process

type Process func(cemetery Cemetery) error

type Prophet

type Prophet interface {
	Goner
	//AfterRevive 在Goner复活后会被执行
	AfterRevive() AfterReviveError
}

Prophet 先知

type SetLoggerError

type SetLoggerError error

type SuckError

type SuckError error

type TestHeaven

type TestHeaven[T Goner] interface {
	Heaven
	WithId(id GonerId) TestHeaven[T]
	WithPriest(priests ...Priest) TestHeaven[T]
	Run()
}

func TestKit

func TestKit[T Goner](fn func(T)) TestHeaven[T]

type Tomb

type Tomb interface {
	SetId(GonerId) Tomb
	GetId() GonerId
	GetGoner() Goner
	GonerIsRevive(flags ...bool) bool
}

Tomb 坟墓，逝者的容器

func NewTomb

func NewTomb(goner Goner) Tomb

type Tombs

type Tombs []Tomb

func (Tombs) GetTomByType

func (tombs Tombs) GetTomByType(t reflect.Type) (filterTombs []Tomb)

type Vampire

type Vampire interface {
	Goner
	Suck(conf string, v reflect.Value) SuckError
}