CodeLAB
на главную карта сайта обратная связь

Популярные задачи:

#Древовидные структуры. (55249 hits)
#Вставка новой записи в таблицу БД. (34739 hits)
#Пирамидальная сортировка. (195191 hits)
#Рисование окружности (по Брезенхэму). (31706 hits)
#Сортировка Шелла, оптимальный выбор приращений. (189310 hits)
#Часики на js. (88721 hits)
#Вычисление эксцесса и коэффициентов асимметрии заданной выборки. (43830 hits)
#Сортировка Шелла, обший принцип. (141260 hits)
#Преобразование целых чисел в битовый массив. (35334 hits)
#Относительный путь к файлу. (37725 hits)
#Случайный выбор элемента при неизвестном их количестве. (34567 hits)
#Хранение иерархических деревьев. (51544 hits)
#Программное создание ссылок. (97815 hits)
#Динамическое изменение цвета полоски прокрутки в IE5.5 и выше. (29230 hits)
#Заливка замкнутой области. (60278 hits)
#Арктангенс. (43648 hits)
#Динамическая очистка выпадающего списка (select) на javascript. (87173 hits)
#Сравнение алгоритмов сортировки массива. (174645 hits)
#Вращение 3D объекта. (33976 hits)
#Синус. (58277 hits)


Главная >> Каталог задач >> Паттерны >> Поведения >> Стратегия (Strategy)

Стратегия (Strategy)

Aвтор:
Дата:
Просмотров: 193284
реализации(java: 5шт...) +добавить

Имя

«Паттерн
Strategy»
Стратегия - паттерн поведения объектов, инкапсулирующий отдельные алгоритмы.

Также известен под именем Policy.

Условия, Задача, Назначение

Если в системе фигурируют различные алгоритмы, которые часто могут использоваться повторно в других частях, слоях приложения, было бы удобно инкапсулировать каждый из них в отдельную сущность, параметризовать и запускать их там, где понадобится, не дублируя, таким образом, код.

Паттерн стратегия это осуществляет. По-сути, он:

определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. И далее – позволяет изменять алгоритмы независимо от клиентов, которые ими пользуются.

Мотивация

Рассмотрим такую задачу, как разбиение текста на строки. Существует много алгоритмов для этого. Жестко «зашивать» все подобные алгоритмы в классы, которые в них нуждаются, нежелательно по нескольким причинам:
  • Клиент, которому требуется алгоритм разбиения на строки, усложняется при включении в него соответствующего кода. Таким образом, клиенты становятся более громоздкими, а сопровождать их труднее, особенно если нужно поддержать сразу несколько алгоритмов.
  • В зависимости от обстоятельств стоит применять тот или иной алгоритм.
    Не хотелось бы поддерживать несколько алгоритмов разбиения на строки сразу во всех классах, которые это разбиение используют. Особенно, если мы не уверены, будет ли оно использоваться во всех этих классах.
  • Если разбиение на строки - неотъемлемая часть клиента, то задача добавления новых и модификации существующих алгоритмов усложняется.
Всех этих проблем можно избежать, если определить классы, инкапсулирующие различные алгоритмы разбиения на строки. Инкапсулированный таким образом алгоритм называется стратегией.

Предположим, что класс Composition отвечает за разбиение на строки текста, отображаемого в окне программы просмотра, и его своевременное обновление. Стратегии разбиения на строки определяются не в классе Composition, а в подклассах абстрактного класса Compositor. Это могут быть, например, такие стратегии:
  • SimpleCompositor реализует простую стратегию, выделяющую по одной строке за раз.
  • TeXCompositor реализует алгоритм поиска точек разбиения на строки. Эта стратегия пытается выполнить глобальную оптимизацию разбиения на строки, рассматривая сразу целый параграф.
  • ArrayCompositor реализует стратегию расстановки переходов на новую строку таким образом, что в каждой строке оказывается одно и то же число элементов.
    Это полезно, например, при построчном отображении набора пиктограмм.

Объект Composition хранит ссылку на объект Compositor. Всякий раз, когда объекту Composition требуется переформатировать текст, он делегирует данную обязанность своему объекту Compositor. Клиент задает, какой объект Compositor следует использовать, параметризуя им объект Composition.

Признаки применения, использования паттерна Стратегия (Strategy)

Используйте паттерн стратегия, когда:
  1. Имеется много родственных классов, отличающихся только поведением.
    Т.е. имеющих похожие интерфейсы, но реализующих свою логику по разному.
    Стратегия позволяет сконфигурировать класс, задав одно из возможных поведений.
  2. Вам нужно иметь несколько разных вариантов алгоритма.
    Например, можно определить два варианта алгоритма, один из которых требует больше времени, а другой - больше памяти.
  3. В алгоритме содержатся данные, о которых клиент не должен «знать».
    Используйте паттерн стратегия, чтобы не раскрывать сложные, специфичные для алгоритма структуры данных (подход «черного ящика»).
  4. В классе определено много поведений.
    И все это добро представлено разветвленными условными операторами. В этом случае проще перенести код из ветвей в отдельные классы стратегий.

Решение

Участники паттерна Стратегия (Strategy)

  1. Strategy (Compositor) – стратегия.
    Объявляет общий для всех поддерживаемых алгоритмов (стратегий) интерфейс. Класс Context пользуется этим интерфейсом для вызова конкретного алгоритма, определенного в классе ConcreteStrategy.
  2. ConcreteStrategy (SimpleCompositor, TeXCompositor, ArrayCompositor) - конкретная стратегия.
    Реализует алгоритм, использующий интерфейс, объявленный в классе Strategy.
  3. Context (Composition) – контекст.
    Конфигурируется объектом класса ConcreteStrategy.
    Хранит ссылку на объект класса Strategy.
    Может определять интерфейс, который позволяет объекту Strategy получить доступ к данным контекста.

Схема использования паттерна Стратегия (Strategy)

Классы Strategy и Context взаимодействуют для реализации выбранного алгоритма. Контекст может передать стратегии все необходимые алгоритму данные в момент его вызова. Вместо этого контекст может позволить обращаться к своим операциям в нужные моменты, передав ссылку на самого себя операциям класса Strategy.
Контекст переадресует запросы своих клиентов объекту-стратегии. Обычно

клиент создает объект ConcreteStrategy и передает его контексту, после чего клиент «общается» исключительно с контекстом. Часто в распоряжении клиента находится несколько классов ConcreteStrategy, которые он может выбирать.

Вопросы, касающиеся реализации паттерна Стратегия (Strategy)

Рассмотрим следующие вопросы реализации:
  1. Определение интерфейсов классов Strategy и Context.
    Интерфейсы классов Strategy и Context могут обеспечить объекту класса ConcreteStrategy эффективный доступ к любым данным контекста, и наоборот.
    Например, Context передает данные в виде параметров операциям класса Strategy. Это разрывает тесную связь между контекстом и стратегией. При этом не исключено, что иногда контекст будет передавать данные, которые стратегии не нужны.
    Другой метод - передать контекст в качестве аргумента, в таком случае стратегия сама будет запрашивать у него данные, или, например, сохранить ссылку на свой контекст, так что передавать вообще ничего не придется.
    И в том, и в другом случаях стратегия может запрашивать только ту информацию, которая реально необходима. Но тогда в контексте должен быть определен более развитый интерфейс доступа к своим данным, что несколько усиливает связанность классов Strategy и Context.
    Какой подход лучше, зависит от конкретного алгоритма и требований, которые он предъявляет к данным.
  2. Стратегии как параметры класса.
    В C++ для конфигурирования класса стратегией можно использовать шаблоны. Этот способ хорош, только если стратегия определяется на этапе компиляции и ее не нужно менять во время выполнения. Тогда конфигурируемый класс (например, Context) определяется в виде шаблона, для которого класс Strategy является параметром:
     паметризация шаблона стратегией [C++]  ссылка
    1. template <class AStrategy>
    2. class Context {
    3. void Operation)) { theStrategy .DoAlgorithm( ) ; }
    4. // ...
    5. private :
    6. AStrategy theStrategy;
    7. };
    8.  
    9. //...
    10. //Затем этот класс конфигурируется классом Strategy в момент инстанцирования:
    11. class MyStrategy {
    12. public:
    13. void DoAlgorithm( ) ;
    14. };
    15.  
    16. Context<MyStrategy> aContext;


    При использовании шаблонов отпадает необходимость в абстрактном классе для определения интерфейса Strategy. Кроме того, передача стратегии в виде параметра шаблона позволяет статически связать стратегию с контекстом, вследствие чего повышается эффективность программы.

    В языке Java имеется похожий механизм Generics. Вот как бы это все выглядело там:
     контект, параметризированный стратегией с помощью java Generics [java]  ссылка
    1. package strategy;
    2.  
    3. public class Context<T extends Strategy> {
    4. private T strategy;
    5.  
    6. public void Operation() {
    7. strategy.DoAlgorithm();
    8. }
    9. }
     использование параметризованного контекста [java]  ссылка
    1. package strategy;
    2.  
    3. public class Client2 {
    4. public static void main(String[] args) {
    5. /**
    6. * Новая стратегия в виде локального
    7. * внутреннего класса
    8. */
    9. class MyStrategy extends Strategy {
    10.  
    11. public void DoAlgorithm() {
    12. /* Переопределение стандартного поведения
    13. */
    14. }
    15. }
    16.  
    17. /* Теперь - используем */
    18. Context<MyStrategy> aContext;
    19.  
    20. /* дальнейшая логика
    21. * ...
    22. */
    23. }
    24. }

  3. Стратегия по-умалчанию.
    Класс Context разрешается упростить, если для него отсутствие какой бы то ни было стратегии является нормой. Прежде чем обращаться к объекту Strategy, объект Context проверяет наличие стратегии. Если да, то работа продолжается как обычно, в противном случае контекст реализует некое поведение по умолчанию. Достоинство такого подхода в том, что клиентам вообще не нужно иметь дело со стратегиями, если их устраивает поведение по умолчанию.

Результаты

У паттерна стратегия есть следующие достоинства и недостатки:
  1. Семейства родственных алгоритмов.
    Иерархия классов Strategy определяет семейство алгоритмов или поведений, которые можно повторно использовать в разных контекстах и приложениях. А наследование позволяет вычленить общую для всех алгоритмов функциональность.
  2. Альтернатива порождению подклассов.
    Наследование поддерживает многообразие алгоритмов или поведений. Можно напрямую породить от Context подклассы с различными поведениями. Но при этом поведение жестко «зашивается» в класс Context. Вот почему реализации алгоритма и контекста смешиваются, что затрудняет понимание, сопровождение и расширение контекста. Кроме того, заменить алгоритм динамически уже не удастся. В результате вы получите множество родственных классов, отличающихся только алгоритмом или поведением. Инкапсуляции алгоритма в отдельный класс Strategy позволяют изменять его независимо от контекста.
  3. Избавление от серии условных операторов.
    Благодаря паттерну стратегия удается отказаться от условных операторов при выборе нужного поведения. Когда различные поведения помещаются в один класс, трудно выбрать нужное без применения условных операторов. Инкапсуляция же каждого поведения в отдельный класс Strategy решает эту проблему.
    Так, без использования стратегий код для разбиения текста на строки мог бы выглядеть следующим образом:
     разбиение текста на строки, типовое решение [java]  ссылка
    1. package strategy;
    2.  
    3. public class Composition {
    4.  
    5. public void Repair() {
    6. switch (_breakingStrategy) {
    7. case SIMPLE_STRATEGY:
    8. ComposeWithSimpleCompositor () ;
    9. break;
    10. case TEX_STRATEGY:
    11. ComposeWithTeXCompositor() ;
    12. break;
    13. // ...
    14. }
    15. /* если необходимо, объединить результаты с имеющейся
    16. * композицией
    17. */
    18. }
    19.  
    20. }
    21.  

    Паттерн же стратегия позволяет обойтись без оператора переключения за счет делегирования задачи разбиения на строки объекту Strategy:
     разбиение текста на строки, реализация стратегией [java]  ссылка
    1. package strategy;
    2.  
    3. public class Composition {
    4. //...
    5.  
    6. public void Repair() {
    7. _compositor->Compose();
    8. }
    9. }

    Вообще, если код содержит много условных операторов, то часто это уже признак того, что нужно применить паттерн стратегия.
  4. Выбор реализации.
    Стратегии могут предлагать различные реализации одного и того же поведения. Клиент вправе выбирать подходящую стратегию в зависимости от своих требований к быстродействию и памяти.
  5. Клиенты должны «знатъ» о различных стратегиях.
    Потенциальный недостаток этого паттерна в том, что для выбора подходящей стратегии клиент должен понимать, чем отличаются разные стратегии. Поэтому наверняка придется раскрыть клиенту некоторые особенности реализации. Отсюда следует, что паттерн стратегия стоит применять лишь тогда, когда различия в поведении имеют значение для клиента.
  6. Обмен информацией между стратегией и контекстом.
    Интерфейс класса Strategy разделяется всеми подклассами ConcreteStrategy — неважно, сложна или тривиальна их реализация. Поэтому вполне вероятно, что некоторые стратегии не будут пользоваться всей передаваемой им информацией, особенно простые. Это означает, что в отдельных случаях контекст создаст и проинициализирует параметры, которые никому не нужны. Если возникнет проблема, то между классами Strategy и Context придется установить более тесную связь.
  7. Увеличение числа объектов.
    Применение стратегий увеличивает число объектов в приложении. Иногда эти издержки можно сократить, если реализовать стратегии в виде объектов без состояния, которые могут разделяться несколькими контекстами. Остаточное состояние хранится в самом контексте и передается при каждом обращении к объекту-стратегии. Разделяемые стратегии не должны сохранять состояние между вызовами. В описании паттерна приспособленец этот подход обсуждается более подробно.

Пример

В системе имеется список ее пользователей и в зависимости от ситуации он должен быть отсортирован по разным параметрам, как-то: ФИО пользователя, или дата его регистрации и т.д.

Класс пользователей выглядит так: User.

Подумаем, каким способом лучше представить список из этих объектов, который решал бы поставленные задачи.
Можно использовать стандартный список и в зависимости от ситуации каждый раз добавлять туда пользователей в нужной последовательности, соответсвующей требуемой сортировке. Не решается задача сортировки – ее придется решать отдельно.
Другой способ – заложить алгоритмы сортировки в сам объект список, при его создании указывать тип сортировки, а при добавлении – располагать елементы в нужной последовательности. Плохо по тем же причинам, указанным в «мотивации».
 
Данная ситуация – идеальный случай применения паттерна стратегия.
Список пользователей выступает в роли контекста (Context). Отдельные алгоритмы сортировки инкапсулируются в отдельные классы (стратегии) и при создании списка пользователей – передаются ему.
При этом в Java для этого уже все предусмотрено: имеется специальный интерфейс Comparator, объекты которого передаются в специальный тип коллекции (TreeSet). И далее эта коллекция сама сортирует все свои элементы в соответствии с указанным объектом Comparator-а.
Поэтому стратегии сортировки, Comparator-ы в нашем случае будут: SortByIDStrategy, SortByFioStrategy, SortByDateStrategy.
 
Контекст нам, как уже понятно, реализовывать не надо – в качестве реализации списка, сортирующего свои элементы, используется стандартный TreeSet, входящий в ядро языка.
Поэтому – определяем примерного клиента: Client
Во-первых, обратите внимание, как указывается конкретный способ сортировки: клиент передает в контекст (в TreeSet т.е.) нужный Comparator (ConcreteStrategy).
Во-вторых, - выбор списка вынесен в отдельный метод, специально, чтобы продемонстрировать, что клиент не должен знать о каких либо подробностях контекста – он просто работает в соответсвии с его интерфейсом (интерфейсом стандартного множества Set в данном случае), который единый вне зависимости от использующихся стратегий.

И, в-третьих, имена переменных пользователей – на русском языке, что, конечно, к делу не относится, а просто демонстрирует очередные широкие возможности языка. В данном случае фамилии великих русских писателей очень уместно написать на их родном языке!

 

Известные применения паттерна Стратегия (Strategy)

В языке Java и в его многочисленных библиотеках паттерн-стратегия применяется довольно часто. Прежде всего, это классы сортированных коллекций TreeMap и TreeSet. Оба они имеют вариант конструктора, имеющего один параметр типа Comparator. Это интерфейс, который содержит одну операцию compare() с 2-мя аргументами объектами, которые сравниваются. Таким образом, передаются объекты, реализующие по-разному эту стратегию сравнения объектов, и соответственно, создавая упорядоченную коллекцию с разными стратегиями сравнения – мы прозразно получаем разную сортировку в ней.
Далее включенная в ядро языка подсистема логирования java.util.logging, берущая корни из известного log4j. И там и там для экспорта сообщений изпользуются специальные классы (Handler-ы или Appender-ы), реализующие разные способы записи логов в разные подсистемы (в файл, в базу данных, отправлять на почту и т.д.), имеющий единый интерфейс для своего контекста (Logger-а). Т.е. стратегии. 
Библиотеки ЕТ++ и Interviews используют стратегии для инкапсуляции алгоритмов разбиения на строки - так, как мы только что видели.
В системе RTL для оптимизации кода компиляторов с помощью стратегий определяются различные схемы распределения регистров (RegisterAllocator) и политики управления потоком команд (RISCscheduler, CISCscheduler). Это позволяет гибко настраивать оптимизатор для разных целевых машинных архитектур.
Каркас ЕТ++ SwapsManager предназначен для построения программ, рассчитывающих цены для различных финансовых инструментов. Ключевыми абстракциями для него являются Instrument (инструмент) и YieldCurve (кривая дохода). Различные инструменты реализованы как подклассы класса Instrument.
YieldCurve рассчитывает коэффициенты дисконтирования, на основе которых вычисляется текущее значение будущего движения ликвидности. Оба класса делегируют часть своего поведения объектам-стратегиям класса Strategy. В каркасе присутствует семейство конкретных стратегий для генерирования движения ликвидности, оценки оборотов и вычисления коэффициентов дисконтирования.
Можно создавать новые механизмы расчетов, конфигурируя классы Instrument и YieldCurve другими объектами конкретных стратегий. Этот подход поддерживает как использование существующих реализаций стратегий в различных сочетаниях, так и определение новых.
 
В библиотеке компонентов Грейди Буча стратегии используются как аргументы шаблонов. В классах коллекций поддерживаются три разновидности стратегий распределения памяти: управляемая (распределение из пула), контролируемая (распределение и освобождение защищены замками) и неуправляемая (стандартное распределение памяти). Стратегия передается классу коллекции в виде аргумента шаблона в момент его инстанцирования.
RApp - это система для проектирования топологии интегральных схем. Задача RApp - проложить провода между различными подсистемами на схеме. Алгоритмы трассировки в RApp определены как подклассы абстрактного класса Router, который является стратегией.
В библиотеке ObjectWindows фирмы Borland стратегии используются в диалоговых окнах для проверки правильности введенных пользователем данных.
Например, можно контролировать, что число принадлежит заданному диапазону, а в данном поле должны быть только цифры. Не исключено, что при проверке корректности введенной строки потребуется поиск данных в справочной таблице.
Для инкапсуляции стратегий проверки в ObjectWindows используются объекты класса Validator — частный случай паттерна стратегия. Поля для ввода данных делегируют стратегию контроля необязательному объекту Validator. Клиент при необходимости присоединяет таких проверяющих к полю (пример необязательной стратегии). В момент закрытия диалогового окна поля «просят» своих контролеров проверить правильность данных. В библиотеке имеются классы контролеров для наиболее распространенных случаев, например RangeValidator для проверки принадлежности числа диапазону. Но клиент может легко определить и собственные стратегии проверки, порождая подклассы от класса Validator.

Родственные паттерны

Приспособленец: объекты-стратегии для большей экономии и оптимизации могут быть реализованы как приспособленцы.

Реализации:

java(5)   +добавить

1) User.java на java, code #522[автор:this]
2) SortByIDStrategy.java на java, code #523[автор:this]
3) SortByFioStrategy.java на java, code #524[автор:this]
4) SortByDateStrategy.java на java, code #525[автор:this]
5) Client.java на java, code #526[автор:this]