<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andrew Zhukov on Medium]]></title>
        <description><![CDATA[Stories by Andrew Zhukov on Medium]]></description>
        <link>https://medium.com/@ioszhukov?source=rss-2e6743f5e5b1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4YPQ-c95vpwoBA5msWQsPw.png</url>
            <title>Stories by Andrew Zhukov on Medium</title>
            <link>https://medium.com/@ioszhukov?source=rss-2e6743f5e5b1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:35:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ioszhukov/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[SOLID в iOS разработке. Принцип открытости закрытости]]></title>
            <link>https://medium.com/@ioszhukov/solid-in-ios-ocp-890a5aedf2e5?source=rss-2e6743f5e5b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/890a5aedf2e5</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ocp]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Andrew Zhukov]]></dc:creator>
            <pubDate>Fri, 07 Jul 2017 11:50:45 GMT</pubDate>
            <atom:updated>2017-07-07T11:50:45.398Z</atom:updated>
            <content:encoded><![CDATA[<p>Кто бы мог подумать, что два противоположных по смыслу слова окажутся рядом, образовав один из основных принципов проектирования объектно-ориентированного дизайна. На первый взгляд такое словосочетание может показаться бессмыслицей. Давайте взглянем на формулировку:</p><blockquote><strong><em>Программные сущности (классы, модули, функции и т.п.) должны быть открыты для расширения, но закрыты для изменения</em></strong></blockquote><p>Именно в таком виде принцип появился в книге Бертрана Мейера еще в далеком 1988 году. Позже Роберт Мартин популяризовал его, включив в свою известную аббревиатуру SOLID под буквой О.</p><p>Пожалуй, единственное, что становится ясным после прочтения этого определения, это то, что связь между словами в названии все-таки есть. Но что имеется в виду — по-прежнему непонятно.</p><h4>Закрытость</h4><p>Начнем с закрытости для изменений. Вы когда-нибудь заходили в хедеры классов от Apple, пытаясь (в основном случайно) там что-то изменить? Xcode сразу же сообщал, чуть ли не цитируя вышеупомянутую формулировку, что данный класс закрыт, менять его не стоит. Это и есть закрытость: интерфейсы привычны нам, потому что они неизменны. Мы пользуемся ими каждый день, зная наизусть названия методов и свойств. Но представьте, если бы названия или входные параметры у методов менялись с каждым обновлением. Смогли бы мы помнить их? Вряд ли, но это даже не самое страшное. Что было бы с многочисленными проектами по всему миру, если бы внезапно инженеры из Apple решили, что свойство backgroundColor класса UIView чересчур длинное и заменили его на bgColor, поставив всех перед фактом с очередным обновлением? Страшно представить, в скольких местах придется менять код, чтобы просто скомпилировать проект. Но все-таки после долгих правок проекты скомпилируются, а что если метод просто изменит свое поведение, начав работать совершенно неожиданным образом? Такими ужасными последствиями может обернуться нарушение закрытости. Если перефразировать эту часть, класс должен оставаться <strong>доступным для использования</strong> в других классах. А для этого его публичный интерфейс (поведение) надежнее всего зафиксировать (закрыть от изменений).</p><h4>Открытость</h4><p>Что же теперь, зафиксировать интерфейсы и не добавлять ничего нового? Конечно нет, мы должны расширять классы, делая их более функциональными, и мы можем, ведь они <strong>открыты для расширения</strong>. Возвращаясь к эппловским классам, расширением можно назвать весь функционал, около которого вы найдете макрос NS_AVAILABLE <em>(который обозначает доступность с определенной версии ОС)</em>. При этом поведение старых методов не меняется, как и самого класса в целом. Также расширение может осуществляться с помощью наследования: у классов UIImageView или UIScrollView намного больше возможностей, чем у простого UIView, но при этом базовое поведение не изменилось, мы уверены в этом, что позволяет без труда заменить на них все UIView в проекте. <em>(что также является примером принципа подстановки, о котором поговорим позже). </em>И, наконец, расширение функциональности прекрасно реализуется с помощью протокола: объявив в нем интерфейс, можно создавать сколько угодно все более и более современных реализаций, отвечающих этому интерфейсу.</p><h4>Пример: DataStore</h4><p>Вспомним пример из прошлой статьи: у нас была задача хранить данные пользователя. Выполним ее с самого начала. Выделив ответственность из контроллера, мы создали класс DataStore, отвечающий за локальное хранение. Настало время реализовать сохранение модели пользователя, и самый простой способ — явно сообщить об этом:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c9169d7fc71fb2bfa3e0570ae8b22ec8/href">https://medium.com/media/c9169d7fc71fb2bfa3e0570ae8b22ec8/href</a></iframe><p>Но по мере добавления новых типов хранимых моделей, количество методов будет расти:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6a02fe3c104dab30f5d3953c7c955dc7/href">https://medium.com/media/6a02fe3c104dab30f5d3953c7c955dc7/href</a></iframe><p>Чтобы избавиться от дублирования, сделаем интерфейс более абстрактным:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/40cab9b68f9d13d079d61d74e57411c5/href">https://medium.com/media/40cab9b68f9d13d079d61d74e57411c5/href</a></iframe><p>На вход принимается любой объект, что без труда позволит нам реализовывать хранение любых моделей, не меняя интерфейс. То есть интерфейс зафиксирован. Но зафиксировано ли поведение метода? Посмотрим на возможную реализацию:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/524cbc1008bbacfaa5077b3dac5a8fed/href">https://medium.com/media/524cbc1008bbacfaa5077b3dac5a8fed/href</a></iframe><p>Проблема заключается в том, что при реализации сохранения любой новой модели, в метод будут вноситься изменения. А это значит, что метод открыт для модификации. При каждом изменении будет меняться его поведение. Классы, использующие хранилище, не могут ожидать такого, а значит в них также возможно появление ошибок. Чтобы решить эту проблему, создадим протокол:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ddfae0d7e0a77dda327479d4ad5d765c/href">https://medium.com/media/ddfae0d7e0a77dda327479d4ad5d765c/href</a></iframe><p>Теперь для любой модели, которую в будущем понадобится кэшировать, надо будет лишь реализовать протокол в соответствии со своей специфичной логикой:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/598a89d178e8a23f46ffcaabf8692c3d/href">https://medium.com/media/598a89d178e8a23f46ffcaabf8692c3d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9371d738cf0e2abf915569c03dbd37b8/href">https://medium.com/media/9371d738cf0e2abf915569c03dbd37b8/href</a></iframe><p>А реализация сохранения будет выглядеть так:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e99f017f832b97e9de045220aa6f154/href">https://medium.com/media/1e99f017f832b97e9de045220aa6f154/href</a></iframe><p>Метод всегда будет оставаться неизменным, и в то же время открытым для расширения: мы сможем добавить столько новых моделей, сколько захотим.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*vBpyPRWKErdLEYpJ65iCZg.png" /><figcaption>Закрыт для модификации, но открыт для расширения</figcaption></figure><h4>Вывод</h4><p>Принцип открытости закрытости позволяет строить систему таким образом, чтобы её легко было масштабировать в будущем, не затрагивая при этом функциональность уже существующих частей. При этом нет необходимости пытаться предусматривать всё заранее. Можно сказать, что это некая рекомендация об изоляции компонентов модулей: чем меньше связаны классы, тем легче менять систему в целом. В то же время, принцип не стоит воспринимать критично, создавая абстракции везде, где только возможно. Наиболее правильная рекомендация: создавать абстракции, только если уже в данный момент понятно, что класс будет нуждаться в расширении.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=890a5aedf2e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID в iOS разработке. Принцип единственной ответственности]]></title>
            <link>https://medium.com/@ioszhukov/solid-in-ios-srp-1f4d63641f10?source=rss-2e6743f5e5b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f4d63641f10</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[rp]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <dc:creator><![CDATA[Andrew Zhukov]]></dc:creator>
            <pubDate>Wed, 28 Jun 2017 23:33:13 GMT</pubDate>
            <atom:updated>2017-07-03T13:31:00.847Z</atom:updated>
            <content:encoded><![CDATA[<h3>Введение</h3><p>В этом цикле статей я хотел бы рассказать о SOLID принципах, и, что самое главное, дополнить их практическими примерами из iOS разработки. Понимая смысл использования каждого принципа, нет необходимости даже заучивать его формулировку: она будет формироваться сама собой на основании примера.</p><h4>Немного истории</h4><p>В начале 2000-х Роберт Мартин, также известный как дядюшка Боб, придумал список из 11 принципов хорошего объектно-ориентированного дизайна. Первые 5 принципов описывали, как сделать хороший дизайн класса. Позже они стали известны под говорящей аббревиатурой <strong>SOLID</strong>, придуманной Майклом Физерсом. Эти принципы помогают писать надежный, гибкий код.</p><p><strong>Надежность</strong> означает простоту и понятность кода, что позволяет легко вносить в него изменения, упрощает его поддержку, работу в команде.</p><p><strong>Гибкость</strong> позволяет с минимальными усилиями масштабировать проект, увеличивая кодовую базу без вреда для надежности.</p><h4>SOLID</h4><p>Что же обозначает аббревиатура?</p><ul><li><strong>S</strong> — Принцип единственной ответственности (<em>The Single Responsibility Principle, SRP</em>)</li><li><strong>O</strong> — Принцип открытости/закрытости (<em>The Open Closed Principle, OCP</em>)</li><li><strong>L</strong> — Принцип подстановки Б. Лисков (<em>The Liskov Substitution Principle, LSP</em>)</li><li><strong>I</strong> — Принцип разделения интерфейса (<em>The Interface Segregation Principle, ISP</em>)</li><li><strong>D</strong> — Принцип инверсии зависимостей (<em>The Dependency Inversion Principle, DIP</em>)</li></ul><p>Опытному разработчику могут быть очевидны все принципы даже после быстрого взгляда на их расшифровку. Но очень часто многие начинающие разработчики не до конца понимают, почему эти принципы так важны. Для устранения этого пробела в знаниях давайте пройдемся по каждому из них.</p><h3>Принцип единственной ответственности</h3><p>Роберт Мартин описывал его так:</p><blockquote><strong><em>Каждый класс должен иметь только одну причину для изменения</em></strong></blockquote><p>Другими словами, объект должен нести только одну ответственность. Его интерфейс и имплементация должны быть направлены только на эту ответственность.</p><p>Принцип должен соблюдаться всегда: не только при проектировании класса, но и при его багфиксе. Очень часто класс создается, следуя принципу, но потом в него попадает всё, что только возможно.</p><p>Как принцип выглядит на практике? Для начала я приведу простой пример для общего понимания. После этого мы рассмотрим более приближенную к реальности ситуацию, часто встречающуюся в iOS разработке.</p><h4>Простой пример: Больница</h4><p>Итак, давайте представим, что у нас есть больница, в которой работают врачи, а к ним ходят пациенты.</p><p>Врач может записать пациента к себе на прием, а также принять его:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2983c4967e1a2c302cf4f79bbca28a68/href">https://medium.com/media/2983c4967e1a2c302cf4f79bbca28a68/href</a></iframe><p>Попробуем определить обязанность класса Doctor. Очевидно, что главная его обязанность — лечить людей. Но доктора в этой больнице также сами записывают пациентов к себе на прием, ведут очередь своих пациентов, другими словами, занимаются не своими обязанностями.</p><p>Следуя определению от дядюшки Боба, имплементация класса Doctor должна меняться только при изменении способа лечения пациента. Но в данном примере любые изменения в порядке регистрации также будут менять класс Doctor.</p><p>Вынесем функционал регистрации в отдельный класс Registry:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e47ad3d84dcc6244f5f0855dc76d3ca2/href">https://medium.com/media/e47ad3d84dcc6244f5f0855dc76d3ca2/href</a></iframe><p>Теперь всех входящих пациентов обрабатывают в регистратуре, записывая их в очереди и направляя к докторам.</p><p>А доктора стали заниматься только своей главной обязанностью — лечить людей:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e75451594833aa1798a3efc1a857ef25/href">https://medium.com/media/e75451594833aa1798a3efc1a857ef25/href</a></iframe><h4>Другой пример: ViewController</h4><p>Рассмотрим более реальный пример, с которым когда-то сталкивался любой iOS разработчик. При создании нового проекта (например, single view application), Apple предоставляет нам первый контроллер, намекая на использование архитектурного паттерна MVC. Не буду сейчас углубляться в рассуждения о плюсах и минусах этого подхода, но скажу, что некоторые неопытные разработчики часто размещают в таких контроллерах большую часть логики приложения. Возьмем в качестве примера экран для редактирования пользовательских данных. Первые наброски контроллера могут выглядеть так:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e52079e94a94ca5317e358664f3ae2b0/href">https://medium.com/media/e52079e94a94ca5317e358664f3ae2b0/href</a></iframe><p>Может показаться, что всё не так плохо: контроллер содержит аутлеты и обработку пользовательских действий, а также методы бизнес логики приложения.</p><p>Но через какое-то время нужно настроить работу с данными по сети. Тут наш контроллер начинает создавать и посылать запросы. А если понадобится хранить локальный кэш? Теперь в контроллере строятся запросы в базу данных, создаются сущности и происходит прочая работа с БД. Кроме этого, вспомним, что с самого начала в контроллере присутствует логика отрисовки интерфейса, пользовательских действий, а также бизнес логика приложения. В короткие сроки мы уже имеем нечто похожее:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e38ff8360a2b085caad89deb0418f064/href">https://medium.com/media/e38ff8360a2b085caad89deb0418f064/href</a></iframe><p>Отходя от темы, замечу, что разработка с такой архитектурой безусловно будет идти быстрее. Более того, существуют ситуации, когда это может быть осознанным и правильным выбором. Например, набросать прототип проекта с минимальным функционалом <em>(minimal viable product, MVP)</em>, чтобы показать заказчику, но не более того.</p><p>Масштабировать такой продукт с каждой строчкой кода становится всё труднее. А что насчет рефакторинга? Что произойдет, если мы решим поменять способ получения данных из сети? А если решим изменить способ хранения данных? Что если поменяется логика приложения? Или же добавим новые элементы интерфейса? Все эти вопросы имеют сходство — они являются причиной для изменения нашего контроллера. Не слишком ли много причин? Вспомните описание принципа. Дядюшка Боб утверждает, что такая причина должна быть одна.</p><h4>Исправляем ситуацию</h4><p>Начнем с работы с сетью. Конечно, этим не должен заниматься контроллер. Создадим класс NetworkClient, который будет заниматься всей этой работой. Тем самым мы освободили контроллер от одной лишней ответственности: теперь он просит сетевой клиент получить или отправить данные по сети, ничего не подозревая о реализации. Ответственность мы заменили на зависимость. <em>(О правильной реализации зависимостей между классами я расскажу в рамках одной из последующих статей данного цикла, принципе инверсии зависимостей)</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f9e977d3052217b5d3253eadb0d039c/href">https://medium.com/media/8f9e977d3052217b5d3253eadb0d039c/href</a></iframe><p>Заметьте, что в интерфейсе сетевого клиента остались только общие методы, о которых следует знать другим классам. Все подробности реализации теперь скрыты внутри класса.</p><p>Сделаем тоже самое с хранением данных. Создадим класс DataStore и вынесем в него все подробности реализации сохранения и получения данных из хранилища, при этом оставив в публичном интерфейсе только абстрактные методы:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4676b47f52af14f66040db9d7712c123/href">https://medium.com/media/4676b47f52af14f66040db9d7712c123/href</a></iframe><p>Обратите внимание, с таким интерфейсом ни один из классов, использующих наше хранилище, не знает, как именно хранятся данные. Это может быть Core Data, Realm, NSUserDefaults или даже виртуальное хранилище в оперативной памяти.</p><p>Давайте посмотрим, как стал выглядеть контроллер после рефакторинга:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/be75fba22a63fd4a012f07775571488c/href">https://medium.com/media/be75fba22a63fd4a012f07775571488c/href</a></iframe><p>Мы вернулись к начальному состоянию, где, казалось, всё было не так уж плохо. В принципе, такой результат уже можно считать приемлемым и остановиться. Но давайте подумаем, сколько ответственностей сейчас выполняет контроллер? Он реализует бизнес логику приложения, а также отвечает за отрисовку интерфейса с пользовательскими нажатиями, соответственно, выполняет две ответственности. Контроллер не должен содержать в себе бизнес логику, поэтому её также следует вынести в отведенный для этого класс. Существует множество вариантов решения этой задачи: интеракторы, сервисы, вью модели и много других вариантов. Мне нравится сервис-ориентированная архитектура, поэтому я решил создать ProfileService и вынести бизнес логику туда:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a4047f985ce31a503b7bd06ea0a05ee/href">https://medium.com/media/4a4047f985ce31a503b7bd06ea0a05ee/href</a></iframe><p>Вместе с бизнес логикой мы вынесли из контроллера и зависимости сетевого клиента с хранилищем. Также удалось инкапсулировать валидацию нового имени пользователя, немного изменив публичный метод.</p><p>Ну а в контроллере теперь осталась его одна главная ответственность и причина для изменения: взаимодействие с пользователем:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2616adcc8cd44263b5225b5df6df258d/href">https://medium.com/media/2616adcc8cd44263b5225b5df6df258d/href</a></iframe><h4>А если оставить как было?</h4><p>Вспомните, как начал расти контроллер после добавления в него работы с сетью и БД. У принципа единственной ответственности существует противоположность: антипаттерн God Object. Так в шутку называют объект, который отвечает за всё и сразу. Основная проблема заключается в поддержке такого объекта. Впервые взглянув на его интерфейс, невозможно ответить на вопрос: за что же он отвечает? В имплементации класса каждой из ответственностей открыты подробности реализации всех остальных. Это способствует переплетению между ними, ведь нет необходимости работать через строгие публичные интерфейсы, когда всё рядом, по соседству. Неочевидные связи начинают создаваться неосознанно, нарастая, как снежный ком. В результате система становится хрупкой, запутанной и непредсказуемой: изменение кода в одном месте приводит к появлению багов в других, казалось, никак не связанных друг с другом местах.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*Yd195v2ezSV7KevIMI4bZA.jpeg" /><figcaption>God Object</figcaption></figure><h4>Вывод</h4><p>В обоих примерах нам пришлось рефакторить классы, изначально содержащие несколько ответственностей. Принцип единственной ответственности помогает нам в этом, но в первую очередь он придуман для предотвращения таких ситуаций. Его, как и остальные принципы, можно сравнить с рекомендациями по техническому обслуживанию авто. Только вместо авто — ваш проект. Следуйте рекомендациям, регулярно задумываясь об ответственностях классов, не бойтесь разделять их, создавая новые классы, и код проекта будет служить вам долго и исправно.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f4d63641f10" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>