這篇文章主要介紹了GoLang職責(zé)鏈模式代碼實(shí)現(xiàn)，職責(zé)鏈模式是一種常用的設(shè)計(jì)模式，可以提高代碼的靈活性與可維護(hù)性，職責(zé)鏈模式將請(qǐng)求和處理分離，可以讓請(qǐng)求在處理鏈中依次經(jīng)過多個(gè)處理者，直到找到能夠處理請(qǐng)求的處理者為止

1. 需求

實(shí)現(xiàn)一個(gè)工具能準(zhǔn)確判斷英雄能秒人的技能傷害！方便開掛時(shí)選擇最優(yōu)技能，直接秒人，有的英雄現(xiàn)如今只有三個(gè)技能，但也不排除之后重做會(huì)有四個(gè)技能，要求實(shí)現(xiàn)簡單上手，易擴(kuò)展！

技能 2 進(jìn)來了
技能 2 滿足條件釋放造成 9000 傷害
技能 3 進(jìn)來了
技能 3 滿足條件釋放造成 10000 傷害
2023/5/10 10:26:31 技能1,傷害7000有點(diǎn)低不太行啊!推薦你換其他技能
2023/5/10 10:26:31 技能1,傷害7000有點(diǎn)低不太行啊!推薦你換其他技能

職責(zé): 判斷能秒人的傷害技能

鏈：技能鏈

Golang實(shí)現(xiàn)職責(zé)鏈模式時(shí)候，因?yàn)闆]有繼承的支持，使用鏈對(duì)象包涵職責(zé)的方式，即：

鏈對(duì)象包含當(dāng)前職責(zé)對(duì)象以及下一個(gè)職責(zé)鏈。
職責(zé)對(duì)象提供接口表示是否能處理對(duì)應(yīng)請(qǐng)求。
職責(zé)對(duì)象提供處理函數(shù)處理相關(guān)職責(zé)。

2. 代碼實(shí)現(xiàn)

1. manager.go

下面是先定義一個(gè)職責(zé)鏈管理器,來幫助每個(gè)對(duì)象判斷它是否符合職責(zé)

package main
import "log"
// 職責(zé)鏈模式
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) // 釋放連招把并且播報(bào)
	}
	if r.successor != nil {
		log.Printf("技能%d,傷害%d有點(diǎn)低不太行啊!推薦你換其他技能\n", skillId, attack)
		return r.successor.HandleAttackRequest(skillId, attack)
	}
	return false
}
func (r *SkillChain) HaveKill(attack int) bool {
	return true
}

2. skill1_manager.go

給英雄技能一對(duì)象實(shí)現(xiàn)對(duì)應(yīng)的職責(zé)

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 進(jìn)來了\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])
}

總結(jié)

職責(zé)鏈模式算是迭代器模式的一個(gè)延伸，里面的思想與迭代器模式有些相似之處。迭代器是把隊(duì)列每個(gè)元素作為輸入，然后用戶自己定義處理邏輯，而職責(zé)鏈?zhǔn)怯脩糁付ǘ鄠€(gè)處理邏輯，處理同一個(gè)輸入，只有滿足條件的那個(gè)處理邏輯才能真正輸出，而其他處理邏輯只是把輸入傳遞給下一個(gè)處理邏輯。

到此這篇關(guān)于GoLang職責(zé)鏈模式分離組合職責(zé)的文章就介紹到這了,更多相關(guān)GoLang職責(zé)鏈模式內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: