责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，用于将一个任务连续传递给多个处理器直到被处理为止。在 Swift 中，可以使用类来实现责任链模式。

我们可以实现一个处理销售订单的责任链，有以下三种处理器：

• 销售经理（SalesManager）：处理订单金额范围在0到1000之间的订单。
• 财务部门（FinanceDepartment）：处理订单金额范围在1000到5000之间的订单。
• 总经理（GeneralManager）：处理订单金额超过5000的订单。

下面是 Swift 中责任链模式的实现：

protocol OrderHandler {
    var next: OrderHandler? {get set}
    func handleOrder(amount: Double)
}

class SalesManager: OrderHandler {
    var next: OrderHandler?
    func handleOrder(amount: Double) {
        if amount < 100 {
            print("小职员 可以已经处理 价值 \(amount) 的货物")
        } else {
            next?.handleOrder(amount: amount)
        }
    }
}

class FinanceDepartment: OrderHandler {
    var next: OrderHandler?
    func handleOrder(amount: Double) {
        if amount < 1000 {
            print("财务总监 可以已经处理 价值 \(amount) 的货物")
        } else {
            next?.handleOrder(amount: amount)
        }
    }
}

class GeneralManager: OrderHandler {
    var next: OrderHandler?
    func handleOrder(amount: Double) {
        if amount < 10000 {
            print("总经理 可以已经处理 价值 \(amount) 的货物")
        } else {
            print("没有人能处理这个 货物")
        }
    }
}

调用方式

 		let salesManager = SalesManager()
        let financeDepartment = FinanceDepartment()
        let generalManager = GeneralManager()
        
        salesManager.next = financeDepartment
        financeDepartment.next = generalManager
        generalManager.next = nil
        
        financeDepartment.handleOrder(amount: 100.0)
        financeDepartment.handleOrder(amount: 20000.0)

在上面的代码中，我们定义了一个 OrderHandler 协议，该协议包含一个 handleOrder(amount:) 方法和一个可选属性 next，用于构建责任链。对于每个订单，可以逐一调用责任链上的每个处理器，直到订单得到处理为止。

客户端操作如下：

1. 创建销售经理（SalesManager）、财务部门（FinanceDepartment）和总经理（GeneralManager）对象，并设置下一个处理器。
2. 调用销售经理处理订单的方法。
3. 根据订单金额，逐一调用责任链上的处理器，直到找到能够处理该订单的处理器为止。

以处理用户登录的示例为例
我们将创建一个基于责任链模式的用户登录过程，其涉及以下步骤：

• 判断用户名是否存在。
• 判断用户密码是否正确。
• 是否启用了双重验证或两步验证。
• 是否已通过所有安全检查，允许用户登录。

如果某个步骤未成功完成，则不会执行后续步骤。

实现如下：

// 处理用户请求的责任链
protocol LoginHandler {
    var next: LoginHandler? { get set }
    func handle(request: LoginRequest)
}

// 用户登录请求
struct LoginRequest {
    let username: String
    let password: String
    var isTwoFactorAuthEnabled: Bool = false
    var isSecurityCheckPassed: Bool = false
}

// 判断用户名是否存在的处理器
class CheckUsernameHandler: LoginHandler {
    var next: LoginHandler?
    
    func handle(request: LoginRequest) {
        if request.username.count == 0 {
            print("用户名不能为空")
        } else {
            next?.handle(request: request)
        }
    }
}

// 判断用户密码是否正确的处理器
class CheckPasswordHandler: LoginHandler {
    var next: LoginHandler?
    
    func handle(request: LoginRequest) {
        if request.password.count == 0 {
            print("密码不能为空")
        } else {
            next?.handle(request: request)
        }
    }
}

// 双重验证或两步验证处理器
class TwoFactorAuthHandler: LoginHandler {
    var next: LoginHandler?
    
    func handle(request: LoginRequest) {
        if request.isTwoFactorAuthEnabled {
            print("请通过双重验证或两步验证")
        } else {
            next?.handle(request: request)
        }
    }
}

// 安全检测处理器
class SecurityCheckHandler: LoginHandler {
    var next: LoginHandler?
    
    func handle(request: LoginRequest) {
        if request.isSecurityCheckPassed {
            print("登录成功")
        } else {
            print("安全检测未通过，请联系管理员")
        }
    }
}

调用方式

let checkUsernameHandler = CheckUsernameHandler()
let checkPasswordHandler = CheckPasswordHandler()
let twoFactorAuthHandler = TwoFactorAuthHandler()
let securityCheckHandler = SecurityCheckHandler()

checkUsernameHandler.next = checkPasswordHandler
checkPasswordHandler.next = twoFactorAuthHandler
twoFactorAuthHandler.next = securityCheckHandler

let request1 = LoginRequest(username: "test", password: "", isTwoFactorAuthEnabled: false, isSecurityCheckPassed: false)
checkUsernameHandler.handle(request: request1)

let request2 = LoginRequest(username: "test", password: "test123", isTwoFactorAuthEnabled: true, isSecurityCheckPassed: false)
checkUsernameHandler.handle(request: request2)

let request3 = LoginRequest(username: "test", password: "test123", isTwoFactorAuthEnabled: false, isSecurityCheckPassed: true)
checkUsernameHandler.handle(request: request3)

在上述代码中，我们首先定义了 LoginHandler 责任链模式，然后连续添加了四个处理器，用于检查用户名、密码、双重验证或两步验证，以及安全检查。如果给定的登录请求未通过任何一项，则停止责任链。

客户端调用的示例代码如下所示：

1. 创建 LoginRequest 对象，并在创建 CheckUsernameHandler 处理器后调用 handle(request:) 方法，开始责任链流程。
2. 逐一调用责任链上的每个处理器，直到找到能够处理该请求的处理器为止。
3. 如果未通过任何一项，则停止责任链。

输出结果如下：

密码不能为空
请通过双重验证或两步验证
登录成功

这个例子简单演示了如何在 Swift 中使用责任链模式处理流程。