Go语言设计模式实战：状态模式详解

在软件开发中，如何有效管理对象的不同状态及其相应行为是一个常见挑战。状态模式（State Pattern）作为一种行为设计模式，提供了一种优雅的解决方案。通过将状态与行为分离，状态模式允许对象在其内部状态改变时动态调整其行为。本文将深入探讨 Go 语言中的状态模式，结合实际案例——直播计划，帮助开发者理解如何运用这一模式提高代码的可读性和维护性。

👉 点击查看《Go语言设计模式实战》系列文章目录

《Go语言设计模式实战》以 Go 语言为示例，详细解读编程开发中常见设计模式的实现，涵盖创建型、结构型和行为型设计模式。每篇文章通过具体的 Go 代码展示模式的实际应用，帮助读者深入理解设计模式的核心原理及其在软件开发中的最佳实践。以下是该系列文章的全部内容：

什么是状态模式？

状态模式（State Pattern）是一种重要的行为设计模式，它允许对象在其内部状态发生变化时改变其行为。这种模式适用于那些实现方法会根据自身状态而变化的对象。状态模式的核心思想是将状态的相关行为封装到具体的状态类中，从而避免使用复杂的条件语句（如 if…else…）来管理状态转移。

状态模式的应用场景

以一个主播的直播计划为例，直播的状态可以有多个，如“未开始”、“直播中”、“已结束”和“已取消”。在不同状态下，主播可以执行的操作（如开始直播、停止直播和取消直播）也是不同的。通过使用状态模式，可以有效管理这些状态及其对应的行为，避免冗长且难以维护的条件判断代码。

直播计划的状态示例

未开始状态：
- Start 方法：将状态更改为“直播中”。
- Stop 方法：返回“执行失败，该直播未开始”。
- Cancel 方法：返回“已取消”。
直播中状态：
- Start 方法：返回“执行失败，该直播已开始”。
- Stop 方法：将状态更改为“已结束”。
- Cancel 方法：返回“执行失败，该直播已开始”。
已结束状态：
- Start 方法：返回“执行失败，该直播已结束”。
- Stop 方法：返回“执行失败，该直播已结束”。
- Cancel 方法：返回“执行失败，该直播已结束”。
已取消状态：
- Start 方法：返回“执行失败，该直播已取消”。
- Stop 方法：返回“执行失败，该直播已取消”。
- Cancel 方法：返回“执行失败，该直播已取消”。

状态模式的实现

下面是使用状态模式实现直播计划的示例代码，清晰地展示了如何定义状态接口、具体状态类和上下文类。

package main

import "fmt"

// 状态接口
type Stater interface {
	Start(*Live)
	Stop(*Live)
	Cancel(*Live)
}

// 直播计划的具体状态——未开始
type StateNotStarted struct{}

func (s *StateNotStarted) Start(l *Live) {
	fmt.Println("Do Start:", l.ID+"直播中")
	l.SetState(&StateLiving{}) // 切换状态
}

func (s *StateNotStarted) Stop(l *Live) {
	fmt.Println("Do Stop:", l.ID+"执行失败，该直播未开始")
}

func (s *StateNotStarted) Cancel(l *Live) {
	fmt.Println("Do Cancel:", l.ID+"已取消")
	l.SetState(&StateCanceled{}) // 切换状态
}

// 直播计划的具体状态——直播中
type StateLiving struct{}

func (s *StateLiving) Start(l *Live) {
	fmt.Println("Do Start:", l.ID+"执行失败，该直播已开始")
}

func (s *StateLiving) Stop(l *Live) {
	fmt.Println("Do Stop:", l.ID+"已结束")
	l.SetState(&StateEnded{}) // 切换状态
}

func (s *StateLiving) Cancel(l *Live) {
	fmt.Println("Do Cancel:", l.ID+"执行失败，该直播已开始")
}

// 直播计划的具体状态——已结束
type StateEnded struct{}

func (s *StateEnded) Start(l *Live) {
	fmt.Println("Do Start:", l.ID+"执行失败，该直播已结束")
}

func (s *StateEnded) Stop(l *Live) {
	fmt.Println("Do Stop:", l.ID+"执行失败，该直播已结束")
}

func (s *StateEnded) Cancel(l *Live) {
	fmt.Println("Do Cancel:", l.ID+"执行失败，该直播已结束")
}

// 直播计划的具体状态——已取消
type StateCanceled struct{}

func (s *StateCanceled) Start(l *Live) {
	fmt.Println("Do Start:", l.ID+"执行失败，该直播已取消")
}

func (s *StateCanceled) Stop(l *Live) {
	fmt.Println("Do Stop:", l.ID+"执行失败，该直播已取消")
}

func (s *StateCanceled) Cancel(l *Live) {
	fmt.Println("Do Cancel:", l.ID+"执行失败，该直播已取消")
}

// 直播计划
type Live struct {
	ID           string
	CurrentState Stater
}

func (l *Live) Start() {
	l.CurrentState.Start(l)
}

func (l *Live) Stop() {
	l.CurrentState.Stop(l)
}

func (l *Live) Cancel() {
	l.CurrentState.Cancel(l)
}

func (l *Live) SetState(s Stater) {
	l.CurrentState = s
}

func main() {
	var state Stater

	// 未开始状态
	live := &Live{ID: "001"}
	fmt.Println("Live" + live.ID + "当前状态：未开始")
	state = &StateNotStarted{}
	live.SetState(state)
	live.Start()
	live.Stop()
	live.Cancel()
	fmt.Println("-----------")

	// 直播中状态
	live = &Live{ID: "002"}
	fmt.Println("Live" + live.ID + "当前状态：直播中")
	state = &StateLiving{}
	live.SetState(state)
	live.Start()
	live.Stop()
	live.Cancel()
	fmt.Println("-----------")

	// 已结束状态
	live = &Live{ID: "003"}
	fmt.Println("Live" + live.ID + "当前状态：已结束")
	state = &StateEnded{}
	live.SetState(state)
	live.Start()
	live.Stop()
	live.Cancel()
	fmt.Println("-----------")

	// 已取消状态
	live = &Live{ID: "004"}
	fmt.Println("Live" + live.ID + "当前状态：已取消")
	state = &StateCanceled{}
	live.SetState(state)
	live.Start()
	live.Stop()
	live.Cancel()
}

通过上述代码的执行，可以观察到不同状态下的直播计划如何响应不同操作的输出，确保了逻辑的清晰性和可维护性。

Live001当前状态：未开始
Do Start: 001直播中
Do Stop: 001执行失败，该直播未开始
Do Cancel: 001已取消
-----------
Live002当前状态：直播中
Do Start: 002执行失败，该直播已开始
Do Stop: 002已结束
Do Cancel: 002执行失败，该直播已开始
-----------
Live003当前状态：已结束
Do Start: 003执行失败，该直播已结束
Do Stop: 003执行失败，该直播已结束
Do Cancel: 003执行失败，该直播已结束
-----------
Live004当前状态：已取消
Do Start: 004执行失败，该直播已取消
Do Stop: 004执行失败，该直播已取消
Do Cancel: 004执行失败，该直播已取消