文章摘要
这篇文章介绍了如何使用Go语言的职责链模式来分离组合职责，实现判断英雄技能是否能秒人的功能。文章详细讲解了技能判断逻辑的设计和实现，包括技能Manager的实现和职责链的管理。技能Manager通过迭代式的设计，将技能判断逻辑分离出来，使得代码逻辑更清晰，扩展性更好。文章还提到，职责链模式类似于迭代器模式的延伸，通过多个处理逻辑协同工作，实现对同一输入的处理。整篇文章通过具体的代码实现，展示了如何将复杂的技能判断逻辑分解为多个独立的职责，从而提升了代码的可读性和维护性。
目录1. 需求2. 代码实现1. manager.go2. skill1_manager.go3. skill2_manager.go4. skill3_manager.go5. mian.go总结
实现一个工具能准确判断英雄能秒人的技能伤害！方便开挂时选择最优技能，直接秒人，有的英雄现如今只有三个技能，但也不排除之后重做会有四个技能，要求实现简单上手，易扩展！
技能 2 进来了
技能 2 满足条件释放 造成 9000 伤害
技能 3 进来了
技能 3 满足条件释放 造成 10000 伤害
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能职责: 判断能秒人的伤害技能
链：技能链
Golang实现职责链模式时候，因为没有继承的支持，使用链对象包涵职责的方式，即：
链对象包含当前职责对象以及下一个职责链。职责对象提供接口表示是否能处理对应请求。职责对象提供处理函数处理相关职责。下面是先定义一个职责链管理器,来帮助每个对象判断它是否符合职责
package main
import “log”
// 职责链模式
type Manager interface {
HaveKill(attack int) bool // 是否击杀
HandleAttackRequest(skillId int, attack int) bool // 连招
}
// 连招
type SkillChain struct {
Manager
successor *SkillChain
}
func (r *SkillChain) SetSuccessor(m *SkillChain) {
r.successor=m
}
func (r *SkillChain) HandleAttackRequest(skillId int, attack int) bool {
// 伤害是否满足击杀
if r.Manager.HaveKill(attack) {
return r.Manager.HandleAttackRequest(skillId, attack) // 释放连招把并且播报
}
if r.successor !=nil {
log.Printf(“技能%d,伤害%d有点低不太行啊!推荐你换其他技能\n”, skillId, attack)
return r.successor.HandleAttackRequest(skillId, attack)
}
return false
}
func (r *SkillChain) HaveKill(attack int) bool {
return true
}
给英雄技能一对象实现对应的职责
package main
import (
“fmt”
)
const (
Hp=8000
SkillOne=1
SkillTwo=2
SkillThree=3
)
type SkillOneManager struct {
}
func NewSkillOneManager() *SkillChain {
return &SkillChain{
Manager:&SkillOneManager{},
}
}
func (s SkillOneManager) HaveKill(attack int) bool {
return attack>Hp
}
func (s SkillOneManager) HandleAttackRequest(skillId int, attack int) bool {
fmt.Printf(“技能 %d 进来了\n”,skillId)
if skillId==SkillOne{
fmt.Printf(“技能 %d满足条件释放 造成 %d 伤害\n”, skillId, attack)
return true
}
fmt.Printf(“技能 %d 满足条件释放 造成 %d 伤害\n”, skillId, attack)
return false
}
package main
import (
“fmt”
)
type SkillTwoManager struct {}
func NewSkillTwoManager() *SkillChain {
return &SkillChain{
Manager:&SkillTwoManager{},
}
}
func (s SkillTwoManager) HaveKill(attack int) bool {
return attack>Hp
}
func (s SkillTwoManager) HandleAttackRequest(skillId int, attack int) bool {
if skillId==SkillTwo{
fmt.Printf(“技能 %d 满足条件释放 造成 %d 伤害\n”, skillId, attack)
return true
}
fmt.Printf(“技能 %d不 满足条件释放 造成 %d 伤害\n”, skillId, attack)
return false
}
package main
import (
“fmt”
)
type SkillThreeManager struct {
}
func NewSkillThreeManager() *SkillChain {
return &SkillChain{
Manager:&SkillThreeManager{},
}
}
func (s SkillThreeManager) HaveKill(attack int) bool {
return attack>Hp
}
func (s SkillThreeManager) HandleAttackRequest(skillId int, attack int) bool {
if skillId==SkillThree{
fmt.Printf(“技能 %d 满足条件释放 造成 %d 伤害\n”, skillId, attack)
return true
}
fmt.Printf(“技能 %d不 满足条件释放 造成 %d 伤害\n”, skillId, attack)
return false
}
package main
type (
HeroId=int
SkillId=int
Attack=int
)
type DaJi struct {
HeroId HeroId
Name string
SkillInfo map[SkillId]Attack
}
func NewDaJi(skillInfo map[SkillId]Attack) *DaJi {
return &DaJi{HeroId: 1, Name: “妲己”, SkillInfo: skillInfo}
}
func main() {
c1 :=NewSkillOneManager()
c2 :=NewSkillTwoManager()
c3 :=NewSkillThreeManager()
c1.SetSuccessor(c2)
c2.SetSuccessor(c3)
var c Manager=c1
skillInfo :=make(map[SkillId]Attack, 3)
skillInfo[SkillOne]=7000 // 技能一 伤害
skillInfo[SkillTwo]=9000 // 技能一 伤害
skillInfo[SkillThree]=10000 // 大招 伤害
daji:=NewDaJi(skillInfo)
c.HandleAttackRequest(SkillOne, daji.SkillInfo[SkillOne])
c.HandleAttackRequest(SkillTwo, daji.SkillInfo[SkillTwo])
c.HandleAttackRequest(SkillThree, daji.SkillInfo[SkillThree])
}
职责链模式算是迭代器模式的一个延伸，里面的思想与迭代器模式有些相似之处。迭代器是把队列每个元素作为输入，然后用户自己定义处理逻辑，而职责链是用户指定多个处理逻辑，处理同一个输入，只有满足条件的那个处理逻辑才能真正输出，而其他处理逻辑只是把输入传递给下一个处理逻辑。
到此这篇关于GoLang职责链模式分离组合职责的文章就介绍到这了,更多相关GoLang职责链模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
您可能感兴趣的文章:一文详解Golang的中间件设计模式Golang设计模式之组合模式讲解Golang设计模式之单例模式详细讲解