本文大部分內(nèi)容翻譯至《Pro Design Pattern In Swift》By Adam Freeman，一些地方做了些許修改性芬，并將代碼升級到了Swift2.0,翻譯不當(dāng)之處望多包涵峡眶。
抽象工廠模式(The Abstract Factory Pattern)
抽象工廠模式提供了一種方式，可以將一組具有同一主題的單獨(dú)的工廠封裝起來植锉。在正常使用中辫樱，客戶端程序需要創(chuàng)建抽象工廠的具體實(shí)現(xiàn)，然后使用抽象工廠作為接口來創(chuàng)建這一主題的具體對象俊庇∈ㄊ睿客戶端程序不需要知道（或關(guān)心）它從這些內(nèi)部的工廠方法中獲得對象的具體類型，因?yàn)榭蛻舳顺绦騼H使用這些對象的通用接口辉饱。抽象工廠模式將一組對象的實(shí)現(xiàn)細(xì)節(jié)與他們的一般使用分離開來搬男。
示例工程
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
}
定義了一個協(xié)議Floorplan 代表車的構(gòu)建，枚舉EngineOption代表引擎的位置等彭沼。接著我們看另一個相關(guān)Suspension(汽車懸架)：
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
}
接下來是Drivetrains(汽車動力傳動系統(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)")
}
}
理解抽象工廠模式解決的問題
工廠方法模式允許請求組件不需要知道各種細(xì)節(jié)而獲得一個實(shí)現(xiàn)類的實(shí)例缔逛， 而抽象工廠解決的問題有點(diǎn)類似但是一組并非實(shí)現(xiàn)同一個協(xié)議或者繼承相同基類的相關(guān)的對象。
我們修改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
理解抽象工廠模式
抽象工廠模式和工廠方法模式都是為了解決同一個問題褐奴，但是抽象工廠模式是用在創(chuàng)建一組對象，并且這些對象并沒有實(shí)現(xiàn)同一個協(xié)議或者繼承相同的基類于毙。在示例中敦冬，構(gòu)建一個Car結(jié)構(gòu)體需要三個對象，并且每一個對象實(shí)現(xiàn)的不同的協(xié)議：Floorplan, Suspension, Drivetrain 唯沮。
抽象工廠模式用合并的方式來解決散亂的對象選擇邏輯問題脖旱，用只向請求組件提供協(xié)議來解決依賴問題。
- 提供一個抽象工廠類介蛉，定義了一個返回一個協(xié)議實(shí)例或者基類實(shí)例的方法夯缺。
- 抽象工廠方法檢查調(diào)用者的請求并選擇一個具體工廠類，這個工廠類就是實(shí)現(xiàn)了工廠方法模式的類甘耿。具體工廠類的實(shí)例就被創(chuàng)建了并返回給了調(diào)用者。
- 調(diào)用者調(diào)用具體工廠類的的工廠方法竿滨。
- 實(shí)現(xiàn)類被初始化并提供給調(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對象捏境，讓它從抽象工廠中獲得產(chǎn)品對象。
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)品類之間沒有了依賴垫言。我們可以直接改變具體工廠類而不修改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
抽象工廠模式的變形
-
隱藏抽象工廠類
第一個最普通的變形就是將抽象工廠模式的實(shí)現(xiàn)隱藏結(jié)構(gòu)體或者類中倾剿。在本例中顯然就是Car類筷频。
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)")
}
}
這樣一來，main.swift就變得更簡單了：
main.swift
let car = Car(carType: Cars.SPORTS)
car.printDetails()
-
具體工廠類實(shí)現(xiàn)單例模式
另一個很普遍的變形就是具體工廠類實(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
}
}
接下來修改：
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)類應(yīng)用原型模式
最重要的是為實(shí)現(xiàn)類去應(yīng)用原型模式而非具體工廠類凛捏。
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
}
}
接下來修改：
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()
}
}
