责任链设计模式的场景
问题
这里我们以一个机器师傅为例子，每个师傅他的经验技能都是不一样的，有些人比较熟练，有些人比较生手，那么我们怎么保证，当订单来了的时候，找到最合适师傅去处理这个任务呢？此时，可以使用责任链设计模式。
解决方案
我们把所有的工程师分为四种不同的等级：只是加油的、初级、学徒和熟练的工程师。每个人都有属于自己的技能等级的标志，相同等级的人归为一个组，每一个组都有可能有更高级别的技能组存在（当然，如果是最高技能的那个组，那就没有更高级别的组了）。这样子分配之后，我们模拟在一个店里面，现在有一个任务，那么，我们应该如何执行呢？按照责任链设计模式，应该先找最低级别的技能组，寻找是否有人能够解决，如果不能，继续网下一个级别寻找，直到找到人去处理任务，或者认为店里面已经没人能够处理任务了。
好，基本情况介绍到这里，下面进行代码拆解。。。。。
这是一条完美的分割线
首先我们定义一个技能表
/// 技能表
///
/// - OilChangeOnly: 只是加油的
/// - junior: 初级
/// - Apprentice: 学徒
/// - MasterMechanic: 熟练
enum Skill: Int {
case OilChangeOnly = 1, junior, Apprentice, MasterMechanic
}
接下来，我们定义一个工作类,工作类里面包含了需要的技能、工作名称和是否完成等属性。
/// 工作
class Job {
let minimumSkillSet: Skill
let name: String
var completed: Bool = false
init(minimumSkillSet: Skill, name: String) {
self.minimumSkillSet = minimumSkillSet
self.name = name
}
}
有了工作，怎么能少得了干活的机器呢？同样的，这个机器拥有技能、名称和是否在忙等属性，并且他有一个去执行工作的方法，具体，请看代码.....
class Mechanic {
let skill: Skill
var name: String
var isBusy: Bool = false
init(skill: Skill, name: String) {
self.skill = skill
self.name = name
}
func performJob(job: Job) -> Bool {
//该技能不在此机器的工作范围或者该机器在忙
if job.minimumSkillSet.rawValue > self.skill.rawValue || isBusy == true {
assert(false, "This mechanic is either busy or insufficiently skilled for this job, he should have never been asked to perform it, there is something wrong in the chain of responsibility")
}else {
isBusy = true
print("\(name) with skill set \(skill) has started to do \(job.name)")
job.completed = true
return true
}
}
}
为了将拥有同样技能的机器分类，我们再定义一个叫机器组的类，让他来管理所有拥有相同技能的机器。功能，看代码你就懂了，哈哈
class MechanicSkillGroup {
var mechanics: [Mechanic]
var nextLevel: MechanicSkillGroup?
var skill: Skill
init(skill: Skill, mechanics: [Mechanic], nextLevel: MechanicSkillGroup?) {
self.mechanics = mechanics
self.skill = skill
self.nextLevel = nextLevel
}
func performJobOrPassItUp(job: Job) -> Bool {
//当前工作组的机器无法满足功能
if job.minimumSkillSet.rawValue > skill.rawValue || mechanics.filter({$0.isBusy == false}).count == 0{
//寻找下一个机器组工作
if let nextLevel = nextLevel {
return nextLevel.performJobOrPassItUp(job: job)
}else {
print("No one is aavailable to do this job")
return false
}
}else {
//不忙又满足技能要求的，随便找一个工作就可以了
if let firstAvailavbleMechanic = mechanics.filter({$0.isBusy == false}).first {
return firstAvailavbleMechanic.performJob(job: job)
}
assert(false, "This should never be reached since our if-else statment is fully exhaustive. You cannot have both all mechanics busy and an available mechanic within one skill group")
}
}
}
最后，我们模拟一个商店类：
class Shop {
private var firstMechanics: MechanicSkillGroup
init(firstMechanics: MechanicSkillGroup) {
self.firstMechanics = firstMechanics
}
@discardableResult
func performJob(job: Job) -> Bool {
return firstMechanics.performJobOrPassItUp(job: job)
}
}
好了，基本的准备，我们都有了，下面我们来测试一下：
func chainOfResponsibilityTestFunction() {
/// 获得熟练的工程师
///
/// - Returns: 熟练的工程师
func masterMechanics() -> MechanicSkillGroup {
let steve = Mechanic(skill: .MasterMechanic, name: "Steve Frank")
let joe = Mechanic(skill: .MasterMechanic, name: "Joe Alison")
let jack = Mechanic(skill: .MasterMechanic, name: "Jack Ryan")
let brian = Mechanic(skill: .MasterMechanic, name: "Drake Jin")
return MechanicSkillGroup(skill: .MasterMechanic, mechanics: [steve, joe, jack, brian], nextLevel: nil)
}
/// 获得学徒工程师
///
/// - Returns: 学徒工程师
func apprenticeMechanics() -> MechanicSkillGroup {
let tyson = Mechanic(skill: .Apprentice, name: "Tyson Trup")
let tina = Mechanic(skill: .Apprentice, name: "Tina Bernard")
let bryan = Mechanic(skill: .Apprentice, name: "Bryan Tram")
let lin = Mechanic(skill: .Apprentice, name: "Lin Young")
return MechanicSkillGroup(skill: .Apprentice, mechanics: [tyson, tina, bryan, lin], nextLevel: masterMechanics())
}
/// 获得初级工程师
///
/// - Returns: 初级工程师
func juniorMechanics() -> MechanicSkillGroup {
let ken = Mechanic(skill: .junior, name: "ken Hudson")
let matt = Mechanic(skill: .junior, name: "Matt Lowes")
let sandeep = Mechanic(skill: .junior, name: "Sandeep Shenoy")
let tom = Mechanic(skill: .junior, name: "Tom Berry")
return MechanicSkillGroup(skill: .junior, mechanics: [ken, matt, sandeep, tom], nextLevel: apprenticeMechanics())
}
/// 获得只有石油改变工程师
///
/// - Returns: 只有石油改变工程师
func oilChangeOnlyesMechanics() -> MechanicSkillGroup {
let grant = Mechanic(skill: .OilChangeOnly, name: "Grant Hughes")
return MechanicSkillGroup(skill: .OilChangeOnly, mechanics: [grant], nextLevel: juniorMechanics())
}
//建造虚拟商店
let shop = Shop(firstMechanics: oilChangeOnlyesMechanics())
let jobs = [Job(minimumSkillSet: .junior, name: "Windshield Wiper"),
Job(minimumSkillSet: .Apprentice, name: "Light Bulb Change"),
Job(minimumSkillSet: .Apprentice, name: "Battery Replacement"),
Job(minimumSkillSet: .OilChangeOnly, name: "General Oil Change"),
Job(minimumSkillSet: .OilChangeOnly, name: "General Oil Change"),
Job(minimumSkillSet: .OilChangeOnly, name: "General Oil Change"),
Job(minimumSkillSet: .OilChangeOnly, name: "General Oil Change"),
Job(minimumSkillSet: .MasterMechanic, name: "Timing Belt Replacement"),
Job(minimumSkillSet: .junior, name: "Brake Pads Replacement")]
for job in jobs {
shop.performJob(job: job)
}
}
下面我们来看看打印信息：
image.png
所有的工作，都有序的进行，但你会发现，一些加油这种小事情，有可能让拥有junior技能的机器去干活，这正是责任链设计模式特点，他是可以很好的分配你的工作资源，更合理的利用你的资源，在初级都在忙的情况下，他会去找更高级的人去干活，而不是让更高级的人闲着。
好了，责任链设计模式就介绍到这里吧，有疑问的欢迎咨询......
对了，如果你喜欢看英文，欢迎点开这个链接英文原文
网友评论