当前位置：首页 > news >正文

设计模式-行为型

news 文章来源：https://blog.csdn.net/qiuxuewei2012/article/details/129198902 2025/5/9 9:29:49

设计模式-行为型

行为型设计模式主要用于软件运行时复杂的流程控制。包含：模板方法模式、策略模式、命令模式、职责链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式和解释器模式

模板方法模式

在软件设计时，很多时候系统的运行流程都是确定的，在整个流程中，可能只有部分环节的具体实现是有差别的，这时我们就可以使用模板方法模式，其具体定义为：定义一个操作流程中的算法骨架，将部分算法环节的实现延迟到子类中，使子类可以在不改变算法骨架的前提下对特定步骤进行定制。

以职员的工作流程为例：

class Management {func clockIn() {print("上班")}func working() {print("工作")}func clockOut() {print("下班")}func start() {clockIn()working()clockOut()}
}

无论对于任何岗位的职员，这个流程都不变，对于不同的岗位不同的是具体的工作内容，例如添加一位工程师，以模板方法模式设计：

重构后

...
class Engineer: Management {override func working() {print("软件设计")}
}

使用模板方法模式设计后，代码的复用性更强，但是因为子类修改了父类的方法的实现，有悖里氏替换原则，因此在选择时需要根据具体场景进行分析。

策略模式

策略模式核心原则是定义一系列算法，将每个算法独立封装，使用者可以灵活的进行选择替换。

例如现实生活中到某地的出行方式有很多种，可以灵活选择：出租车、公交车、地铁、自行车等，需要根据路程远近和交通状况灵活的选择，这就是一种策略模式。

重构后

protocol Transport {func toDestination()
}
class Taxi: Transport {func toDestination() {print("出租车")}
}
class Bus: Transport {func toDestination() {print("公交车")}
}
class Subway: Transport {func toDestination() {print("地铁")}
}
class Action {var destination: Stringvar transport: Transportinit(destination: String, transport: Transport) {self.destination = destinationself.transport = transport}func go() {self.transport.toDestination()}
}
let action = Action(destination: "北京", transport: Subway())
action.go()

通过策略模式，不同的Action对象调用go方法很容易根据场景实现不同的行为。

命令模式

命令模式的核心是将请求封装为对象，使得请求的发起与执行分开，发起方和执行方通过命令进行交互。
以教务系统为例，

struct Teacher {var name: Stringvar subject: Stringfunc log() {print("\(name) + \(subject)")}
}
class School {var teachers = [Teacher]()func addTeacher(name: String, subject: String) {teachers.append(Teacher(name: name, subject: subject))}func deleteTeacher(name: String) {teachers = teachers.filter {$0.name != name}}func show() {for teacher in teachers {teacher.log()}}
}
let school = School()
school.addTeacher(name: "学伟", subject: "计算机")
school.addTeacher(name: "张三", subject: "体育")
school.addTeacher(name: "李四", subject: "数学")
school.show()
school.deleteTeacher(name: "李四")
school.show()

其中，School 提供了展示所有教师信息的方法，也提供了添加和删除教师的方法，通过这种方式对教师的操作难以维护，可以使用命令模式对其重构，将添加和删除教师、展示所有教师的逻辑都封装成一种命令。

重构后

struct Teacher {var name: Stringvar subject: Stringfunc log() {print("\(name) + \(subject)")}
}
class SchoolCommand {enum ActionType {case addcase deletecase show}var type: ActionTypevar name: String?var subject: String?init(type: ActionType, name: String? = nil, subject: String? = nil) {self.type = typeself.name = nameself.subject = subject}
}
class School {var teachers = [Teacher]()func runCommand(command: SchoolCommand) {switch command.type {case .add:addTeacher(name: command.name!, subject: command.subject!)case .delete:deleteTeacher(name: command.name!)case .show:show()}}private func addTeacher(name: String, subject: String) {teachers.append(Teacher(name: name, subject: subject))}private func deleteTeacher(name: String) {teachers = teachers.filter {$0.name != name}}private func show() {for teacher in teachers {teacher.log()}}
}
let school = School()
school.runCommand(command: SchoolCommand(type: .add, name: "学伟", subject: "计算机"))
school.runCommand(command: SchoolCommand(type: .add, name: "张三", subject: "体育"))
school.runCommand(command: SchoolCommand(type: .add, name: "李四", subject: "数学"))
school.runCommand(command: SchoolCommand(type: .show))
school.runCommand(command: SchoolCommand(type: .delete,name: "李四"))
school.runCommand(command: SchoolCommand(type: .show))

使用命令模式重构后，对于 School 的操作都通过命令 SchoolCommand 触发，代码扩展性更强，且命令可以作为对象直接被存储、传输、重复和撤销，在某些场景下会非常有用。

职责链模式

一个请求被发出，从低层向高层依次寻找可以处理此请求的对象，直到找到处理者才结束责任链。

重构后

struct Requet {enum Level {case lowcase middlecase high}var level: Level
}
protocol Handler {var nextHandler: Handler? { get }func handlerRequest(request: Requet)func nextHanderDo(request: Requet)
}
extension Handler {func nextHanderDo(request: Requet) {if let nextHandler = nextHandler {nextHandler.handlerRequest(request: request)} else {print("无法处理请求")}}
}
class HighHandler: Handler {var nextHandler: Handler? = nilfunc handlerRequest(request: Requet) {if request.level == .high {print("HighHandler 处理请求")} else {nextHanderDo(request: request)}}
}
class MiddleHandler: Handler {var nextHandler: Handler? = HighHandler()func handlerRequest(request: Requet) {if request.level == .middle {print("MiddleHandler 处理请求")} else {nextHanderDo(request: request)}}
}
class LowHandler: Handler {var nextHandler: Handler? = MiddleHandler()func handlerRequest(request: Requet) {if request.level == .low {print("LowHandler 处理请求")} else {nextHanderDo(request: request)}}
}
class Chain: Handler {var nextHandler: Handler? = LowHandler()func handlerRequest(request: Requet) {nextHandler?.handlerRequest(request: request)}
}
var request = Requet(level: .low)
Chain().handlerRequest(request: request)
request = Requet(level: .middle)
Chain().handlerRequest(request: request)
request = Requet(level: .high)
Chain().handlerRequest(request: request)

外界只需传入指定等级的请求，责任链内部即可根据等级选择相应的处理逻辑。

责任链模式的核心是将请求发送到责任链上，链上的每一个处理者可以根据实际情况决定是否处理此请求，如果不能处理则将请求继续向上发送，直到被某个处理者处理或者没有处理者为止。这种结构可以灵活地向责任链中增加或删除处理者，对于不同种类的请求，发出方只需要将其发送到责任链上，不需要关心具体被哪一个处理者处理。降低了对象间的耦合性，并且使责任的分担更加清晰。

状态模式

状态模式的核心是：当控制一个对象行为的状态转换过于复杂时，把状态处理的逻辑分离出到单独的状态类中。
在软件设计中，对象在不同的情况下会表现出不同的行为，被称为有状态的对象。影响对象行为的属性被称为状态，影响对象行为的属性被称为状态。对有状态的对象进行编程时，使用状态设计模式可以使代码的内聚性更强。

重构后

class StateContent {var currentState: Stateinit(_ currentState: State) {self.currentState = currentState}func changeState(curState: State) {self.currentState = curState}
}
protocol State {func info()func doAction(content: StateContent)
}
class Open: State {func info() {print("开灯")}func doAction(content: StateContent) {content.currentState = Open()}
}
class Close: State {func info() {print("关灯")}func doAction(content: StateContent) {content.currentState = Close()}
}
class LightButton {var stateContent: StateContentinit(state: State) {self.stateContent = StateContent(state)}func change(state: State) {self.stateContent.changeState(curState: state)}func log() {stateContent.currentState.info()}
}
let light = LightButton(state: Close())
light.log()
light.change(state: Open())
light.log()

其中 StateContent 定义了状态的上下文，用来维护当前开关的状态。而 Open 、Close 则是对状态的封装。

观察者模式

观察者模式又被称为发布-订阅模式，在观察者模式中，一个对象发生变化会通知到所有依赖它的对象，依赖它的对象可以根据情况进行自身行为的更改。
在iOS开发中，通知中心和键值监听系统的实现都使用了观察者模式。如下代码通过实现一个简易的通知中心演示观察者模式

重构后

typealias XWNotificationCallback = (XWNotification) -> Void
struct XWNotification {var name: Stringvar data: Stringvar object: AnyObject?func info() {print("name: \(name), data: \(data), object: \(String(describing: object))")}
}
struct XWObsever {var object: AnyObjectvar callback: XWNotificationCallback
}
class XWNotificationCenter {static let shared = XWNotificationCenter()private var observers = Dictionary<String, Array<XWObsever>>()private init() {}func addObserver(name: String, object: AnyObject, callback: @escaping XWNotificationCallback) {let observer = XWObsever(object: object, callback: callback)if var curObserver = observers[name] {curObserver.append(observer)} else {observers[name] = [observer]}}func removeObserver(name: String) {observers.removeValue(forKey: name)}func postNotification(notification: XWNotification) {if let array = observers[notification.name] {var postNotification = notificationfor observer in array {postNotification.object = observer.objectobserver.callback(postNotification)}}}
}
let key = "KEY"
XWNotificationCenter.shared.addObserver(name: key, object: "监听者A" as AnyObject) { noti innoti.info()
}
//XWNotificationCenter.shared.removeObserver(name: key)
XWNotificationCenter.shared.postNotification(notification: XWNotification(name: key, data: "通知内容"))

以上就是一个简易通知中心的实现，当添加了监听之后，一旦通知被发出，回调方法就会立刻执行，对于相同名称的通知，可以添加多个观察者。

中介者模式

中介者模式的核心是将网状的对象交互结构改为星形结构，即所有的对象都与一个中介者进行交互。使用中介者模式可以使原本耦合性很强的对象间的耦合变得松散，提高系统的灵活性和扩展性。

如下代码演示了网状的对象交互结构

class ServerA {func handleClientA() {print("ServerA 处理 ClientA 的请求")}func handleClientB() {print("ServerA 处理 ClientB 的请求")}
}
class ServerB {func handleClientA() {print("ServerB 处理 ClientA 的请求")}func handleClientB() {print("ServerB 处理 ClientB 的请求")}
}
class ClientA {func requestServerA() {ServerA().handleClientA()}func requestServerB() {ServerB().handleClientA()}
}
class ClientB {func requestServerA() {ServerA().handleClientB()}func requestServerB() {ServerB().handleClientB()}
}
let clientA = ClientA()
clientA.requestServerA()
clientA.requestServerB()
let clientB = ClientB()
clientB.requestServerA()
clientB.requestServerB()

如上所述，两个客户端可以分别与服务端进行交互，有时客户端也可以点对点的与另外的客户端进行交互，这样会使系统的结构更加复杂，可以通过中介者模式统一客户端与服务端的交互逻辑

重构后

class ServerA {func handleClientA() {print("ServerA 处理 ClientA 的请求")}func handleClientB() {print("ServerA 处理 ClientB 的请求")}
}
class ServerB {func handleClientA() {print("ServerB 处理 ClientA 的请求")}func handleClientB() {print("ServerB 处理 ClientB 的请求")}
}
class ClientA {}
class ClientB {}
class Mediator {static func handler(client: AnyObject, server: AnyObject) {if client is ClientA {if server is ServerA {ServerA().handleClientA()} else {ServerB().handleClientA()}} else {if server is ServerA {ServerA().handleClientB()} else {ServerB().handleClientB()}}}
}
let clientA = ClientA()
let clientB = ClientB()
let serverA = ServerA()
let serverB = ServerB()
Mediator.handler(client: clientA, server: serverA)
Mediator.handler(client: clientA, server: serverB)
Mediator.handler(client: clientB, server: serverA)
Mediator.handler(client: clientB, server: serverB)

重构后客户端相关类中无须知道服务端具体的实现细节，中介者统一封装了这些逻辑。

迭代器模式

软件设计中，很多对象都是以聚合的方式组成的，或者其内部包含集合类型的数据，在访问对象时，通常需要通过遍历的方式获取到其中的各个元素。这样，如果对象内部组合的方式产生了变化就必须对源码进行修改。

迭代器模式的核心是提供一个对象来访问聚合对象中的一系列数据，不暴露聚合对象内部的具体实现，这样即保证了类的安全性，也将内部的集合遍历逻辑与聚合对象本身进行了分离。

重构后

protocol Iterator {associatedtype ObjectTypevar cursor: Int { get }func next() -> ObjectType?func reset()
}
class School: Iterator {private var teachers = [String]()typealias ObjectType = Stringvar cursor: Int = 0func next() -> String? {if cursor < teachers.count {let teacher = teachers[cursor]cursor += 1return teacher} else {return nil}}func reset() {cursor = 0}func addTeacher(name: String) {teachers.append(name)}
}
let school = School()
school.addTeacher(name: "学伟")
school.addTeacher(name: "小王")
school.addTeacher(name: "乔布斯")
while let teacher = school.next() {print(teacher)
}
print("遍历完成")

外界对 School 内部的数组是不感知的，使用迭代器模式可以很好的对内部实现进行封闭，外部除了通过类中暴露的函数来操作 teachers 数组外，不能直接操作。
在Swift标准库中，可以直接使用官方迭代器协议 IteratorProtocol 。

访问者模式

当数据的类型固定，但对其访问的操作相对灵活时，可以采用访问者模式对软件系统进行设计。访问者模式的核心是将数据的处理方式从数据结构中分离出来，之后可以方便地对数据的处理方法进行扩展。
举一个现实生活中应用访问者模式的例子：作为一种数据，不同的角色对其访问会有不同的行为表现，对于景区门票这一数据，作为游客需要购买，作为验票员需要验票，这种场景：

重构后

struct Ticket {var name: String
}
protocol Visitor {func visit(ticket: Ticket)
}
class Tourist: Visitor {func visit(ticket: Ticket) {print("游客购买\(ticket.name)")}
}
class Guard: Visitor {func visit(ticket: Ticket) {print("检票员检查了\(ticket.name)")}
}
let ticket = Ticket(name: "公园门票")
let tourist = Tourist()
tourist.visit(ticket: ticket)
let guarder = Guard()
guarder.visit(ticket: ticket)

如上，不同角色对门票的操作分别封装在了独立的类中，这使之后新增行为变得非常容易，例如财务人员对门票价格进行核对等。

备忘录模式

备忘录模式的定义：在不破坏封装性的前提下，对一个对象的状态进行保存，在需要时，可以方便地恢复到原来保存的状态，备忘录模式又被称为快照模式。
从功能上讲，备忘录模式与命令模式有许多相似之处，都是提供了一种恢复状态的机制；不同的是，命令模式是将操作封装成命令，命令可以回滚，备忘录模式则是存储对象某一时刻的状态，可以将状态进行重置。
例如，很多应用都提供了用户自定义偏好设置的功能，偏好设置的保存与重置可以采用备忘录模式实现。

重构后

protocol MementoProtocol {func allKeys() -> [String]func valueForKey(key: String) -> Anyfunc setValue(value: Any, key: String)
}
class Setting: MementoProtocol {var setting1 = falsevar setting2 = falsefunc allKeys() -> [String] {return ["setting1", "setting2"]}func valueForKey(key: String) -> Any {switch key {case "setting1":return setting1case "setting2":return setting2default:return ""}}func setValue(value: Any, key: String) {switch key {case "setting1":setting1 = value as? Bool ?? falsecase "setting2":setting2 = value as? Bool ?? falsedefault:print("key: \(key) 设置错误")}}func show() {print("setting1: \(setting1) ++ setting2: \(setting2)")}
}
class MementoManager {var dictionary = [String: [String: Any]]()func saveState(obj: MementoProtocol, stateName: String) {var dict = [String: Any]()for key in obj.allKeys() {dict[key] = obj.valueForKey(key: key)}dictionary[stateName] = dict}func resetState(obj: MementoProtocol, stateName: String) {if let dict = dictionary[stateName] {for kv in dict {obj.setValue(value: kv.value, key: kv.key)}}}
}
var setting = Setting()
let manager = MementoManager()
setting.setting1 = true
setting.setting2 = true
manager.saveState(obj: setting, stateName: "vip")
setting.setting2 = false
manager.saveState(obj: setting, stateName: "super")
setting.show()
manager.resetState(obj: setting, stateName: "vip")
setting.show()
manager.resetState(obj: setting, stateName: "super")
setting.show()

MementoManager 是一个快照管理类，可以将任何符合 MementoProtocol 协议的对象进行快照保存。一个对象可以保存多个快照，在需要时可以方便地恢复到某个快照。有存档机制的软件可以按照备忘录设计模式的思路实现。

解释器模式

定义一种简洁的语言，通过实现一个解释器来对语言进行解析，从而实现逻辑。
正则表达式和iOS开发中用于自动布局的 VFL（Visual Format Language）是对解释器模式的应用。

例如，在软件中的页面路由跳转可以采用解释器模式进行设计。

重构后

class Interpreter {static func handler(string: String) {let proto = string.components(separatedBy: "://")if let pro = proto.first {print("路由协议: \(pro)")if proto.count > 1, let last = proto.last {let path = last.split(separator: "?", maxSplits: 2, omittingEmptySubsequences: true)if let pathFirst = path.first {print("路由路径: \(pathFirst)")if path.count > 1, let param = path.last {print("路由参数: \(param)")}}}}}
}
Interpreter.handler(string: "http://www.xxx.com?key=value")

此类用于解析某逻辑的设计模式即解释器模式的应用。

总结

模板方法模式：定义算法骨架的前提下允许对关键环节的算法实现做修改
策略模式：定义一系列方便切换的算法实现
命令模式：将操作封装为命令对象
责任链模式：通过责任链对请求进行处理，隐藏处理请求的对象细节
状态模式：将变化的属性封装为状态对象进行统一管理
观察者模式：通过监听的方式处理对象间的交互逻辑
中介者模式：通过定义中介者来将网状结构的逻辑改为星状结构
迭代器模式：提供一种访问对象内部集合数据的接口
访问者模式：将数据的操作与数据本身分离
备忘录模式：通过快照的方式存储对象的状态
解释器模式：通过编写解释器对自定义的简单语言进行解析，从而实现逻辑

设计模式-行为型

模板方法模式

重构后

策略模式

重构后

命令模式

重构后

职责链模式

重构后

状态模式

重构后

观察者模式

重构后

中介者模式

重构后

迭代器模式

重构后

访问者模式

重构后

备忘录模式

重构后

解释器模式

重构后

总结

相关文章：