Go | 非导出字段反射访问

Notion链接

背景：由于调试需要，需要获取scheduler结构体中的started字段。

type Scheduler interface {
	// Jobs returns all the jobs currently in the scheduler.
	Jobs() []Job
	// NewJob creates a new job in the Scheduler. The job is scheduled per the provided
	// definition when the Scheduler is started. If the Scheduler is already running
	// the job will be scheduled when the Scheduler is started.
	NewJob(JobDefinition, Task, ...JobOption) (Job, error)
	// RemoveByTags removes all jobs that have at least one of the provided tags.
	RemoveByTags(...string)
	// RemoveJob removes the job with the provided id.
	RemoveJob(uuid.UUID) error
	// Shutdown should be called when you no longer need
	// the Scheduler or Job's as the Scheduler cannot
	// be restarted after calling Shutdown. This is similar
	// to a Close or Cleanup method and is often deferred after
	// starting the scheduler.
	Shutdown() error
	// Start begins scheduling jobs for execution based
	// on each job's definition. Job's added to an already
	// running scheduler will be scheduled immediately based
	// on definition. Start is non-blocking.
	Start()
	// StopJobs stops the execution of all jobs in the scheduler.
	// This can be useful in situations where jobs need to be
	// paused globally and then restarted with Start().
	StopJobs() error
	// Update replaces the existing Job's JobDefinition with the provided
	// JobDefinition. The Job's Job.ID() remains the same.
	Update(uuid.UUID, JobDefinition, Task, ...JobOption) (Job, error)
	// JobsWaitingInQueue number of jobs waiting in Queue in case of LimitModeWait
	// In case of LimitModeReschedule or no limit it will be always zero
	JobsWaitingInQueue() int
}
...
type scheduler struct {
	// context used for shutting down
	shutdownCtx context.Context
	// cancel used to signal scheduler should shut down
	shutdownCancel context.CancelFunc
	// the executor, which actually runs the jobs sent to it via the scheduler
	exec executor
	// the map of jobs registered in the scheduler
	jobs map[uuid.UUID]internalJob
	// the location used by the scheduler for scheduling when relevant
	location *time.Location
	// whether the scheduler has been started or not
	started bool
	// globally applied JobOption's set on all jobs added to the scheduler
	// note: individually set JobOption's take precedence.
	globalJobOptions []JobOption
	// the scheduler's logger
	logger Logger

	// used to tell the scheduler to start
	startCh chan struct{}
	// used to report that the scheduler has started
	startedCh chan struct{}
	// used to tell the scheduler to stop
	stopCh chan struct{}
	// used to report that the scheduler has stopped
	stopErrCh chan error
	// used to send all the jobs out when a request is made by the client
	allJobsOutRequest chan allJobsOutRequest
	// used to send a jobs out when a request is made by the client
	jobOutRequestCh chan jobOutRequest
	// used to run a job on-demand when requested by the client
	runJobRequestCh chan runJobRequest
	// new jobs are received here
	newJobCh chan newJobIn
	// requests from the client to remove jobs by ID are received here
	removeJobCh chan uuid.UUID
	// requests from the client to remove jobs by tags are received here
	removeJobsByTagsCh chan []string
}
...

func getSchedulerStartedField(sched gocron.Scheduler) (bool, error) {
    // 1. 使用 reflect.ValueOf() 函数将 gocron.Scheduler 接口转换为反射值。这是反射操作的起点，它创建了一个 reflect.Value 类型的变量，该变量包含了传入接口的运行时表示。
    schedValue := reflect.ValueOf(sched)
    
    // 2. 接口的具体实现可能是指针类型。如果是指针，需要使用 Elem() 方法获取指针指向的实际值。这确保我们能够访问到底层结构体，而不是仅仅操作指针本身。
    if schedValue.Kind() == reflect.Ptr {
        schedValue = schedValue.Elem()
    }
    
    // 3. 这一步检查反射值是否是结构体类型。因为我们要访问的 started 字段应该是结构体的一个成员，所以需要确认我们操作的确实是一个结构体。如果不是，函数返回错误。
    if schedValue.Kind() != reflect.Struct {
        return false, fmt.Errorf("scheduler不是结构体，而是%s", schedValue.Kind())
    }
    
    // 4. 使用 FieldByName 方法通过字段名称 "started" 获取对应的反射字段。这个方法会在结构体的所有字段中查找匹配的名称。
    startedField := schedValue.FieldByName("started")
    
    // 5. IsValid() 方法检查字段是否存在。如果字段不存在，FieldByName 会返回一个无效的 reflect.Value，这时函数返回错误。
    if !startedField.IsValid() {
        return false, fmt.Errorf("无法找到started字段")
    }
    
    // 6. 验证找到的字段确实是布尔类型。这确保我们不会错误地处理其他类型的数据，增加了代码的健壮性。
    if startedField.Kind() != reflect.Bool {
        return false, fmt.Errorf("started字段不是bool类型，而是%s", startedField.Kind())
    }
    
    // 7. 使用unsafe包访问非导出字段，用于绕过 Go 语言的访问控制机制访问非导出字段
    startedPtr := unsafe.Pointer(startedField.UnsafeAddr())
    started := *(*bool)(startedPtr)
    
    return started, nil
}

• 步骤4
  • FieldByName 方法在无法找到指定名称的字段时，不会返回 nil 或抛出错误，而是返回一个特殊的"零值" reflect.Value。
• 步骤5
  • IsValid() 方法用于检查一个 reflect.Value 是否包含有效值。在以下情况下 reflect.Value 被视为无效：
    1. 它是通过零值构造函数 reflect.Value{} 创建的
    2. 它代表一个 nil 接口值或 nil 指针
    3. 它是 FieldByName 在找不到字段时返回的零值
• 步骤7
  • startedField.UnsafeAddr() 获取字段的内存地址
  • unsafe.Pointer(...) 将该地址转换为通用指针类型
  • (*bool)(startedPtr) 将通用指针转换为 bool 类型指针并解引用，获取实际的 bool 值

• Claude 3.7 Sonnet Thinking