24.总结

9.行为型模式-职责链模式

---

9.1 基础知识

学习难度：3

使用频率：2

总分：5

定义

职责链模式（Chain of Responsibility Pattern）使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

说人话

给对象设置继任者，处理时选择自己处理或者传给继任者处理。

结构图

实现步骤

• 抽象处理者类：定义同为抽象处理者接口类型对象，称之为继任者。定义设置继任者方法，外部传入继任者。定义处理请求抽象方法，传入请求。
• 具体处理者类：继承抽象处理者类。实现处理请求抽象方法，自定义逻辑处理请求或传给继任者处理。
• 客户端：实例化多个具体处理者。设置其中某些具体处理者的继任者。调用具体处理者的处理请求。

说明

职责链模式允许请求者不必知道谁将处理请求，请求会被沿着链传递，直到有一个处理者能够处理它。这样可以使系统更灵活，并且降低了对象之间的耦合度。

---

9.2 模版代码

抽象处理者和具体处理者

// 抽象处理者
abstract class Handler
{
    protected Handler successor;

    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }

    public abstract void HandleRequest(int request);
}

// 具体处理者1
class ConcreteHandler1 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request <= 10)
        {
            Console.WriteLine("具体处理者1 处理请求：" + request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

// 具体处理者2
class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request > 10 && request <= 20)
        {
            Console.WriteLine("具体处理者2 处理请求：" + request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}            

客户端

class Program
{
    static void Main()
    {
        // 创建处理者对象
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();

        // 设置处理者的继任者
        handler1.SetSuccessor(handler2);

        // 发起请求
        int[] requests = { 5, 12, 25, 7, 18 };

        foreach (int request in requests)
        {
            handler1.HandleRequest(request);
            // 具体处理者1 处理请求：5
            // 具体处理者2 处理请求：12
            // 具体处理者1 处理请求：7
            // 具体处理者2 处理请求：18
        }
    }
}

---

9.3 CSharp实践

实践需求

使用职责链模式，实现和领导请假的流程。

请假申请类

// 请假申请类
class LeaveRequest
{
    public string Applicant { get; set; } // 申请人
    public int Days { get; set; }         // 请假天数

    public LeaveRequest(string applicant, int days)
    {
        Applicant = applicant;
        Days = days;
    }
}

抽象处理者和具体处理者

// 抽象处理者
abstract class Approver
{
    protected Approver successor; // 下一个处理者

    public void SetSuccessor(Approver successor)
    {
        this.successor = successor;
    }

    //处理请假请求
    public abstract void ProcessRequest(LeaveRequest request);
}

// 具体处理者 - 组长
class TeamLead : Approver
{
    public override void ProcessRequest(LeaveRequest request)
    {
        if (request.Days <= 2)
        {
            Console.WriteLine($"组长批准 {request.Applicant} 的请假申请，天数：{request.Days}");
        }
        else if (successor != null)
        {
            Console.WriteLine("请假天数较长，无法由组长批准，交由下一级处理者。");
            successor.ProcessRequest(request); // 传递给下一个处理者
        }
        else
        {
            Console.WriteLine($"请假天数太长，没有合适的处理者，申请不予批准。");
        }
    }
}

// 具体处理者 - 经理
class Manager : Approver
{
    public override void ProcessRequest(LeaveRequest request)
    {
        if (request.Days <= 5)
        {
            Console.WriteLine($"经理批准 {request.Applicant} 的请假申请，天数：{request.Days}");
        }
        else if (successor != null)
        {
            Console.WriteLine("请假天数较长，无法由经理批准，交由总经理处理。");
            successor.ProcessRequest(request); // 传递给总经理处理
        }
        else
        {
            Console.WriteLine($"请假天数太长，没有合适的处理者，申请不予批准。");
        }
    }
}

// 具体处理者 - 总经理
class GeneralManager : Approver
{
    public override void ProcessRequest(LeaveRequest request)
    {
        Console.WriteLine($"总经理批准 {request.Applicant} 的请假申请，天数：{request.Days}");
    }
}

客户端

class Program
{
    static void Main()
    {
        // 创建处理者对象
        Approver teamLead = new TeamLead(); // 创建组长处理者
        Approver manager = new Manager(); // 创建经理处理者
        Approver generalManager = new GeneralManager(); // 创建总经理处理者

        // 设置处理者的继任者关系
        teamLead.SetSuccessor(manager); // 组长的继任者是经理
        manager.SetSuccessor(generalManager); // 经理的继任者是总经理

        // 创建请假申请
        LeaveRequest request1 = new LeaveRequest("张三", 1); // 申请1天的请假
        LeaveRequest request2 = new LeaveRequest("李四", 3); // 申请3天的请假
        LeaveRequest request3 = new LeaveRequest("王五", 7); // 申请7天的请假

        // 提交请假申请并让处理者处理
        teamLead.ProcessRequest(request1); // 组长处理请假申请1
        teamLead.ProcessRequest(request2); // 组长处理请假申请2，但需要经过经理审批
        teamLead.ProcessRequest(request3); // 组长处理请假申请3，但需要经过经理和总经理的审批
    }
}

---

9.4 Unity实践

实践需求

使用职责链模式，让狗头，剑圣和薇恩形成三角阵，随机生成一个敌方英雄，让三者的随机一人攻击敌方英雄，假如敌方英雄和己方攻击者英雄相同要传递给下一个攻击者。

英雄处理抽象类和具体英雄处理类

public abstract class HeroHandler : MonoBehaviour
{
    protected Animator animator;

    private void Awake()
    {
        // 获取与英雄相关的Animator组件
        animator = this.gameObject.GetComponent<Animator>();
    }

    protected HeroHandler successor;

    public void SetSuccessor(HeroHandler successor)
    {
        // 设置下一个处理器，即在职责链中的下一个英雄
        this.successor = successor;
    }

    public abstract void HandleRequest(HeroHandler heroHandler);
    // 定义一个抽象方法，用于处理请求的具体逻辑，由具体的英雄子类来实现
}

public class DogHandler : HeroHandler
{
    public override void HandleRequest(HeroHandler heroHandler)
    {
        if (heroHandler.GetType() != this.GetType())
        {
            transform.LookAt(heroHandler.gameObject.transform.position);

            if (animator != null)
            {
                animator.SetTrigger("attack");
            }

            Debug.Log("对象不是我的同类狗头，使用法天象地打你");
        }
        else if (successor != null)
        {
            Debug.Log($"这是我的同类，叫给{successor.name}来打吧");
            successor.HandleRequest(heroHandler);
        }
    }
}

public class VayneHandler : HeroHandler
{
    public override void HandleRequest(HeroHandler heroHandler)
    {
        if (heroHandler.GetType() != this.GetType())
        {
            transform.LookAt(heroHandler.gameObject.transform.position);

            if (animator != null)
            {
                animator.SetTrigger("attack");
            }

            Debug.Log("对象不是我的同类薇恩，使用闪避突袭打你");
        }
        else if (successor != null)
        {
            Debug.Log($"这是我的同类，叫给{successor.name}来打吧");
            successor.HandleRequest(heroHandler);
        }
    }
}

public class YiHandler : HeroHandler
{
    public override void HandleRequest(HeroHandler heroHandler)
    {
        if (heroHandler.GetType() != this.GetType())
        {
            transform.LookAt(heroHandler.gameObject.transform.position);

            if (animator != null)
            {
                animator.SetTrigger("attack");
            }

            Debug.Log("对象不是我的同类剑圣，使用阿尔法突袭打你");
        }
        else if (successor != null)
        {
            Debug.Log($"这是我的同类，叫给{successor.name}来打吧");
            successor.HandleRequest(heroHandler);
        }
    }
}

客户端

public class TestChainOfResponsibilityPattern : MonoBehaviour
{
    // 定义处理请求的不同英雄的处理器
    public HeroHandler dogHandler;
    public HeroHandler yiHandler;
    public HeroHandler vayneHandler;

    // 存储所有英雄的处理器
    public List<HeroHandler> heroHandlers;

    // 存储不同英雄的游戏对象
    public GameObject[] heroGameObjects;

    private GameObject enemy;

    private void Start()
    {
        // 设置处理请求的职责链顺序，这里构建一个循环链
        dogHandler.SetSuccessor(yiHandler);
        yiHandler.SetSuccessor(vayneHandler);
        vayneHandler.SetSuccessor(dogHandler);

        // 将处理器添加到处理器列表中
        heroHandlers.Add(dogHandler);
        heroHandlers.Add(yiHandler);
        heroHandlers.Add(vayneHandler);

        // 启动协程来生成敌人并交给不同的英雄处理
        StartCoroutine(RandomCreateEnemy());
    }

    IEnumerator RandomCreateEnemy()
    {
        while (true)
        {
            // 销毁之前的敌人
            if (enemy != null) Destroy(enemy);

            // 随机选择一个英雄对象生成敌人
            int index = Random.Range(0, heroGameObjects.Length);
            enemy = Instantiate(heroGameObjects[index], GenerateRandomVectorInSquare(-5f, 5f), Quaternion.identity);
            Debug.Log("生成了敌人" + enemy.name);

            // 随机选择一个英雄处理器来处理敌人
            int index2 = Random.Range(0, heroHandlers.Count);
            Debug.Log("交给你来打" + heroHandlers[index2].name);
            heroHandlers[index2].HandleRequest(enemy.GetComponentInChildren<HeroHandler>());

            yield return new WaitForSeconds(1f);

            // 销毁敌人并等待一段时间再生成新的敌人
            if (enemy != null) Destroy(enemy);
            yield return new WaitForSeconds(4f);
        }
    }

    // 生成一个随机位置的三维向量
    Vector3 GenerateRandomVectorInSquare(float min, float max)
    {
        float randomX = Random.Range(min, max);
        float randomZ = Random.Range(min, max);

        Vector3 randomVector = new Vector3(randomX, 0f, randomZ);

        return randomVector;
    }
}

运行结果

---

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com