首页 > Golang > Go教程

GoLang职责链模式代码实现介绍

来源：脚本之家

时间：2023-05-13 14:24:44 207浏览收藏

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《GoLang职责链模式代码实现介绍》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

1. 需求

实现一个工具能准确判断英雄能秒人的技能伤害！方便开挂时选择最优技能，直接秒人，有的英雄现如今只有三个技能，但也不排除之后重做会有四个技能，要求实现简单上手，易扩展！

技能 2 进来了
技能 2 满足条件释放造成 9000 伤害
技能 3 进来了
技能 3 满足条件释放造成 10000 伤害
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能

职责: 判断能秒人的伤害技能

链：技能链

Golang实现职责链模式时候，因为没有继承的支持，使用链对象包涵职责的方式，即：

链对象包含当前职责对象以及下一个职责链。
职责对象提供接口表示是否能处理对应请求。
职责对象提供处理函数处理相关职责。

2. 代码实现

1. manager.go

下面是先定义一个职责链管理器,来帮助每个对象判断它是否符合职责

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
}

2. skill1_manager.go

给英雄技能一对象实现对应的职责

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
}

3. skill2_manager.go

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
}

4. skill3_manager.go

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
}

5. mian.go

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])
}

总结

职责链模式算是迭代器模式的一个延伸，里面的思想与迭代器模式有些相似之处。迭代器是把队列每个元素作为输入，然后用户自己定义处理逻辑，而职责链是用户指定多个处理逻辑，处理同一个输入，只有满足条件的那个处理逻辑才能真正输出，而其他处理逻辑只是把输入传递给下一个处理逻辑。

今天带大家了解了Lang职责链、责任链的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~

golang Lang职责链责任链

声明：本文转载于：脚本之家如有侵犯，请联系study_golang@163.com删除