Swiftでのデザインパターンまとめ２（オブジェクトの構造に関するパターン）

はじめに
Adapter パターン
Bridge パターン
Composite パターン
Decorator パターン
Facade パターン
Flyweight パターン
Proxy パターン
さいごに
参考

はじめに

その１の続き。今回はオブジェクトの構造に関するパターンについてです。

オブジェクトの構造に関するパターン
- Adapter パターン
- Bridge パターン
- Composite パターン
- Decorator パターン
- Facade パターン
- Flyweight パターン
- Proxy パターン

その１同様、基本的には下記２つを参考に書いてます。

github でこんなんみつけたのでこれ見ればいいと思うよ！（私まだ理解してないので。。。）

ochococo/Design-Patterns-In-Swift

Adapter パターン

異なる２つのインターフェースを変換してつなげる仕組み。ラッパー？？みたいなやつだと思う。
Target と Adaptee を Adapter を介してつなげるらしい。

struct Adaptee {
    let value: Float
    func printValue() {
        print("value: \(value)")
    }
}

protocol Target {
    var value: Double { get }
    func printValue()
}

struct Adapter: Target {
    var value: Double {
        return Double(adaptee.value)
    }
    private let adaptee: Adaptee
    func printValue() {
        adaptee.printValue()
    }
    init(adaptee: Adaptee) {
        self.adaptee = adaptee
    }
}

class Hoge {
    func hogehoge() {
        let target = Adaptee(value: 10.5)
        let adapter = Adapter(adaptee: target)
        adapter.printValue()
    }
}

struct Adaptee {

let value: Float

func printValue() {

print("value: \(value)")

}

protocol Target {

var value: Double { get }

func printValue()

}

struct Adapter: Target {

var value: Double {

return Double(adaptee.value)

}

private let adaptee: Adaptee

func printValue() {

adaptee.printValue()

}

init(adaptee: Adaptee) {

self.adaptee = adaptee

}

class Hoge {

func hogehoge() {

let target = Adaptee(value: 10.5)

let adapter = Adapter(adaptee: target)

adapter.printValue()

}

Android の ListView とかの Adapter はこれなのか？？

参考：マンガでわかる Adapter

Bridge パターン

クラスなどの実装と、呼出し側の間の橋渡しをするクラスを用意し、実装を隠蔽する。

protocol Animal {
    var impl: MoveImpl? { get }
    func move()
}

extension Animal {
    func move() {
        impl?.move()
    }
}

protocol MoveImpl {
    func move()
}

struct RunMoveImpl: MoveImpl {
    func move() {
        print("Run!")
    }
}

struct SwimMoveImpl: MoveImpl {
    func move() {
        print("Swim!")
    }
}

struct JumpMoveImpl: MoveImpl {
    func move() {
        print("Jump!")
    }
}

struct Cat: Animal {
    var impl: MoveImpl?
}

struct Fish: Animal {
    var impl: MoveImpl?
}

class Hoge {
    func hogehoge() {
        var cat = Cat()
        cat.impl = RunMoveImpl()
        cat.move() // Run!
        cat.impl = JumpMoveImpl()
        cat.move() // Jump!
        var fish = Fish()
        fish.impl = SwimMoveImpl()
        fish.move() // Swim!
    }
}

protocol Animal {

var impl: MoveImpl? { get }

func move()

}

extension Animal {

func move() {

impl?.move()

}

protocol MoveImpl {

func move()

}

struct RunMoveImpl: MoveImpl {

func move() {

print("Run!")

}

struct SwimMoveImpl: MoveImpl {

func move() {

print("Swim!")

}

struct JumpMoveImpl: MoveImpl {

func move() {

print("Jump!")

}

struct Cat: Animal {

var impl: MoveImpl?

}

struct Fish: Animal {

var impl: MoveImpl?

}

class Hoge {

func hogehoge() {

var cat = Cat()

cat.impl = RunMoveImpl()

cat.move() // Run!

cat.impl = JumpMoveImpl()

cat.move() // Jump!

var fish = Fish()

fish.impl = SwimMoveImpl()

fish.move() // Swim!

}

使い方はこれであってんのかな？？

参考：マンガでわかる Bridge

Composite パターン

木構造モデルを一つのオブジェクトとして操作する仕組み。

protocol Component {
    var name: String { get }
    var isReadable: Bool { get set }
    func setUnreadable()
}

class Directory: Component, CustomStringConvertible {
    var description: String {
        return "name: \(name), isReadable: \(isReadable), subs: \(subs)"
    }

    let name: String
    var isReadable = true
    var subs: [Component]
    func setUnreadable() {
        isReadable = false
        for sub in subs {
            sub.setUnreadable()
        }
    }

    init(name: String, subs: [Component]) {
        self.name = name
        self.subs = subs
    }
}

class File: Component, CustomStringConvertible {
    var description: String {
        return "name: \(name), isReadable: \(isReadable)"
    }
    let name: String
    var isReadable = true
    func setUnreadable() {
        isReadable = false
    }

    init(name: String) {
        self.name = name
    }
}

class Hoge {
    func hogehoge() {
        let subFiles: [File] = [.init(name: "SubFile1"), .init(name: "SubFile3"), .init(name: "SubFile2")]
        let subDirectory = Directory(name: "Subs", subs: subFiles)
        let rootDirectory = Directory(name: "Root", subs: [subDirectory, File(name: "File1")])
        print(rootDirectory) 
        rootDirectory.setUnreadable()
        print(rootDirectory)
    }
}
// 一個目のプリント(isReadableはtrue)
// name: Root, isReadable: true, subs: [name: Subs, isReadable: true, subs: [name: SubFile1, isReadable: true, name: SubFile3, isReadable: true, name: SubFile2, isReadable: true], name: File1, isReadable: true]

// 二個目のプリント(isReadableがfalseになる)
// name: Root, isReadable: false, subs: [name: Subs, isReadable: false, subs: [name: SubFile1, isReadable: false, name: SubFile3, isReadable: false, name: SubFile2, isReadable: false], name: File1, isReadable: false]

protocol Component {

var name: String { get }

var isReadable: Bool { get set }

func setUnreadable()

}

class Directory: Component, CustomStringConvertible {

var description: String {

return "name: \(name), isReadable: \(isReadable), subs: \(subs)"

}

let name: String

var isReadable = true

var subs: [Component]

func setUnreadable() {

isReadable = false

for sub in subs {

sub.setUnreadable()

}

init(name: String, subs: [Component]) {

self.name = name

self.subs = subs

}

class File: Component, CustomStringConvertible {

var description: String {

return "name: \(name), isReadable: \(isReadable)"

}

let name: String

var isReadable = true

func setUnreadable() {

isReadable = false

}

init(name: String) {

self.name = name

}

class Hoge {

func hogehoge() {

let subFiles: [File] = [.init(name: "SubFile1"), .init(name: "SubFile3"), .init(name: "SubFile2")]

let subDirectory = Directory(name: "Subs", subs: subFiles)

let rootDirectory = Directory(name: "Root", subs: [subDirectory, File(name: "File1")])

print(rootDirectory)

rootDirectory.setUnreadable()

print(rootDirectory)

}

// 一個目のプリント(isReadableはtrue)

// name: Root, isReadable: true, subs: [name: Subs, isReadable: true, subs: [name: SubFile1, isReadable: true, name: SubFile3, isReadable: true, name: SubFile2, isReadable: true], name: File1, isReadable: true]

// 二個目のプリント(isReadableがfalseになる)

// name: Root, isReadable: false, subs: [name: Subs, isReadable: false, subs: [name: SubFile1, isReadable: false, name: SubFile3, isReadable: false, name: SubFile2, isReadable: false], name: File1, isReadable: false]

View も Composite パターンになるのかな？？

参考：マンガでわかる Composite

Decorator パターン

既存のクラスを修正することなく機能を追加する仕組み。（きっとデコレーションするって意味だと思う）

protocol Item {
    var price: Double { get }
}

protocol Topping: Item {
    var item: Item { get }
}

struct Pancake: Item {
    var price: Double {
        return 300
    }
}

struct Chocolate: Topping {
    var item: Item

    var price: Double {
        return item.price + 100
    }
}

struct WhippedCream: Topping {
    var item: Item

    var price: Double {
        return item.price + 120
    }
}

class Hoge {
    func hogehoge() {
        let order = WhippedCream(item: Pancake())
        print(order.price)
        let order2 = WhippedCream(item: Chocolate(item: Pancake()))
        print(order2.price)
    }
}

protocol Item {

var price: Double { get }

}

protocol Topping: Item {

var item: Item { get }

}

struct Pancake: Item {

var price: Double {

return 300

}

struct Chocolate: Topping {

var item: Item

var price: Double {

return item.price + 100

}

struct WhippedCream: Topping {

var item: Item

var price: Double {

return item.price + 120

}

class Hoge {

func hogehoge() {

let order = WhippedCream(item: Pancake())

print(order.price)

let order2 = WhippedCream(item: Chocolate(item: Pancake()))

print(order2.price)

}

これでパンケーキクラス（構造体だけど）をいじらずにチョコレートやホイップクリームをトッピングできるようになった！

参考：マンガでわかる Decorator

Facade パターン

複数のオブジェクトの連携でひとつの処理をするときに窓口を使って操作する仕組み。（ファサードは外観とかそういう意味っぽい）

class Facade {
    private let objectA = ObjectA()
    private let objectB = ObjectB()

    func operation() {
        objectA.methodA()
        objectB.methodB()
    }
}

class ObjectA {
    func methodA() {
    }
}

class ObjectB {
    func methodB() {
    }
}

class Facade {

private let objectA = ObjectA()

private let objectB = ObjectB()

func operation() {

objectA.methodA()

objectB.methodB()

}

class ObjectA {

func methodA() {

}

class ObjectB {

func methodB() {

}

ちょっと具体的な処理については思いつかなかった。。。

参考サイトには下記のように書いてあった。。。1:1だと Adapterらしい。

Adapter や Decorator パターンなどの、単一のオブジェクト関係に着目したものと異なり、Facade は複数のオブジェクトを集約するラッパークラスです。

ラッパークラスのメソッドが、つねにひとつの内部オブジェクトに 1:1 でマップされる場合、それがいくら矢面に立つ受付であっても、それは Adapter です。

参考：マンガでわかる Facade

Flyweight パターン

既存のインスタンスがあればそれを共有して負荷を減らす仕組み。

struct Book {
    let id: String
    let name: String
}

protocol BookSearching {
    func search(id: String, name: String) -> Book?
}

final class Library: BookSearching {

    private var books: [String: Book] = [:]

    func search(id: String, name: String) -> Book? {
        if books.index(forKey: id) == nil {
            books[id] = Book(id: id, name: name)
        }
        return books[id]
    }
}

class Hoge {
    func hogehoge() {
         let library = Library()
         let book = library.search(id: "12345", name: "ほげほげ本")
    }
}

struct Book {

let id: String

let name: String

}

protocol BookSearching {

func search(id: String, name: String) -> Book?

}

final class Library: BookSearching {

private var books: [String: Book] = [:]

func search(id: String, name: String) -> Book? {

if books.index(forKey: id) == nil {

books[id] = Book(id: id, name: name)

}

return books[id]

}

class Hoge {

func hogehoge() {

let library = Library()

let book = library.search(id: "12345", name: "ほげほげ本")

}

参考：マンガでわかる Flyweight

Proxy パターン

ユーザと対象オブジェクトの間に入って対象オブジェクトの代理としてユーザとやり取りする仕組み。

protocol HEVSuitMedicalAid {
    func administerMorphine() -> String
}

final class HEVSuit: HEVSuitMedicalAid {
    func administerMorphine() -> String {
        return "Morphine administered."
    }
}

final class HEVSuitHumanInterface: HEVSuitMedicalAid {

    lazy private var physicalSuit: HEVSuit = HEVSuit()

    func administerMorphine() -> String {
        return physicalSuit.administerMorphine()
    }
}

protocol HEVSuitMedicalAid {

func administerMorphine() -> String

}

final class HEVSuit: HEVSuitMedicalAid {

func administerMorphine() -> String {

return "Morphine administered."

}

final class HEVSuitHumanInterface: HEVSuitMedicalAid {

lazy private var physicalSuit: HEVSuit = HEVSuit()

func administerMorphine() -> String {

return physicalSuit.administerMorphine()

}

よくわかんなかったので ochococo/Design-Patterns-In-Swift の Virtual Proxy載せときます。

Decorator と似てるけど Decorator は機能拡張が目的で Proxy は効率的な運用が目的らしい。

参考：マンガでわかる Proxy

さいごに

うーん。。。なんとなくわかった気になったけど実務で使えるレベルではない。。。
きっと数年後見返したときに何か気づきがあるだろう。たぶんなんで使うかっていう目的がよくわかってないからな気がするので目的については後日追記するかも。。。