1、初始化项目

This commit is contained in:
2025-05-12 14:49:01 +08:00
commit 20a741ae11
242 changed files with 29323 additions and 0 deletions

69
app/jobs/apis/sys_job.go Normal file
View File

@ -0,0 +1,69 @@
package apis
import (
"net/http"
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/sdk"
"github.com/go-admin-team/go-admin-core/sdk/api"
"go-admin/app/jobs/service"
"go-admin/common/dto"
)
type SysJob struct {
api.Api
}
// RemoveJobForService 调用service实现
func (e SysJob) RemoveJobForService(c *gin.Context) {
v := dto.GeneralDelDto{}
s := service.SysJob{}
err := e.MakeContext(c).
MakeOrm().
Bind(&v).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
return
}
s.Cron = sdk.Runtime.GetCrontabKey(c.Request.Host)
err = s.RemoveJob(&v)
if err != nil {
e.Logger.Errorf("RemoveJob error, %s", err.Error())
e.Error(500, err, "")
return
}
e.OK(nil, s.Msg)
}
// StartJobForService 启动job service实现
func (e SysJob) StartJobForService(c *gin.Context) {
e.MakeContext(c)
log := e.GetLogger()
db, err := e.GetOrm()
if err != nil {
log.Error(err)
return
}
var v dto.GeneralGetDto
err = c.BindUri(&v)
if err != nil {
log.Warnf("参数验证错误, error: %s", err)
e.Error(http.StatusUnprocessableEntity, err, "参数验证失败")
return
}
s := service.SysJob{}
s.Orm = db
s.Log = log
s.Cron = sdk.Runtime.GetCrontabKey(c.Request.Host)
err = s.StartJob(&v)
if err != nil {
log.Errorf("GetCrontabKey error, %s", err.Error())
e.Error(500, err, err.Error())
return
}
e.OK(nil, s.Msg)
}

40
app/jobs/examples.go Normal file
View File

@ -0,0 +1,40 @@
package jobs
import (
"fmt"
"time"
)
// InitJob
// 需要将定义的struct 添加到字典中;
// 字典 key 可以配置到 自动任务 调用目标 中;
func InitJob() {
jobList = map[string]JobExec{
"ExamplesOne": ExamplesOne{},
// ...
}
}
// ExamplesOne
// 新添加的job 必须按照以下格式定义并实现Exec函数
type ExamplesOne struct {
}
func (t ExamplesOne) Exec(arg interface{}) error {
str := time.Now().Format(timeFormat) + " [INFO] JobCore ExamplesOne exec success"
// TODO: 这里需要注意 Examples 传入参数是 string 所以 arg.(string);请根据对应的类型进行转化;
switch arg.(type) {
case string:
if arg.(string) != "" {
fmt.Println("string", arg.(string))
fmt.Println(str, arg.(string))
} else {
fmt.Println("arg is nil")
fmt.Println(str, "arg is nil")
}
break
}
return nil
}

203
app/jobs/jobbase.go Normal file
View File

@ -0,0 +1,203 @@
package jobs
import (
"fmt"
log "github.com/go-admin-team/go-admin-core/logger"
"github.com/go-admin-team/go-admin-core/sdk"
models2 "go-admin/app/jobs/models"
"gorm.io/gorm"
"time"
"github.com/robfig/cron/v3"
"github.com/go-admin-team/go-admin-core/sdk/pkg"
"github.com/go-admin-team/go-admin-core/sdk/pkg/cronjob"
)
var timeFormat = "2006-01-02 15:04:05"
var retryCount = 3
var jobList map[string]JobExec
//var lock sync.Mutex
type JobCore struct {
InvokeTarget string
Name string
JobId int
EntryId int
CronExpression string
Args string
}
// HttpJob 任务类型 http
type HttpJob struct {
JobCore
}
type ExecJob struct {
JobCore
}
func (e *ExecJob) Run() {
startTime := time.Now()
var obj = jobList[e.InvokeTarget]
if obj == nil {
log.Warn("[Job] ExecJob Run job nil")
return
}
err := CallExec(obj.(JobExec), e.Args)
if err != nil {
// 如果失败暂停一段时间重试
fmt.Println(time.Now().Format(timeFormat), " [ERROR] mission failed! ", err)
}
// 结束时间
endTime := time.Now()
// 执行时间
latencyTime := endTime.Sub(startTime)
//TODO: 待完善部分
//str := time.Now().Format(timeFormat) + " [INFO] JobCore " + string(e.EntryId) + "exec success , spend :" + latencyTime.String()
//ws.SendAll(str)
log.Info("[Job] JobCore %s exec success , spend :%v", e.Name, latencyTime)
return
}
// Run http 任务接口
func (h *HttpJob) Run() {
startTime := time.Now()
var count = 0
var err error
var str string
/* 循环 */
LOOP:
if count < retryCount {
/* 跳过迭代 */
str, err = pkg.Get(h.InvokeTarget)
if err != nil {
// 如果失败暂停一段时间重试
fmt.Println(time.Now().Format(timeFormat), " [ERROR] mission failed! ", err)
fmt.Printf(time.Now().Format(timeFormat)+" [INFO] Retry after the task fails %d seconds! %s \n", (count+1)*5, str)
time.Sleep(time.Duration(count+1) * 5 * time.Second)
count = count + 1
goto LOOP
}
}
// 结束时间
endTime := time.Now()
// 执行时间
latencyTime := endTime.Sub(startTime)
//TODO: 待完善部分
log.Infof("[Job] JobCore %s exec success , spend :%v", h.Name, latencyTime)
return
}
// Setup 初始化
func Setup(dbs map[string]*gorm.DB) {
fmt.Println(time.Now().Format(timeFormat), " [INFO] JobCore Starting...")
for k, db := range dbs {
sdk.Runtime.SetCrontab(k, cronjob.NewWithSeconds())
setup(k, db)
}
}
func setup(key string, db *gorm.DB) {
crontab := sdk.Runtime.GetCrontabKey(key)
sysJob := models2.SysJob{}
jobList := make([]models2.SysJob, 0)
err := sysJob.GetList(db, &jobList)
if err != nil {
fmt.Println(time.Now().Format(timeFormat), " [ERROR] JobCore init error", err)
}
if len(jobList) == 0 {
fmt.Println(time.Now().Format(timeFormat), " [INFO] JobCore total:0")
}
_, err = sysJob.RemoveAllEntryID(db)
if err != nil {
fmt.Println(time.Now().Format(timeFormat), " [ERROR] JobCore remove entry_id error", err)
}
for i := 0; i < len(jobList); i++ {
if jobList[i].JobType == 1 {
j := &HttpJob{}
j.InvokeTarget = jobList[i].InvokeTarget
j.CronExpression = jobList[i].CronExpression
j.JobId = jobList[i].JobId
j.Name = jobList[i].JobName
sysJob.EntryId, err = AddJob(crontab, j)
} else if jobList[i].JobType == 2 {
j := &ExecJob{}
j.InvokeTarget = jobList[i].InvokeTarget
j.CronExpression = jobList[i].CronExpression
j.JobId = jobList[i].JobId
j.Name = jobList[i].JobName
j.Args = jobList[i].Args
sysJob.EntryId, err = AddJob(crontab, j)
}
err = sysJob.Update(db, jobList[i].JobId)
}
// 其中任务
crontab.Start()
fmt.Println(time.Now().Format(timeFormat), " [INFO] JobCore start success.")
// 关闭任务
defer crontab.Stop()
select {}
}
// AddJob 添加任务 AddJob(invokeTarget string, jobId int, jobName string, cronExpression string)
func AddJob(c *cron.Cron, job Job) (int, error) {
if job == nil {
fmt.Println("unknown")
return 0, nil
}
return job.addJob(c)
}
func (h *HttpJob) addJob(c *cron.Cron) (int, error) {
id, err := c.AddJob(h.CronExpression, h)
if err != nil {
fmt.Println(time.Now().Format(timeFormat), " [ERROR] JobCore AddJob error", err)
return 0, err
}
EntryId := int(id)
return EntryId, nil
}
func (e *ExecJob) addJob(c *cron.Cron) (int, error) {
id, err := c.AddJob(e.CronExpression, e)
if err != nil {
fmt.Println(time.Now().Format(timeFormat), " [ERROR] JobCore AddJob error", err)
return 0, err
}
EntryId := int(id)
return EntryId, nil
}
// Remove 移除任务
func Remove(c *cron.Cron, entryID int) chan bool {
ch := make(chan bool)
go func() {
c.Remove(cron.EntryID(entryID))
fmt.Println(time.Now().Format(timeFormat), " [INFO] JobCore Remove success ,info entryID :", entryID)
ch <- true
}()
return ch
}
// 任务停止
//func Stop() chan bool {
// ch := make(chan bool)
// go func() {
// global.GADMCron.Stop()
// ch <- true
// }()
// return ch
//}

View File

@ -0,0 +1,61 @@
package models
import (
"go-admin/common/models"
"gorm.io/gorm"
)
type SysJob struct {
JobId int `json:"jobId" gorm:"primaryKey;autoIncrement"` // 编码
JobName string `json:"jobName" gorm:"size:255;"` // 名称
JobGroup string `json:"jobGroup" gorm:"size:255;"` // 任务分组
JobType int `json:"jobType" gorm:"size:1;"` // 任务类型
CronExpression string `json:"cronExpression" gorm:"size:255;"` // cron表达式
InvokeTarget string `json:"invokeTarget" gorm:"size:255;"` // 调用目标
Args string `json:"args" gorm:"size:255;"` // 目标参数
MisfirePolicy int `json:"misfirePolicy" gorm:"size:255;"` // 执行策略
Concurrent int `json:"concurrent" gorm:"size:1;"` // 是否并发
Status int `json:"status" gorm:"size:1;"` // 状态
EntryId int `json:"entry_id" gorm:"size:11;"` // job启动时返回的id
models.ControlBy
models.ModelTime
DataScope string `json:"dataScope" gorm:"-"`
}
func (*SysJob) TableName() string {
return "sys_job"
}
func (e *SysJob) Generate() models.ActiveRecord {
o := *e
return &o
}
func (e *SysJob) GetId() interface{} {
return e.JobId
}
func (e *SysJob) SetCreateBy(createBy int) {
e.CreateBy = createBy
}
func (e *SysJob) SetUpdateBy(updateBy int) {
e.UpdateBy = updateBy
}
func (e *SysJob) GetList(tx *gorm.DB, list interface{}) (err error) {
return tx.Table(e.TableName()).Where("status = ?", 2).Find(list).Error
}
// Update 更新SysJob
func (e *SysJob) Update(tx *gorm.DB, id interface{}) (err error) {
return tx.Table(e.TableName()).Where(id).Updates(&e).Error
}
func (e *SysJob) RemoveAllEntryID(tx *gorm.DB) (update SysJob, err error) {
if err = tx.Table(e.TableName()).Where("entry_id > ?", 0).Update("entry_id", 0).Error; err != nil {
return
}
return
}

View File

@ -0,0 +1,36 @@
package router
import (
//"github.com/go-admin-team/go-admin-core/sdk/pkg"
"os"
"github.com/gin-gonic/gin"
log "github.com/go-admin-team/go-admin-core/logger"
"github.com/go-admin-team/go-admin-core/sdk"
common "go-admin/common/middleware"
)
// InitRouter 路由初始化,不要怀疑,这里用到了
func InitRouter() {
var r *gin.Engine
h := sdk.Runtime.GetEngine()
if h == nil {
log.Fatal("not found engine...")
os.Exit(-1)
}
switch h.(type) {
case *gin.Engine:
r = h.(*gin.Engine)
default:
log.Fatal("not support other engine")
os.Exit(-1)
}
authMiddleware, err := common.AuthInit()
if err != nil {
log.Fatalf("JWT Init Error, %s", err.Error())
}
// 注册业务路由
initRouter(r, authMiddleware)
}

42
app/jobs/router/router.go Normal file
View File

@ -0,0 +1,42 @@
package router
import (
"github.com/gin-gonic/gin"
jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
)
var (
routerNoCheckRole = make([]func(*gin.RouterGroup), 0)
routerCheckRole = make([]func(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware), 0)
)
// initRouter 路由示例
func initRouter(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) *gin.Engine {
// 无需认证的路由
noCheckRoleRouter(r)
// 需要认证的路由
checkRoleRouter(r, authMiddleware)
return r
}
// noCheckRoleRouter 无需认证的路由示例
func noCheckRoleRouter(r *gin.Engine) {
// 可根据业务需求来设置接口版本
v1 := r.Group("/api/v1")
for _, f := range routerNoCheckRole {
f(v1)
}
}
// checkRoleRouter 需要认证的路由示例
func checkRoleRouter(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) {
// 可根据业务需求来设置接口版本
v1 := r.Group("/api/v1")
for _, f := range routerCheckRole {
f(v1, authMiddleware)
}
}

View File

@ -0,0 +1,38 @@
package router
import (
"github.com/gin-gonic/gin"
jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
"go-admin/app/jobs/apis"
models2 "go-admin/app/jobs/models"
dto2 "go-admin/app/jobs/service/dto"
"go-admin/common/actions"
"go-admin/common/middleware"
)
func init() {
routerCheckRole = append(routerCheckRole, registerSysJobRouter)
}
// 需认证的路由代码
func registerSysJobRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
r := v1.Group("/sysjob").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
{
sysJob := &models2.SysJob{}
r.GET("", actions.PermissionAction(), actions.IndexAction(sysJob, new(dto2.SysJobSearch), func() interface{} {
list := make([]models2.SysJob, 0)
return &list
}))
r.GET("/:id", actions.PermissionAction(), actions.ViewAction(new(dto2.SysJobById), func() interface{} {
return &dto2.SysJobItem{}
}))
r.POST("", actions.CreateAction(new(dto2.SysJobControl)))
r.PUT("", actions.PermissionAction(), actions.UpdateAction(new(dto2.SysJobControl)))
r.DELETE("", actions.PermissionAction(), actions.DeleteAction(new(dto2.SysJobById)))
}
sysJob := apis.SysJob{}
v1.GET("/job/remove/:id", sysJob.RemoveJobForService)
v1.GET("/job/start/:id", sysJob.StartJobForService)
}

View File

@ -0,0 +1,108 @@
package dto
import (
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/sdk/api"
"go-admin/app/jobs/models"
"go-admin/common/dto"
common "go-admin/common/models"
)
type SysJobSearch struct {
dto.Pagination `search:"-"`
JobId int `form:"jobId" search:"type:exact;column:job_id;table:sys_job"`
JobName string `form:"jobName" search:"type:icontains;column:job_name;table:sys_job"`
JobGroup string `form:"jobGroup" search:"type:exact;column:job_group;table:sys_job"`
CronExpression string `form:"cronExpression" search:"type:exact;column:cron_expression;table:sys_job"`
InvokeTarget string `form:"invokeTarget" search:"type:exact;column:invoke_target;table:sys_job"`
Status int `form:"status" search:"type:exact;column:status;table:sys_job"`
}
func (m *SysJobSearch) GetNeedSearch() interface{} {
return *m
}
func (m *SysJobSearch) Bind(ctx *gin.Context) error {
log := api.GetRequestLogger(ctx)
err := ctx.ShouldBind(m)
if err != nil {
log.Errorf("Bind error: %s", err)
}
return err
}
func (m *SysJobSearch) Generate() dto.Index {
o := *m
return &o
}
type SysJobControl struct {
JobId int `json:"jobId"`
JobName string `json:"jobName" validate:"required"` // 名称
JobGroup string `json:"jobGroup"` // 任务分组
JobType int `json:"jobType"` // 任务类型
CronExpression string `json:"cronExpression"` // cron表达式
InvokeTarget string `json:"invokeTarget"` // 调用目标
Args string `json:"args"` // 目标参数
MisfirePolicy int `json:"misfirePolicy"` // 执行策略
Concurrent int `json:"concurrent"` // 是否并发
Status int `json:"status"` // 状态
EntryId int `json:"entryId"` // job启动时返回的id
}
func (s *SysJobControl) Bind(ctx *gin.Context) error {
return ctx.ShouldBind(s)
}
func (s *SysJobControl) Generate() dto.Control {
cp := *s
return &cp
}
func (s *SysJobControl) GenerateM() (common.ActiveRecord, error) {
return &models.SysJob{
JobId: s.JobId,
JobName: s.JobName,
JobGroup: s.JobGroup,
JobType: s.JobType,
CronExpression: s.CronExpression,
InvokeTarget: s.InvokeTarget,
Args: s.Args,
MisfirePolicy: s.MisfirePolicy,
Concurrent: s.Concurrent,
Status: s.Status,
EntryId: s.EntryId,
}, nil
}
func (s *SysJobControl) GetId() interface{} {
return s.JobId
}
type SysJobById struct {
dto.ObjectById
}
func (s *SysJobById) Generate() dto.Control {
cp := *s
return &cp
}
func (s *SysJobById) GenerateM() (common.ActiveRecord, error) {
return &models.SysJob{}, nil
}
type SysJobItem struct {
JobId int `json:"jobId"`
JobName string `json:"jobName" validate:"required"` // 名称
JobGroup string `json:"jobGroup"` // 任务分组
JobType int `json:"jobType"` // 任务类型
CronExpression string `json:"cronExpression"` // cron表达式
InvokeTarget string `json:"invokeTarget"` // 调用目标
Args string `json:"args"` // 目标参数
MisfirePolicy int `json:"misfirePolicy"` // 执行策略
Concurrent int `json:"concurrent"` // 是否并发
Status int `json:"status"` // 状态
EntryId int `json:"entryId"` // job启动时返回的id
}

View File

@ -0,0 +1,93 @@
package service
import (
"errors"
"time"
"github.com/go-admin-team/go-admin-core/sdk/service"
"github.com/robfig/cron/v3"
"go-admin/app/jobs"
"go-admin/app/jobs/models"
"go-admin/common/dto"
)
type SysJob struct {
service.Service
Cron *cron.Cron
}
// RemoveJob 删除job
func (e *SysJob) RemoveJob(c *dto.GeneralDelDto) error {
var err error
var data models.SysJob
err = e.Orm.Table(data.TableName()).First(&data, c.Id).Error
if err != nil {
e.Log.Errorf("db error: %s", err)
return err
}
cn := jobs.Remove(e.Cron, data.EntryId)
select {
case res := <-cn:
if res {
err = e.Orm.Table(data.TableName()).Where("entry_id = ?", data.EntryId).Update("entry_id", 0).Error
if err != nil {
e.Log.Errorf("db error: %s", err)
}
return err
}
case <-time.After(time.Second * 1):
e.Msg = "操作超时!"
return nil
}
return nil
}
// StartJob 启动任务
func (e *SysJob) StartJob(c *dto.GeneralGetDto) error {
var data models.SysJob
var err error
err = e.Orm.Table(data.TableName()).First(&data, c.Id).Error
if err != nil {
e.Log.Errorf("db error: %s", err)
return err
}
if data.Status == 1 {
err = errors.New("当前Job是关闭状态不能被启动请先启用。")
return err
}
if data.JobType == 1 {
var j = &jobs.HttpJob{}
j.InvokeTarget = data.InvokeTarget
j.CronExpression = data.CronExpression
j.JobId = data.JobId
j.Name = data.JobName
data.EntryId, err = jobs.AddJob(e.Cron, j)
if err != nil {
e.Log.Errorf("jobs AddJob[HttpJob] error: %s", err)
}
} else {
var j = &jobs.ExecJob{}
j.InvokeTarget = data.InvokeTarget
j.CronExpression = data.CronExpression
j.JobId = data.JobId
j.Name = data.JobName
j.Args = data.Args
data.EntryId, err = jobs.AddJob(e.Cron, j)
if err != nil {
e.Log.Errorf("jobs AddJob[ExecJob] error: %s", err)
}
}
if err != nil {
return err
}
err = e.Orm.Table(data.TableName()).Where(c.Id).Updates(&data).Error
if err != nil {
e.Log.Errorf("db error: %s", err)
}
return err
}

16
app/jobs/type.go Normal file
View File

@ -0,0 +1,16 @@
package jobs
import "github.com/robfig/cron/v3"
type Job interface {
Run()
addJob(*cron.Cron) (int, error)
}
type JobExec interface {
Exec(arg interface{}) error
}
func CallExec(e JobExec, arg interface{}) error {
return e.Exec(arg)
}