Что такое паттерны поведения простыми словами и как они влияют на человека
Здравствуйте!
Слово “паттерн” пришло к нам с Запада и используется сегодня во многих областях, вследствие чего его смысл варьируется в зависимости от области применения. В рамках раздела о саморазвитии мы рассмотрим, что такое паттерн с точки зрения психологии. Мы расскажем, какими они бывают и как влияют на человека.
Значение слова
В переводе с английского pattern означает “образец, шаблон”. В русскоязычную среду этот термин перекочевал из западных дисциплин и технологий. В общем смысле паттерн – это повторяющийся элемент в различных сферах жизни.
В зависимости от контекста слово имеет довольно широкий диапазон трактовок:
- В дизайне это бесшовный узор с повторяющимися элементами.
- В программировании – способ решения характерных задач с помощью повторяемой кодовой конструкции.
- В электронной музыке – набор последовательно звучащих инструментальных партий.
- В рукоделии – схема узора для вязания, которая несколько раз повторяется в ряду.
- В инвестировании – устойчивые повторяющиеся сочетания данных на графике.
- В медицине – комбинация результатов исследований. К примеру, колебания в кардиограмме.
Простыми словами паттерн – это то, что часто повторяется и может быть использовано в качестве шаблона.
В психологии есть понятие поведенческого паттерна. Это естественные шаблонные реакции и модели поведения человека, которые сформировались под влиянием жизненного опыта.
Психологи используют этот термин в двух основных значениях:
- Набор шаблонных действий. В качестве примера можно привести ежедневную чистку зубов, приготовление кофе по утрам и т. п.
- Стереотипные поведенческие реакции. Поскольку человеческий мозг всегда стремится к упрощению, для классификации внешних событий он использует стереотипы. Оценка получается далеко не точной, зато быстрой.
С точки зрения физиологии мозга паттерн можно сравнить с привычкой.
О том, что такое ностальгия, вы можете прочесть в отдельной публикации.
Формирование паттернов
Как мы уже отметили чуть выше, наш мозг склонен к упрощению, в том числе и в вопросах взаимодействия с окружающим миром. Чтобы не тратить силы на придумывание новых моделей реагирования, он использует уже имеющиеся в “арсенале” и просто дублирует в аналогичных ситуациях. Это касается любых паттернов: поведенческих, словесных, в мышлении и т. д.
Паттерны формируются в процессе воспитания, обучения и наблюдения за другими людьми.
Наиболее активно они создаются в детском возрасте, причем зачастую модели просто копируются без изменений. Именно поэтому говорят, что лучшее воспитание – это личный пример. Поскольку дети повторяют все, что делают или говорят их родители.
По мере взросления модели поведения перенимаются уже не в исходном, а преобразованном виде, чтобы вписаться в характер и другие особенности человека. Помните поговорку “С кем поведешься, от того и наберешься”? Речь как раз об этом. Когда мы часто общаемся с тем или иным человеком, мы неосознанно берем от него определенные шаблоны реагирования и поведения.
Избавиться от паттернов нельзя. Их можно только обнаружить, признать, начать отслеживать и попытаться взять под свой контроль.
Виды
Есть три классификации, в каждой из которых выделяют по два типа:
- Врожденные и приобретенные. Первые заложены в нас на уровне инстинктов. Например, крик в момент испуга, улыбка при виде близких. Вторые – те, что сложились в результате жизненного опыта.
- Позитивные и негативные. Как и любые привычки, паттерны могут быть разными. Одни способствуют поддержанию здоровья, улучшают отношения, позволяют быстрее достигать успеха. Другие, наоборот, отнимают время и усложняют разные аспекты жизни, например, привычка заполнять рабочие перерывы серфингом соцсетей или заострять внимание на собственных неудачах.
- Индивидуальные и социальные. К первой категории можно отнести личные модели поведения. Это то, как мы размешиваем сахар в чашке чая, водим автомобиль, держим зубную щетку. Вторая категория – это наши привычки в коммуникациях. Кто-то отпускает колкие шутки, кто-то учтив и аккуратен в выборе выражений. Приветственные объятия, кивок, поклон – все это социальные (культурные) паттерны.
Как можно использовать в повседневной жизни
Зная паттерны другого человека, мы можем предугадывать его реакции и поведение, и исходя из этого делать для себя соответствующие выводы.
К примеру, если вы хорошо знаете своего коллегу как болтуна и любителя посплетничать, вы не станете доверять ему свои секреты и будете осторожны в высказываниях относительно других людей в его присутствии.
Также стоит помнить о том, что поведенческие модели, сформированные в раннем детстве, с трудом поддаются исправлению. По этой причине многие специалисты утверждают, что при выборе невесты стоит сначала посмотреть на ее мать. Ведь в будущем, когда флер романтики пройдет, супруга может повторять усвоенную модель поведения. Девушкам же, выбирающим жениха, рекомендуют обратить внимание на то, как потенциальный муж относится к своей маме, чтобы понять, как он будет проявляться в семейной жизни по отношению к супруге.
Интересно и то, что все мы ищем для близких отношений людей с подходящими нам паттернами. К примеру, когда женщине попадаются одни альфонсы, она думает, что ей просто не везет.
На самом деле она сама неосознанно выбирает мужчин, которые способны реализовать сложившиеся у нее паттерны. Таким образом, жертвы часто привлекают абьюзеров, подозрительные – обманщиков и т. д.
Кстати, маркетологи тоже используют паттерны своей целевой аудитории, чтобы продвигать товары и услуги. Они внимательно изучают, как пользователи ищут продукт, на что в первую очередь обращают внимание, как принимают решение о покупке. Такая информация помогает добиваться более высоких продаж.
Заключение
Мы с вами разобрали, что значит слово “паттерн” и как формируются поведенческие модели.
Зная, как работают паттерны, можно не только разобраться с собственной жизнью, но и улучшить качество взаимодействия с окружающими людьми.
Благодарим за внимание и до скорого!
Поведенческие паттерны проектирования
Весенняя скидка/ Паттерны проектирования / Каталог
Список поведенческих паттернов проектирования, которые решают задачи эффективного и безопасного взаимодействия между объектами программы.
Цепочка обязанностей Chain of ResponsibilityПозволяет передавать запросы последовательно по цепочке обработчиков. Каждый последующий обработчик решает, может ли он обработать запрос сам и стоит ли передавать запрос дальше по цепи.
Превращает запросы в объекты, позволяя передавать их как аргументы при вызове методов, ставить запросы в очередь, логировать их, а также поддерживать отмену операций.
Итератор IteratorДаёт возможность последовательно обходить элементы составных объектов, не раскрывая их внутреннего представления.
Позволяет уменьшить связанность множества классов между собой, благодаря перемещению этих связей в один класс-посредник.
Снимок MementoПозволяет сохранять и восстанавливать прошлые состояния объектов, не раскрывая подробностей их реализации.
Наблюдатель ObserverСоздаёт механизм подписки, позволяющий одним объектам следить и реагировать на события, происходящие в других объектах.
Состояние StateОпределяет семейство схожих алгоритмов и помещает каждый из них в собственный класс, после чего алгоритмы можно взаимозаменять прямо во время исполнения программы.
Шаблонный метод Template MethodОпределяет скелет алгоритма, перекладывая ответственность за некоторые его шаги на подклассы. Паттерн позволяет подклассам переопределять шаги алгоритма, не меняя его общей структуры.
Позволяет добавлять в программу новые операции, не изменяя классы объектов, над которыми эти операции могут выполняться.
Войти Связаться
Стратегия
/ Шаблоны проектирования / Модели поведения
НамерениеСтратегия — это поведенческий шаблон проектирования, который позволяет определить семейство алгоритмов, поместить каждый из них в отдельный класс и сделать их объекты взаимозаменяемыми.
Однажды вы решили создать навигационное приложение для случайных путешественников. В основе приложения лежала красивая карта, которая помогала пользователям быстро ориентироваться в любом городе.
Одной из наиболее востребованных функций приложения было автоматическое планирование маршрута. Пользователь должен иметь возможность ввести адрес и увидеть на карте самый быстрый маршрут к этому пункту назначения.
Первая версия приложения могла строить маршруты только по дорогам. Люди, которые путешествовали на машине, распирали от радости. Но, видимо, не всем нравится водить машину в отпуске. Итак, в следующем обновлении вы добавили возможность строить пешеходные маршруты. Сразу после этого вы добавили еще одну опцию, позволяющую людям пользоваться общественным транспортом на своих маршрутах.
Однако это было только начало. Позже вы планировали добавить построение маршрута для велосипедистов. А еще позже — еще один вариант построения маршрутов по всем достопримечательностям города.
Код навигатора раздулся.
Хотя с точки зрения бизнеса приложение было успешным, техническая часть вызвала у вас много головной боли. Каждый раз, когда вы добавляли новый алгоритм маршрутизации, основной класс навигатора увеличивался вдвое. В какой-то момент зверя стало слишком сложно поддерживать.
Любое изменение в одном из алгоритмов, будь то простое исправление ошибки или небольшая корректировка уличного счета, влияло на весь класс, увеличивая вероятность создания ошибки в уже работающем коде.
Кроме того, командная работа стала неэффективной. Ваши товарищи по команде, которых наняли сразу после успешного релиза, жалуются, что тратят слишком много времени на разрешение конфликтов слияния. Реализация новой функции требует от вас изменения того же самого огромного класса, конфликтующего с кодом, созданным другими людьми.
Шаблон Стратегия предполагает, что вы берете класс, который делает что-то конкретное множеством различных способов, и выделяете все эти алгоритмы в отдельные классы, называемые стратегиями .
Исходный класс с именем context должен иметь поле для хранения ссылки на одну из стратегий. Контекст делегирует работу связанному объекту стратегии вместо того, чтобы выполнять его самостоятельно.
Контекст не отвечает за выбор подходящего алгоритма для задания. Вместо этого клиент передает желаемую стратегию контексту. На самом деле контекст мало что знает о стратегиях. Он работает со всеми стратегиями через один и тот же общий интерфейс, который предоставляет только один метод запуска алгоритма, инкапсулированного в выбранной стратегии.
Таким образом, контекст становится независимым от конкретных стратегий, поэтому вы можете добавлять новые алгоритмы или модифицировать существующие без изменения кода контекста или других стратегий.
Стратегии планирования маршрута.
В нашем навигационном приложении каждый алгоритм маршрутизации можно выделить в отдельный класс с помощью одного метода buildRoute
. Метод принимает исходную и конечную точки и возвращает набор контрольных точек маршрута.
Несмотря на то, что при одних и тех же аргументах каждый класс маршрутизации может построить свой маршрут, основному классу навигатора все равно, какой алгоритм выбран, поскольку его основной задачей является отображение набора контрольных точек на карте. У класса есть метод для переключения активной стратегии маршрутизации, поэтому его клиенты, такие как кнопки в пользовательском интерфейсе, могут заменить текущее выбранное поведение маршрутизации другим.
Аналогия из реального мираРазличные способы добраться до аэропорта.
Представьте, что вам нужно добраться до аэропорта. Вы можете сесть на автобус, заказать такси или сесть на велосипед. Это ваши транспортные стратегии. Вы можете выбрать одну из стратегий в зависимости от таких факторов, как бюджет или временные ограничения.
СтруктураКонтекст поддерживает ссылку на одну из конкретных стратегий и связывается с этим объектом только через интерфейс стратегии.
Интерфейс Strategy является общим для всех конкретных стратегий. Он объявляет метод, который контекст использует для выполнения стратегии.
Конкретные стратегии реализуют различные варианты алгоритма, который использует контекст.
Контекст вызывает метод выполнения для связанного объекта стратегии каждый раз, когда ему необходимо запустить алгоритм. Контекст не знает, с какой стратегией он работает или как выполняется алгоритм.
Клиент создает определенный объект стратегии и передает его контексту. Контекст предоставляет установщик, который позволяет клиентам заменить стратегию, связанную с контекстом, во время выполнения.
В этом примере контекст использует несколько стратегий для выполнения различных арифметических операций.
// В интерфейсе стратегии объявлены общие для всех операции
// поддерживаемые версии некоторого алгоритма. Контекст использует это
// интерфейс для вызова алгоритма, определенного конкретным
// стратегии.
Интерфейс Стратегия
метод выполнить (а, б)
// Конкретные стратегии реализуют алгоритм при следовании
// интерфейс базовой стратегии. Интерфейс делает их
// взаимозаменяемы в контексте.
класс ConcreteStrategyAdd реализует стратегию
метод execute(a, b) есть
вернуть а + б
класс ConcreteStrategySubtract реализует стратегию
метод execute(a, b) есть
вернуть а - б
класс ConcreteStrategyMultiply реализует стратегию
метод execute(a, b) есть
вернуть а * б
// Контекст определяет интересующий клиентов интерфейс.
Контекст класса
// Контекст поддерживает ссылку на одну из стратегий
// объекты. Контекст не знает конкретного класса
// стратегия. Он должен работать со всеми стратегиями через
// интерфейс стратегии.
частная стратегия: Стратегия
// Обычно контекст принимает стратегию через
// конструктор, а также предоставляет сеттер, чтобы
// стратегию можно переключать во время выполнения.
метод setStrategy (Стратегия стратегии)
this.strategy = стратегия
// Контекст делегирует часть работы объекту стратегии
// вместо реализации нескольких версий
// алгоритм сам по себе.
метод executeStrategy(int a, int b)
возврат Strategy.execute(a, b)
// Клиентский код выбирает конкретную стратегию и передает ее в
// контекст. Клиент должен знать об отличиях
// между стратегиями, чтобы сделать правильный выбор.
класс ExampleApplication
метод main() есть
Создать объект контекста.
Прочитайте первое число.
Прочтите последнюю цифру.
Прочитайте желаемое действие из пользовательского ввода.
если (действие == сложение), то
context.setStrategy(новый ConcreteStrategyAdd())
если (действие == вычитание), то
context.setStrategy (новый ConcreteStrategySubtract())
если (действие == умножение), то
context.setStrategy (новый ConcreteStrategyMultiply())
результат = context. executeStrategy (первое число, второе число)
Распечатать результат.
ПрименимостьИспользуйте шаблон Стратегия, если вы хотите использовать различные варианты алгоритма внутри объекта и иметь возможность переключаться с одного алгоритма на другой во время выполнения.
Шаблон «Стратегия» позволяет вам косвенно изменять поведение объекта во время выполнения, связывая его с различными подобъектами, которые могут выполнять определенные подзадачи разными способами.
Используйте Стратегию, когда у вас есть много похожих классов, которые отличаются только тем, как они выполняют некоторое поведение.
Шаблон Стратегия позволяет выделить различное поведение в отдельную иерархию классов и объединить исходные классы в один, тем самым уменьшив дублирование кода.
Используйте шаблон, чтобы изолировать бизнес-логику класса от деталей реализации алгоритмов, которые могут быть не такими важными в контексте этой логики.
Шаблон Strategy позволяет изолировать код, внутренние данные и зависимости различных алгоритмов от остального кода. Различные клиенты получают простой интерфейс для выполнения алгоритмов и переключения их во время выполнения.
Используйте шаблон, если в вашем классе есть массивный условный оператор, который переключается между различными вариантами одного и того же алгоритма.
Шаблон Стратегия позволяет отказаться от такого условного выражения, выделяя все алгоритмы в отдельные классы, реализующие один и тот же интерфейс. Исходный объект делегирует выполнение одному из этих объектов вместо реализации всех вариантов алгоритма.
Как реализоватьВ классе контекста определите алгоритм, который подвержен частым изменениям. Это также может быть массивное условное выражение, которое выбирает и выполняет вариант одного и того же алгоритма во время выполнения.
Объявить интерфейс стратегии общим для всех вариантов алгоритма.
Один за другим извлеките все алгоритмы в их собственные классы. Все они должны реализовать интерфейс стратегии.
В классе контекста добавить поле для хранения ссылки на объект стратегии. Предоставьте сеттер для замены значений этого поля. Контекст должен работать с объектом стратегии только через интерфейс стратегии. Контекст может определять интерфейс, который позволяет стратегии получать доступ к своим данным.
Клиенты контекста должны связать его с подходящей стратегией, которая соответствует тому, как они ожидают, что контекст будет выполнять свою основную работу.
- Вы можете поменять местами алгоритмы, используемые внутри объекта во время выполнения.
- Вы можете изолировать детали реализации алгоритма от кода, который его использует.
- Вы можете заменить наследование композицией.
- Принцип открытия/закрытия . Вы можете внедрять новые стратегии, не меняя контекст.
- Если у вас всего пара алгоритмов и они редко меняются, нет никакой реальной причины усложнять программу новыми классами и интерфейсами, которые поставляются вместе с шаблоном.
- Клиенты должны знать о различиях между стратегиями, чтобы иметь возможность выбрать правильную.
- Многие современные языки программирования поддерживают функциональные типы, что позволяет реализовывать различные версии алгоритма внутри набора анонимных функций. Затем вы могли бы использовать эти функции точно так же, как вы использовали бы объекты стратегии, но без раздувания кода дополнительными классами и интерфейсами.
Мост, Состояние, Стратегия (и в некоторой степени Адаптер) имеют очень похожую структуру. Действительно, все эти шаблоны основаны на композиции, которая делегирует работу другим объектам. Однако все они решают разные задачи. Шаблон — это не просто рецепт структурирования вашего кода определенным образом. Он также может сообщить другим разработчикам о проблеме, которую решает шаблон.
Command и Strategy могут выглядеть одинаково, потому что вы можете использовать их для параметризации объекта с помощью некоторого действия. Однако у них очень разные намерения.
Вы можете использовать команду для преобразования любой операции в объект. Параметры операции становятся полями этого объекта. Преобразование позволяет отложить выполнение операции, поставить ее в очередь, сохранить историю команд, отправить команды в удаленные службы и т. д.
С другой стороны, Стратегия обычно описывает разные способы выполнения одних и тех же действий, позволяя вам менять местами эти алгоритмы в одном классе контекста.
Decorator позволяет изменить внешний вид объекта, а Strategy позволяет изменить его внутреннюю часть.
- Шаблонный метод
основан на наследовании: он позволяет вам изменять части алгоритма, расширяя эти части в подклассах. Стратегия основана на композиции: вы можете изменять части поведения объекта, снабжая его различными стратегиями, соответствующими этому поведению. Метод шаблона работает на уровне класса, поэтому он статичен. Стратегия работает на уровне объекта, позволяя переключать поведение во время выполнения.
Состояние можно рассматривать как расширение Стратегии. Оба шаблона основаны на композиции: они изменяют поведение контекста, делегируя часть работы вспомогательным объектам. Стратегия делает эти объекты полностью независимыми и не знающими друг друга. Однако State не ограничивает зависимости между конкретными состояниями, позволяя им изменять состояние контекста по желанию.
Цепочка ответственности
/ Шаблоны проектирования / Модели поведения
Также известен как: CoR, Chain of Command
НамерениеЦепочка ответственности — это поведенческий шаблон проектирования, позволяющий передавать запросы по цепочке обработчиков. Получив запрос, каждый обработчик решает либо обработать запрос, либо передать его следующему обработчику в цепочке.
ПроблемаПредставьте, что вы работаете над системой онлайн-заказов. Вы хотите ограничить доступ к системе, чтобы только авторизованные пользователи могли создавать заказы. Кроме того, пользователи с правами администратора должны иметь полный доступ ко всем заказам.
После небольшого планирования вы поняли, что эти проверки должны выполняться последовательно. Приложение может попытаться аутентифицировать пользователя в системе всякий раз, когда оно получает запрос, содержащий учетные данные пользователя. Однако, если эти учетные данные неверны и аутентификация не удалась, нет причин продолжать какие-либо другие проверки.
Запрос должен пройти ряд проверок, прежде чем система заказов сможет его обработать.
В течение следующих нескольких месяцев вы реализовали еще несколько таких последовательных проверок.
Один из ваших коллег предположил, что передавать необработанные данные прямо в систему заказов небезопасно. Итак, вы добавили дополнительный шаг проверки для очистки данных в запросе.
Позже кто-то заметил, что система уязвима для взлома паролей методом грубой силы. Чтобы предотвратить это, вы быстро добавили проверку, которая отфильтровывает повторяющиеся неудачные запросы, поступающие с одного и того же IP-адреса.
Кто-то еще предложил ускорить работу системы, возвращая кэшированные результаты при повторных запросах, содержащих одни и те же данные. Следовательно, вы добавили еще одну проверку, которая пропускает запрос в систему, только если нет подходящего кэшированного ответа.
Чем больше код рос, тем запутаннее он становился.
Код чеков, и без того выглядевший кашей, становился все более и более раздутым по мере добавления каждой новой функции. Изменение одного чека иногда влияло на другие. Хуже всего то, что когда вы пытались повторно использовать проверки для защиты других компонентов системы, вам приходилось дублировать часть кода, поскольку эти компоненты требовали некоторых проверок, но не всех.
Система стала очень сложной для понимания и дорогой в обслуживании. Вы какое-то время боролись с кодом, пока однажды не решили провести рефакторинг всего этого.
РешениеПодобно многим другим поведенческим шаблонам проектирования, цепочка ответственности полагается на преобразование определенного поведения в автономные объекты, называемые обработчиками . В нашем случае каждая проверка должна быть извлечена в свой класс с помощью одного метода, выполняющего проверку. Запрос вместе со своими данными передается этому методу в качестве аргумента.
Шаблон предлагает связать эти обработчики в цепочку. Каждый связанный обработчик имеет поле для хранения ссылки на следующий обработчик в цепочке. Помимо обработки запроса, обработчики передают запрос дальше по цепочке. Запрос перемещается по цепочке до тех пор, пока все обработчики не получат возможность его обработать.
Вот лучшая часть: обработчик может принять решение не передавать запрос дальше по цепочке и эффективно остановить дальнейшую обработку.
В нашем примере с системами заказов обработчик выполняет обработку, а затем решает, передать ли запрос дальше по цепочке. Предполагая, что запрос содержит правильные данные, все обработчики могут выполнять свое основное поведение, будь то проверка подлинности или кэширование.
Дрессировщики выстраиваются один за другим, образуя цепочку.
Однако есть немного другой подход (и он немного более каноничный), при котором, получив запрос, обработчик решает, может ли он его обработать. Если это возможно, он не передает запрос дальше. Таким образом, либо только один обработчик обрабатывает запрос, либо вообще ничего. Этот подход очень распространен при работе с событиями в стеках элементов в графическом пользовательском интерфейсе.
Например, когда пользователь нажимает кнопку, событие распространяется по цепочке элементов графического интерфейса, которая начинается с кнопки, проходит по ее контейнерам (таким как формы или панели) и заканчивается главным окном приложения. Событие обрабатывается первым элементом в цепочке, способным его обработать. Этот пример также примечателен тем, что он показывает, что цепочку всегда можно извлечь из дерева объектов.
Цепочка может быть сформирована из ветви дерева объектов.
Крайне важно, чтобы все классы обработчиков реализовывали один и тот же интерфейс. Каждый конкретный обработчик должен заботиться только о следующем, имеющем метод execute
. Таким образом, вы можете создавать цепочки во время выполнения, используя различные обработчики, не связывая свой код с их конкретными классами.
Звонок в службу технической поддержки может проходить через нескольких операторов.
Вы только что купили и установили на свой компьютер новое оборудование. Поскольку вы гик, на компьютере установлено несколько операционных систем. Вы пытаетесь загрузить их все, чтобы увидеть, поддерживается ли оборудование. Windows автоматически обнаруживает и включает оборудование. Однако ваш любимый Linux отказывается работать с новым железом. С небольшим проблеском надежды вы решаете позвонить по телефону техподдержки, указанному на коробке.
Первое, что вы слышите, это механический голос автоответчика. Он предлагает девять популярных решений различных проблем, ни одно из которых не имеет отношения к вашему делу. Через некоторое время робот подключает вас к живому оператору.
Увы, ничего конкретного оператор подсказать тоже не может. Он продолжает цитировать длинные выдержки из руководства, отказываясь слушать ваши комментарии. Услышав фразу «вы пробовали выключить и снова включить компьютер?» в 10-й раз вы требуете, чтобы вас соединили с настоящим инженером.
В конце концов, оператор передает ваш звонок одному из инженеров, который, вероятно, часами жаждал живого человеческого общения, сидя в своей одинокой серверной в темном подвале какого-то офисного здания. Инженер расскажет вам, где скачать подходящие драйверы для вашего нового оборудования и как установить их в Linux. Наконец-то решение! Вы заканчиваете разговор, разрываясь от радости.
СтруктураОбработчик объявляет интерфейс, общий для всех конкретных обработчиков. Обычно он содержит только один метод для обработки запросов, но иногда может иметь и другой метод для установки следующего обработчика в цепочке.
Базовый обработчик — это необязательный класс, в который можно поместить шаблонный код, общий для всех классов обработчиков.
Обычно этот класс определяет поле для хранения ссылки на следующий обработчик. Клиенты могут построить цепочку, передав обработчик конструктору или сеттеру предыдущего обработчика. Класс также может реализовать поведение обработки по умолчанию: он может передать выполнение следующему обработчику после проверки его существования.
Бетонные обработчики содержат фактический код для обработки запросов. При получении запроса каждый обработчик должен решить, обрабатывать ли его и, дополнительно, передавать ли по цепочке.
Обработчики обычно автономны и неизменяемы, принимая все необходимые данные только один раз через конструктор.
Клиент может составлять цепочки только один раз или составлять их динамически, в зависимости от логики приложения. Обратите внимание, что запрос может быть отправлен любому обработчику в цепочке — он не обязательно должен быть первым.
В этом примере шаблон Цепочка ответственности отвечает за отображение контекстной справочной информации для активных элементов графического интерфейса.
Классы GUI построены по шаблону Composite. Каждый элемент связан со своим элементом-контейнером. В любой момент вы можете построить цепочку элементов, которая начинается с самого элемента и проходит через все его элементы-контейнеры.
Графический интерфейс приложения обычно имеет структуру дерева объектов. Например, Класс Dialog
, который отображает главное окно приложения, будет корнем дерева объектов. Диалог содержит панелей
, которые могут содержать другие панели или простые низкоуровневые элементы, такие как кнопок
и текстовых полей
.
Простой компонент может отображать краткие контекстные всплывающие подсказки, если компоненту назначен текст справки. Но более сложные компоненты определяют свой собственный способ отображения контекстной справки, например, показ выдержки из руководства или открытие страницы в браузере.
Вот как запрос на помощь проходит через объекты GUI.
Когда пользователь наводит курсор мыши на элемент и нажимает клавишу F1
, приложение обнаруживает компонент под указателем и отправляет ему запрос на помощь. Запрос проходит через все контейнеры элемента, пока не достигнет элемента, способного отображать справочную информацию.
// Интерфейс обработчика объявляет метод для выполнения
// запрос.
Интерфейс ComponentWithContextualHelp
метод showHelp()
// Базовый класс для простых компонентов.
абстрактный класс Компонент реализует ComponentWithContextualHelp
поле tooltipText: строка
// Контейнер компонента действует как следующая ссылка в
// цепочка обработчиков.
Контейнер защищенного поля: Контейнер
// Компонент показывает всплывающую подсказку, если есть текст справки
// присвоено ему. В противном случае вызов перенаправляется на
// контейнер, если он существует.
метод showHelp() есть
если (текст подсказки != ноль)
// Показать всплывающую подсказку.
еще
контейнер.showHelp()
// Контейнеры могут содержать как простые компоненты, так и другие
// контейнеры как дочерние элементы. Цепные отношения
// установлено здесь. Класс наследует поведение showHelp от
// его родитель.
абстрактный класс Контейнер расширяет компонент
дочерние элементы защищенного поля: массив компонентов
метод add(child) есть
дети.добавить(ребенок)
ребенок.контейнер = это
// Примитивные компоненты могут работать со справкой по умолчанию
// выполнение...
Класс Кнопка расширяет Компонент
// ...
// Но сложные компоненты могут переопределить значение по умолчанию
// выполнение. Если текст справки не может быть предоставлен в новом
// таким образом, компонент всегда может вызвать базовую реализацию
// (см. Класс компонента).
класс Panel расширяет контейнер
поле modalHelpText: строка
метод showHelp() есть
если (modalHelpText != ноль)
// Показать модальное окно с текстом справки.
еще
супер.showHelp()
// ...то же, что и выше...
диалоговое окно класса расширяет контейнер
поле wikiPageURL: строка
метод showHelp() есть
если (wikiPageURL != ноль)
// Открытие страницы справки вики.
еще
супер.showHelp()
// Клиентский код.
приложение класса
// Каждое приложение настраивает цепочку по-своему.
метод createUI() есть
диалог = новый диалог ("Бюджетные отчеты")
dialog.wikiPageURL = "http://..."
панель = новая панель (0, 0, 400, 800)
panel.modalHelpText = "Эта панель делает..."
ок = новая кнопка (250, 760, 50, 20, "ОК")
ok.tooltipText = "Это кнопка OK, которая..."
отмена = новая кнопка (320, 760, 50, 20, "Отмена")
// ...
панель.добавить(ок)
панель.добавить(отмена)
диалог.добавить(панель)
// Представьте, что здесь происходит.
метод onF1KeyPress() есть
компонент = this.getComponentAtMouseCoords()
компонент. showHelp()
ПрименимостьИспользуйте шаблон цепочки ответственности, когда предполагается, что ваша программа будет обрабатывать различные типы запросов различными способами, но точные типы запросов и их последовательность заранее неизвестны.
Паттерн позволяет связать несколько обработчиков в одну цепочку и, получив запрос, «спросить» у каждого обработчика, может ли он его обработать. Таким образом, все обработчики получают возможность обработать запрос.
Используйте шаблон, когда необходимо выполнить несколько обработчиков в определенном порядке.
Поскольку вы можете связывать обработчики в цепочке в любом порядке, все запросы будут проходить через цепочку именно так, как вы планировали.
Используйте шаблон CoR, когда предполагается изменение набора обработчиков и их порядка во время выполнения.
Если вы предоставляете сеттеры для ссылочного поля внутри классов обработчиков, вы сможете динамически вставлять, удалять или изменять порядок обработчиков.
Как реализоватьОбъявить интерфейс обработчика и описать сигнатуру метода для обработки запросов.
Решите, как клиент будет передавать данные запроса в метод. Самый гибкий способ — преобразовать запрос в объект и передать его методу обработки в качестве аргумента.
Чтобы устранить повторяющийся шаблонный код в конкретных обработчиках, возможно, стоит создать абстрактный базовый класс обработчика, производный от интерфейса обработчика.
Этот класс должен иметь поле для хранения ссылки на следующий обработчик в цепочке. Подумайте о том, чтобы сделать класс неизменяемым. Однако, если вы планируете изменять цепочки во время выполнения, вам необходимо определить установщик для изменения значения поля ссылки.
Вы также можете реализовать удобное поведение по умолчанию для метода обработки, которое заключается в перенаправлении запроса к следующему объекту, если не осталось ни одного. Конкретные обработчики смогут использовать это поведение, вызвав родительский метод.
Один за другим создайте конкретные подклассы обработчиков и реализуйте их методы обработки. Каждый обработчик должен принять два решения при получении запроса:
- Будет ли обрабатываться запрос.
- Будет ли передаваться запрос по цепочке.
Клиент может либо собирать цепочки самостоятельно, либо получать готовые цепочки от других объектов. В последнем случае необходимо реализовать некоторые фабричные классы для построения цепочек в соответствии с настройками конфигурации или среды.
Клиент может вызвать любой обработчик в цепочке, а не только первый. Запрос будет передаваться по цепочке до тех пор, пока какой-либо обработчик не откажется передавать его дальше или пока он не достигнет конца цепочки.
Из-за динамического характера цепочки клиент должен быть готов к следующим сценариям:
- Цепь может состоять из одного звена.
- Некоторые запросы могут не достигать конца цепочки.
- Другие могут достичь конца цепочки без обработки.
- Вы можете управлять порядком обработки запросов.
- Принцип единой ответственности . Вы можете отделить классы, вызывающие операции, от классов, выполняющих операции.
- Открытый/Закрытый принцип . Вы можете добавлять в приложение новые обработчики, не нарушая существующий клиентский код.
- Некоторые запросы могут остаться необработанными.
Chain of Responsibility, Command, Mediator и Observer обращаются к различным способам соединения отправителей и получателей запросов:
- Цепочка ответственности передает запрос последовательно по динамической цепочке потенциальных получателей, пока один из них не обработает его.
- Команда устанавливает однонаправленные соединения между отправителями и получателями.
- Посредник устраняет прямые соединения между отправителями и получателями, заставляя их взаимодействовать косвенно через объект-посредник.
- Observer позволяет получателям динамически подписываться на получение запросов и отписываться от них.
Chain of Responsibility часто используется в сочетании с Composite. В этом случае, когда листовой компонент получает запрос, он может передать его по цепочке всех родительских компонентов до корня дерева объектов.
Обработчики в цепочке ответственности могут быть реализованы как команды. В этом случае вы можете выполнять множество различных операций над одним и тем же объектом контекста, представленным запросом.
Однако есть и другой подход, когда сам запрос представляет собой Команда объект. В этом случае вы можете выполнять одну и ту же операцию в ряде различных контекстов, связанных в цепочку.