創(chuàng)建者模式－抽象工廠模式(The Abstract Factory Pattern)

本文大部分內(nèi)容翻譯至《Pro Design Pattern In Swift》By Adam Freeman，一些地方做了些許修改，并將代碼升級(jí)到了Swift2.0,翻譯不當(dāng)之處望多包涵。

抽象工廠模式(The Abstract Factory Pattern)

抽象工廠模式提供了一種方式，可以將一組具有同一主題的單獨(dú)的工廠封裝起來(lái)。在正常使用中，客戶端程序需要?jiǎng)?chuàng)建抽象工廠的具體實(shí)現(xiàn)，然后使用抽象工廠作為接口來(lái)創(chuàng)建這一主題的具體對(duì)象?？蛻舳顺绦虿恍枰溃ɑ蜿P(guān)心）它從這些內(nèi)部的工廠方法中獲得對(duì)象的具體類(lèi)型，因?yàn)榭蛻舳顺绦騼H使用這些對(duì)象的通用接口。抽象工廠模式將一組對(duì)象的實(shí)現(xiàn)細(xì)節(jié)與他們的一般使用分離開(kāi)來(lái)。

示例工程

OS X Command Line Tool 工程：

Floorplans.swift

protocol Floorplan {
    var seats:Int { get }
    var enginePosition:EngineOption { get }
}

enum EngineOption : String {
    case FRONT = "Front"
    case MID = "Mid"
}

class ShortFloorplan: Floorplan {
    var seats = 2
    var enginePosition = EngineOption.MID
}

class StandardFloorplan: Floorplan {
    var seats = 4
    var enginePosition = EngineOption.FRONT
}

class LongFloorplan: Floorplan {
    var seats = 8
    var enginePosition = EngineOption.FRONT
}

定義了一個(gè)協(xié)議Floorplan 代表車(chē)的構(gòu)建，枚舉EngineOption代表引擎的位置等。接著我們看另一個(gè)相關(guān)Suspension(汽車(chē)懸架)：

Suspension.swift

protocol Suspension {
    var suspensionType:SuspensionOption { get }
}

enum SuspensionOption : String {
    case STANDARD = "Standard"
    case SPORTS = "Firm"
    case SOFT = "Soft"
}

class RoadSuspension : Suspension {
    var suspensionType = SuspensionOption.STANDARD
}

class OffRoadSuspension : Suspension {
    var suspensionType = SuspensionOption.SOFT
}

class RaceSuspension : Suspension {
    var suspensionType = SuspensionOption.SPORTS
}

接下來(lái)是Drivetrains(汽車(chē)動(dòng)力傳動(dòng)系統(tǒng))：

Drivetrains.swift

protocol Drivetrain {
    var driveType:DriveOption { get }
}

enum DriveOption : String {
    case FRONT = "Front"
        case REAR = "Rear"
        case ALL = "4WD"
}

class FrontWheelDrive : Drivetrain {
    var driveType = DriveOption.FRONT
}

class RearWheelDrive : Drivetrain {
    var driveType = DriveOption.REAR
}

class AllWheelDrive : Drivetrain {
    var driveType = DriveOption.ALL
}

最后我們創(chuàng)建CarsParts.swift文件：

CarsParts.swift

enum Cars: String {
    case COMPACT = "VW Golf"
    case SPORTS = "Porsche Boxter"
    case SUV = "Cadillac Escalade"
}

struct Car {
    var carType:Cars
    var floor:Floorplan
    var suspension:Suspension
    var drive:Drivetrain
    
    func printDetails() {
        print("Car type: \(carType.rawValue)")
        print("Seats: \(floor.seats)")
        print("Engine: \(floor.enginePosition.rawValue)")
        print("Suspension: \(suspension.suspensionType.rawValue)")
        print("Drive: \(drive.driveType.rawValue)")
    }
}

理解抽象工廠模式解決的問(wèn)題

工廠方法模式允許請(qǐng)求組件不需要知道各種細(xì)節(jié)而獲得一個(gè)實(shí)現(xiàn)類(lèi)的實(shí)例， 而抽象工廠解決的問(wèn)題有點(diǎn)類(lèi)似但是一組并非實(shí)現(xiàn)同一個(gè)協(xié)議或者繼承相同基類(lèi)的相關(guān)的對(duì)象。



我們修改main.swift

main.swift

var car = Car(carType: Cars.SPORTS,
    floor: ShortFloorplan(),
    suspension: RaceSuspension(),
    drive: RearWheelDrive())

car.printDetails()

運(yùn)行程序，得到下面輸出：

Car type: Porsche Boxter
Seats: 2
Engine: Mid
Suspension: Firm
Drive: Rear

理解抽象工廠模式

抽象工廠模式和工廠方法模式都是為了解決同一個(gè)問(wèn)題，但是抽象工廠模式是用在創(chuàng)建一組對(duì)象，并且這些對(duì)象并沒(méi)有實(shí)現(xiàn)同一個(gè)協(xié)議或者繼承相同的基類(lèi)。在示例中，構(gòu)建一個(gè)Car結(jié)構(gòu)體需要三個(gè)對(duì)象，并且每一個(gè)對(duì)象實(shí)現(xiàn)的不同的協(xié)議：Floorplan, Suspension, Drivetrain 。

抽象工廠模式用合并的方式來(lái)解決散亂的對(duì)象選擇邏輯問(wèn)題，用只向請(qǐng)求組件提供協(xié)議來(lái)解決依賴問(wèn)題。


  1. 提供一個(gè)抽象工廠類(lèi)，定義了一個(gè)返回一個(gè)協(xié)議實(shí)例或者基類(lèi)實(shí)例的方法。
  2. 抽象工廠方法檢查調(diào)用者的請(qǐng)求并選擇一個(gè)具體工廠類(lèi)，這個(gè)工廠類(lèi)就是實(shí)現(xiàn)了工廠方法模式的類(lèi)。具體工廠類(lèi)的實(shí)例就被創(chuàng)建了并返回給了調(diào)用者。
  3. 調(diào)用者調(diào)用具體工廠類(lèi)的的工廠方法。
  4. 實(shí)現(xiàn)類(lèi)被初始化并提供給調(diào)用者。

實(shí)現(xiàn)抽象工廠模式

  • 創(chuàng)建抽象工廠

Abstract.swift

class CarFactory {
    func createFloorplan() -> Floorplan {
        fatalError("Not implemented")
    }
    
    func createSuspension() -> Suspension {
        fatalError("Not implemented")
    }
    
    func createDrivetrain() -> Drivetrain {
        fatalError("Not implemented")
    }
}

  • 創(chuàng)建具體工廠

Concrete.swift

class CompactCarFactory : CarFactory {
    override func createFloorplan() -> Floorplan {
        return StandardFloorplan()
    }
    override func createSuspension() -> Suspension {
        return RoadSuspension()
    }
    override func createDrivetrain() -> Drivetrain {
    return FrontWheelDrive()
    }
}

class SportsCarFactory : CarFactory {
    override func createFloorplan() -> Floorplan {
        return ShortFloorplan()
        }
    override func createSuspension() -> Suspension {
        return RaceSuspension()
        }
    override func createDrivetrain() -> Drivetrain {
        return RearWheelDrive()
        }
}
class SUVCarFactory : CarFactory {
    override func createFloorplan() -> Floorplan {
        return LongFloorplan()
        }
    override func createSuspension() -> Suspension {
        return OffRoadSuspension()
        }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
        }
}

  • 完成抽象工廠

Abstract.swift

class CarFactory {
    func createFloorplan() -> Floorplan {
        fatalError("Not implemented")
    }
    
    func createSuspension() -> Suspension {
        fatalError("Not implemented")
    }
    
    func createDrivetrain() -> Drivetrain {
        fatalError("Not implemented")
    }
    
    final class func getFactory(car:Cars) -> CarFactory? {
        var factory:CarFactory?
        switch (car) {
        case .COMPACT:
            factory = CompactCarFactory()
        case .SPORTS:
            factory = SportsCarFactory()
        case .SUV:
            factory = SUVCarFactory()
        }
        return factory
    }
}

  • 消費(fèi)抽象工廠模式

最后一步就是更新Car對(duì)象，讓它從抽象工廠中獲得產(chǎn)品對(duì)象。

main.swift

let factory = CarFactory.getFactory(Cars.SPORTS)
if (factory != nil) {
    let car = Car(carType: Cars.SPORTS,
    floor: factory!.createFloorplan(),
    suspension: factory!.createSuspension(),
    drive: factory!.createDrivetrain())
    car.printDetails()
}

運(yùn)行程序，得到和上面一樣的結(jié)果：

Car type: Porsche Boxter
Seats: 2
Engine: Mid
Suspension: Firm
Drive: Rear

我們可以看出main.swift和獨(dú)立的產(chǎn)品類(lèi)之間沒(méi)有了依賴。我們可以直接改變具體工廠類(lèi)而不修改main.swift。

Concrete.swift

...
class SportsCarFactory : CarFactory {
    override func createFloorplan() -> Floorplan {
        return ShortFloorplan()
        }
    override func createSuspension() -> Suspension {
        return RaceSuspension()
        }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
        }
}
...

再次運(yùn)行程序：

Car type: Porsche Boxter
Seats: 2
Engine: Mid
Suspension: Firm
Drive: 4WD

抽象工廠模式的變形

  • 隱藏抽象工廠類(lèi)

第一個(gè)最普通的變形就是將抽象工廠模式的實(shí)現(xiàn)隱藏結(jié)構(gòu)體或者類(lèi)中。在本例中顯然就是Car類(lèi)。

CarParts.swift

...
struct Car {
    var carType:Cars
    var floor:Floorplan
    var suspension:Suspension
    var drive:Drivetrain
    
    init(carType:Cars) {
        let concreteFactory = CarFactory.getFactory(carType)
        self.floor = concreteFactory!.createFloorplan()
        self.suspension = concreteFactory!.createSuspension()
        self.drive = concreteFactory!.createDrivetrain()
        self.carType = carType
    }
    
    func printDetails() {
        print("Car type: \(carType.rawValue)")
        print("Seats: \(floor.seats)")
        print("Engine: \(floor.enginePosition.rawValue)")
        print("Suspension: \(suspension.suspensionType.rawValue)")
        print("Drive: \(drive.driveType.rawValue)")
    }
}

這樣一來(lái)，main.swift就變得更簡(jiǎn)單了：

main.swift

let car = Car(carType: Cars.SPORTS)
car.printDetails()

  • 具體工廠類(lèi)實(shí)現(xiàn)單例模式

另一個(gè)很普遍的變形就是具體工廠類(lèi)實(shí)現(xiàn)單例模式。

class CarFactory {
    
    func createFloorplan() -> Floorplan {
        fatalError("Not implemented")
    }
    
    func createSuspension() -> Suspension {
        fatalError("Not implemented")
    }
    
    func createDrivetrain() -> Drivetrain {
        fatalError("Not implemented")
    }
    
    final class func getFactory(car:Cars) -> CarFactory? {
        var factory:CarFactory
        switch (car) {
        case .COMPACT:
            factory = CompactCarFactory.sharedInstance
        case .SPORTS:
            factory = SportsCarFactory.sharedInstance
        case .SUV:
            factory = SUVCarFactory.sharedInstance
        }
        return factory
    }
}

接下來(lái)修改：

Concrete.swift

class CompactCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = CompactCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return StandardFloorplan()
    }
    
    override func createSuspension() -> Suspension {
        return RoadSuspension()
    }
    
    override func createDrivetrain() -> Drivetrain {
        return FrontWheelDrive()
    }
}

class SportsCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = SportsCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return ShortFloorplan()
    }
    override func createSuspension() -> Suspension {
        return RaceSuspension()
    }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
    }
}

class SUVCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = SUVCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return LongFloorplan()
    }
    override func createSuspension() -> Suspension {
        return OffRoadSuspension()
    }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
    }
}

  • 為實(shí)現(xiàn)類(lèi)應(yīng)用原型模式

最重要的是為實(shí)現(xiàn)類(lèi)去應(yīng)用原型模式而非具體工廠類(lèi)。

Suspersion.swift

import Foundation

protocol Suspension {
    var suspensionType:SuspensionOption { get }
}

enum SuspensionOption : String {
    case STANDARD = "Standard"
    case SPORTS = "Firm"
    case SOFT = "Soft"
}
***

class RoadSuspension :NSObject, NSCopying,Suspension {

    var suspensionType = SuspensionOption.STANDARD
        
    static let sharedInstance = RoadSuspension()
        
    func copyWithZone(zone: NSZone) -> AnyObject {
        return RoadSuspension()
            
    }
        
    class func getInstance() -> Suspension {
        return sharedInstance.copy() as! Suspension
        
    }
    
}

class OffRoadSuspension :NSObject, NSCopying, Suspension {
    
    var suspensionType = SuspensionOption.SOFT
    
    static let sharedInstance = OffRoadSuspension()
    
    func copyWithZone(zone: NSZone) -> AnyObject {
        return OffRoadSuspension()
        
    }
    
    class func getInstance() -> Suspension {
        return sharedInstance.copy() as! Suspension
        
    }
}

class RaceSuspension :NSObject, NSCopying,  Suspension {
    
    var suspensionType = SuspensionOption.SPORTS
    
    static let sharedInstance = RaceSuspension()
    
    func copyWithZone(zone: NSZone) -> AnyObject {
        return RaceSuspension()
        
    }
    
    class func getInstance() -> Suspension {
        return sharedInstance.copy() as! Suspension
        
    }
}

接下來(lái)修改：

Concrete.swift

class CompactCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = CompactCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return StandardFloorplan()
    }
    
    override func createSuspension() -> Suspension {
        return RoadSuspension.getInstance()
    }
    
    override func createDrivetrain() -> Drivetrain {
        return FrontWheelDrive()
    }
}

class SportsCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = SportsCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return ShortFloorplan()
    }
    override func createSuspension() -> Suspension {
        return RaceSuspension.getInstance()
    }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
    }
}

class SUVCarFactory : CarFactory {
    
    private override init(){}
    
    static let sharedInstance = SUVCarFactory()
    
    override func createFloorplan() -> Floorplan {
        return LongFloorplan()
    }
    override func createSuspension() -> Suspension {
        return OffRoadSuspension.getInstance()
    }
    override func createDrivetrain() -> Drivetrain {
        return AllWheelDrive()
    }
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容