Swift实现车辆管理器：注册类按需初始化（自定义构造器）

核心思路 #

让每个车辆类型自行负责从URN解析参数并完成初始化，管理器仅维护URN类型与车辆创建逻辑的映射，无需关心具体构造器细节。

具体实现 #

1. 定义URN解析结构体 #

先实现一个用于解析URN字符串的结构体：

struct URN {
    let namespace: String
    let type: String
    let identifier: String
    
    init(rawValue: String) throws {
        let components = rawValue.split(separator: ":")
        guard components.count == 3 else {
            throw URLError(.badURL)
        }
        self.namespace = String(components[0])
        self.type = String(components[1])
        self.identifier = String(components[2])
    }
}

2. 重构Vehicle协议 #

给协议添加静态属性（关联URN类型标识）和创建方法（子类自定义初始化逻辑）：

protocol Vehicle {
    static var vehicleURNType: String { get } // 对应URN中的类型字段，如"car"、"bus"
    func start()
    static func create(from urn: URN) throws -> Self // 子类实现从URN生成实例的逻辑
}

3. 实现具体车辆类 #

每个车辆类实现协议要求的方法，自定义构造器逻辑：

class Car: Vehicle {
    static let vehicleURNType = "car"
    let seats: Int
    
    init(seats: Int) {
        self.seats = seats
    }
    
    func start() {
        print("Car with \(seats) seats starts")
    }
    
    static func create(from urn: URN) throws -> Car {
        guard let seats = Int(urn.identifier) else {
            throw URLError(.badURL)
        }
        return Car(seats: seats)
    }
}

class Bus: Vehicle {
    static let vehicleURNType = "bus"
    let shouldStop: Bool
    
    init(shouldStop: Bool) {
        self.shouldStop = shouldStop
    }
    
    func start() {
        print("Bus \(shouldStop ? "will stop" : "won't stop") starts")
    }
    
    static func create(from urn: URN) throws -> Bus {
        guard let shouldStop = Bool(urn.identifier) else {
            throw URLError(.badURL)
        }
        return Bus(shouldStop: shouldStop)
    }
}

4. 实现车辆管理器 #

用字典存储车辆类型对应的创建工厂，支持外部注册和实例化：

class VehicleManager {
    private var registeredFactories: [String: (URN) throws -> Vehicle] = [:]
    
    // 注册车辆类型
    func registerVehicle<T: Vehicle>(_ type: T.Type) {
        registeredFactories[T.vehicleURNType] = { try T.create(from: $0) }
    }
    
    // 根据URN生成对应车辆实例
    func run(for rawURN: String) throws -> Vehicle {
        let urn = try URN(rawValue: rawURN)
        guard let factory = registeredFactories[urn.type] else {
            throw URLError(.unsupportedURL)
        }
        return try factory(urn)
    }
}

5. 使用示例 #

let manager = VehicleManager()
manager.registerVehicle(Car.self)
manager.registerVehicle(Bus.self)

do {
    let car = try manager.run(for: "urn:car:1234")
    car.start() // 输出: Car with 1234 seats starts
    
    let bus = try manager.run(for: "urn:bus:true")
    bus.start() // 输出: Bus will stop starts
} catch {
    print("Error: \(error.localizedDescription)")
}

方案优势 #

• 解耦逻辑：车辆的初始化细节由子类自行维护，管理器无需知晓每个类的构造器参数。
• 扩展性好：新增车辆类型时，只需实现Vehicle协议并注册到管理器，无需修改现有代码。
• 高效查找：用字典存储工厂闭包，根据URN类型快速定位创建逻辑，比遍历数组效率更高。
• 统一错误处理：所有解析、初始化错误通过throws抛出，调用方可统一处理。

内容的提问来源于stack exchange，提问作者palme