fix: 依赖注入支持私有变量

mayfly_go_web/src/views/ops/db/DbBackupEdit.vue

@@ -23,7 +23,7 @@
                 </el-form-item>
 
                 <el-form-item prop="name" label="任务名称">
-                    <el-input v-model.number="state.form.name" type="text" placeholder="任务名称"></el-input>
+                    <el-input v-model="state.form.name" type="text" placeholder="任务名称"></el-input>
                 </el-form-item>
                 <el-form-item prop="startTime" label="开始时间">
                     <el-date-picker v-model="state.form.startTime" type="datetime" placeholder="开始时间" />
@@ -101,7 +101,7 @@ const state = reactive({
         id: 0,
         dbId: 0,
         dbNames: '',
-        name: null as any,
+        name: '',
         intervalDay: null,
         startTime: null as any,
         repeated: null as any,

server/internal/db/api/db_backup.go

@@ -14,8 +14,8 @@ import (
 )
 
 type DbBackup struct {
-	DbBackupApp *application.DbBackupApp `inject:""`
+	dbBackupApp *application.DbBackupApp `inject:"DbBackupApp"`
-	DbApp       application.Db           `inject:""`
+	dbApp       application.Db           `inject:"DbApp"`
 }
 
 // todo: 鉴权，避免未经授权进行数据库备份和恢复
@@ -25,13 +25,13 @@ type DbBackup struct {
 func (d *DbBackup) GetPageList(rc *req.Ctx) {
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
 	biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 
 	queryCond, page := ginx.BindQueryAndPage[*entity.DbJobQuery](rc.GinCtx, new(entity.DbJobQuery))
 	queryCond.DbInstanceId = db.InstanceId
 	queryCond.InDbNames = strings.Fields(db.Database)
-	res, err := d.DbBackupApp.GetPageList(queryCond, page, new([]vo.DbBackup))
+	res, err := d.dbBackupApp.GetPageList(queryCond, page, new([]vo.DbBackup))
 	biz.ErrIsNilAppendErr(err, "获取数据库备份任务失败: %v")
 	rc.ResData = res
 }
@@ -48,7 +48,7 @@ func (d *DbBackup) Create(rc *req.Ctx) {
 
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
 	biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "instanceId")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "instanceId")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 
 	jobs := make([]*entity.DbBackup, 0, len(dbNames))
@@ -64,7 +64,7 @@ func (d *DbBackup) Create(rc *req.Ctx) {
 		}
 		jobs = append(jobs, job)
 	}
-	biz.ErrIsNilAppendErr(d.DbBackupApp.Create(rc.MetaCtx, jobs), "添加数据库备份任务失败: %v")
+	biz.ErrIsNilAppendErr(d.dbBackupApp.Create(rc.MetaCtx, jobs), "添加数据库备份任务失败: %v")
 }
 
 // Update 保存数据库备份任务
@@ -79,7 +79,7 @@ func (d *DbBackup) Update(rc *req.Ctx) {
 	job.Name = backupForm.Name
 	job.StartTime = backupForm.StartTime
 	job.Interval = backupForm.Interval
-	biz.ErrIsNilAppendErr(d.DbBackupApp.Update(rc.MetaCtx, job), "保存数据库备份任务失败: %v")
+	biz.ErrIsNilAppendErr(d.dbBackupApp.Update(rc.MetaCtx, job), "保存数据库备份任务失败: %v")
 }
 
 func (d *DbBackup) walk(rc *req.Ctx, fn func(ctx context.Context, backupId uint64) error) error {
@@ -104,28 +104,28 @@ func (d *DbBackup) walk(rc *req.Ctx, fn func(ctx context.Context, backupId uint6
 // Delete 删除数据库备份任务
 // @router /api/dbs/:dbId/backups/:backupId [DELETE]
 func (d *DbBackup) Delete(rc *req.Ctx) {
-	err := d.walk(rc, d.DbBackupApp.Delete)
+	err := d.walk(rc, d.dbBackupApp.Delete)
 	biz.ErrIsNilAppendErr(err, "删除数据库备份任务失败: %v")
 }
 
 // Enable 启用数据库备份任务
 // @router /api/dbs/:dbId/backups/:backupId/enable [PUT]
 func (d *DbBackup) Enable(rc *req.Ctx) {
-	err := d.walk(rc, d.DbBackupApp.Enable)
+	err := d.walk(rc, d.dbBackupApp.Enable)
 	biz.ErrIsNilAppendErr(err, "启用数据库备份任务失败: %v")
 }
 
 // Disable 禁用数据库备份任务
 // @router /api/dbs/:dbId/backups/:backupId/disable [PUT]
 func (d *DbBackup) Disable(rc *req.Ctx) {
-	err := d.walk(rc, d.DbBackupApp.Disable)
+	err := d.walk(rc, d.dbBackupApp.Disable)
 	biz.ErrIsNilAppendErr(err, "禁用数据库备份任务失败: %v")
 }
 
 // Start 禁用数据库备份任务
 // @router /api/dbs/:dbId/backups/:backupId/start [PUT]
 func (d *DbBackup) Start(rc *req.Ctx) {
-	err := d.walk(rc, d.DbBackupApp.Start)
+	err := d.walk(rc, d.dbBackupApp.Start)
 	biz.ErrIsNilAppendErr(err, "运行数据库备份任务失败: %v")
 }
 
@@ -133,10 +133,10 @@ func (d *DbBackup) Start(rc *req.Ctx) {
 // @router /api/dbs/:dbId/db-names-without-backup [GET]
 func (d *DbBackup) GetDbNamesWithoutBackup(rc *req.Ctx) {
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 	dbNames := strings.Fields(db.Database)
-	dbNamesWithoutBackup, err := d.DbBackupApp.GetDbNamesWithoutBackup(db.InstanceId, dbNames)
+	dbNamesWithoutBackup, err := d.dbBackupApp.GetDbNamesWithoutBackup(db.InstanceId, dbNames)
 	biz.ErrIsNilAppendErr(err, "获取未配置定时备份的数据库名称失败: %v")
 	rc.ResData = dbNamesWithoutBackup
 }
@@ -146,13 +146,13 @@ func (d *DbBackup) GetDbNamesWithoutBackup(rc *req.Ctx) {
 func (d *DbBackup) GetHistoryPageList(rc *req.Ctx) {
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
 	biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 
 	queryCond, page := ginx.BindQueryAndPage[*entity.DbBackupHistoryQuery](rc.GinCtx, new(entity.DbBackupHistoryQuery))
 	queryCond.DbInstanceId = db.InstanceId
 	queryCond.InDbNames = strings.Fields(db.Database)
-	res, err := d.DbBackupApp.GetHistoryPageList(queryCond, page, new([]vo.DbBackupHistory))
+	res, err := d.dbBackupApp.GetHistoryPageList(queryCond, page, new([]vo.DbBackupHistory))
 	biz.ErrIsNilAppendErr(err, "获取数据库备份历史失败: %v")
 	rc.ResData = res
 }

server/internal/db/api/db_restore.go

@@ -14,8 +14,8 @@ import (
 )
 
 type DbRestore struct {
-	DbRestoreApp *application.DbRestoreApp `inject:""`
+	restoreApp *application.DbRestoreApp `inject:"DbRestoreApp"`
-	DbApp        application.Db            `inject:""`
+	dbApp      application.Db            `inject:"DbApp"`
 }
 
 // GetPageList 获取数据库恢复任务
@@ -23,14 +23,14 @@ type DbRestore struct {
 func (d *DbRestore) GetPageList(rc *req.Ctx) {
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
 	biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 
 	var restores []vo.DbRestore
 	queryCond, page := ginx.BindQueryAndPage[*entity.DbJobQuery](rc.GinCtx, new(entity.DbJobQuery))
 	queryCond.DbInstanceId = db.InstanceId
 	queryCond.InDbNames = strings.Fields(db.Database)
-	res, err := d.DbRestoreApp.GetPageList(queryCond, page, &restores)
+	res, err := d.restoreApp.GetPageList(queryCond, page, &restores)
 	biz.ErrIsNilAppendErr(err, "获取数据库恢复任务失败: %v")
 	rc.ResData = res
 }
@@ -44,7 +44,7 @@ func (d *DbRestore) Create(rc *req.Ctx) {
 
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
 	biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "instanceId")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "instanceId")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 
 	job := &entity.DbRestore{
@@ -59,7 +59,7 @@ func (d *DbRestore) Create(rc *req.Ctx) {
 		DbBackupHistoryName: restoreForm.DbBackupHistoryName,
 	}
 	job.DbName = restoreForm.DbName
-	biz.ErrIsNilAppendErr(d.DbRestoreApp.Create(rc.MetaCtx, job), "添加数据库恢复任务失败: %v")
+	biz.ErrIsNilAppendErr(d.restoreApp.Create(rc.MetaCtx, job), "添加数据库恢复任务失败: %v")
 }
 
 // Update 保存数据库恢复任务
@@ -73,7 +73,7 @@ func (d *DbRestore) Update(rc *req.Ctx) {
 	job.Id = restoreForm.Id
 	job.StartTime = restoreForm.StartTime
 	job.Interval = restoreForm.Interval
-	biz.ErrIsNilAppendErr(d.DbRestoreApp.Update(rc.MetaCtx, job), "保存数据库恢复任务失败: %v")
+	biz.ErrIsNilAppendErr(d.restoreApp.Update(rc.MetaCtx, job), "保存数据库恢复任务失败: %v")
 }
 
 func (d *DbRestore) walk(rc *req.Ctx, fn func(ctx context.Context, restoreId uint64) error) error {
@@ -98,21 +98,21 @@ func (d *DbRestore) walk(rc *req.Ctx, fn func(ctx context.Context, restoreId uin
 // Delete 删除数据库恢复任务
 // @router /api/dbs/:dbId/restores/:restoreId [DELETE]
 func (d *DbRestore) Delete(rc *req.Ctx) {
-	err := d.walk(rc, d.DbRestoreApp.Delete)
+	err := d.walk(rc, d.restoreApp.Delete)
 	biz.ErrIsNilAppendErr(err, "删除数据库恢复任务失败: %v")
 }
 
 // Enable 启用数据库恢复任务
 // @router /api/dbs/:dbId/restores/:restoreId/enable [PUT]
 func (d *DbRestore) Enable(rc *req.Ctx) {
-	err := d.walk(rc, d.DbRestoreApp.Enable)
+	err := d.walk(rc, d.restoreApp.Enable)
 	biz.ErrIsNilAppendErr(err, "启用数据库恢复任务失败: %v")
 }
 
 // Disable 禁用数据库恢复任务
 // @router /api/dbs/:dbId/restores/:restoreId/disable [PUT]
 func (d *DbRestore) Disable(rc *req.Ctx) {
-	err := d.walk(rc, d.DbRestoreApp.Disable)
+	err := d.walk(rc, d.restoreApp.Disable)
 	biz.ErrIsNilAppendErr(err, "禁用数据库恢复任务失败: %v")
 }
 
@@ -120,10 +120,10 @@ func (d *DbRestore) Disable(rc *req.Ctx) {
 // @router /api/dbs/:dbId/db-names-without-backup [GET]
 func (d *DbRestore) GetDbNamesWithoutRestore(rc *req.Ctx) {
 	dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
-	db, err := d.DbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
+	db, err := d.dbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
 	biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
 	dbNames := strings.Fields(db.Database)
-	dbNamesWithoutRestore, err := d.DbRestoreApp.GetDbNamesWithoutRestore(db.InstanceId, dbNames)
+	dbNamesWithoutRestore, err := d.restoreApp.GetDbNamesWithoutRestore(db.InstanceId, dbNames)
 	biz.ErrIsNilAppendErr(err, "获取未配置定时备份的数据库名称失败: %v")
 	rc.ResData = dbNamesWithoutRestore
 }
@@ -134,7 +134,7 @@ func (d *DbRestore) GetHistoryPageList(rc *req.Ctx) {
 	queryCond := &entity.DbRestoreHistoryQuery{
 		DbRestoreId: uint64(ginx.PathParamInt(rc.GinCtx, "restoreId")),
 	}
-	res, err := d.DbRestoreApp.GetHistoryPageList(queryCond, ginx.GetPageParam(rc.GinCtx), new([]vo.DbRestoreHistory))
+	res, err := d.restoreApp.GetHistoryPageList(queryCond, ginx.GetPageParam(rc.GinCtx), new([]vo.DbRestoreHistory))
 	biz.ErrIsNilAppendErr(err, "获取数据库备份历史失败: %v")
 	rc.ResData = res
 }

server/internal/db/application/db_backup.go

@@ -10,66 +10,66 @@ import (
 )
 
 type DbBackupApp struct {
-	DbApp             Db                         `inject:"DbApp"`
+	dbApp             Db                         `inject:"DbApp"`
-	Scheduler         *dbScheduler               `inject:"DbScheduler"`
+	scheduler         *dbScheduler               `inject:"DbScheduler"`
-	InstanceRepo      repository.Instance        `inject:"DbInstanceRepo"`
+	instanceRepo      repository.Instance        `inject:"DbInstanceRepo"`
-	BackupRepo        repository.DbBackup        `inject:"DbBackupRepo"`
+	backupRepo        repository.DbBackup        `inject:"DbBackupRepo"`
-	BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+	backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
 }
 
 func (app *DbBackupApp) Init() error {
 	var jobs []*entity.DbBackup
-	if err := app.BackupRepo.ListToDo(&jobs); err != nil {
+	if err := app.backupRepo.ListToDo(&jobs); err != nil {
 		return err
 	}
-	if err := app.Scheduler.AddJob(context.Background(), false, entity.DbJobTypeBackup, jobs); err != nil {
+	if err := app.scheduler.AddJob(context.Background(), false, entity.DbJobTypeBackup, jobs); err != nil {
 		return err
 	}
 	return nil
 }
 
 func (app *DbBackupApp) Close() {
-	app.Scheduler.Close()
+	app.scheduler.Close()
 }
 
 func (app *DbBackupApp) Create(ctx context.Context, jobs []*entity.DbBackup) error {
-	return app.Scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeBackup, jobs)
+	return app.scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeBackup, jobs)
 }
 
 func (app *DbBackupApp) Update(ctx context.Context, job *entity.DbBackup) error {
-	return app.Scheduler.UpdateJob(ctx, job)
+	return app.scheduler.UpdateJob(ctx, job)
 }
 
 func (app *DbBackupApp) Delete(ctx context.Context, jobId uint64) error {
 	// todo: 删除数据库备份历史文件
-	return app.Scheduler.RemoveJob(ctx, entity.DbJobTypeBackup, jobId)
+	return app.scheduler.RemoveJob(ctx, entity.DbJobTypeBackup, jobId)
 }
 
 func (app *DbBackupApp) Enable(ctx context.Context, jobId uint64) error {
-	return app.Scheduler.EnableJob(ctx, entity.DbJobTypeBackup, jobId)
+	return app.scheduler.EnableJob(ctx, entity.DbJobTypeBackup, jobId)
 }
 
 func (app *DbBackupApp) Disable(ctx context.Context, jobId uint64) error {
-	return app.Scheduler.DisableJob(ctx, entity.DbJobTypeBackup, jobId)
+	return app.scheduler.DisableJob(ctx, entity.DbJobTypeBackup, jobId)
 }
 
 func (app *DbBackupApp) Start(ctx context.Context, jobId uint64) error {
-	return app.Scheduler.StartJobNow(ctx, entity.DbJobTypeBackup, jobId)
+	return app.scheduler.StartJobNow(ctx, entity.DbJobTypeBackup, jobId)
 }
 
 // GetPageList 分页获取数据库备份任务
 func (app *DbBackupApp) GetPageList(condition *entity.DbJobQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
-	return app.BackupRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
+	return app.backupRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
 }
 
 // GetDbNamesWithoutBackup 获取未配置定时备份的数据库名称
 func (app *DbBackupApp) GetDbNamesWithoutBackup(instanceId uint64, dbNames []string) ([]string, error) {
-	return app.BackupRepo.GetDbNamesWithoutBackup(instanceId, dbNames)
+	return app.backupRepo.GetDbNamesWithoutBackup(instanceId, dbNames)
 }
 
 // GetHistoryPageList 分页获取数据库备份历史
 func (app *DbBackupApp) GetHistoryPageList(condition *entity.DbBackupHistoryQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
-	return app.BackupHistoryRepo.GetHistories(condition, pageParam, toEntity, orderBy...)
+	return app.backupHistoryRepo.GetHistories(condition, pageParam, toEntity, orderBy...)
 }
 
 func NewIncUUID() (uuid.UUID, error) {

server/internal/db/application/db_binlog.go

@@ -11,12 +11,12 @@ import (
 )
 
 type DbBinlogApp struct {
-	DbApp             Db                         `inject:"DbApp"`
+	dbApp             Db                         `inject:"DbApp"`
-	Scheduler         *dbScheduler               `inject:"DbScheduler"`
+	scheduler         *dbScheduler               `inject:"DbScheduler"`
-	BinlogRepo        repository.DbBinlog        `inject:"DbBinlogRepo"`
+	binlogRepo        repository.DbBinlog        `inject:"DbBinlogRepo"`
-	BinlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
+	binlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
-	BackupRepo        repository.DbBackup        `inject:"DbBackupRepo"`
+	backupRepo        repository.DbBackup        `inject:"DbBackupRepo"`
-	BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+	backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
 	context           context.Context
 	cancel            context.CancelFunc
 	waitGroup         sync.WaitGroup
@@ -48,7 +48,7 @@ func (app *DbBinlogApp) run() {
 		if app.closed() {
 			break
 		}
-		if err := app.Scheduler.AddJob(app.context, false, entity.DbJobTypeBinlog, jobs); err != nil {
+		if err := app.scheduler.AddJob(app.context, false, entity.DbJobTypeBinlog, jobs); err != nil {
 			logx.Error("DbBinlogApp: 添加 BINLOG 同步任务失败: ", err.Error())
 		}
 		timex.SleepWithContext(app.context, entity.BinlogDownloadInterval)
@@ -57,7 +57,7 @@ func (app *DbBinlogApp) run() {
 
 func (app *DbBinlogApp) loadJobs() ([]*entity.DbBinlog, error) {
 	var instanceIds []uint64
-	if err := app.BackupRepo.ListDbInstances(true, true, &instanceIds); err != nil {
+	if err := app.backupRepo.ListDbInstances(true, true, &instanceIds); err != nil {
 		return nil, err
 	}
 	jobs := make([]*entity.DbBinlog, 0, len(instanceIds))
@@ -84,7 +84,7 @@ func (app *DbBinlogApp) closed() bool {
 }
 
 func (app *DbBinlogApp) AddJobIfNotExists(ctx context.Context, job *entity.DbBinlog) error {
-	if err := app.BinlogRepo.AddJobIfNotExists(ctx, job); err != nil {
+	if err := app.binlogRepo.AddJobIfNotExists(ctx, job); err != nil {
 		return err
 	}
 	if job.Id == 0 {
@@ -95,7 +95,7 @@ func (app *DbBinlogApp) AddJobIfNotExists(ctx context.Context, job *entity.DbBin
 
 func (app *DbBinlogApp) Delete(ctx context.Context, jobId uint64) error {
 	// todo: 删除 Binlog 历史文件
-	if err := app.BinlogRepo.DeleteById(ctx, jobId); err != nil {
+	if err := app.binlogRepo.DeleteById(ctx, jobId); err != nil {
 		return err
 	}
 	return nil

server/internal/db/application/db_restore.go

@@ -8,62 +8,62 @@ import (
 )
 
 type DbRestoreApp struct {
-	DbApp              Db                          `inject:"DbApp"`
+	dbApp              Db                          `inject:"DbApp"`
-	Scheduler          *dbScheduler                `inject:"DbScheduler"`
+	scheduler          *dbScheduler                `inject:"DbScheduler"`
-	InstanceRepo       repository.Instance         `inject:"DbInstanceRepo"`
+	instanceRepo       repository.Instance         `inject:"DbInstanceRepo"`
-	BackupHistoryRepo  repository.DbBackupHistory  `inject:"DbBackupHistoryRepo"`
+	backupHistoryRepo  repository.DbBackupHistory  `inject:"DbBackupHistoryRepo"`
-	RestoreRepo        repository.DbRestore        `inject:"DbRestoreRepo"`
+	restoreRepo        repository.DbRestore        `inject:"DbRestoreRepo"`
-	RestoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
+	restoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
-	BinlogHistoryRepo  repository.DbBinlogHistory  `inject:"DbBinlogHistoryRepo"`
+	binlogHistoryRepo  repository.DbBinlogHistory  `inject:"DbBinlogHistoryRepo"`
 }
 
 func (app *DbRestoreApp) Init() error {
 	var jobs []*entity.DbRestore
-	if err := app.RestoreRepo.ListToDo(&jobs); err != nil {
+	if err := app.restoreRepo.ListToDo(&jobs); err != nil {
 		return err
 	}
-	if err := app.Scheduler.AddJob(context.Background(), false, entity.DbJobTypeRestore, jobs); err != nil {
+	if err := app.scheduler.AddJob(context.Background(), false, entity.DbJobTypeRestore, jobs); err != nil {
 		return err
 	}
 	return nil
 }
 
 func (app *DbRestoreApp) Close() {
-	app.Scheduler.Close()
+	app.scheduler.Close()
 }
 
 func (app *DbRestoreApp) Create(ctx context.Context, job *entity.DbRestore) error {
-	return app.Scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeRestore, job)
+	return app.scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeRestore, job)
 }
 
 func (app *DbRestoreApp) Update(ctx context.Context, job *entity.DbRestore) error {
-	return app.Scheduler.UpdateJob(ctx, job)
+	return app.scheduler.UpdateJob(ctx, job)
 }
 
 func (app *DbRestoreApp) Delete(ctx context.Context, jobId uint64) error {
 	// todo: 删除数据库恢复历史文件
-	return app.Scheduler.RemoveJob(ctx, entity.DbJobTypeRestore, jobId)
+	return app.scheduler.RemoveJob(ctx, entity.DbJobTypeRestore, jobId)
 }
 
 func (app *DbRestoreApp) Enable(ctx context.Context, jobId uint64) error {
-	return app.Scheduler.EnableJob(ctx, entity.DbJobTypeRestore, jobId)
+	return app.scheduler.EnableJob(ctx, entity.DbJobTypeRestore, jobId)
 }
 
 func (app *DbRestoreApp) Disable(ctx context.Context, jobId uint64) error {
-	return app.Scheduler.DisableJob(ctx, entity.DbJobTypeRestore, jobId)
+	return app.scheduler.DisableJob(ctx, entity.DbJobTypeRestore, jobId)
 }
 
 // GetPageList 分页获取数据库恢复任务
 func (app *DbRestoreApp) GetPageList(condition *entity.DbJobQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
-	return app.RestoreRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
+	return app.restoreRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
 }
 
 // GetDbNamesWithoutRestore 获取未配置定时恢复的数据库名称
 func (app *DbRestoreApp) GetDbNamesWithoutRestore(instanceId uint64, dbNames []string) ([]string, error) {
-	return app.RestoreRepo.GetDbNamesWithoutRestore(instanceId, dbNames)
+	return app.restoreRepo.GetDbNamesWithoutRestore(instanceId, dbNames)
 }
 
 // GetHistoryPageList 分页获取数据库备份历史
 func (app *DbRestoreApp) GetHistoryPageList(condition *entity.DbRestoreHistoryQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
-	return app.RestoreHistoryRepo.GetDbRestoreHistories(condition, pageParam, toEntity, orderBy...)
+	return app.restoreHistoryRepo.GetDbRestoreHistories(condition, pageParam, toEntity, orderBy...)
 }

server/internal/db/application/db_scheduler.go

@@ -21,13 +21,13 @@ const (
 type dbScheduler struct {
 	mutex              sync.Mutex
 	runner             *runner.Runner[entity.DbJob]
-	DbApp              Db                          `inject:"DbApp"`
+	dbApp              Db                          `inject:"DbApp"`
-	BackupRepo         repository.DbBackup         `inject:"DbBackupRepo"`
+	backupRepo         repository.DbBackup         `inject:"DbBackupRepo"`
-	BackupHistoryRepo  repository.DbBackupHistory  `inject:"DbBackupHistoryRepo"`
+	backupHistoryRepo  repository.DbBackupHistory  `inject:"DbBackupHistoryRepo"`
-	RestoreRepo        repository.DbRestore        `inject:"DbRestoreRepo"`
+	restoreRepo        repository.DbRestore        `inject:"DbRestoreRepo"`
-	RestoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
+	restoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
-	BinlogRepo         repository.DbBinlog         `inject:"DbBinlogRepo"`
+	binlogRepo         repository.DbBinlog         `inject:"DbBinlogRepo"`
-	BinlogHistoryRepo  repository.DbBinlogHistory  `inject:"DbBinlogHistoryRepo"`
+	binlogHistoryRepo  repository.DbBinlogHistory  `inject:"DbBinlogHistoryRepo"`
 	binlogTimes        map[uint64]time.Time
 }
 
@@ -47,11 +47,11 @@ func (s *dbScheduler) scheduleJob(job entity.DbJob) (time.Time, error) {
 func (s *dbScheduler) repo(typ entity.DbJobType) repository.DbJob {
 	switch typ {
 	case entity.DbJobTypeBackup:
-		return s.BackupRepo
+		return s.backupRepo
 	case entity.DbJobTypeRestore:
-		return s.RestoreRepo
+		return s.restoreRepo
 	case entity.DbJobTypeBinlog:
-		return s.BinlogRepo
+		return s.binlogRepo
 	default:
 		panic(errors.New(fmt.Sprintf("无效的数据库任务类型: %v", typ)))
 	}
@@ -177,7 +177,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
 		DbInstanceId: backup.DbInstanceId,
 		DbName:       backup.DbName,
 	}
-	conn, err := s.DbApp.GetDbConnByInstanceId(backup.DbInstanceId)
+	conn, err := s.dbApp.GetDbConnByInstanceId(backup.DbInstanceId)
 	if err != nil {
 		return err
 	}
@@ -197,7 +197,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
 	history.BinlogSequence = binlogInfo.Sequence
 	history.BinlogPosition = binlogInfo.Position
 
-	if err := s.BackupHistoryRepo.Insert(ctx, history); err != nil {
+	if err := s.backupHistoryRepo.Insert(ctx, history); err != nil {
 		return err
 	}
 	return nil
@@ -205,7 +205,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
 
 func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error {
 	restore := job.(*entity.DbRestore)
-	conn, err := s.DbApp.GetDbConnByInstanceId(restore.DbInstanceId)
+	conn, err := s.dbApp.GetDbConnByInstanceId(restore.DbInstanceId)
 	if err != nil {
 		return err
 	}
@@ -223,14 +223,14 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
 		}
 
 		latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
-		binlogHistory, ok, err := s.BinlogHistoryRepo.GetLatestHistory(restore.DbInstanceId)
+		binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(restore.DbInstanceId)
 		if err != nil {
 			return err
 		}
 		if ok {
 			latestBinlogSequence = binlogHistory.Sequence
 		} else {
-			backupHistory, ok, err := s.BackupHistoryRepo.GetEarliestHistory(restore.DbInstanceId)
+			backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(restore.DbInstanceId)
 			if err != nil {
 				return err
 			}
@@ -243,7 +243,7 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
 		if err != nil {
 			return err
 		}
-		if err := s.BinlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
+		if err := s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
 			return err
 		}
 		if err := s.restorePointInTime(ctx, dbProgram, restore); err != nil {
@@ -259,7 +259,7 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
 		CreateTime:  time.Now(),
 		DbRestoreId: restore.Id,
 	}
-	if err := s.RestoreHistoryRepo.Insert(ctx, history); err != nil {
+	if err := s.restoreHistoryRepo.Insert(ctx, history); err != nil {
 		return err
 	}
 	return nil
@@ -330,7 +330,7 @@ func relatedToBinlog(typ entity.DbJobType) bool {
 }
 
 func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProgram, job *entity.DbRestore) error {
-	binlogHistory, err := s.BinlogHistoryRepo.GetHistoryByTime(job.DbInstanceId, job.PointInTime.Time)
+	binlogHistory, err := s.binlogHistoryRepo.GetHistoryByTime(job.DbInstanceId, job.PointInTime.Time)
 	if err != nil {
 		return err
 	}
@@ -343,7 +343,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
 		Sequence: binlogHistory.Sequence,
 		Position: position,
 	}
-	backupHistory, err := s.BackupHistoryRepo.GetLatestHistory(job.DbInstanceId, job.DbName, target)
+	backupHistory, err := s.backupHistoryRepo.GetLatestHistory(job.DbInstanceId, job.DbName, target)
 	if err != nil {
 		return err
 	}
@@ -352,7 +352,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
 		Sequence: backupHistory.BinlogSequence,
 		Position: backupHistory.BinlogPosition,
 	}
-	binlogHistories, err := s.BinlogHistoryRepo.GetHistories(job.DbInstanceId, start, target)
+	binlogHistories, err := s.binlogHistoryRepo.GetHistories(job.DbInstanceId, start, target)
 	if err != nil {
 		return err
 	}
@@ -389,7 +389,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
 
 func (s *dbScheduler) restoreBackupHistory(ctx context.Context, program dbi.DbProgram, job *entity.DbRestore) error {
 	backupHistory := &entity.DbBackupHistory{}
-	if err := s.BackupHistoryRepo.GetById(backupHistory, job.DbBackupHistoryId); err != nil {
+	if err := s.backupHistoryRepo.GetById(backupHistory, job.DbBackupHistoryId); err != nil {
 		return err
 	}
 	return program.RestoreBackupHistory(ctx, backupHistory.DbName, backupHistory.DbBackupId, backupHistory.Uuid)
@@ -398,14 +398,14 @@ func (s *dbScheduler) restoreBackupHistory(ctx context.Context, program dbi.DbPr
 func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob) error {
 	instanceId := backup.GetJobBase().DbInstanceId
 	latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
-	binlogHistory, ok, err := s.BinlogHistoryRepo.GetLatestHistory(instanceId)
+	binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(instanceId)
 	if err != nil {
 		return err
 	}
 	if ok {
 		latestBinlogSequence = binlogHistory.Sequence
 	} else {
-		backupHistory, ok, err := s.BackupHistoryRepo.GetEarliestHistory(instanceId)
+		backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(instanceId)
 		if err != nil {
 			return err
 		}
@@ -414,7 +414,7 @@ func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob)
 		}
 		earliestBackupSequence = backupHistory.BinlogSequence
 	}
-	conn, err := s.DbApp.GetDbConnByInstanceId(instanceId)
+	conn, err := s.dbApp.GetDbConnByInstanceId(instanceId)
 	if err != nil {
 		return err
 	}
@@ -423,5 +423,5 @@ func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob)
 	if err != nil {
 		return err
 	}
-	return s.BinlogHistoryRepo.InsertWithBinlogFiles(ctx, instanceId, binlogFiles)
+	return s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, instanceId, binlogFiles)
 }

server/internal/db/router/db_backup.go

@@ -12,10 +12,7 @@ import (
 func InitDbBackupRouter(router *gin.RouterGroup) {
 	dbs := router.Group("/dbs")
 
-	d := &api.DbBackup{
+	d := &api.DbBackup{}
-		//DbBackupApp: application.GetDbBackupApp(),
-		//DbApp:       application.GetDbApp(),
-	}
 	biz.ErrIsNil(ioc.Inject(d))
 
 	reqs := []*req.Conf{

server/internal/db/router/db_restore.go

@@ -12,10 +12,7 @@ import (
 func InitDbRestoreRouter(router *gin.RouterGroup) {
 	dbs := router.Group("/dbs")
 
-	d := &api.DbRestore{
+	d := &api.DbRestore{}
-		//DbRestoreApp: application.GetDbRestoreApp(),
-		//DbApp:        application.GetDbApp(),
-	}
 	biz.ErrIsNil(ioc.Inject(d))
 
 	reqs := []*req.Conf{

server/pkg/ioc/ioc.go

@@ -108,12 +108,13 @@ func (c *Container) injectWithField(objValue reflect.Value) error {
 			return fmt.Errorf("%s error: 注入类型不一致(期望类型->%s.%s, 组件类型->%s.%s)", injectInfo, field.Type.PkgPath(), field.Type.Name(), componentType.PkgPath(), componentType.Name())
 		}
 
-		objValueField := objValue.Field(i)
+		fieldValue := objValue.Field(i)
-		if !objValueField.IsValid() || !objValueField.CanSet() {
+		fieldPtrValue := reflect.NewAt(fieldValue.Type(), fieldValue.Addr().UnsafePointer())
+		fieldValue = fieldPtrValue.Elem()
+		if !fieldValue.IsValid() || !fieldValue.CanSet() {
 			return fmt.Errorf("%s error: 字段无效或为不可导出类型", injectInfo)
 		}
-
+		fieldValue.Set(reflect.ValueOf(component))
-		objValueField.Set(reflect.ValueOf(component))
 	}
 
 	return nil