diff --git "a/ObjectiveC/ios-patterns-cliff-notes2.pdf.txt" "b/ObjectiveC/ios-patterns-cliff-notes2.pdf.txt" new file mode 100644--- /dev/null +++ "b/ObjectiveC/ios-patterns-cliff-notes2.pdf.txt" @@ -0,0 +1,5209 @@ +Хрестоматия  iOS  паттернов.  На  всякий…   + +V1.1 +Дима Малеев + + + + +   +   +   +   +   +   +   +   +   +   + + Оглавление   + +Привет ............................................................................................................................ 3   + +История изменений ...................................................................................................... 5   + +Prototype ......................................................................................................................... 6   + +Factory Method. .............................................................................................................. 9   + +Abstract Factory ........................................................................................................... 12   + +Builder ........................................................................................................................... 16   + +Singleton ....................................................................................................................... 20   + +Adapter .......................................................................................................................... 22   + +Bridge ............................................................................................................................ 27   + +Facade ........................................................................................................................... 29   + +Mediator ........................................................................................................................ 32   + +Observer ........................................................................................................................ 35   + +Composite ..................................................................................................................... 40   + +Iterator ........................................................................................................................... 43   + +Visitor ............................................................................................................................ 48   + +Decorator ...................................................................................................................... 52   + +Chain of responsibility ................................................................................................. 54   + +Template Method .......................................................................................................... 57   + +Strategy ......................................................................................................................... 60   + +Command ...................................................................................................................... 63   + +Flyweight ....................................................................................................................... 68   + +Proxy ............................................................................................................................. 71   + +Memento ........................................................................................................................ 74   + + + + + + + + Привет +Привет, Друг! Очень мило что ты решил прочитать эту книгу. Ну или просто скачал +чтобы посмотреть что тут находится. А находятся здесь просто примеры +реализации паттернов GoF для iOS. Так как примеры писаны на Objective-C, +вероятнее всего их можно использовать и для Mac, но так как я круче програмы +чем “Hello, World!” под Mac не писал – то утверждать не могу. +Что тебя ждет дальше? Невероятно, но паттерны! И вероятнее всего +граматические ошибки, потому как я просто физически не умею писать без +ошибок. Но, я торжественно клянусь, что исправлю каждую ошибку которую ты +мне пришлешь на diwingless@gmail.com. Я очень надеюсь, что ты не граммар +наци, и поможешь мне исправить ошибки, и конечно же оценишь те знания +которыми я попытался поделиться с тобой. + +Для кого эта книга? + +Книга будет полезна всем iOS разработчикам, потому как книги просто полезно +читать. Говорят - это улучшает память. Для начинающих разработчиков, можно +будет прочитать про паттерны и примеры их реализации, в будущем про это вас +спросят на собеседовании. Для более продвинутых ребят, книга может послужить +небольшой напоминалкой про забытое описание паттернов. Книга однозначно не +являет собой учебник по Obj-С, и прочитва ее вы врятли сможете написать +вторую Angry Birds, однако некоторые проблемы она вам все же решить поможет. +Паттерны вообще хорошо знать чтобы структурировать свои знания в головеJ + +Почему эта книга? + +По моему глубоко личному убеждению – знания должны быть бесплатны. Просто, +представьте как далеко было бы человечество, если бы у нас культура была бы +направлена не на бесконечное зарабатывание денег, а на продвижение +человечества к звездам? К сожалению, я не фармацевт который придумал +лекарство от рака, и не ученый который придумал телепортациюJ Потому, я +попытаюсь поделиться знаниями которые есть у меня. Что меня радует – я далеко +не первый, и даже решение о написании этой книги пришло мне в голову из-за +успеха Андрея Будая с его книжкой, которую я вам очень рекомендую почитать. +Внимательный читатель увидит, что книги сами по себе очень похожи, разве что +язык примеров другой (ну и сами примеры, кроме одного). + +Распространение книги + +Книга бесплатнаJ Глубоко писать другое, особенно если вы прочитали +предыдущий пункт. Распространятся книга будет путем скачивания откуда угодно. +Я не очень знаю какие лицензии в ходу, да и в данном случае мне откровенно все +равно. Потому, просто пару правил: + +1. Книга не должна продоваться. Книга может только беслптано +распространяться в любом виде, но за просто так. Совсем. + +2. Книгу можно перепечатывать, копировать себе в блог, отсылать голубиной +почтой и даже менять имя автора. Если вспомните вашего покорного слугу +– респект вам и уважуха, если нет – это тоже отлично, наверное, у вас была +причина. + + + + + + + + + + + 3. Естественно, автор не несет ответственности за те знания которые вы тут + +получилиJ Ну серъезно - делайте добро, вы ж не политики. + +4. Вы можете дописывать книгу, изменять в любом месте, но тогда будьте + +добры, меняйте автора. + +5. Если вы поменяли контент книги, даже одну буковку – это уже ваша книгаJ + +Наслаждайтесь! Вы стали автором! + +6. Кстати да, менять можно все кроме этих простых правил. +7. После прочтения книги, задумайтесь какими знаниями можете поделиться +вы. Вероятнее всего, вы можете расскать уникальные и интересные вещи, +которые поменяют что-то в этом мире! Пользуйтесь! Это ваша суперсила! + +Напутственное слово + +Читайте. + + + + + + + + История изменений +Книга же не бумажная, потому имеет возможность меняться и эволюционировать! + +V1.0 – базовый контент книги +V1.1 – «подкрашен» код, немного пофиксаны ошибки, книга выложена в опен сорс + + + + + + Prototype +Прототип – один из самых простых паттернов, который позволяет нам получить +точную копию необходимого объекта. Тоесть использовать как прототип для +нового объекта + +Когда использовать: + +1. У нас есть семейство схожих объектов, разница между которыми только в + +состоянии их полей. + +2. Чтобы создать объект вам надо пройти через огонь, воду и медные трубы. +Особенно если этот объект состоит из еще одной кучи объектов, многие из +которых для заполнения требуют подгрузку даных из базы, веб сервисов и +тому подобных источников. Часто, легче скопировать объект и поменять +несколько полей + +3. Да и в принципе, нам особо и не важно как создается объект. Ну есть и + +есть. + +4. Нам страшно лень писать иерархию фабрик (читай дальше), которые будут + +инкапсулировать всю противную работу создания объекта. + +Да, и есть еще частое заблуждение ( вероятнее всего из названия ) – прототип – +это архитип, которые никогда не должен использоваться, и служит только для +создания себе подобных объектов. Хотя, протип, как архитип – тоже достаточно +популярный кейс. Собственно, нам ничего не мешает делать прототипом любой +объект который у нас в подчинении. + +Поверхностное и глубокое копирование +Тут особенно разницы с .NET нету. Есть указатель, есть значение в куче. + +Поверхностное копирование – это просто создание нового указателя на те же +самые байты в куче. Тоесть, в результате мы можем получить два объекта, +которые указывают на одно и тоже значение. + +К примеру создадим объект: + +@interface Person : NSObject + +@property (nonatomic,weak) NSString *name; +@property (nonatomic,weak) NSString *surname; +@property (nonatomic,weak) NSString *age; + +@end + +А теперь давайте просто создадим два объекта и посмотрим что же получится: + +Person *firstPerson = [[Person alloc] init]; + + firstPerson.name = @"Dima"; + firstPerson.surname = @"Surname"; + Person *secondPerson = firstPerson; + NSLog(@"First Person name = %@ and surname = %@", + + secondPerson.name = @"Roma"; + NSLog(@"Second Person name = %@ and surname = %@", + +firstPerson.name, firstPerson.surname); + + NSLog(@"First Person name = %@ and surname = %@", + +firstPerson.name, firstPerson.surname); + +secondPerson.name, secondPerson.surname); + + + + + + + + + + + + + + + + + + + + + + + + + + Как видим лог достаточно ожидаемый: + +2013-01-21 01:31:20.986 PrototypePattern[1961:11303] First Person name = Dima +2013-01-21 01:31:20.987 PrototypePattern[1961:11303] Second Person name = Roma +2013-01-21 01:31:20.987 PrototypePattern[1961:11303] First Person name = Roma + +Заметьте, что хоть и меняли мы имя для secondPerson, но и у firstPerson имя +поменялось. Просто потому что мы создали два указателя на один и тот же +объект. + +Для таких задач, стоит использовать глубокое копирование, которое в Objective-C +сделанно в принципе очень похоже как и в .NET: + +Для этого надо реализовать протокол NSCopying, и перегрузить: + +-(id) copyWithZone:(NSZone *)zone; + +И да, не стоит переживать что мы не реализуем метод “copy”. Он уже есть у +класса NSObject. Если вызвать этот метод, и не реализовать copyWithZone – то +мы получем ошибку типа NSInvalidArgumentException. + +Потому интерфейс нашего объекта теперь будет выглядеть следующим образом: + +@interface Person : NSObject + +@property (nonatomic,weak) NSString *name; +@property (nonatomic,weak) NSString *surname; +@property (nonatomic,weak) NSString *age; + +-(id) copyWithZone:(NSZone *)zone; + +@end + +а сама реализация: + +@implementation Person + +-(id) copyWithZone:(NSZone *)zone +{ + Person *copy = [[self class] allocWithZone:zone]; + copy.name = self.name; + copy.age = self.age; + copy.surname = self.surname; + return copy; +} + +@end + + Теперь немного изменим код нашего тестового приложения: + + Person *firstPerson = [[Person alloc] init]; + firstPerson.name = @"Dima"; + firstPerson.surname = @"Surname"; + Person *secondPerson = firstPerson.copy; + NSLog(@"First Person name = %@ and surname = %@", + +firstPerson.name, firstPerson.surname); + + secondPerson.name = @"Roma"; + NSLog(@"Second Person name = %@ and surname = %@", + +secondPerson.name, secondPerson.surname); + +NSLog(@"First Person name = %@ and surname = %@", + + + + + + + + + + + + + + + + + + + + + + + + + + firstPerson.name, firstPerson.surname); + +Ну и естественно лог: + +2013-01-21 01:48:36.538 PrototypePattern[2090:11303] First Person name = Dima +and surname = Surname +2013-01-21 01:48:36.539 PrototypePattern[2090:11303] Second Person name = Roma +and surname = Surname +2013-01-21 01:48:36.540 PrototypePattern[2090:11303] First Person name = Dima +and surname = Surname + +Как видим, мы в результате получили два независимых объекта, один из которых +сделан по подобию первого. + +Код примера. + + + + + + + + + + Factory Method. +Еще один порождающий паттерн, довольно прост и популярен.Паттерн позволяет +переложить создание специфических объектов, на наследников родительского +класса, потому можно манипулировать объектами на более высоком уровне, не +заморачиваясь объект какого класса будет создан. Частенько этот паттерн +называют виртуальный конструктор, что по моему мнению более выражает его +предназначение. + +Когда использовать: + +1. Мы не до конца уверены объект какого типа нам необходим. +2. Мы хотим чтобы не родительский объект решал какой тип создавать, а его + +наследники. + +Почему хорошо использовать: + +Объекты созданные фабричным методом – схожи, потому как у них один и тот же +родительский объект. Потому, если локализировать создание таких объектов, то +можно добавлять новые типы, не меняя при это код который использует +фабричный метод. + +Пример: + +Давайте представим, что мы такой неправильный магазин в котором тип товара +оценивается по цене:) На данный момент товар есть 2х типов – Игрушки и +Одежда. + +В чеке мы получаем только цены, и нам надо сохранить объекты которые +куплены. + +Для начала создадим клас Product. Его реализация нас особо не интересует, хотя +он может содержать в себе общие для разных типов товаров методы (сделано +для примера, мы их особо не используем): + +@interface Product : NSObject +@property(nonatomic) int *price; +@property(nonatomic, strong) NSString *name; +-(NSInteger *)getTotalPrice:(int)sum; +-(void)saveObject; +@end + +@implementation Product +-(NSInteger *) getTotalPrice:(int)sum +{ + return self.price + sum;} + +-(void) saveObject +{ + NSLog(@"I am saving an object in to product database"); +} +@end + +Теперь создадим две реализации этого интерфейса. + + + + + + + + + + + + + + + + + + Игрушка: + +@interface Toy : Product +@end + +@implementation Toy +-(void) saveObject +{ + NSLog(@"Saving object into Toys database"); +} +@end + +И одежда: + +@interface Dress : Product +@end + +@implementation Dress +-(void) saveObject +{ + NSLog(@"Saving object into Dress database"); +} +@end + +Ну теперь мы практически подошли в плотную к нашему паттерну. Собственно, +теперь надо создать метод, который будет по цене определять что же за продукт +у нас в чеке, и создавать объект необходимого типа. + +@interface ProductGenerator : NSObject + +-(Product *) getProduct:(int)price; +@end + +@implementation ProductGenerator + +-(Product *) getProduct:(int)price +{ + + if ( price > 0 && price < 100 ) + { + Toy *p = [[Toy alloc] init]; + return p; + } + + if (price >= 100) + { + Dress *p = [[Dress alloc] init]; + return p; + } + return nil; +} +@end + +Ну вот собственно и все. Теперь просто создадим метод, который будет считать и +записывать расходы: + +-(void) saveExpenses:(int)aPrice +{ + ProductGenerator *pd = [[ProductGenerator alloc] init]; + + Product *expense = [pd getProduct:aPrice]; + + [expense saveObject];} + + + + + + + + + + + + + + + + + + + + + + + + + + Попробуем! + + [self saveExpenses:50]; + [self saveExpenses:56]; + [self saveExpenses:79]; + [self saveExpenses:100]; + [self saveExpenses:123]; + [self saveExpenses:51]; + +Лог: + +2013-01-23 23:27:54.223 FactoryMethodPattern[8833:11303] Saving object into Toys +database +2013-01-23 23:27:54.226 FactoryMethodPattern[8833:11303] Saving object into Toys +database +2013-01-23 23:27:54.226 FactoryMethodPattern[8833:11303] Saving object into Toys +database +2013-01-23 23:27:54.227 FactoryMethodPattern[8833:11303] Saving object into Dress +database +2013-01-23 23:27:54.227 FactoryMethodPattern[8833:11303] Saving object into Dress +database +2013-01-23 23:27:54.228 FactoryMethodPattern[8833:11303] Saving object into Toys +database + +Код примера. + + + + + + + + + Abstract Factory +Абстрактная фабрика – еще один очень популярный паттерн, который как и в +названии так и в реализации слегка похож на фабричный метод. +Итак, что же делает абстрактная фабрика: + +Абстрактная фабрик дает простой интерфейс для создания объектов которые +принадлежат к тому или иному сеймейству объектов. + +Отличия от фабричного метода: + +1. Фабричный метод порождает объекты одного и того же типа, фабрике же + +может создавать независимые объекты + +2. Чтобы добавить новый тип объекта – надо поменять интерфейс фабрики, в + +фабричном методе же легко просто поменять внутренности метода, +который ответственный за порождение объектов. + +Давайте представим ситуацию: у нас есть две фабрики по производству IPhone и +IPad. Одна оригинальная, компании Apple, другая – хижина дядюшки Хуа. И вот, +мы хотим производить эти товары: если в страны 3-го мира – то товар от +дядюшки, в другие страны – товар любезно предоставлен компанией Apple. + +Итак, пускай у нас есть фабрика, которая умеет производить и айпады и айфоны: + +@interface IPhoneFactory : NSObject + +-(GenericIPhone *) getIPhone; +-(GenericIPad *) getIPad; + +@end + +Естественно, нам необходимо реализовать продукты которые фабрика будет +производить: + +@interface GenericIPad : NSObject + +@property(nonatomic,weak) NSString *osName; +@property(nonatomic, weak) NSString *productName; +@property(nonatomic, strong) NSNumber *screenSize; + +@end + +//----- + +@interface GenericIPhone : NSObject + +@property (nonatomic, weak) NSString *osName; +@property (nonatomic, weak) NSString *productName; + +@end + +Но, продукты немного отличаются. + +Пускай у нас есть два типа продуктов, оригинальные Apple и продукты которые +произведены трутолюбивым дядюшкой Хуа: + +@interface AppleIPhone : GenericIPhone +@end + + + + + + + + + + + + + + + + + + + + + + + @implementation AppleIPhone + +-(id) init +{ + self = [super init]; + + self.productName = @"IPhone"; + self.osName = @"iOS"; + + return self; +} +@end + +//-------- +//Айпад +@interface AppleIPad : GenericIPad +@end + +@implementation AppleIPad +-(id) init +{ + self = [super init]; + self.productName = @"IPad"; + self.osName = @"iOS"; + self.screenSize = [[NSNumber alloc] initWithFloat:7.7f]; + + return self; +} +@end + +Дядюшкофоны: + +@interface ChinaPad : GenericIPad +@end + +@implementation ChinaPad + +-(id) init +{ + self = [super init]; + self.osName = @"Windows CE"; + self.productName = @"Buan Que Ipado Killa"; + self.screenSize = [[NSNumber alloc] initWithFloat:12.5f]; + + return self; +} +@end +//-------- + +@interface ChinaPhone : GenericIPhone +@end + +@implementation ChinaPhone + +-(id) init +{ + self = [super init]; + + self.osName = @"Android"; + self.productName = @"Chi Huan Hua Phone"; + + return self; +} +@end + + + + + + + + + + + + + + + + + + + + + + + + Разные телефоны, конечно же, производятся на различных фабриках, потому мы +просто обязанны их создать! Приблизительно так должны выглядеть фабрика +Apple: + +@interface AppleFactory : IPhoneFactory +@end + +@implementation AppleFactory + +-(GenericIPhone *) getIPhone +{ + AppleIPhone *iphone = [[AppleIPhone alloc] init]; + return iphone; +} + +-(GenericIPad *) getIPad +{ + AppleIPad *ipad = [[AppleIPad alloc] init]; + return ipad; +} +@end + +Конечно же у нашего китайского дядюшки тоже есть своя фабрика: + +@interface ChinaFactory : IPhoneFactory +@end + +@implementation ChinaFactory + +-(GenericIPad *) getIPad +{ + ChinaPad *pad = [[ChinaPad alloc] init]; + return pad; +} + +-(GenericIPhone *) getIPhone +{ + ChinaPhone *phone = [[ChinaPhone alloc] init]; + return phone; +} +@end + +Как видим, фабрики одинаковые, а вот девайсы у них получются разныеJ + +Ну вот собственно и все, мы приготовили все что надо для доменострации! +Теперь, давайте напишем небольшой метод который будет возвращать нам +фабрику которую мы хотим ( кстати, тут фабричный метод таки будет): + +-(IPhoneFactory *) getFactory +{ + if (_isThirdWorld) + return [[ChinaFactory alloc] init]; + + return [[AppleFactory alloc] init]; +} + +Теперь, давайте как создадим несколько телефонов: + + _isThirdWorld = false; + IPhoneFactory *factory = self.getFactory; + GenericIPad *ipad = factory.getIPad; + GenericIPhone *iphone = factory.getIPhone; + NSLog(@"IPad named = %@, osname = %@, screensize = %@", + + + + + + + + + + + + + + + + + + + + ipad.productName, ipad.osName, ipad.screenSize.stringValue); + NSLog(@"IPhone named = %@, osname = %@", iphone.productName, iphone.osName); + +Лог будет выглядить следующим образом: + +2013-01-26 20:00:56.663 AbstractFactory[13093:11303] IPad named = Buan Que +Ipado Killa, osname = Windows CE, screensize = 12.5 +2013-01-26 20:00:56.665 AbstractFactory [13093:11303] IPhone named = Chi Huan +Hua Phone, osname = Android + +Теперь, просто поменяв значение переменной _isThirdWorld на false, и лог будет +совсем другой: + +2013-01-26 20:02:21.745 AbstractFactory [13115:11303] IPad named = IPad, osname += iOS, screensize = 7.7 +2013-01-26 20:02:21.747 AbstractFactory [13115:11303] IPhone named = IPhone, +osname = iOS + +Код примера. + + + + + + + + + + + + + Builder + +Вот представьте что у нас есть фабрика. Но в отличии от фабрики из +предыдущего поста, она умеет создавать только телефоны на базе андроида, и +еще при этом различной конфигурации. Тоесть, есть один объект, но при этом его +состояние может быть совершенно разным, а еще представьте если его очень +трудно создавать, и во время создания этого объекта еще и создается миллион +дочерних объектов. Именно в такие моменты, нам очень помогает такой паттерн +как строитель. + +Когда использовать: + +1. Создание сложного объекта +2. Процесс создания объекта тоже очень не тривиальный – к примеру + +получение данных из базы и манипуляция ими. + +Сам паттерн состоит из двух компонент – Bulilder и Director. Builder занимается +именно построение объекта, а Director знает какой Builder использовать чтобы +выдать необходимый продукт. Приступим! + +Пускай у нас есть телефон, который обладает следующими свойствами: + +@interface AndroidPhone : NSObject + +@property (nonatomic, weak) NSString *osVersion; +@property (nonatomic, weak) NSString *name; +@property (nonatomic, weak) NSString *cpuCodeName; +@property (nonatomic, strong) NSNumber *RAMsize; +@property (nonatomic, strong) NSNumber *osVersionCode; +@property (nonatomic, weak) NSString *launcher; +@end + +Давайте создадим дженерик строителя от которого будут наследоваться +конкретные строители: + +@interface BPAndroidPhoneBuilder : NSObject + +@property (nonatomic, strong) AndroidPhone* _phone; + +-(void) setOSVersion; +-(void) setName; +-(void) setCPUCodeName; +-(void) setRAMSize; +-(void) setOSVersionCode; +-(void) setLauncher; + +-(AndroidPhone *) getPhone; + +@end + +//--- + +@implementation BPAndroidPhoneBuilder + +-(id) init +{ + self = [super init]; + + self._phone = [[AndroidPhone alloc] init]; + + + + + + + + + + + + + + + + + + + + + + return self; +} + +-(AndroidPhone *) getPhone +{ + return self._phone; +} + +@end + +Ну а теперь напишем код для конкретных строителий. К примеру, так бы выглядел +строитель для дешевого телефона: + +@interface LowPricePhoneBuilder : BPAndroidPhoneBuilder +@end + +//---- +@implementation LowPricePhoneBuilder + +-(void) setOSVersion +{ + self._phone.osVersion = @"Android 2.3"; +} +-(void) setName +{ + self._phone.name = @"Low price phone!"; +} +-(void) setCPUCodeName +{ + self._phone.cpuCodeName = @"Some shitty CPU"; +} +-(void) setRAMSize +{ + self._phone.RAMsize = [[NSNumber alloc] initWithInt:256]; +} +-(void) setOSVersionCode +{ + self._phone.osVersionCode = [[NSNumber alloc] initWithFloat:3.0f]; +} +-(void) setLauncher +{ + self._phone.launcher = @"Hia Tsung!"; +} +@end + +И конечно же строительство дорогого телефона: + +@interface HighPricePhoneBuilder : BPAndroidPhoneBuilder +@end + +//---- + +@implementation HighPricePhoneBuilder + +-(void) setOSVersion +{ + self._phone.osVersion = @"Android 4.1"; +} +-(void) setName +{ + self._phone.name = @"High price phone!"; +} +-(void) setCPUCodeName +{ + self._phone.cpuCodeName = @"Some shitty but expensive CPU"; + + + + + + + + + + + + + + + + } +-(void) setRAMSize +{ + self._phone.RAMsize = [[NSNumber alloc] initWithInt:1024]; +} +-(void) setOSVersionCode +{ + self._phone.osVersionCode = [[NSNumber alloc] initWithFloat:4.1f]; +} +-(void) setLauncher +{ + self._phone.launcher = @"Samsung Launcher"; +} +@end + +Кто-то же должен использовать строителей, потому давайте создадим объект +который будет с помощью строителей создавать дешевые или дорогие телефоны: + +@interface FactorySalesMan : NSObject + +@property (nonatomic, strong) BPAndroidPhoneBuilder *_builder; + +-(void) setBulider:(BPAndroidPhoneBuilder *)aBuilder; +-(AndroidPhone *) getPhone; +-(void) constructPhone; + +@end + +//---- + +@implementation FactorySalesMan + +-(void)setBulider:(BPAndroidPhoneBuilder *)aBuilder +{ + self._builder = aBuilder; +} + +-(AndroidPhone *) getPhone +{ + return self._builder.getPhone; +} + +-(void) constructPhone +{ + [self._builder setOSVersion]; + [self._builder setName]; + [self._builder setCPUCodeName]; + [self._builder setRAMSize]; + [self._builder setOSVersionCode]; + [self._builder setLauncher]; +} + +@end + +Ну и конечно же куда мы без теста и кода: + +LowPricePhoneBuilder *_cheapPhoneBuilder = [[LowPricePhoneBuilder alloc] init]; + + HighPricePhoneBuilder *_expensivePhoneBuilder = + +[[HighPricePhoneBuilder alloc] init]; + + FactorySalesMan *_salesMan = [[FactorySalesMan alloc] init]; + [_salesMan setBulider:_cheapPhoneBuilder]; + [_salesMan constructPhone]; + AndroidPhone *_phone = [_salesMan getPhone]; + + NSLog(@"Phone Name = %@, osVersion = %@, cpu code name = %@, ram size = %@, os + + + + + + + + + + + + + + + + + + + + + + + + + + version code = %@, launcher = %@", + +_phone.name, _phone.osVersion, _phone.cpuCodeName, _phone.RAMsize, +_phone.osVersionCode, _phone.launcher); + + [_salesMan setBulider:_expensivePhoneBuilder]; + [_salesMan constructPhone]; + _phone = [_salesMan getPhone]; + NSLog(@"Phone Name = %@, osVersion = %@, cpu code name = %@, ram size = %@, os +version code = %@, launcher = %@", + +_phone.name, _phone.osVersion, _phone.cpuCodeName, _phone.RAMsize, +_phone.osVersionCode, _phone.launcher); + +Как видим, мы создали различных строителей, и сказав директору ( +FactorySalesMan) какой строитель мы хотим использовать, мы получаем тот +девайс который нам необходим: + +Традиционный лог: + +2013-01-28 00:38:51.863 BuilderPattern[708:11303] Phone Name = Low price phone!, +osVersion = Android 2.3, cpu code name = Some shitty CPU, ram size = 256, os +version code = 3, launcher = Hia Tsung! +2013-01-28 00:38:51.867 BuilderPattern[708:11303] Phone Name = High price phone!, +osVersion = Android 4.1, cpu code name = Some shitty but expensive CPU, ram size = +1024, os version code = 4.1, launcher = Samsung Launcher + +Код примера. + + + + + + + + + Singleton +//реализация паттерна, которая будет приведена тут, подразумевает +использование GDC и ARC. + +Кто вообще бы мог подумать, что Singleton такой не самый просто паттерн в iOS? +Вернее, что есть столько версий. Собственно, в .NET, помнится, наблюдалась +точно такая же штука, но там в основном были просто апдейты к самой простой +версии паттерна. Я вообще считаю, что сколько людей - столько и версий +синглтона. + +Итак, давайте начнем с простого – с описания. + +Singleton - это такой объект, который существует в системе только в +единственном экземпляре. Очень часто используется для хранения каких-то +глобальных переменных, например настроек приложения. + +Итак, как и все в Obj-C начнем мы естественно с создания интерфейса: + +@interface SingletonObject : NSObject + +@property (nonatomic, weak) NSString *tempProperty; ++(SingletonObject *) singleton; + +@end + +Как видим, обычный объект с одним свойством и класс методом. Естественно, +просто от интерфейса мы не получим всего чего ожидаем: + +@implementation SingletonObject + ++(SingletonObject *) singleton +{ + static SingletonObject *singletonObject = nil; + + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + singletonObject = [[self alloc] init]; + }); + + return singletonObject; +} +@end + +Собственно вот и все:) iOS сам за нас позаботится о том, чтобы создан был +только один экземпляр нашего объекта. Тут стоит сделать шаг назад и описать +проблему, которая являетя головной болью любого кто более-менее блихко +работал с потоками: + +1. Представьте что есть 2 потока. +2. И тут каждый, одновременно создает singleton.Вроде бы и должен + +создасться только один объект, но потому что все происходит в один +момент – бывают случаи когда создается два объекта. + +“Но ведь можно сделать проверку на nil!” – скажете Вы. + +А теперь, представьте более сложную ситуацию: объекта singleton не существует. +Два потока хотят его создать одновременно: + + + + + + + + + + + + + + + + + + + + 1. Поток 1 делает проверку или объект существует. Видит что его нет, и + +проходит этап проверки. + +2. Поток 2 делает проверку на существование объекта, и хоть и поток 1 + +проверку УЖЕ прошел, но объект ЕЩЕ не существует. + +Для решения таких проблем, в .NET использовали locks – блокирование кода, для +других потоков, пока он исполняется в каком – либо потоке. Собственно +dispatch_once делает тоже самое – он просто синхронный:) Потому, ни один поток +не может зайти в этот код, пока он занят. + +Собственно, без GCD такое создать тоже можно, тогда наш код бы выглядел +следующим образом: + ++(SingletonObject *) singleton +{ + static SingletonObject *singletonObject = nil; + @synchronized(self) + { + if (singletonObject == nil ) + { + singletonObject = [[self alloc] init]; + } + } + + return singletonObject; +} + +Получится тоже самое. Единственное, что dispatch_once() по документации +быстрее:) Ну и семантически более правильнее. + +Можно вообще бахнуть по хардкору, и создать макрос: + +#define DEFINE_SHARED_INSTANCE_USING_BLOCK(block) \ +static dispatch_once_t pred = 0; \ +__strong static id _sharedObject = nil; \ +dispatch_once(&pred, ^{ \ +_sharedObject = block(); \ +}); \ +return _sharedObject; \ + +Тогда сама реализация создания объекта будет выглядеть следующим образом: + ++(SingletonObject *) singleton +{ + DEFINE_SHARED_INSTANCE_USING_BLOCK(^{ + return [[self alloc] init]; + }); +} + +Ну, а использование простое: + +[[SingletonObject singleton] setTempProperty:@"Hello 2 You!"]; +NSLog(@"%@", [[SingletonObject singleton] tempProperty]); + +Код примера. + + + + + + + + + + + + + + + + + + + Adapter +Тяжело найти более красочно описание паттерна Адаптер, чем пример из жизни +каждого, кто покупал технику из США. Розетка! Вот почему не сделать одинаковую +розетку всюду? Но нет, в США розетка с квадратными дырками, в Европе с +круглыми, а в некоторых странах вообще треугольные. Следовательно – потому +вилки на зарядный устройствах, и других устройствах питания тоже различные. + +Представьте, что Вы едете в коммандировку в США. У Вас есть, допустим, +ноутбук купленный в Европе – следовательно вилка на проводе от блока питания +имеет круглые окончания. Что делать? Покупать зарядку для американского типа +розетки? А когда вы вернетесь домой – она будет лежать у Вас мертвым грузом? + +Потому, вероятнее всего, Вы приобретете один из адаптеров, которые +надеваются на вилку, и которая позволяет Вам использовать старую зарядку и +заряжаться от совершенно другой розетки. + +Так и с Адаптером – он конвертит интерфейс класса – на такой, который +ожидается. + +Сам паттерн состоит из трех частей: Цели (target), Адаптера (adapter), и +адаптируемого (adaptee). + +В нашей с вами проблеме: + +1. Target – ноутбук со старой зарядкой +2. Adapter – переходник. +3. Adaptee – розетка с квадртаными дырками. + +Имплементация паттерна Адаптер в Objective-C может быть 2 ( вероятно даже больше, +но я вижу две): + +Итак, первая – это простенькая имплементация. Пускай у нас есть объект Bird, +который реализует протокол BirdProtocol: + +@protocol BirdProtocol +-(void) sing; +-(void) fly; +@end + +@interface Bird : NSObject + +@end +//реализация +@implementation Bird + +-(void) sing +{ + NSLog(@"Tew-tew-tew"); +} + +-(void) fly +{ + NSLog(@"OMG! I am flying!"); +} +@end + + + + + + + + + + + + + + + + + + + И пускай у нас есть объект Raven, у которого есть свой интерфейс: + +@interface Raven : NSObject + +-(void) flySearchAndDestroy; +-(void) voice; + +@end + +@implementation Raven + +-(void) flySearchAndDestroy +{ + NSLog(@"I am flying and seak for killing!"); +} + +-(void) voice +{ + NSLog(@"Kaaaar-kaaaaar-kaaaaaaar!"); +} +@end + +Чтобы использовать ворону в методах которые ждут птицу:) стоит создать так +называемый адаптер: + +@interface RavenAdapter : NSObject +{ + @private Raven *_raven; +} + +@property (nonatomic, strong) Raven *raven; + +-(id) initWithRaven:(Raven*) adaptee; +@end + +//ну и сама реализация. Как видим мы завернули ворона в обертку протоколом +BirdProtocol +@implementation RavenAdapter + +@synthesize raven = _raven; + +-(id) initWithRaven:(Raven*) adaptee +{ + self = [super self]; + _raven = adaptee; + return self; +} + +-(void) sing +{ + [_raven voice ]; +} + +-(void) fly +{ + [_raven flySearchAndDestroy]; +} + +@end + +Ну и конечно же тест: + +-(void) makeTheBirdTest:(id)aBird +{ + [aBird fly]; + [aBird sing]; + + + + + + + + + + + + + + + + + + + + + + } +//и тестовый код: + + Bird *simpleBird = [[Bird alloc] init]; + + Raven *simpleRaven = [[Raven alloc] init]; + + RavenAdapter *ravenAdapter = [[RavenAdapter alloc] initWithRaven:simpleRaven]; + + [self makeTheBirdTest:simpleBird]; + [self makeTheBirdTest:ravenAdapter]; + +Результат можно легко увидеть в логе: + +2013-02-03 15:43:14.447 AdapterPattern[5985:11303] OMG! I am flying! +2013-02-03 15:43:14.449 AdapterPattern[5985:11303] Tew-tew-tew +2013-02-03 15:43:14.449 AdapterPattern[5985:11303] I am flying and seak for killing! +2013-02-03 15:43:14.450 AdapterPattern[5985:11303] Kaaaar-kaaaaar-kaaaaaaar! + +Теперь более сложная реализация, которая все еще зависит от протоколов, но +уже использует делегацию. Вернемся к нашему несчастному ноутбуку и зарядке: +Допустим у нас есть базовый клас Charger: + +@interface Charger : NSObject +-(void) charge; +@end + +@implementation Charger + +-(void) charge +{ + NSLog(@"C'mon I am charging"); +} +@end + +И есть протокол для европейской зардяки: + +@protocol EuropeanNotebookChargerDelegate +-(void) chargetNotebookRoundHoles:(Charger *)charger; +@end + +Если сделать просто реализацию – то получится тоже самое, что и в прошлом +примере:) Потому, давайте добавим делегат: + +@interface EuropeanNotebookCharger : Charger +{ +@private id _delegate; +} + +@property (nonatomic, strong) id delegate; +@end + +//реализация +@implementation EuropeanNotebookCharger + +@synthesize delegate = _delegate; + +-(id) init +{ + self = [super self]; + self.delegate = self; + return self; +} + + + + + + + + + + + + + + + + + + + + + + -(void) charge +{ + [_delegate chargetNotebookRoundHoles:self]; + [super charge]; +} + +-(void) chargetNotebookRoundHoles:(Charger *)charger +{ + //and yeah you can do smth with charger. + NSLog(@"Charging with 220 and round holes!"); +} + +@end + +Как видим, у нашего класа есть свойство которое реализует тип +EuropeanNotebookChargerDelegate. Так как, наш клас этот протокол реализует, он +может свойсту присвоить себя, потому когда происходит вызов: + +[_delegate chargetNotebookRoundHoles:self]; + +просто вызывается свой же метод. Вы увидите дальше, для чего это сделано. +Теперь, давайте глянем что ж за зверь такой – американская зарядка: + +@interface USANotebookCharger : NSObject +-(void) chargeNotebookRectHoles:(Charger *) charger; +@end + +@implementation USANotebookCharger + +-(void) chargeNotebookRectHoles:(Charger *) charger; +{ + NSLog(@"Charge Notebook Rect Holes"); +} +@end + +Как видим, в американской зарядке совсем другой метод и мировозрение. +Давайте, создадим адаптер для зарядки: + +@interface USANotebookEuropeanAdapter : Charger + +@property (nonatomic, strong) USANotebookCharger *usaCharger; + +-(id) initWithUSANotebookCharger:(USANotebookCharger *) charger; + +-(void) charge; +@end + +@implementation USANotebookEuropeanAdapter + +-(id) initWithUSANotebookCharger:(USANotebookCharger *) charger +{ + self = [super init]; + self.usaCharger = charger; + + return self; +} + +-(void) chargetNotebookRoundHoles:(Charger *) charger +{ + [self.usaCharger chargeNotebookRectHoles:charger]; +} + +-(void) charge +{ + + + + + + + + + + + + + + + + + + + + + + + EuropeanNotebookCharger *euroCharge = [[EuropeanNotebookCharger alloc] init]; + euroCharge.delegate = self; + [euroCharge charge]; +} +@end + +Как видим, наш адптер реализует интерф��йс EuropeanNotebookChargerDelegate и +его метод chargetNotebookRoundHoles. Потому, когда вызывается метод charge – +на самом деле создается тип европейской зарядки, ей присвается наш адаптер +как делегат, и вызывается ее метод charge. Так как делегатом присвоен наш +адаптер, при вызове метода chargetNotebookRoundHoles, будет вызыван этот +метод нашего адаптера, который в свою очередь вызывает метод зардяки США:) + +Давайте посмотрим тест код и вывод лога: + +//сам метод +-(void) makeTheNotebookCharge:(Charger *) aCharger +{ + [aCharger charge]; +} + +//тест код +EuropeanNotebookCharger *euroCharger = [[EuropeanNotebookCharger alloc] init]; + +[self makeTheNotebookCharge:euroCharger]; + +USANotebookCharger *charger = [[USANotebookCharger alloc] init]; +USANotebookEuropeanAdapter *adapter = + +[[USANotebookEuropeanAdapter alloc] initWithUSANotebookCharger:charger]; + +[self makeTheNotebookCharge:adapter]; + +Лог нам выведет: + +2013-02-03 15:57:42.624 AdapterPattern[6179:11303] Charging with 220 and round +holes! +2013-02-03 15:57:42.626 AdapterPattern[6179:11303] C’mon I am charging +2013-02-03 15:57:42.626 AdapterPattern[6179:11303] Charge Notebook Rect Holes +2013-02-03 15:57:42.627 AdapterPattern[6179:11303] C’mon I am charging + +Код примера. + + + + + + + + + + + + + + + + Bridge +Представьте себе, что у нас есть что-то однотипное, к примеру у нас есть +телефон и куча наушников. Если бы у каждого телефона был свой разъем, то мы +могли бы пользоваться только одним типом наушников. Но Бог миловал! +Собственно таже штука и с наушникам. Они могут выдавать различный звук, +иметь различные дополнительные функции, но основная их цель – просто +звучание:) И хорошо, что во многих случаях штекер у них одинаковый ( я не +говорю про различные студийные наушники:) ). + +Собственно, Мост (Bridge) позволяет разделить абстракцию от реализации, так +чтобы реализация в любой момент могла быть поменяна, не меняя при этом +абстракции. + +Когда использовать? + +1. Вам совершенно не нужна связь между абстракцией и реализацией. +2. Собственно, как абстракцию так и имплементацию могут наследовать + +независимо. + +3. Вы не хотите чтобы изменения в реализации имело влияния на клиентский + +код. + +Давайте создадим теперь базовую абстракцию наушников: + +@interface BaseHeadphones : NSObject + +-(void) playSimpleSound; +-(void) playBassSound; + +@end + +И теперь два элемента – дорогие наушники и дешевые:) + +//Наушники обычные - китайские +@interface CheapHeadphones : BaseHeadphones + +@end + +@implementation CheapHeadphones + +-(void) playSimpleSound +{ + NSLog(@"beep - beep - bhhhrhrhrep"); +} + +-(void) playBassSound +{ + NSLog(@"puf - puf - pufhrrr"); +} + +@end + +//наушники дорогие, тоже китайские +@interface ExpensiveHeadphones : BaseHeadphones +@end + +@implementation ExpensiveHeadphones + + + + + + + + + + + + + + + + + + + + + + + -(void) playSimpleSound +{ + NSLog(@"Beep-Beep-Beep Taram - Rararam"); +} + +-(void) playBassSound +{ + NSLog(@"Bam-Bam-Bam"); +} + +@end + +И собственно плеер, через который мы будем слушать музыку: + +@interface MusicPlayer : NSObject + +@property (nonatomic, strong) BaseHeadphones *headPhones; + +-(void) playMusic; + +@end + +@implementation MusicPlayer + +-(void) playMusic +{ + [self.headPhones playBassSound]; + [self.headPhones playBassSound]; + [self.headPhones playSimpleSound]; + [self.headPhones playSimpleSound]; + +} +@end + +Как видите, одно из свойств нашего плеера – наушники. Их можно подменять в +любой момент, так как свойство того же типа, от которого наши дешевые и +дорогие наушники наслед��ются. +Тест! + +MusicPlayer *p = [[MusicPlayer alloc] init]; +CheapHeadphones *ch = [[CheapHeadphones alloc] init]; +ExpensiveHeadphones *ep = [[ExpensiveHeadphones alloc] init]; +p.headPhones = ch; +[p playMusic]; +p.headPhones = ep; +[p playMusic]; + +И конечно же log: + +2013-02-06 23:03:52.378 BridgePattern[3397:c07] puf – puf – pufhrrr +2013-02-06 23:03:52.379 BridgePattern[3397:c07] puf – puf – pufhrrr +2013-02-06 23:03:52.380 BridgePattern[3397:c07] beep – beep – bhhhrhrhrep +2013-02-06 23:03:52.380 BridgePattern[3397:c07] beep – beep – bhhhrhrhrep +2013-02-06 23:03:52.380 BridgePattern[3397:c07] Bam-Bam-Bam +2013-02-06 23:03:52.381 BridgePattern[3397:c07] Bam-Bam-Bam +2013-02-06 23:03:52.381 BridgePattern[3397:c07] Beep-Beep-Beep Taram – Rararam +2013-02-06 23:03:52.381 BridgePattern[3397:c07] Beep-Beep-Beep Taram – Rararam + +Код примера. + + + + + + + + + + + + + + + + + + + + + Facade +Многие сложные системы состоят из огромной кучи компонент. Так же и в жизни, +очень часто для совершения одного основного действия, мы должны выполнить +много маленьких. + +К примеру, чтобы пойти в кино нам надо: + +1. Посмотреть расписание фильмов, выбрать фильм, посмотреть когда есть + +сеансы, посмотреть когда у нас есть время. + +2. Необходимо купить билет, для этого ввести номер карточки, секретный код, + +дождаться снятия денег, распечатать билет. + +3. Приехать в кинотеатр, запарковать машину, купить попкорн, найти места, + +смотреть. + +И все это для того, чтобы просто посмотреть фильм, который нам, очень +вероятно, не понравится. + +Или же возьмем пример Amazon – покупка с одного клика – как много систем +задействовано в операции покупки? И проверка Вашей карточки, и проверка +Вашего адреса, проверка товара на складе, проверка или возможна доставка +даного товара в даную точку мира… В результате очень много действий которые +происходят всего по одному клику. + +Для таких вот процесов был изобретен паттерн – Фасад ( Facade ) который +предоставляет унифицированный интерфейса к большому количеству +интерфейсов системы, в следствии чего систему стает гораздо проще в +использовании. + +Давайте, попробуем создать систему которая нас переносит в другую точку мира с +одного нажатия кнопки! С начала нам нужна система которая проложит путь от +нашего места перебывания в место назначения: + +@interface PathFinder : NSObject + +-(void) findCurrentLocation; +-(void) findLocationToTravel:(NSString *) location; +-(void) makeARoute; + +@end + +@implementation PathFinder + +-(void) findCurrentLocation +{ + NSLog(@"Finding your location. Hmmm, here you are!"); +} + +-(void) findLocationToTravel:(NSString *)location +{ + NSLog(@"So you wanna travell to %@", location); +} + +-(void) makeARoute +{ + NSLog(@"Okay, to travell to this location we are using google maps...."); + //looking for path in google maps. +} + + + + + + + + + + + + + + + + + @end + +Естественно нам необходима сама система заказа транспорта и собственно +путешествия: + +@interface TravellEngine : NSObject + +-(void) findTransport; +-(void) orderTransport; +-(void) travel; + +@end + +@implementation TravellEngine + +-(void) findTransport +{ + NSLog(@"Okay, to travell there you will probabply need dragon!Arghhhhh"); +} + +-(void) orderTransport +{ + NSLog(@"Maaaam, can I order a dragon?... Yes... Yes, green one... Yes, with +fire!... No, not a dragon of death... Thank you!"); +} + +-(void) travel +{ + NSLog(@"Maaan, you are flying on dragon!"); +} + +@end + +Ну и какие же путешествия без билетика: + +@interface TicketPrinitingSystem : NSObject + +-(void) createTicket; +-(void) printingTicket; + +@end + +@implementation TicketPrinitingSystem + +-(void) createTicket +{ + NSLog(@"Connecting to our ticketing system..."); +} + +-(void) printingTicket +{ + NSLog(@"Hmmm, ticket for travelling on the green dragon.Interesting..."); +} + +@end + +А теперь, давайте создадим единый доступ ко всем этим системам: + +@interface TravellSystemFacade : NSObject + +-(void) travellTo:(NSString *)location; + +@end + +@implementation TravellSystemFacade + + + + + + + + + + + + + + + + + + + + + + + + + + -(void) travellTo:(NSString *)location +{ + + PathFinder *pf = [[PathFinder alloc] init]; + TravellEngine *te = [[TravellEngine alloc] init]; + TicketPrinitingSystem *tp = [[TicketPrinitingSystem alloc] init]; + + [pf findCurrentLocation]; + [pf findLocationToTravel:location]; + [pf makeARoute]; + + [te findTransport]; + [te orderTransport]; + [tp createTicket]; + [tp printingTicket]; + [te travel]; +} + +@end + +Как видим, наш фасад знает все про все системы, потому в одном методе он +берет и транспортирует нас куда следует. Код теста элементарен: + + TravellSystemFacade *facade = [[TravellSystemFacade alloc] init]; + [facade travellTo:@"Lviv"]; + +Давайте посмотрим лог: + +2013-02-09 17:46:28.442 FacadePattern[2410:c07] Finding your location. Hmmm, here +you are! +2013-02-09 17:46:28.444 FacadePattern[2410:c07] So you wanna travell to Lviv +2013-02-09 17:46:28.445 FacadePattern[2410:c07] Okay, to travell to this location we +are using google maps…. +2013-02-09 17:46:28.446 FacadePattern[2410:c07] Okay, to travell there you will +probabply need dragon!Arghhhhh +2013-02-09 17:46:28.446 FacadePattern[2410:c07] Maaaam, can I order a dragon?… +Yes… Yes, green one… Yes, with fire!… No, not a dragon of death… Thank you! +2013-02-09 17:46:28.447 FacadePattern[2410:c07] Connecting to our ticketing +system… +2013-02-09 17:46:28.447 FacadePattern[2410:c07] Hmmm, ticket for travelling on the +green dragon.Interesting… +2013-02-09 17:46:28.448 FacadePattern[2410:c07] Maaan, you are flying on dragon! + +Код примера. + + + + + + + + + + + + + + + + + + Mediator +Медиатор – паттерн которые определяет внутри себя объект, в котором +реализуется взаимодействие между некоторым количеством объектов. При этом +эти объекты, могут даже не знать про существования друг друга, потому +взаимодействий реализованых в медиаторе может быть огромное количество. + +Когда стоит использовать: + +1. Когда у вас есть некоторое количество объектов, и очень тяжело + +реализовать взаимодействие между ними. Яркий пример – умный дом. +Онозначно есть неколько датчиков, и несколько устройств. К примеру, +датчик температуры следит за тем какая на даный момент температура, а +кондционер умеет охлаждать воздух. При чем кондиционер, не обязательно +что знает про существования датичка температуры. Есть центральный +компьютер, который получает сигналы от каждого из устройств и понимает, +что делать в том или ином случает. + +2. Тяжело переиспользовать объект, так как он взаимодействует и + +коммуницирует с огромным количеством других объектов. + +3. Логика взаимодействия должна легко настраиваться и расширяться. + +Собственно, пример медиатора даже писать безсмысленно, потому как это любой +контроллер который мы используем во время нашей разработки. Посудите сами – +на view есть очень много контролов, и все правила взаимодействия мы +прописываем в контроллере. Элементарно. + +И все же пример не будет лишним Давайте все же создадим пример который +показывает создание аля умного дома. + +Пускай у нас есть оборудование которое может взаимодействоать с нашим умным +домом: + +@class CentrallProcessor; + +@interface SmartHousePart : NSObject +{ +@private CentrallProcessor *_processor; +} + +-(id) initWithCore:(CentrallProcessor *) processor; + +-(void) numbersChanged; + +@end + +@implementation SmartHousePart + +-(id) initWithCore:(CentrallProcessor *)processor +{ + self = [super init]; + _processor = processor; + + return self; +} + +-(void) numbersChanged +{ + [_processor valueChanged:self]; +} + + + + + + + + + + + + + + + + + + @end + +Теперь, создадим сердце нашего умного дома: + +@interface CentrallProcessor : NSObject + +@property (nonatomic, weak) Thermometer *_thermometer; +@property (nonatomic, weak) ConditioningSystem *_condSystem; + +-(void) valueChanged:(SmartHousePart *) aPart; + +@end + +@implementation CentrallProcessor + +-(void) valueChanged:(SmartHousePart *) aPart +{ + NSLog(@"Value changed! We need to do smth!"); + + //detecting that changes are done by thermometer + if ( [aPart isKindOfClass:[Thermometer class]]) + { + NSLog(@"Oh, the change is temperature"); + + [[self _condSystem] startCondition]; + } +} + +@end + +Тут очень интересный момент – класс CentrallProcessor должен знать про +существование SmartHousePart, собственно и SmartHousePart должен знать про +существование CentrallProcessor. Если все сделать простым import – то проект не +скомпилируется.Потому, в SmartHousePart.h мы добавили +@class CentrallProcessor; для того чтобы XCode знал что за объект будет +использован, и при этом не импортил файл заголовков CentrallProcessor. + +Заголовки же мы импортим в SmartHousePart.m. + +Дальше в классе CentrallPart в методе valueChanged мы определяем с какой +деталью и что произошло, чтобы адекватно среагировать. В нашем примере – +изменение температуры приводт к тому что мы включаем кондиционер. + +А вот, и код термометра и кондиционера: + +@interface Thermometer : SmartHousePart + +@property (nonatomic) int temperature; + +-(void) temperatureChanged:(int) temperature; + +@end + +@implementation Thermometer + +-(void)temperatureChanged:(int)temperature +{ + self.temperature = temperature; + [self numbersChanged]; +} + +@end + + + + + + + + + + + + + + + + + + + + + + + + + + @interface ConditioningSystem : SmartHousePart + +-(void) startCondition; + +@end + +@implementation ConditioningSystem + +-(void) startCondition +{ + NSLog(@"Conditioning..."); +} + +@end + +Как видим в результате у нас есть два объекта, которые друг про друга не в курсе, +и все таки они взаимодействуют друг с другом посредством нашего медиатора +CentrallProcessor. + +Код для тестинга: + +CentrallProcessor *proccessor = [[CentrallProcessor alloc] init]; + + Thermometer *therm = [[Thermometer alloc] initWithCore:proccessor]; + ConditioningSystem *condSystem = + +[[ConditioningSystem alloc] initWithCore:proccessor]; + + proccessor._condSystem = condSystem; + proccessor._thermometer = therm; + [therm temperatureChanged:45]; + +И конечно же лог: + +2013-02-12 18:45:06.790 MediatorPattern[8809:c07] Value changed! We need to do +smth! +2013-02-12 18:45:06.793 MediatorPattern[8809:c07] Oh, the change is temperature +2013-02-12 18:45:06.793 MediatorPattern[8809:c07] Conditioning… + +Код примера. + + + + + + + + + + + + + + + + + + + + + + + + Observer +Что такое паттерн Observer? Вот вы когда нибудь подписывались на газету? Вы +подписываетесь, и каждый раз когда выходит новый номер газеты вы получаете +ее к своему дому. Вы никуда не ходите, просто даете информацию про себя, и +организация которая выпускает газету сама знает куда и какую газету отнесту. +Второе название этого паттерна – Publish – Subscriber. + +Как описывает этот паттерн наша любимая GoF книга – Observer определяет +одно-ко-многим отношение между объектами, и если изменения происходят в +объекте – все подписанные на него объекты тут же узнают про это изменение. + +Идея проста, объект который мы называем Subject – дает возможность другим +объектам, которые реализуют интерфейс Observer, подписываться и +отписываться от изменений происходящик в Subject. Когда изменение происходит +– всем заинетерсованным объектам высылается сообщение, что изменение +произошло. В нашем случае – Subject – это издатель газеты, Observer это мы с +вами – те кто подписывается на газету, ну и собсвтенно изменение – это выход +новой газеты, а оповещение – отправка газеты всем кто подписался. + +Когда используется паттерн: + +1. Когда Вам необходимо сообщить всеи объектаь подписанным на + +изменения, что изменение произошло, при этом вы не знаете типы этих +объектов. + +2. Изменения в одном объекте, требуют чтоб состояние изменилось в других + +объектах, при чем количество объектов может быть разное. + +Реализация этого паттерна возможно двумя способами: + +1. Notification + +Notificaiton – механизм использования возможностей NotificationCenter самой +операционной системы. Использование NSNotificationCenter позволяет объектам +комуницировать, даже не зная друг про друга. Это очень удобно использовать +когда у вас в паралельном потоке пришел push-notification, или же обновилась +база, и вы хотите дать об этом знать активному на даный момент View. + +Чтобы послать такое сообщение стоит использовать конструкцию типа: + +NSNotification *broadCastMessage = [NSNotification + + notificationWithName:@"broadcastMessage" + object:self]; + NSNotificationCenter * notificationCenter = + [NSNotificationCenter defaultCenter]; + +Как видим мы создали объект типа NSNotification в котором мы указали имя +нашего оповещения: “broadcastMessage”, и собственно сообщили о нем через +NotificationCenter. + +Чтобы подписаться на событие в объекте который заинтересован в изменении +стоит использовать следующую конструкцию: + +NSNotificationCenter * notificationCenter = + + + + + + + + + + + + + + + + + + [NSNotificationCenter defaultCenter]; + [notificationCenter addObserver:self + selector:@selector(update:) + name:@"broadcastMessage" object:nil]; + +Собственно, из кода все более-менее понятно: мы подписываемся на событие, и +вызывается метод который задан в своействе selector. + +2. Стандартный метод. + +Стандартный метод, это реализация этого паттерна тогда, когда Subject знает про +всех подписчиков, но при этом не знает их типа. Давайте начнем с того, что +создадим протоколы для Subject и Observer: + +@protocol StandardObserver + +-(void) valueChanged:(NSString *)valueName newValue:(NSString *) newValue; + +@end + +@protocol StandardSubject + +-(void) addObserver:(id) observer; +-(void) removeObserver:(id) observer; +-(void) notifyObjects; + +@end + +Теперь, давайте создадим реализацию Subject: + +@interface StandardSubjectImplementation : NSObject +{ + @private NSString *_valueName; + @private NSString *_newValue; +} + +@property (nonatomic, strong) NSMutableSet *observerCollection; + +-(void)changeValue:(NSString *)valueName andValue:(NSString *) newValue; + +@end + +@implementation StandardSubjectImplementation + +-(NSMutableSet *) observerCollection +{ + if (_observerCollection == nil) + _observerCollection = [[NSMutableSet alloc] init]; + + return _observerCollection; +} + +-(void) addObserver:(id)observer +{ + [self.observerCollection addObject:observer]; +} + +-(void) removeObserver:(id)observer +{ + [self.observerCollection removeObject:observer]; +} + +-(void) notifyObjects +{ + + + + + + + + + + + + + + + + + + + + + + + + + for (id observer in self.observerCollection) { + [observer valueChanged: _valueName newValue:_newValue]; + } +} + +-(void)changeValue:(NSString *)valueName andValue:(NSString *) newValue +{ + _newValue = newValue; + _valueName = valueName; + [self notifyObjects]; +} + +@end + +Ну и куда же без обсерверов: + +@interface SomeSubscriber : NSObject +@end + +@implementation SomeSubscriber +-(void) valueChanged:(NSString *)valueName newValue:(NSString *)newValue +{ + NSLog(@"And some subscriber tells: Hmm, value %@ changed to %@", valueName, +newValue); + +} +@end + +//и второй подписчик: +@interface OtherSubscriber : NSObject + +@end + +@implementation OtherSubscriber + +-(void) valueChanged:(NSString *)valueName newValue:(NSString *)newValue +{ + NSLog(@"And some another subscriber tells: Hmm, value %@ changed to %@", +valueName, newValue); +} + +@end + +Собственно – все:) теперь демо-код: + + StandardSubjectImplementation *subj = [[StandardSubjectImplementation alloc] +init]; + SomeSubscriber *someSubscriber = [[SomeSubscriber alloc] init]; + OtherSubscriber *otherSubscriber = [[OtherSubscriber alloc] init]; + + [subj addObserver:someSubscriber]; + [subj addObserver: otherSubscriber]; + +[subj changeValue:@"strange value" andValue:@"newValue"]; + +И естественно log: + +2013-02-16 17:31:43.176 ObserverPattern[24332:c07] And some subscriber tells: +Hmm, value strange value changed to newValue +2013-02-16 17:31:43.177 ObserverPattern[24332:c07] And some another subscriber +tells: Hmm, value strange value changed to newValue + +Ну и конечно же без использования KVO описание паттерна выглядило бы +неполным. + + + + + + + + + + + + + + + + + + + + + + + + Одна из моих самых любимых особенностей Obj-C – это key-value coding. Про +него очень клево описанно в официальной документации, но если объяснять на +валенках – то это возможность изменять значения свойств объекта с помощью +строчек – которые указывают именно само название свойства. Как пример такие +две конструкции идентичны: + + kvoSubj.changeableProperty = @"new value"; + + [kvoSubj setValue:@"new value" forKey:@"changeableProperty"]; + +Такая гибкость дает нам доступ к еще одной очень замечательной возможности, +которая называется key-value observing. Опять же, все круто описанно в +документации, но если объяснять на валенках:) то это возможность подписаться +на изменение любого свойства, у любого объекта который KV compilant, любым +объектом. На самом деле легче объяснить на примере. + +Давайте создадим клас с одним свойством, которое мы будем менять: + +@interface KVOSubject : NSObject + +@property (nonatomic, strong) NSString *changeableProperty; + +@end + +@implementation KVOSubject + +@end + +И создадим объект который будет слушать изменение свойства +changeableProperty: + +@interface KVOObserver : NSObject +@end + +@implementation KVOObserver + +-(void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object +change:(NSDictionary *)change context:(void *)context +{ + NSLog(@"KVO: Value changed;"); +} + +@end + +Как видим, этот класс реализует только один метод: observeValueForKeyPath. +Этот метод будет вызван когда поменяется свойство объекта за которым мы +наблюдаем. + +Теперь тест: + + KVOSubject *kvoSubj = [[KVOSubject alloc] init]; + KVOObserver *kvoObserver = [[KVOObserver alloc] init]; + + [kvoSubj addObserver:kvoObserver forKeyPath:@"changeableProperty" + options:NSKeyValueObservingOptionNew context:nil]; + + [kvoSubj setValue:@"new value" forKey:@"changeableProperty"]; + + //because kvoSubj will be deallocated after this functions ends we need to remove +observer information. + + + + + + + + + + + + + + + + + + + + + + + + + [kvoSubj removeObserver:kvoObserver forKeyPath:@"changeableProperty"]; + +Как видно из примера, мы для объекта за которым мы наблюдаем, выполняем +функцию addObserver – где устанавливаем кто будет наблюлать за изменениями, +за изменениями какого свойства мы будем наблюдать и остальные опции. Дальше +меняем значение свойства, и так как мы все это проделываем на нажатие кнопки +– в конце мы удаляем наблюдателя с нашего объекта, что бы память не текла. +Лог говорит сам за себя: + +2013-02-17 11:41:58.051 ObserverPattern[26689:c07] KVO: Value changed; +2013-02-17 11:41:58.052 ObserverPattern[26689:c07] KVO: Value changed; + +Код примера. + + + + + + + + + Composite +Вы задумывались как много в нашей жизни древовидных структур? Начиная +собственно от самих деревьев, и заканчивая структурами компаний. Да даже, +ладно компаний – целые страны используют древовидные структуры, чтобы +построить власть. + +Во главе компании или страны частенько стоит один человек, у него есть с 10 +помошников. У них тоже есть с десяток помошников, и так далее… Если +нарисовать их отношения на листе бумаги – увидим дерево! + +Очень часто, и мы используем такие типы даных, которые лучше всего храняться +в древовидной структуре. Возьмите к примеру стандартный UI: в начале у нас +есть View, в нем находяться Subview, в которых могут быть или другие View, или +все такие компоненты. Та же самая структура:) + +Именно для хранения таких типов данных, а вернее их организации, используется +паттерн – Композит. + +Когда использовать такой паттерн? + +Собственно когда вы работаете с древовидными типами данных, или хотите +отобразить иерархию даных таким образом. + +Давайте разберем более детально структуру: + +В начале всегда есть контейнер в котором находятся все остальные объекта. +Контейнер может хранить как другие контейнеры – ветки нашего дерева, так и +объекты которые контейнерами не являюстся – листья нашего дерева. Не сложно +представить, что контейнеры второго уровня могут хранить как другие +контейнеры, так и листья. + +Давайте пример! + +Начнем с создания протокола для наших объектов: + +@protocol CompositeObjectProtocol + +-(NSString *) getData; +-(void) addComponent:(id)aComponent; + +@end + +Создадим объект листа: + +@interface LeafObject : NSObject + +@property (nonatomic, strong) NSString *leafValue; + +@end + +@implementation LeafObject + +-(NSString *) getData +{ + return [[NSString alloc] initWithFormat:@"<%@/>",self.leafValue ]; +} + + + + + + + + + + + + + + + + + + + + + + -(void) addComponent:(id)aComponent +{ + NSLog(@"Can't add component. Sorry, man"); +} + +@end + +Как видим наш объект не может добавлять себе детей (ну он же не контейнер:) ), +и может возвращать свое значение с помощью метода getData. + +Теперь нам очень необходим конейтнер: + +@interface Container : NSObject + +@property (nonatomic,strong) NSMutableArray *components; + +@end + +@implementation Container + +-(NSMutableArray *) components +{ + if (_components == nil) + _components = [[NSMutableArray alloc] init]; + + return _components; +} + +-(void) addComponent:(id)aComponent +{ + [self.components addObject:aComponent]; +} + +-(NSString *) getData +{ + NSMutableString *valueToReturn = [[NSMutableString alloc] init]; + [valueToReturn appendString:@""]; + + for ( id object in _components) + { + [valueToReturn appendString:[object getData]]; + } + [valueToReturn appendString:@""]; + + return valueToReturn; + +} + +@end + +Как видим, наш контейнер может добавлять в себя детей, которые могут быть как +типа Container так и типа LeafObject. Метод getData же, бегает по всем объектам в +массиве components, и вызывает тот же самый метод в детях. Вот собственно и +все. + +Теперь, конечно же пример: + + Container *rootContainer = [[Container alloc] init]; + LeafObject *object = [[LeafObject alloc] init]; + object.leafValue = @"level1 value"; + [rootContainer addComponent:object]; + + Container *firstLevelContainer1 = [[Container alloc] init]; + LeafObject *object2 = [[LeafObject alloc] init]; + + + + + + + + + + + + + + + + + + + + + + + + object2.leafValue = @"level2 value"; + [firstLevelContainer1 addComponent:object2]; + [rootContainer addComponent:firstLevelContainer1]; + + Container *firstLevelContainer2 = [[Container alloc] init]; + LeafObject *object3 = [[LeafObject alloc] init]; + object3.leafValue = @"level2 value 2"; + [firstLevelContainer2 addComponent:object3]; + [rootContainer addComponent:firstLevelContainer2]; + + NSLog(@"%@", rootContainer.getData); + +И конечно же лог: + +2013-02-17 13:04:09.470 CompositePattern[27392:c07] + + + + + + + + + + + + + + + + +Код примера. + + + + + + + + + + + + + + + + + + + Iterator +Я задумался о том, какой бы пример из жизни привести, чтобы показать пример +как работает паттерн итератор, и оказалось что это не такой простое задание. И +как показывает практика, самый простой пример – это обычная вендинг машина. ( +сам пример взят из книги Pro Objective-C Design Patterns for iOS. ) . У нас есть +контейнер, который разделен на секции, каждая из которых содержит +определенный вид товара, к примеру набор бутылок Coca-Cola. Когда мы +заказываем товар, то нам выпадет следующий из колекции. Образно говоря, +команда cocaColaCollection.next. Две независимые части – контейнер и итератор. + +Паттерн итератор позволяет последовательно обращаться к колекции +объектов,не особо вникая что же это за коллекция. + +Разделяют два вида итераторов – внутрений и внешний. Как видно из названия, +внешний иетратор – итератор про который знает клиент, и собственно он +сам(клиент) скармливает коллекцию по которой надо бегать итатору. Внутрений +иетратор – это внутрения кухня самой колекции, которая предоставляет +интерфейс клиенту для итерирования. + +При внешнем итераторе, клиенту надо: + +1. Вообще знать про существование итератора, хоть это и дает больше + +контроля. + +2. Создавать и управлять итератором. + +3. Можно использовать различные итераторы, для различных алгоритмов + +итерации. + +При внутренем: + +1. Клиенту совершенно не известно существование итератора. Он просто + +дергает интерфейс коллекции. + +2. Коллекция сама создает и управляет итератором + +3. Коллекция может менять различные итераторы, при этом не трогая код + +клиента. + +Когда использовать итератор: + +1. Вам неообходимо доступиться к объектам коллекции, без того чтобу щупать +внутренности коллекции. + +2. Вам надо обходить объекты коллекции различными способами (вспомните +Композит ��� у вас коллекция может быть древовидной ) + +3. Вам необходимо дать унифицированный интерфейс для различных подходов +итерации. + +Самый просто пример внешнего итератора, это использование класса +NSEnumerator: + + + + NSEnumerator *enumerator = [internallArrayCollection objectEnumerator]; + NSString* element; + + while (element = [enumerator nextObject]) { + NSLog(@"%@",element); + +} + +Как видим, мы просто вызываем у объекта internallArrayCollection метод +objectEnumerator – и получаем необходимый нам иетратор. Вообще можно не +заморачиваться, и использовать обычный цикл for: + + for (NSString *element in internallArrayCollection) + { + NSLog(@"%@",element); + +} + +Я не уверен что смогу правильно объяснить разницу между созданием итератора +и цикла for (если она есть), потому этот момент будет упущен. + +Одним из примеров реализации внешнего итератора – может быть итерация с +помощью блоков: + + [internallArrayCollection enumerateObjectsUsingBlock: + ^(id obj, NSUInteger idx, BOOL *stop) { + if([obj localizedCaseInsensitiveCompare:@"Dima"] == NSOrderedSame) + { + NSLog(@"Dima has been found!"); + *stop = YES; + } + }]; + +Радость этого метода в том, что сам алгоритм итерации может написать другой +программист, вам же необходимо будет только использовать блок написанный +этим программистом. Все выглядит приблизительно так: + +//создание блока поиска Dima в массиве строчек + + void (^simpleDimaSearchBlock)(id, NSUInteger, BOOL*) = + ^(id obj, NSUInteger idx, BOOL *stop){ + if([obj localizedCaseInsensitiveCompare:@"Dima"] == NSOrderedSame) + { + NSLog(@"Dima has been found!"); + *stop = YES; + } + }; + + [internallArrayCollection enumerateObjectsUsingBlock:simpleDimaSearchBlock]; + +Приятно же:) + +Теперь давайте создадим свой итератор, а то и два:) Пускай у нас будет +коллекция товаров, одни их них будут сломаны, другие же – целыми. Создадим +два итератора, которые будут бегать по разным типам товаров. Итак, для начала +сам клас товаров: + +@interface ItemInShop : NSObject + +@property (nonatomic, strong) NSString *name; +@property (nonatomic) BOOL isBroken; + +-(id) initWithArgs:(NSString *)aName andQaulity:(BOOL)isBroken; + + + + + + + + + + + + + + + + @end + +@implementation ItemInShop + +-(id) initWithArgs:(NSString *)aName andQaulity:(BOOL)isBroken +{ + self = [super init]; + self.name = aName; + self.isBroken = isBroken; + return self; +} + +@end + +Как видим не густо – два свойства, и инициализатор. +Теперь давайте создадим склад в котором собственно товары то и будут: + +@interface ShopWarehouse : NSObject +{ + @private NSMutableArray *goods; + @private GoodItemsEnumerator *goodItemsEnumerator; + @private BadItemsEnumerator *badItemsEnumerator; +} + +-(void) addItem:(ItemInShop *)anItem; + +-(NSEnumerator *) getBrokenItemsEnumerator; +-(NSEnumerator *) getGoodItemsEnumerator; + +@end + +@implementation ShopWarehouse + +-(id) init +{ + self = [super init]; + + goods = [[NSMutableArray alloc] init]; + + return self; +} + +-(void) addItem:(ItemInShop *)anItem +{ + [goods addObject:anItem]; +} + +-(NSEnumerator *) getBrokenItemsEnumerator +{ + badItemsEnumerator = [[BadItemsEnumerator alloc] initWithItems:goods]; + return badItemsEnumerator; +} + +-(NSEnumerator *) getGoodItemsEnumerator +{ + goodItemsEnumerator = [[GoodItemsEnumerator alloc] initWithItems:goods]; + return goodItemsEnumerator; +} + +@end + +Как видим, наш склад умеет добавлять товары, а также возвращать два +таинственных объекта под названием GoodItemsEnumerator и BadItemsIterator. + + + + + + + + + + + + + + + + + + + + Собственно их назначение очевидно, давайте посмотрим на реализацию. Для +начала создадим базовый клас для обоих: + +@interface BasicEnumerator : NSEnumerator +-(id)initWithItems:(NSMutableArray *)anItems; +-(NSArray *)allObjects; +-(id) nextObject; +@end + +Как видим, это просто интерфейс, который предпологает реализацию 3х методов: +инициализация, вернуть все объекты, и вернуть следующий объект. Давайте +создадим два итератора как и задумывалось: + +@interface BadItemsEnumerator : BasicEnumerator +{ + @private NSMutableArray *itemsArray; + @private NSEnumerator *internalEnumerator; +} +@end + +@implementation BadItemsEnumerator +-(id) initWithItems:(NSMutableArray *)anItems +{ + self = [super init]; + itemsArray = [[NSMutableArray alloc] init]; + for ( ItemInShop *item in anItems) + { + if (item.isBroken) + [itemsArray addObject:item]; + } + internalEnumerator = [itemsArray objectEnumerator]; + + return self; +} + +-(NSArray *)allObjects +{ + return itemsArray; +} + +-(id) nextObject +{ + return [internalEnumerator nextObject]; +} + +@end + +Я не привожу код GoodItemsIterator, потому как разнится они будут только в одной +строчке: + +if (!item.isBroken) + +Как видим во время инициализации, мы создаем свою копию данных, в которых +только плохие товары. Так же создаем свой внутренний иетратор, из стандартных +Cocoa. + +Ну что, тестим: + +//создание тестовых даных + + shopWarehouse = [[ShopWarehouse alloc] init]; + + [shopWarehouse addItem:[[ItemInShop alloc]initWithArgs:@"Item1" andQaulity:NO]]; + [shopWarehouse addItem:[[ItemInShop alloc]initWithArgs:@"Item2" andQaulity:NO]]; + + + + + + + + + + [shopWarehouse addItem:[[ItemInShop alloc]initWithArgs:@"Item3" andQaulity:YES]]; + [shopWarehouse addItem:[[ItemInShop alloc]initWithArgs:@"Item4" andQaulity:YES]]; + +[shopWarehouse addItem:[[ItemInShop alloc]initWithArgs:@"Item5" andQaulity:NO]]; + +Сам тест: + + GoodItemsEnumerator *goodIterator = [shopWarehouse getGoodItemsEnumerator]; + BadItemsEnumerator *badIterator = [shopWarehouse getBrokenItemsEnumerator]; + + ItemInShop *element; + while (element = [goodIterator nextObject]) { + NSLog(@"Good Item = %@", element.name); + } + + while (element = [badIterator nextObject]) { + NSLog(@"Bad Item = %@", element.name); + +И конечно же лог: + +2013-02-25 01:18:10.401 IteratorPattern[5000:c07] Good Item = Item1 +2013-02-25 01:18:10.403 IteratorPattern[5000:c07] Good Item = Item2 +2013-02-25 01:18:10.403 IteratorPattern[5000:c07] Good Item = Item5 +2013-02-25 01:18:10.404 IteratorPattern[5000:c07] Bad Item = Item3 +2013-02-25 01:18:10.405 IteratorPattern[5000:c07] Bad Item = Item4 + +Код примера. + + + + + + + + + Visitor +Вот у каждого дома вероятнее всего есть холодильник. В ВАШЕМ доме, ВАШ +холодильник. Что будет если холодильник сломается? Некоторые пойдут +почитают в интернете как чинить холодильник, какая модель, попробуют +поколдовать над ним, и разочаровавшись вызовут мастера по ремонту +холодильников. Заметьте – холодильник ваш, но функцию “Чинить Холодильник” +выполняет совершенно другой человек, про которого вы ничего не знаете, а +попросту – обычный визитер. + +Паттерн визитер – позволяет вынести из наших объектов логику, которая +относится к этим объектам, в отдельный клас, что позволяет нам легко изменять / +добавлять алгоритмы, при этом не меняя логику самого класа. + +Когда мы захотим использовать этот паттерн: + +1. Когда у нас есть сложный объект, в котором содержится большое + +количество различных элементов, и вы хотите выполнять различные +операции в зависимости от типа этих элиментов. + +2. Вам необходимо выполнять различные операции над класами, и при этом + +Вы не хотите писать вагон кода внутри реализации этих классов. +3. В конце – ��онцов, вам нужно добавлять различные операции над + +элементами, и вы не хотите постоянно обновлять классы этих элементов. + +Чтож, давайте вернемся к примеру из прошлой статьи, только теперь сложнее – у +нас есть несколько складов, в каждом складе можнт хранится товар. Один визитер +будет смотреть склады, другой визитер будет называть цену товара в складе. + +Итак, для начала сам товар: + +@interface WarehouseItem : NSObject + +@property (nonatomic, strong) NSString *name; +@property (nonatomic) BOOL isBroken; +@property (nonatomic) int price; + +-(id) initWithArgs:(NSString *)aName andQuality:(BOOL) isBrokenState +andPrice:(int)aPrice; + +@end + +@implementation WarehouseItem + +-(id) initWithArgs:(NSString *)aName andQuality:(BOOL)isBrokenState +andPrice:(int)aPrice +{ + self = [super init]; + self.name = aName; + self.isBroken = isBrokenState; + self.price = aPrice; + return self; +} +@end + +И естественно сам склад: + + + + + + + + + + + @interface Warehouse : NSObject +{ +@private NSMutableArray *_itemsArray; +} + +-(void) addItem:(WarehouseItem *) anItem; +-(void) accept:(id) visitor; + +@end + +@implementation Warehouse +-(void) addItem:(WarehouseItem *)anItem +{ + if (!_itemsArray) + _itemsArray = [[NSMutableArray alloc] init]; + + [_itemsArray addObject:anItem]; +} + +-(void) accept:(id) visitor +{ + [visitor visit:self]; + for (WarehouseItem *item in _itemsArray) + [visitor visit:item]; +} + +@end + +Как видим, наш склад умеет хранить и добавлять товар, но также обладает +таинственным методом accept который принимает в себя визитор и вызвает его +метод visit. Чтобы картинка сложилась, давайте создадим протокол BasicVisitor и +различных визиторов: + +@protocol BasicVisitor + +-(void) visit:(id)anObject; + +@end + +Как видим, протокол требует реализацию только одного метода. Теперь давайте +перейдем к самим визитерам: + +@interface QualityCheckerVisitor : NSObject + +@end + +@implementation QualityCheckerVisitor + +-(void) visit:(id)anObject +{ + if ([anObject isKindOfClass:[WarehouseItem class]]) + { + if ([anObject isBroken]) + { + NSLog(@"Item: %@ is broken", [anObject name]); + } + else + { + NSLog(@"Item: %@ is pretty cool!", [anObject name]); + } + } + + if ([anObject isKindOfClass:[Warehouse class]]) + { + + + + + + + + + + + + + + + + + + NSLog(@"Hmmm, nice warehouse!"); + return; + } + +} + +@end + +Если почитать код, то сразу видно что визитер при вызове своего метода visit +определяет тип объекта который ему передался, и выполняет определнные +функции в зависимоти от этого типа. Данный объект просто говорит или вещи на +складе поломаны, а так же что ему нравится склад:) + +@interface PriceCheckerVisitor : NSObject + +@end + +@implementation PriceCheckerVisitor + +-(void) visit:(id)anObject +{ + if ([anObject isKindOfClass:[WarehouseItem class]]) + { + NSLog(@"Item: %@ have price = %i", [anObject name], [anObject price]); + } + + if ([anObject isKindOfClass:[Warehouse class]]) + { + NSLog(@"Hmmm, I don't know how much Warehouse costs!"); + return; + } + +} + +@end + +В принципе этот визитер делает тоже самое, только в случае склада он +признается что растерян, а в случае товара говорит цену товара! + +Теперь давайте запустим то что у нас получилось! Код генерации тестовых даных: + + _localWarehouse = [[Warehouse alloc] init]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item1" +andQuality:NO andPrice:25]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item2" +andQuality:NO andPrice:32]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item3" +andQuality:YES andPrice:45]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item4" +andQuality:NO andPrice:33]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item5" +andQuality:NO andPrice:12]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item6" +andQuality:YES andPrice:78]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item7" +andQuality:YES andPrice:34]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item8" +andQuality:NO andPrice:51]]; + [_localWarehouse addItem:[[WarehouseItem alloc] initWithArgs:@"Item9" +andQuality:NO andPrice:25]]; + + + + + + + + + + + + + И собственно сам тестовый код: + + PriceCheckerVisitor *visitor = [[PriceCheckerVisitor alloc] init]; + QualityCheckerVisitor *qualityVisitor = [[QualityCheckerVisitor alloc] init]; + + [_localWarehouse accept:visitor]; + [_localWarehouse accept:qualityVisitor]; + +Итак, при вызове метода accept нашего склада, визитер в начале проведывает +наш склад, а потом проведывает каждый товар на этом склаже. При этом мы +можем менять как визитера так и алгоритм, и это не повлечет изменения в коде +клиента:) + +Традиционный лог: + +2013-02-26 00:19:47.756 VisitorPattern[8748:c07] Hmmm, I don’t know how much +Warehouse costs! +2013-02-26 00:19:47.759 VisitorPattern[8748:c07] Item: Item1 have price = 25 +2013-02-26 00:19:47.759 VisitorPattern[8748:c07] Item: Item2 have price = 32 +2013-02-26 00:19:47.760 VisitorPattern[8748:c07] Item: Item3 have price = 45 +2013-02-26 00:19:47.761 VisitorPattern[8748:c07] Item: Item4 have price = 33 +2013-02-26 00:19:47.762 VisitorPattern[8748:c07] Item: Item5 have price = 12 +2013-02-26 00:19:47.763 VisitorPattern[8748:c07] Item: Item6 have price = 78 +2013-02-26 00:19:47.763 VisitorPattern[8748:c07] Item: Item7 have price = 34 +2013-02-26 00:19:47.764 VisitorPattern[8748:c07] Item: Item8 have price = 51 +2013-02-26 00:19:47.765 VisitorPattern[8748:c07] Item: Item9 have price = 25 +2013-02-26 00:19:47.765 VisitorPattern[8748:c07] Hmmm, nice warehouse! +2013-02-26 00:19:47.766 VisitorPattern[8748:c07] Item: Item1 is pretty cool! +2013-02-26 00:19:47.767 VisitorPattern[8748:c07] Item: Item2 is pretty cool! +2013-02-26 00:19:47.767 VisitorPattern[8748:c07] Item: Item3 is broken +2013-02-26 00:19:47.768 VisitorPattern[8748:c07] Item: Item4 is pretty cool! +2013-02-26 00:19:47.769 VisitorPattern[8748:c07] Item: Item5 is pretty cool! +2013-02-26 00:19:47.837 VisitorPattern[8748:c07] Item: Item6 is broken +2013-02-26 00:19:47.837 VisitorPattern[8748:c07] Item: Item7 is broken +2013-02-26 00:19:47.837 VisitorPattern[8748:c07] Item: Item8 is pretty cool! +2013-02-26 00:19:47.838 VisitorPattern[8748:c07] Item: Item9 is pretty cool! + +Код примера. + + + + + + Decorator +//уже после того как я решил оформить все в книгу, в блог посте в котором +изначально я описал этот паттерн, некто по имени Саша сказал что я +привожу не класический пример этого шаблона. И он действительно прав, +пример тут использует категории, хотя в класическом исполнении сам +декоратор должен быть отдельным объектом. Классическая реализация будет +добавлена позже + +Класный пример декоратора – различные корпуса для новых телефонов. Как-то я +сразу с конца начал:) Для начала у нас есть телефон. Но так как телефон дорогой, +мы будем очень счастливы если он не разобьется при любом падении – потому +мы покупаем чехол для него. Тоесть, к уже существующему предмету мы +добавили функционал защиты от падения. Ну еще мы взяли стильный чехол – +теперь наш телефон еще и выглядит отлично. А потом мы докупили съемный +объектив, с помощью которого можно делать фотографии с эффектом “рыбьего +глаза”. Декорировали наш телефон дополнительным функционалом:) + +Вот, приблизительно так выглядит реально описание паттерна декоратор. Теперь +описание GoF: +Декоратор добавляет некий функционал уже существующему объекту. + +Когда использовать этот паттерн: + +1. Вы хотите добавить определенному объекту дополнительные возможности, + +при этом не задевая и не меняя других объектов +2. Дополнительные возможности класа – опциональны + +Радость Objective-C в даном случае – это использование категорий. Я не буду +детально описывать категории в этой книге, но в двух словах все же расскажу: +Категории – это возможность расширить любой объект дополнительными +методами (ТОЛЬКО МЕТОДАМИ) без унаследования от него. Давайте возьмем +супер простой пример – декорирование Cocoa классов. К примеру добавим новый +метод для объекта NSDate: + +К примеру, нам нужно иметь возможность любую дату в нашем приложении как то +определенно отформатировать и получить в виде строчки. Для начала создадим +категорию: + +@interface NSDate (StringDate) + +-(NSString *) convertDateToString; + +@end + +@implementation NSDate (StringDate) + +-(NSString *) convertDateToString +{ + NSDateFormatter *formatter = [[NSDateFormatter alloc] init]; + [formatter setDateFormat:@"yyyy/dd/MM"]; + + return [formatter stringFromDate:self]; +} + +@end + + + + + + + + + + + + + + + + + + Как видим наша категория определяет только один метод “convertDateToString”, +который дату форматирует в какой-то совсем странный формат, но у нас такая +задача:) +Теперь план-капкан, сделать эту категорию пользуемой для всех объектов NSDate +в нашем приложении. Для этого в файле appName-Prefix, добавляем строчку: + +#ifdef __OBJC__ + #import + #import + #import "NSDate+StringDate.h" +#endif + +строчка выделенна жирным, чтобы не потеряться. + +Вы будете смеятся, но в принципе вот и все:) Примерный код тестирования +выглядит следующим образом: + + NSDate *dateNow = [NSDate date]; + + NSLog(@"Date is %@", [dateNow convertDateToString]); + +Традиционный log: + +2013-03-01 00:30:18.328 DecoratorPattern[11731:c07] Date is 2013/01/03 + +Код примера. + + + + + + + + + + + + + + + Chain of responsibility +Паттерн с моим любимым названием:) + +Представьте себе очередь людей которые пришли за посылками. Выдающий +посылки человек, дает первую посылку первому в очереди человеку, он смотрит +на имя-фамилию на корбке, видит что посылка не для него, и передает посылку +дальше. Второй человек делает собственно тоже самое, и так пока не найдется +получатель. + +Цепочка ответственности (chain of responsibility) – позволяет вам передавать +объекте по цепочке объектов-обработчиков, пока не будет найден необходимый +объект обработчик. + +Когда использовать этот паттерн: + +1. У вас более чем один объект-обработчик. +2. У вас есть несколько объектов обработчика, при этом вы не хотите + +специфицировать который объект должен обрабатывать в даный момент +времени. + +Как всегда – пример: + +Представим что у нас есть конвеер, который обрабатывает различные предметы +которые на нем: игрушки, электронику и другие. +Для начала создадим классы объектов которые могут быть обработаны нашими +обработчиками: + +//базовый объект +@interface BasicItem : NSObject +@end + +@implementation BasicItem +@end + +//игрушка +@interface Toy : BasicItem +@end + +@implementation Toy +@end + +//электроника +@interface Electronics : BasicItem +@end + +@implementation Electronics +@end + +//и мусор +@interface Trash : BasicItem +@end + +@implementation Trash +@end + +Теперь создадим обработчики: + +@interface BasicHandler : NSObject +{ + + + + + + + + + + + + + + + + + + + + @private BasicHandler *_nextHandler; +} + +@property (nonatomic, strong) BasicHandler *nextHandler; +-(void) handleItem:(BasicItem *) item; +@end + +@implementation BasicHandler +@end + +Как видим, наш базовый обработчик, умеет обрабатывать объекты типа BasicItem. +И самое важное – он имеет ссылку на следующий обработчик ( как в нашей +очереди, про людей передающие посылку ). +Давайте создадим код обработчика игрушки: + +@interface ToysHandler : BasicHandler +@end + +@implementation ToysHandler + +-(void) handleItem:(BasicItem *)item +{ + if ([item isKindOfClass:[Toy class]]) + { + NSLog(@"Toy found. Handling"); + } + else + { + NSLog(@"Toy not found. Handling using next handler"); + [self.nextHandler handleItem:item]; + } +} + +@end + +Как видим, если обработчик получает объект класса Toy – то он его +обрабатывает, если нет – то обработчик передает объект следующему +обработчику. +По аналогии создадим два следующих обработчика: для электроники, и мусора: + +//хэндлер электроники +@interface ElectronicsHandler : BasicHandler +@end + +@implementation ElectronicsHandler + +-(void) handleItem:(BasicItem *)item +{ + if ([item isKindOfClass:[Electronics class]]) + { + NSLog(@"Electronics found. Handling"); + } + else + { + NSLog(@"Electronics not found. Handling using next handler"); + [self.nextHandler handleItem:item]; + } +} + +@end + +//хэндлер мусора +@interface OtherItemsHandler : BasicHandler +@end + + + + + + + + + + + + + + + + + + @implementation OtherItemsHandler + +-(void) handleItem:(BasicItem *)item +{ + NSLog(@"Found undefined item. Destroying"); +} + +@end + +Как видим OtherItemsHandler в случае, когда до него дошло дело – объект +уничтожает, и не пробует дергать следующий обработчик. + +Давайте тестировать: + + BasicHandler *toysHandler = [[ToysHandler alloc] init]; + BasicHandler *electronicsHandler = [[ElectronicsHandler alloc] init]; + BasicHandler *otherItemHandler = [[OtherItemsHandler alloc]init]; + + electronicsHandler.nextHandler = otherItemHandler; + toysHandler.nextHandler = electronicsHandler; + + BasicItem *toy = [[Toy alloc] init]; + BasicItem *electronic = [[Electronics alloc] init]; + BasicItem *trash = [[Trash alloc] init]; + + [toysHandler handleItem:toy]; + [toysHandler handleItem:electronic]; + [toysHandler handleItem:trash]; + +Как видим мы в начале создаем обработчики, потом скрепляем их в цепь, и +пытаемся обработать различные элементы.Традиционно лог: + +2013-03-02 15:35:35.668 ChainOfResponsibility[16777:c07] Toy found. Handling +2013-03-02 15:35:35.671 ChainOfResponsibility[16777:c07] Toy not found. +Handling using next handler +2013-03-02 15:35:35.672 ChainOfResponsibility[16777:c07] Electronics found. +Handling +2013-03-02 15:35:35.673 ChainOfResponsibility[16777:c07] Toy not found. +Handling using next handler +2013-03-02 15:35:35.673 ChainOfResponsibility[16777:c07] Electronics not +found. Handling using next handler +2013-03-02 15:35:35.674 ChainOfResponsibility[16777:c07] Found undefined +item. Destroying + +Код примера. + + + + + + + + + + + + + + + + + + + Template Method + +Вы заметили как много в нашей жизни шаблонов? Ну к примеру – наше поведение +когда мы приходим в незнакомый дом: + +1. Зайти +2. Поздороваться с хозяевами +3. Раздеться, молясь о том что у нас носки не дырявые +4. Пройти, и охать удияляясь какая большая/уютная/забавная квартира. + +Или же когда мы приходим в квартиру, где происходит ремонт: + +1. Зайти +2. Поздороваться с хозяевами +3. Не раззуваться, потому как грязно! +4. Поохать когда хозяин квартиры поведает нам смелость его архитектурной + +мысли! + +В целом, все происходит практически одинаково, но с изюминкой в каждом +различно случае:) Наверное потому то, это и называется шаблоном поведения. +Шаблонный метод задает алгоритму пошаговоую инструкцию. Элементы +алгоритма же, определяются в наследующих класах. + +Сам паттерн ну очень интуитивный, и я уверен что многие давно уже +использовали его. Потому давайте попробуем сделать пример. +Вернемся к старой практике, писать примеры по созданию телефонов! + +Итак, напишем наш шаблонный клас, с помощью которого будем создавать +телефон: + +@interface AnyPhoneTemplate : NSObject +//it will be template method +-(void) makePhone; +-(void) takeBox; +-(void) takeMicrophone; +-(void) takeCamera; +-(void) assemble; +@end + +@implementation AnyPhoneTemplate +//our template method +-(void) makePhone +{ + [self takeBox]; + [self takeCamera]; + [self takeMicrophone]; + [self assemble]; +} + +-(void) takeBox +{ + NSLog(@"Taking a box"); +} + +-(void) takeCamera +{ + NSLog(@"Taking a camera"); +} + + + + + + + + + + + + + + + -(void) takeMicrophone +{ + NSLog(@"Taking a microphone"); +} + +-(void) assemble +{ + NSLog(@"Assembling everythig"); +} + +@end + +Как вы уже наверное догадались – сам шаблонный метод, это метод makePhone – +который задает последовательность вызовов методов необходимых для +складывания телефонов. Давайте теперь научим нашу программу создавать +айфоны: + +@interface iPhoneMaker : AnyPhoneTemplate + +-(void) design; + +@end + +@implementation iPhoneMaker + +-(void) takeBox +{ + [self design]; + [super takeBox]; +} + +-(void) design +{ + NSLog(@"Putting label 'Designed in California'"); +} +@end + +Как видим у сборщика яблочных телефонов есть один дополнительный метод – +design, а также перегруженный метод takeBox в котором дополнительно +вызывается метод design и после этого вызывается родительский метод takeBox. + +На очереди сборка Android: + +@interface AndroidMaker : AnyPhoneTemplate + +-(void) addRam; +-(void) addCPU; + +@end + +@implementation AndroidMaker + +-(void) assemble +{ + [self addCPU]; + [self addRam]; + [super assemble]; +} + +-(void) addCPU +{ + NSLog(@"Installing 4 more CPUs"); +} + + + + + + + + + + + + + + + + + + + + + + + -(void) addRam +{ + NSLog(@"Installing 2Gigs of RAM"); + +} + +@end + +Как видим у сборщика андроида аж целых два дополнительных метода, и +перегружен метод assemble. + +Тест здесь конечно же – элементарный: + + AndroidMaker *android = [[AndroidMaker alloc] init]; + iPhoneMaker *iphone = [[iPhoneMaker alloc] init]; + + [android makePhone]; + [iphone makePhone]; + +Традиционный log: + +2013-03-03 22:56:28.996 TemplateMethod[21040:c07] Taking a box +2013-03-03 22:56:28.998 TemplateMethod[21040:c07] Taking a camera +2013-03-03 22:56:28.999 TemplateMethod[21040:c07] Taking a microphone +2013-03-03 22:56:29.000 TemplateMethod[21040:c07] Installing 4 more CPUs +2013-03-03 22:56:29.000 TemplateMethod[21040:c07] Installing 2Gigs of RAM +2013-03-03 22:56:29.001 TemplateMethod[21040:c07] Assembling everythig +2013-03-03 22:56:29.001 TemplateMethod[21040:c07] Putting label ‘Designed in +California’ +2013-03-03 22:56:29.002 TemplateMethod[21040:c07] Taking a box +2013-03-03 22:56:29.003 TemplateMethod[21040:c07] Taking a camera +2013-03-03 22:56:29.003 TemplateMethod[21040:c07] Taking a microphone +2013-03-03 22:56:29.003 TemplateMethod[21040:c07] Assembling everything + +Код примера. + + + + + + + + + + + + + + + + Strategy + +Если Ваша девушка злая, вы скорее всего будете общаться с ней осторожно. +Если на вашем проетке завал, то вероятнее всего вы не будете предлагать в +команде вечерком дернуть пива или поиграть в компьютерные игры. В различных +ситуациях, у нас могут быть очень разные стратегии поведения. К примеру, в +приложении вы мо��ете использовать различные алгоритмы сжатия, в +зависимости от того с каким форматом картинки вы работаете, или же куда вы +хотите после этого картинку деть. Вот мы и добрались до паттерна Стратегия. + +Также отличным примером может быть MVC паттерн – в разных случаях мы +можем использовать разные контроллеры для одного и того же View (к примеру +авторизированный и не авторизированный пользователь). + +Паттерн Стратегия определяет семейство алгоритмов, которые могут +взаимозаменяться. + +Когда использовать паттерн: + +1. Вам необходимы различные алгоритмы +2. Вы очень не хотите использовать кучу вложеных If-ов +3. В различных случаях ваш класс работает по разному. + +Давайте напишем пример – RPG игра, в которой у вас есть различные стратегии +нападения Вашими персонажами:) Каждый раз когда вы делаете ход, ваши +персонажи делают определенное действие. Итак, для начала управление +персонажами! + +Создадим базовую стратегию: + +@interface BasicStrategy : NSObject +-(void) actionCharacter1; +-(void) actionCharacter2; +-(void) actionCharacter3; +@end + +Как видно из кода стратегии – у нас есть 3 персонажа, каждый из которых может +совершать одно действие! Давайте научим персонажей нападать! + +@interface AttackStrategy : BasicStrategy +@end + +@implementation AttackStrategy + +-(void) actionCharacter1 +{ + NSLog(@"Character 1: Attack all enemies!"); +} + +-(void) actionCharacter2 +{ + NSLog(@"Character 2: Attack all enemies!"); +} + +-(void) actionCharacter3 +{ + NSLog(@"Character 3: Attack all enemies!"); + + + + + + + + + + + + + + + + + + } +@end + +Как видим, при использовании такой стратегии наши персонажи нападают на все +что движется! Давайте научим их защищаться: + +@interface DefenceStrategy : BasicStrategy + +@end + +@implementation DefenceStrategy + +-(void) actionCharacter1 +{ + NSLog(@"Character 1: Attack all enemies!"); +} + +-(void) actionCharacter2 +{ + NSLog(@"Character 2: Healing Character 1!"); +} + +-(void) actionCharacter3 +{ + NSLog(@"Character 3: Protecting Character 2!"); +} +@end + +Как видим во время защитной стратегии, наши персонажи действуют по-другому – +кто атакует, кто лечит, а некоторый даже защищают:) Ну, теперь как-то надо это +все использовать. Давайте создадим нашего игрока: + +@interface Player : NSObject + +@property (nonatomic, strong) BasicStrategy *_strategy; + +-(void) makeAction; +-(void) changeStrategy:(BasicStrategy *) strategy; + +@end + +@implementation Player + +-(void) makeAction +{ + [self._strategy actionCharacter1]; + [self._strategy actionCharacter2]; + [self._strategy actionCharacter3]; +} + +-(void) changeStrategy:(BasicStrategy *)strategy +{ + self._strategy = strategy; +} + +@end + +Как видим наш игрок может только менять стратегию и действовать в зависимости +от этой стратегии. +Код для тестирования: + + Player *p = [[Player alloc] init]; + AttackStrategy *a = [[AttackStrategy alloc] init]; + DefenceStrategy *d = [[DefenceStrategy alloc] init]; + + + + + + + + + + + + + + + + + + + + + + + [p changeStrategy:a]; + [p makeAction]; + [p changeStrategy:d]; + [p makeAction]; + +Собcтвенно все предельно ясно:) В первом случае наши персонажи будут активно +атоковать, а после смены стратегии уйдут в глухую оборону. +Традиционный лог: + +2013-03-04 23:57:44.797 StrategyPatterns[22420:c07] Character 1: Attack all enemies! +2013-03-04 23:57:44.799 StrategyPatterns[22420:c07] Character 2: Attack all enemies! +2013-03-04 23:57:44.800 StrategyPatterns[22420:c07] Character 3: Attack all enemies! +2013-03-04 23:57:44.800 StrategyPatterns[22420:c07] Character 1: Attack all enemies! +2013-03-04 23:57:44.801 StrategyPatterns[22420:c07] Character 2: Healing Character +1! +2013-03-04 23:57:44.801 StrategyPatterns[22420:c07] Character 3: Protecting +Character 2! + +Код примера. + + + + + + + + + + Command +Стоять, лежать, сидеть – все это команды которые нам очень часто давали +учителя физкультуры. Так как это очень часто происходит в нашей жизни, глупо +было бы предпологать что кто нибудь не придумает шаблон с одноименным +названием. + +Итак, паттерн – команда – позволяет инкапулировать всю информацию +необходимую для выполнения определенных операций, которые могут быть +выполнены потом, используя объект команды. + +Образно говоря, если взять наш с вами пример физрука, родители давным давно +инкапсулировали в нас команду ”Сидеть”, потому физрук использует ее чтобы мы +сели, не объясняя при этом как это сделать. + +Когда использовать паттерн: + +Ну, собственно ответ один, и выходит он из описания, когда вы хотите +инкапсулировать определенную логику в отдельный класс команду. Отличный +пример – do/undo операции. У вас, вероятнее всего, будет так называмы +CommandManager, которые будет запоминать что делает команда, и при желании +отменять предыдущее действите если выполнить команду undo ( кстати, это +может быть и просто метод ). + +Собственно, есть два пути реализации этого паттерна: + +Для начала создадим базовую команду: + +@interface BaseCommand : NSObject + +-(void) execute; +-(void) undo; + +@end + +Как видим у нашей команды аж два метода – сделать, и вернуть обратно +изменения. + +Теперь реализации наших команд: + +@interface FirstCommand : BaseCommand +{ +@private NSString *_originalString; +@private NSString *_currentString; +} + +-(id) initWithArguments: (NSString *) anArgument; +-(void) printString; + +@end + +@implementation FirstCommand + +-(id) initWithArguments:(NSString *)anArgument +{ + self = [super init]; + _originalString = anArgument; + _currentString = anArgument; + + + + + + + + + + + + + + + + + + + + + return self; +} +-(void) execute +{ + _currentString = @"This is a new string"; + [self printString]; + + NSLog(@"Execute command called"); +} + +-(void) undo +{ + _currentString = _originalString; + [self printString]; + + NSLog(@"Undo of execute command called"); +} + +-(void) printString +{ + NSLog(@"Current string is equal to %@", _currentString); +} + +@end + +Как видим, наша первая команда просто умеет менять одну строчку. При чем +всегда хранит оригинал, чтобы можно было отменить изменение. + +Вторая наша команда: + +@interface SecondCommand : BaseCommand +{ +@private int _originalNumber; +@private int _currentNumber; +} + +-(id) initWithArgs: (int) aNumber; +-(void) printNumber; + +@end + +@implementation SecondCommand + +-(id) initWithArgs:(int)aNumber +{ + self = [super init]; + + _originalNumber = aNumber; + _currentNumber = aNumber; + + return self; +} + +-(void) execute +{ + _currentNumber++; + + [self printNumber]; +} + +-(void) undo +{ + if (_currentNumber > _originalNumber) + _currentNumber--; + + [self printNumber]; + + + + + + + + + + + + + + + + + + + + + + + } + +-(void) printNumber +{ + NSLog(@"current number is %i", _currentNumber); +} +@end + +Вторая команда делает тоже самое, но с числом. + +Давайте теперь создадим объект который будет получать команду и выполнять +ее: + +@interface CommandExecutor : NSObject +{ +@private NSMutableArray *_arrayOfCommands; + +} + +-(void) addCommand:(BaseCommand *) aCommand; +-(void) executeCommands; +-(void) undoAll; + +@end + +@implementation CommandExecutor + +-(id) init +{ + self = [super init]; + + _arrayOfCommands = [[NSMutableArray alloc] init]; + + return self; +} + +-(void) addCommand:(BaseCommand *) aCommand +{ + //id item = aCommand; + + [_arrayOfCommands addObject:aCommand]; +} + +-(void) executeCommands +{ + for (BaseCommand *command in _arrayOfCommands) + { + [command execute]; + } +} + +-(void) undoAll +{ + for (BaseCommand *command in _arrayOfCommands) + { + [command undo]; + } +} +@end + +Как видим, наш менеджер может получать очередь команд, и выполнять их все, +или даже отменять все действия (пример простой и с багами:) ). Итак, наш +тестовый код: + + CommandExecutor *commandE = [[CommandExecutor alloc] init]; + + + + + + + + + + + + + + + + + + + + + + + BaseCommand *cmdF = [[FirstCommand alloc] initWithArguments:@"This is a test +string"]; + BaseCommand *cmdS = [[SecondCommand alloc] initWithArgs:3]; + + [commandE addCommand:cmdF]; + [commandE addCommand:cmdS]; + + [commandE executeCommands]; + [commandE undoAll]; + +И конечно же лог: + +2013-03-06 22:40:47.392 CommandPattern[9871:c07] Current string is equal to This is +a new string +2013-03-06 22:40:47.393 CommandPattern[9871:c07] Execute command called +2013-03-06 22:40:47.393 CommandPattern[9871:c07] current number is 4 +2013-03-06 22:40:47.394 CommandPattern[9871:c07] Current string is equal to This is +a test string +2013-03-06 22:40:47.394 CommandPattern[9871:c07] Undo of execute command +called +2013-03-06 22:40:47.395 CommandPattern[9871:c07] current number is 3 + +2. Второй метод реализации паттерна – это уже использование внутреностей +самой Cocoa – NSInvocation: + +NSInvocation – это объект, который можно использовать чтобы передать возможно +вызова метода одного класса – другому, и при это передать в него несколько +аргументов, а так же объект который вызывал этот метод. + +Давайте напишем в наш CommandExecutor добавим два метода и одно приватное +поле: + +//private field +@private NSInvocation *_specificCommand; + +//two methods: +-(void) setSpecificCommand:(NSInvocation *)aCommand +{ + _specificCommand = aCommand; +} + +-(void) executeSpecificCommand +{ + [_specificCommand invoke]; +} + +Как видим, теперь наш объект сохраняет объект типа NSInvocation и может его +запустить когда требуется. Давайте тепреь в нашем основном контроллере +напишем функцию которую мы будем вызывать: + +-(void) methodInMainController:(int) aFirstArgument andString:(NSString +*)aStringArgument +{ + NSLog(@"Method called with first argument = %i and second argument = %@", + +} + + aFirstArgument, aStringArgument); + +А теперь создадим объект типа NSInvocation который и будет в результате нашей +командой: + + + + + + + + + + + + + + + + + + + + + + + NSMethodSignature *signature = [self methodSignatureForSelector: + + NSInvocation *invocationToPass =[NSInvocation + + [invocationToPass setTarget:self]; + [invocationToPass setSelector:@selector(methodInMainController:andString:)]; + +invocationWithMethodSignature:signature]; + +@selector(methodInMainController:andString:)]; + + int intArgument = 3; + NSString *stringArgument = @"This is a string argument"; + + [invocationToPass setArgument:&intArgument atIndex:2]; + [invocationToPass setArgument:&stringArgument atIndex:3]; + + CommandExecutor *executor = [[CommandExecutor alloc] init]; + [executor setSpecificCommand:invocationToPass]; + [executor executeSpecificCommand]; + +Как видим, в самом начале мы создаем объект который хранит сигнатуры нашего +метода, и создаем объект NSInvocation. После этого мы передаем в него +аргументы – не стоит удивляться что индекс начинается с цифры 2 – index 0 и +index 1 зарезервированы под target и selector:) + +Ну и конечно же лог: + +2013-03-06 23:18:26.624 CommandPattern[10479:c07] Method called with first +argument = 3 and second argument = This is a string argument + +Код примера. + + + + + + + + + + + + + + + + + + + + + + + Flyweight +Я задумался, как объяснить да и перевисти этот паттерн на примеры из реальной +жизни, и потерпел полнейшее фиаско! + + Потому сразу к описанию и примерам! + +Flyweight – паттерн который помогает нам отделять определенную информацию, +для того чтобы в будущем делиться этой информацией с многими объектами. + +Как пример возьмем любую стратегичискую игру – представьте что у вас 1 тысяча +солдат одного типа – если каждый будет лезть на диск и пробовать подгрузить +картинку с диска – вероятнне всего у вас или память закончится или +производительность будет желать лучшего. Очень классно этот пример +рассмотрен в книге Андрея Будая ”Дизайн-патерни — просто, як двері”. + +Потому не найдя ничего лучше, я решил просто портировать пример. + +Когда использовать этот паттерн? + +1. У вас ооочень много однотипых объектов в приложении +2. Много объектов сохранены в памяти, от чего производительность вашего + +приложения страдает + +3. Вы видите, что несколько объектов которые могут быть разшарены – спасут + +вас от создания тонны других объектов + +Итак пример: +Пускай мы пишем игру, где есть два типа персонажей – гоблины и драконы. Для +начала создадим базовый класс для всех юнитов: + +@interface BasicUnit : NSObject + +@property (nonatomic, strong) NSString *name; +@property (nonatomic) int health; +@property (nonatomic, strong) UIImage *image; + +@end + +Как видим у каждого юнита есть свойство image – которое является типом UIImage +и может потребвать подгрузки картинки для каждого юнита. Как же сделать +загрузку только единожды? Ну собвстенно с этим то и справится наш паттерн! + +@interface FlyweightImageFactory : NSObject + ++(UIImage *) getImage:(NSString *)imageName; + +@end + +@implementation FlyweightImageFactory + +NSMutableDictionary *_imageDictionary; + ++(UIImage *)getImage:(NSString *)imageName +{ + if (!_imageDictionary) + _imageDictionary = [[NSMutableDictionary alloc] init]; + + if (![_imageDictionary objectForKey:imageName]) + { + [_imageDictionary setObject:[UIImage imageNamed:[[NSString alloc] + + + + + + + + + + + + + + + + + + + + + + + initWithFormat:@"%@.jpeg",imageName]] forKey:imageName]; + NSLog(@"Loading image of the %@", imageName); + } + + return [_imageDictionary objectForKey:imageName]; +} + +@end + +Как видим, наш flyweight иммет только один класс метод, который картинку по +имени то и возвращает. Если картинки под таким именем нету в его словаре – то +она грузится из бандла, если же есть – то просто передается ссылка на нее. +Каждый раз когда картинка грузится из бандла мы логируем сообщение, это +сделано для того чтобы увидеть сколько раз происходит подгрузка изображения +из бандла. + +Теперь нам просто нужно в конструкторе наших юнитов загружать картинку не на +прямую, а через наш паттерн: + +@implementation Dragon + +-(id) init +{ + self = [super init]; + + self.name = @"Dragon"; + self.health = 150; + self.image = [FlyweightImageFactory getImage:@"dragon"]; + return self; + +} + +@end + +@implementation Goblin + +-(id) init +{ + self = [super init]; + + self.name = @"goblin"; + self.health = 20; + self.image = [FlyweightImageFactory getImage:@"goblin"]; + return self; + +} + +@end + +Ну и конечно же тест: + + NSMutableArray *units = [[NSMutableArray alloc] init]; + for ( int i = 0 ; i < 500; i++) + { + [units addObject:[[Dragon alloc] init]]; + } + for ( int i = 0 ; i < 500; i++) + { + [units addObject:[[Goblin alloc] init]]; + } + +И как ожидается, хоть мы и создаем 1 тысячу юнитов, л��г срабатывает только два +раза: + + + + + + + + + + + + + + + + + + + + + + 2013-03-09 11:08:45.002 FlyweightPattern[5595:c07] Loading image of the dragon +2013-03-09 11:08:45.006 FlyweightPattern[5595:c07] Loading image of the goblin + +Код примера. + + + + + Proxy +Ох, все кто работает в большой компании – ненавидит доступ к интернету через +прокси:) Что делает прокся? Ну многие из нас уверенны, что в основном она +режет скорость интернета, хотя вероятнее всего она делает еще очень много +положительных вещей: + +1. Логирует кто куда ходит. +2. Смотрит, чтобы не ходили куда не следует. +3. Смотрит, чтобы по нашему коннекшену к нам не ходили. + +…и так далее. Все эти активности взяты из головы, но они показывают +использование прокси в реальной жизни – давать стандартный доступ к чему- +либо, при этом обворачивая стандартные вызовы в проксю и добавляют свою +логику. + +Паттерн прокси – подменяет реальный объект, и шлет ему запросы через свои +интерфейсы. При этом может добавлять дополнительную логику, или создавать +реальный объект если тот еще не создан. + +Как пример – вы можете иметь обычных и премиум пользователей приложения. К +примеру – премиум пользователи могут скачивать файлы на большей скорости, +чем обычные пользователи. Потому, как объекту, который отвечает за скачивание +файлов в вашем приложении, не обязательно знать про существование разных +типов пользователей, вы оборачиваете этот объект в прокси, которая в свою +очередь знает про таких пользователей, и говорит объекту скачивания на какой +скорости пользователь должен получить файл. + +Когда использовать паттерн: + +1. Возомжно, у вас есть два сервера – тестовый и продуктовый. Когда Вы + +дебажите – скорее всего вы будете пользовать тестовый сервер, ну а когда +компилируете приложение для продакшена – скорее всего реальный. Эту +логику можно реализовать в проксе + +2. Добавление различных валидаций, и проверок безопасности +3. Миллион других возможных ситуаций. + +Давайте создадим пример. Пускай у нас есть объект который отвечает за скачку +файлов: + +@interface FileDownloader : NSObject + +-(void) slowDownload; +-(void) fastDownload; + +@end + +@implementation FileDownloader + +-(id) init +{ + self = [super init]; + NSLog(@"Downloader created"); + return self; +} + + + + + + + + + + + + + + + + + + -(void) slowDownload +{ + NSLog(@"Sloooooowly downloading..."); +} + +-(void) fastDownload +{ + NSLog(@"Shuuuuuh, already downloaded..."); +} +@end + +Как видим, наш объект умеет скачивать быстро и медленно. При том, ему все +равно какой пользователь и есть ли коннект к интернету. +Давайте создадим нашу прокси: + +@interface FileDownloaderProxy : NSObject +{ +@private FileDownloader *_downloader; +} + +@property (nonatomic) bool isPremiumUser; + +-(void) slowDownload; +-(void) fastDownload; + +@end + +@implementation FileDownloaderProxy + +-(void) fastDownload +{ + if (!_isPremiumUser) + { + [self slowDownload]; + return; + } + + if (!_downloader) + _downloader = [[FileDownloader alloc] init]; + + [self checkNetworkConnectivity]; + + [_downloader fastDownload]; +} + +-(void) slowDownload +{ + if (!_downloader) + _downloader = [[FileDownloader alloc] init]; + + [self checkNetworkConnectivity]; + + [_downloader slowDownload]; +} + +-(void) checkNetworkConnectivity +{ + NSLog(@"Checking network connectivity..."); +} +@end + +Как видим проксятник незначительно умнее: + + + + + + + + + + + + + + + + + + + + + + + + 1. Он знает про тип пользователя, и даже если дернули метод fastDownload но + +пользователь не премиум – будет вызван метод slowDownload. + +2. Он умеет проверять доступ к интернету (пусть это и просто выписка лога). +3. Он проверяет, или тип объекта FileDownloader создан, и если нет – создает + +его. + +Ну что, протестируем: + + FileDownloaderProxy *proxy = [[FileDownloaderProxy alloc] init]; + + [proxy setIsPremiumUser:NO]; + [proxy fastDownload]; + + [proxy setIsPremiumUser:YES]; + [proxy fastDownload]; + +Традиционный лог: + +2013-03-10 13:27:50.312 ProxyPattern[10775:c07] Downloader created +2013-03-10 13:27:50.313 ProxyPattern[10775:c07] Checking network connectivity… +2013-03-10 13:27:50.313 ProxyPattern[10775:c07] Sloooooowly downloading… +2013-03-10 13:27:50.314 ProxyPattern[10775:c07] Checking network connectivity… +2013-03-10 13:27:50.314 ProxyPattern[10775:c07] Shuuuuuh, already downloaded… + +Код примера. + + + + + + + + + + + + + Memento +Ах, как же не хватает в жизни таких штук как Quick Save и Quick Load. На худой +конец Ctrl + Z. Это я Вам как геймер давнейший говорю! Частенько, такой +функционал очень полезен для реализации в приложении. Очень правильно +также защитить наше записанное состояние от других класов, чтобы в них не +смогли внести изменения. + +Итак, что же за паттерн такой? Memento – паттерн который позволяет, не нарушая +инкапсуляцию, зафиксировать и сохранить внутреннее состояние объекта, чтобы +позже восстановить его состояние. + +Состояние, как таковое, может сохраняться как в файловую систему, так и в базу +даных. Яркий пример использование – может быть сворачивание и выключение +вашего приложения – во время выключения приложения вы можете сохранить все +данные с формы, или настройки, или еще что вам угодно в базу даных через +CoreData, чтобы восстановить при включении. + +Когда использовать паттерн: + +1. Вам необходимо сохранять состояние объекта как слепок(snapshot) за + +определенный период + +2. Вы хотите скрыть интерфейс получения состояния объекта. + +В даном паттерне используется три ключевые объекта: Caretaker ( объект который +скрывает реализацию сохранения состояния объекта), originator ( собственно сам +объект ) и конечно же сам Memento ( объект который сохраняет состояние +originator ). + +Давайте небольшой пример: + +@interface OriginatorState : NSObject + +@property (nonatomic) int intValue; +@property (nonatomic) NSString *stringValue; + +@end + +@implementation OriginatorState +@end + +Допустим, у нас есть состояние, в котором всего лишь два знаечение – +целочисельное и строчка. + +@interface Originator : NSObject +{ +@private OriginatorState *_localState; +} + +-(void) changeValues; +-(OriginatorState *) getState; +-(void) setState:(OriginatorState *)oldState; +@end + +@implementation Originator + + + + + + + + + + + + + + + + + + + + -(id) init +{ + self = [super init]; + + _localState = [[OriginatorState alloc] init]; + _localState.intValue = 100; + _localState.stringValue = @"Hello World!"; + + return self; +} + +-(void) changeValues +{ + _localState.intValue++; + _localState.stringValue = [NSString stringWithFormat:@"%@ %@", +_localState.stringValue, @"!"]; + + NSLog(@"Current state int = %i, string = %@", _localState.intValue, +_localState.stringValue); +} + +-(OriginatorState *) getState +{ + return _localState; +} + +-(void) setState:(OriginatorState *)oldState +{ + _localState = oldState; + + NSLog(@"Load completed. Current state: int = %i, string = %@", +_localState.intValue, _localState.stringValue); +} +@end + +Как видим, мы можем изменять состояние объекта состояния, а так же получить +состояние и загрузить состояние. + +Пускай у нас есть Memento – объект который будет заведовать состояние нашего +объекта: + +@interface Memento : NSObject +{ +@private OriginatorState *_localState; +} + +-(id) initWithState:(OriginatorState *)state; +-(OriginatorState*) getState; +@end + +@implementation Memento + +-(id) initWithState:(OriginatorState *)state +{ + self = [super init]; + + _localState = [[OriginatorState alloc] init]; + [_localState setIntValue:state.intValue]; + [_localState setStringValue:state.stringValue]; + + return self; +} + +-(OriginatorState *) getState +{ + return _localState; + + + + + + + + + + + + + + + + + + + + + } +@end + +Тоесть наш объект Memento – умеет хранить состояние, и конечно же отдавать +состояние:) +Ну и теперь, соеденим все это в единый паззл создавая Caretaker: + +@interface Caretaker : NSObject +{ +@private Originator *_originator; +@private Memento *_memento; +} + +-(void) changeValue; +-(void) saveState; +-(void) loadState; +@end + +@implementation Caretaker + +-(void) changeValue +{ + if (!_originator) + _originator = [[Originator alloc] init]; + + [_originator changeValues]; +} + +-(void) saveState +{ + _memento = [[Memento alloc] initWithState:[_originator getState]]; + NSLog(@"Saved state. State int = %i and string = %@",[[_memento getState] +intValue ], [[_memento getState] stringValue ]); +} + +-(void) loadState +{ + [_originator setState:[_memento getState]]; +} + +@end + +Как видим Caretaker умеет держать в себе сохраненное состояние(для примера, +оно все очень просто, но здесь может быть и стек состояний, и так далее), а так +же загружать его:) + +Давайте протестим: + + Caretaker *crtaker = [[Caretaker alloc] init]; + + [crtaker changeValue]; + [crtaker saveState]; + [crtaker changeValue]; + [crtaker changeValue]; + [crtaker changeValue]; + [crtaker loadState]; + +Лог как пример работы паттерна: + +2013-03-11 23:23:30.711 MementoPattern[14985:c07] Current state int = 101, string = +Hello World! ! +2013-03-11 23:23:30.712 MementoPattern[14985:c07] Saved state. State int = 101 and +string = Hello World! ! + + + + + + + + + + + + + + + + + + + 2013-03-11 23:23:30.712 MementoPattern[14985:c07] Current state int = 102, string = +Hello World! ! ! +2013-03-11 23:23:30.713 MementoPattern[14985:c07] Current state int = 103, string = +Hello World! ! ! ! +2013-03-11 23:23:30.713 MementoPattern[14985:c07] Current state int = 104, string = +Hello World! ! ! ! ! +2013-03-11 23:23:30.713 MementoPattern[14985:c07] Load completed. Current state: +int = 101, string = Hello World! ! + +Код примера. + + + + + \ No newline at end of file