Здоровые модели поведения
- Home/
- Здоровые модели поведения: больше внимания к анализу поведенческих и культурных факторов
Здоровые модели поведения: больше внимания к анализу поведенческих и культурных факторов
© Фото
В рамках этой флагманской инициативы ВОЗ-Европа планирует развивать новые методы анализа, применение которых поможет сформировать в Регионе культуру здоровья, дающую возможность каждому человеку делать выбор в пользу здоровья в своей повседневной жизни, в том числе в своих подходах к использованию услуг здравоохранения. На поведение людей могут негативно влиять факторы, которые зачастую недостаточно учитываются в процессе разработки и реализации стратегий и организации услуг или в правилах поведения медицинских работников. К числу таких факторов относятся: недостаточная грамотность в вопросах здоровья, противоречащие друг другу системы убеждений, ощущение страха, недоверия и неопределенности, неправильно истолкованная информация, ощущение неудобства либо опыт неуважительного отношения или дискриминации.
Данная инициатива будет содействовать использованию результатов анализа этих социальных, поведенческих и культурных факторов с целью повышения уровня грамотности в вопросах здоровья, а также с целью улучшения процессов, процедур и правил поведения поставщиков услуг при взаимодействии граждан с медицинскими и социальными службами. Инициатива будет способствовать появлению новых научных знаний о взаимосвязях между этим факторами и теми или иными мерами политики и процессами оказания услуг, для того чтобы помочь странам оптимизировать показатели использования услуг и соблюдения режима лечения, практику самопомощи, а также правила индивидуального и коллективного поведения (в том числе в свете новых подходов к социальному взаимодействию в условиях борьбы с пандемией COVID-19).
Привлекая к этой работе специалистов из других областей знаний, помимо биомедицинской сферы, таких как социальные науки и медицинские гуманитарные науки, данная инициатива поможет органам здравоохранения привести оказываемые ими услуги в соответствие с ожиданиями граждан, которые нуждаются в уважительном и ориентированном на их потребности медицинском обслуживании.В рамках этой флагманской инициативы:
- будет оказываться поддержка заинтересованным странам, а также региональным или субрегиональным структурам в поиске возможностей для адаптации, внедрения и создания успешных методов работы в области формирования культуры здоровья и оптимизации процессов и практики взаимодействия граждан с медицинскими и социальными службами;
- будет подготовлен сборник примеров передовой практики, посвященный разработке таких мер, процессов, процедур и правил, которые были бы в большей степени приемлемыми с культурной точки зрения, ориентированными на нужды людей и удобными в применении, с особым акцентом на учете данных об опыте пациентов в процессе выработки соответствующих мер политики;
- будет создан ресурсный центр для новой сферы научных исследований, касающейся анализа поведенческих и культурных факторов, влияющих на поведение людей в отношении здоровья;
- будут выработаны аргументы в поддержку инвестиций в развитие базы знаний и фактических данных, касающихся этой сферы деятельности.
Европейская программа работы
В ЕПР представлено видение о том, как Европейское региональное бюро ВОЗ способно помочь органам управления здравоохранением в государствах-членах выполнять эти задачи в каждой стране и, общими усилиями, в Регионе. ЕПР не является исчерпывающим списком всех направлений нормотворческой и технической деятельности, которую выполняет ВОЗ-Европа. Она предусматривает возможности для гибких подходов к реализации, скорейшего достижения результатов и поддержки инвестиций в будущее.Он также признает, что для достижения успеха ВОЗ-Европа должна работать в тесном партнерстве с региональными и глобальными партнерами.
Задействованная команда
Публикации
Все →Читать больше
Документы
Все →Читать больше
Новости
Все →Мультимедиа
Все →Смежные вопросы здравоохранения
Создание модели поведения пользователей
Аудио перевод статьи
Как использовать взаимодействие для формирования устойчивых моделей поведения пользователей.
Данная статья демонстрирует потенциал взаимодействия в формировании поведенческих моделей. Для этого мы рассмотрим взаимодействие, которое Facebook Messenger развернул пару лет назад. Возможно, вы успели застать это взаимодействие. Если вы хотите понять о чем идет речь, посмотрите видео, представленное ниже.
Ссылка на видео
Пользователи Android привыкли, что длительное нажатие на диалог показывает список действий, расположенных справа от него, которые вы можете предпринять относительно данного чата. Логично предположить, что происходило бы ровно то же самое, если бы вместо длительного нажатия вы сделали свайп по диалогу. Теперь это возможно! Если вы “свайпните” влево, то получите точно такой же эффект — справа от диалога появится список действий, которые можно совершить.
В этой статье мы разберем взаимодействия и поговорим о том, как Messenger умело использовал их для формирования модели поведения своих пользователей.
Но сначала давайте разберемся, из чего состоят взаимодействия.
1. Разбивка взаимодействия
Взаимодействие состоит из следующих частей:
- Действие пользователя (User Action) — действие, которое пользователь выполняет для взаимодействия с элементом интерфейса. В случае со смартфонами эти действия называются жестами. Некоторые примеры — касание, длительное нажатие, пролистывание и т.д.
- Реакции (Reaction) — реакцией называются изменения, происходящие с интерфейсом в результате действия пользователя. Реакция может распространяться как на один элемент, так и на несколько элементов интерфейса. Это может быть управление различными свойствами, такими как форма, ориентация, высота одного или нескольких элементов.
- Восприятие (Perception) — восприятием называется понимание того, как элементы интерфейса реагируют на определенное действие пользователя. Восприятие позволяет людям освоить принцип работы взаимодействий и понять, как работает продукт, тем самым выстраивая свои ментальные модели с течением времени.
Слишком сложно? Давайте рассмотрим пример.
Ссылка на видео
Убер: Гамбургер
На видео выше показано меню Uber. Доступ к меню осуществляется следующим образом:
- Необходимо нажать на значок гамбургер (три горизонтальные полоски в левом верхнем углу) — действие пользователя;
- Значок гамбургер выдвигает меню с левого края экрана — реакция;
- Это действие сообщает пользователю, что меню остается в левой части экрана — восприятие.
Всякий раз, когда мы захотим открыть меню, оно будет появляться именно с левого края экрана и при закрытии возвращаться в то же самое место. Интересно, что закрытие меню осуществляется свайпом влево, который мы все совершаем интуитивно.
Но почему именно свайп влево, а не вправо или любое другое действие? Можно было бы сослаться на привычку, которая вырабатывалась у нас с течением времени, но не все так просто. Каждый раз, когда мы наблюдали реакцию интерфейса на совершаемое действие, у нас формировалось восприятие того, как функционирует гамбургер.
Если бы гамбургеры, как только они появились, вели себя по-другому, например: меню открывалось слева (так же, как и в примере выше), но закрывалось свайпом вправо — мы бы все интуитивно делали свайпы вправо, чтобы убрать его с экрана.
Каждое взаимодействие создает восприятие. Это восприятие формирует ментальные модели, а ментальные модели формируют поведенческие модели.
Очень важно, чтобы мы, как дизайнеры, думали о восприятии при разработке взаимодействия, поскольку:
- это элементарная необходимость;
- осознание этих восприятий может помочь разрушить барьер между вашим дизайном и ментальной моделью пользователя.
2. Возвращаясь к длительному нажатию в Messenger
Возвращаясь к теме, Messenger использует реакцию и восприятие взаимодействия для формирования модели поведения своих пользователей очень умным способом. При длительном нажатии возможные действия появляются справа, имитируя реакцию свайпа, создавая ощущение, что действия доступны только рядом с пунктом чата. Всем, кому известен принцип работы свайпа на смартфонах, эта реакция сообщает, что это действие может быть достигнуто и через свайп.
Во то время как свайп имеет четко определенную реакцию в приложениях, длительное нажатие не имеет стандартной реакции. В разных приложении оно может выполнять различные действия, например:
- позволяет выполнять многократный выбор элементов;
- получать доступ к действиям над отдельными элементами через список или диалоговое окно.
Невероятный способ, формирующий ментальную модель пользователей: связать длительное нажатие с реакцией на свайп с целью информирования пользователя о том, что существует взаимодействие с помощью свайпа.
Это, несомненно, одно из самых умных взаимодействий, которые я видел.
Почему свайп, а не длительное нажатие?
Вы, возможно, задаетесь вопросом, почему Facebook предпочитает взаимодействие свайпом вместо длительного нажатия. Ответ прост. В зависимости от ОС, к которой привыкли пользователи, их модели поведения отличаются:
- на Android наиболее распространенно взаимодействие — длительное нажатие;
- на iOS альтернативой длительному нажатию во многих случаях является свайп.
Если оценивать количественно, то свайп занимает меньше времени и усилий, чем длительное нажатие, что делает его гораздо более плавным по сравнению с длительным нажатием. Так что, возможно, именно поэтому Messenger предпочитает свайп над длительным нажатием.
Заключение
Поведенческие модели формируются ментальными моделями, которые строятся на опыте взаимодействия. Каждое взаимодействие пользователя с вашим продуктом может подтвердить или изменить (хотя не рекомендуется) устоявшуюся ментальную модель пользователя. Ключ к созданию опыта, формирующего модели пользователя желаемым образом — понимание того, какое восприятие создают наши дизайны и взаимодействия.
Стратегия
/ Шаблоны проектирования / Модели поведения
НамерениеСтратегия — это поведенческий шаблон проектирования, который позволяет определить семейство алгоритмов, поместить каждый из них в отдельный класс и сделать их объекты взаимозаменяемыми.
Однажды вы решили создать навигационное приложение для случайных путешественников. В основе приложения лежала красивая карта, которая помогала пользователям быстро ориентироваться в любом городе.
Одной из наиболее востребованных функций приложения было автоматическое планирование маршрута. Пользователь должен иметь возможность ввести адрес и увидеть на карте самый быстрый маршрут к этому пункту назначения.
Первая версия приложения могла строить маршруты только по дорогам. Люди, которые путешествовали на машине, распирали от радости. Но, видимо, не всем нравится водить машину в отпуске. Итак, в следующем обновлении вы добавили возможность строить пешеходные маршруты. Сразу после этого вы добавили еще одну опцию, позволяющую людям пользоваться общественным транспортом на своих маршрутах.
Однако это было только начало. Позже вы планировали добавить построение маршрута для велосипедистов. А еще позже — еще один вариант построения маршрутов по всем достопримечательностям города.
Код навигатора раздулся.
Хотя с точки зрения бизнеса приложение было успешным, техническая часть вызвала у вас много головной боли. Каждый раз, когда вы добавляли новый алгоритм маршрутизации, основной класс навигатора увеличивался вдвое. В какой-то момент зверя стало слишком сложно поддерживать.
Любое изменение в одном из алгоритмов, будь то простое исправление ошибки или небольшая корректировка уличного счета, влияло на весь класс, увеличивая вероятность создания ошибки в уже работающем коде.
Кроме того, командная работа стала неэффективной. Ваши товарищи по команде, которых наняли сразу после успешного релиза, жалуются, что тратят слишком много времени на разрешение конфликтов слияния. Реализация новой функции требует от вас изменения того же самого огромного класса, конфликтующего с кодом, созданным другими людьми.
Шаблон Стратегия предполагает, что вы берете класс, который делает что-то конкретное множеством разных способов, и выделяете все эти алгоритмы в отдельные классы, называемые стратегиями .
Исходный класс с именем 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 автоматически обнаруживает и включает оборудование. Однако ваш любимый линукс отказывается работать с новым железом. С небольшим проблеском надежды вы решаете позвонить по телефону техподдержки, указанному на коробке.
Первое, что вы слышите, это механический голос автоответчика. Он предлагает девять популярных решений различных проблем, ни одно из которых не имеет отношения к вашему делу. Через некоторое время робот подключает вас к живому оператору.
Увы, ничего конкретного оператор подсказать тоже не может. Он продолжает цитировать длинные выдержки из руководства, отказываясь слушать ваши комментарии. Услышав фразу «вы пробовали выключить и снова включить компьютер?» в 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. В этом случае, когда листовой компонент получает запрос, он может передать его по цепочке всех родительских компонентов до корня дерева объектов.
Обработчики в цепочке ответственности могут быть реализованы как команды. В этом случае вы можете выполнять множество различных операций над одним и тем же объектом контекста, представленным запросом.
Однако есть и другой подход, когда сам запрос представляет собой Команда объект. В этом случае вы можете выполнять одну и ту же операцию в ряде различных контекстов, связанных в цепочку.