Стратегия (англ. Strategy) — поведенческий шаблон проектирования, предназначенный для определения семейства алгоритмов, инкапсуляции каждого из них и обеспечения их взаимозаменяемости. Это позволяет выбирать алгоритм путём определения соответствующего класса. Шаблон Strategy позволяет менять выбранный алгоритм независимо от объектов-клиентов, которые его используют.
Стратегия | |
---|---|
Strategy | |
Тип | поведенческий |
Назначение | позволяет использовать различные бизнес-правила или алгоритмы в зависимости от контекста. |
Применяется в случаях | когда в одном и том же месте в зависимости от текущего состояния системы (или её окружения) должны использоваться различные алгоритмы |
Плюсы |
|
Минусы | создание дополнительных классов |
Родственные шаблоны | Мост, Шаблонный метод, Адаптер |
Описан в Design Patterns | Да |
Основные характеристики
правитьЗадача
правитьПо типу клиента (или по типу обрабатываемых данных) выбрать подходящий алгоритм, который следует применить. Если используется правило, которое не подвержено изменениям, нет необходимости обращаться к шаблону «стратегия».
Мотивы
править- Программа должна обеспечивать различные варианты алгоритма или поведения
- Нужно изменять поведение каждого экземпляра класса
- Необходимо изменять поведение объектов на стадии выполнения
- Введение интерфейса позволяет классам-клиентам ничего не знать о классах, реализующих этот интерфейс и инкапсулирующих в себе конкретные алгоритмы
Способ решения
правитьОтделение процедуры выбора алгоритма от его реализации. Это позволяет сделать выбор на основании контекста.
Участники
править- Класс
Strategy
определяет, как будут использоваться различные алгоритмы. - Конкретные классы
ConcreteStrategy
реализуют эти различные алгоритмы. - Класс
Context
использует конкретные классыConcreteStrategy
посредством ссылки на конкретный тип абстрактного классаStrategy
. КлассыStrategy
иContext
взаимодействуют с целью реализации выбранного алгоритма (в некоторых случаях классуStrategy
требуется посылать запросы классуContext
). КлассContext
пересылает классуStrategy
запрос, поступивший от его класса-клиента.
Следствия
править- Шаблон Strategy определяет семейство алгоритмов.
- Это позволяет отказаться от использования переключателей и/или условных операторов.
- Вызов всех алгоритмов должен осуществляться стандартным образом (все они должны иметь одинаковый интерфейс).
Реализация
правитьКласс, который использует алгоритм (Context
), включает абстрактный класс (Strategy
), обладающий абстрактным методом, определяющим способ вызова алгоритма. Каждый производный класс реализует один требуемый вариант алгоритма.
Замечание: метод вызова алгоритма не должен быть абстрактным, если требуется реализовать некоторое поведение, принимаемое по умолчанию.
Полезные сведения
править- и стратегия, и декоратор могут применяться для изменения поведения конкретных классов. Достоинство стратегии в том, что интерфейс кастомизации не совпадает с публичным интерфейсом и может быть куда более удобным, а недостаток в том, что для использования стратегии необходимо изначально проектировать класс с возможностью регистрации стратегий.
Использование
правитьАрхитектура Microsoft WDF основана на этом паттерне. У каждого объекта «драйвер» и «устройство» есть неизменяемая часть, вшитая в систему, в которой регистрируется изменяемая часть (стратегия), написанная в конкретной реализации. Изменяемая часть может быть и вовсе пустой, что даст ничего не делающий драйвер, но при этом способный участвовать в PnP и управлении питанием.
Библиотека ATL содержит в себе набор классов threading model, которые являются стратегиями (различными реализациями Lock/Unlock, которые потом используются основными классами системы). При этом в этих стратегиях используется статический полиморфизм через параметр шаблона, а не динамический полиморфизм через виртуальные методы.
Примеры
правитьПример на Java
// Класс реализующий конкретную стратегию, должен реализовывать этот интерфейс
// Класс контекста использует этот интерфейс для вызова конкретной стратегии
interface Strategy {
int execute(int a, int b);
}
// Реализуем алгоритм с использованием интерфейса стратегии
class ConcreteStrategyAdd implements Strategy {
public int execute(int a, int b) {
System.out.println("Called ConcreteStrategyAdd's execute()");
return a + b; // Do an addition with a and b
}
}
class ConcreteStrategySubtract implements Strategy {
public int execute(int a, int b) {
System.out.println("Called ConcreteStrategySubtract's execute()");
return a - b; // Do a subtraction with a and b
}
}
class ConcreteStrategyMultiply implements Strategy {
public int execute(int a, int b) {
System.out.println("Called ConcreteStrategyMultiply's execute()");
return a * b; // Do a multiplication with a and b
}
}
// Класс контекста использующий интерфейс стратегии
class Context {
private Strategy strategy;
// Constructor
public Context() {
}
// Set new strategy
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int a, int b) {
return strategy.execute(a, b);
}
}
// Тестовое приложение
class StrategyExample {
public static void main(String[] args) {
Context context = new Context();
context.setStrategy(new ConcreteStrategyAdd());
int resultA = context.executeStrategy(3,4);
context.setStrategy(new ConcreteStrategySubtract());
int resultB = context.executeStrategy(3,4);
context.setStrategy(new ConcreteStrategyMultiply());
int resultC = context.executeStrategy(3,4);
System.out.println("Result A : " + resultA );
System.out.println("Result B : " + resultB );
System.out.println("Result C : " + resultC );
}
}
Пример на C++
#include <iostream>
class Strategy
{
public:
virtual ~Strategy() {}
virtual void use() = 0;
};
class Strategy_1: public Strategy
{
public:
void use(){
std::cout << "Strategy_1" << std::endl;
}
};
class Strategy_2: public Strategy
{
public:
void use(){
std::cout << "Strategy_2" << std::endl;
}
};
class Strategy_3: public Strategy
{
public:
void use(){
std::cout << "Strategy_3" << std::endl;
}
};
class Context
{
protected:
Strategy* operation;
public:
virtual ~Context() {}
virtual void useStrategy() = 0;
virtual void setStrategy(Strategy* v) = 0;
};
class Client: public Context
{
public:
void useStrategy()
{
operation->use();
}
void setStrategy(Strategy* o)
{
operation = o;
}
};
int main(int /*argc*/, char* /*argv*/[])
{
Client customClient;
Strategy_1 str1;
Strategy_2 str2;
Strategy_3 str3;
customClient.setStrategy(&str1);
customClient.useStrategy();
customClient.setStrategy(&str2);
customClient.useStrategy();
customClient.setStrategy(&str3);
customClient.useStrategy();
return 0;
}
#include <iostream>
struct Strategy_1
{
void use(){ std::cout << "Strategy_1" << std::endl; };
};
struct Strategy_2
{
void use(){ std::cout << "Strategy_2" << std::endl; };
};
struct Strategy_3
{
void use(){ std::cout << "Strategy_3" << std::endl; };
};
template <class Operation>
struct Client: public Operation
{
void useStrategy()
{
this->use();
}
};
int main (int /*argc*/, char* /*argv*/[])
{
Client<Strategy_1> customClient1;
customClient1.useStrategy();
Client<Strategy_2> customClient2;
customClient2.useStrategy();
Client<Strategy_3> customClient3;
customClient3.useStrategy();
return 0;
}
Пример на C#
using System;
namespace DesignPatterns.Behavioral.Strategy
{
// Класс реализующий конкретную стратегию, должен наследовать этот интерфейс
// Класс контекста использует этот интерфейс для вызова конкретной стратегии
public interface IStrategy
{
void Algorithm();
}
// Первая конкретная реализация-стратегия.
public class ConcreteStrategy1 : IStrategy
{
public void Algorithm()
{
Console.WriteLine("Выполняется алгоритм стратегии 1.");
}
}
// Вторая конкретная реализация-стратегия.
// Реализаций может быть сколько угодно много.
public class ConcreteStrategy2 : IStrategy
{
public void Algorithm()
{
Console.WriteLine("Выполняется алгоритм стратегии 2.");
}
}
// Контекст, использующий стратегию для решения своей задачи.
public class Context
{
// Ссылка на интерфейс IStrategy
// позволяет автоматически переключаться между конкретными реализациями
// (другими словами, это выбор конкретной стратегии).
private IStrategy _strategy;
// Конструктор контекста.
// Инициализирует объект стратегией.
public Context(IStrategy strategy)
{
_strategy = strategy;
}
// Метод для установки стратегии.
// Служит для смены стратегии во время выполнения.
// В C# может быть реализован также как свойство записи.
public void SetStrategy(IStrategy strategy)
{
_strategy = strategy;
}
// Некоторая функциональность контекста, которая выбирает
//стратегию и использует её для решения своей задачи.
public void ExecuteOperation()
{
_strategy.Algorithm();
}
}
// Класс приложения.
// В данном примере выступает как клиент контекста.
public static class Program
{
// <summary>
// Точка входа в программу.
// </summary>
public static void Main()
{
// Создаём контекст и инициализируем его первой стратегией.
Context context = new Context(new ConcreteStrategy1());
// Выполняем операцию контекста, которая использует первую стратегию.
context.ExecuteOperation();
// Заменяем в контексте первую стратегию второй.
context.SetStrategy(new ConcreteStrategy2());
// Выполняем операцию контекста, которая теперь использует вторую стратегию.
context.ExecuteOperation();
}
}
}
Примеры на D
import std.stdio;
interface IStrategy
{
int Action(int a, int b);
}
class TAddition: IStrategy
{
public int Action(int a, int b)
{
return a+b;
}
}
class TSubtraction: IStrategy
{
public int Action(int a, int b)
{
return a-b;
}
}
class TContexet
{
private:
int a, b;
IStrategy strategy;
public:
void SetAB(int a, int b)
{
TContexet.a = a;
TContexet.b = b;
};
void SetStrategy(IStrategy strategy)
{
TContexet.strategy = strategy;
}
int Action()
{
return strategy.Action(a, b);
}
}
void main()
{
TContexet context = new TContexet;
context.SetAB(10, 5);
context.SetStrategy(new TAddition);
writeln(context.Action()); // 15
context.SetStrategy(new TSubtraction);
writeln(context.Action()); // 5
}
Пример на Delphi
program Strategy_pattern;
{$APPTYPE CONSOLE}
type
IStrategy = interface
['{6105F24C-E5B2-47E5-BE03-835A894DEB42}']
procedure Algorithm;
end;
TConcreteStrategy1 = class(TInterfacedObject, IStrategy)
public
procedure Algorithm;
end;
procedure TConcreteStrategy1.Algorithm;
begin
Writeln('TConcreteStrategy1.Algorithm');
end;
type
TConcreteStrategy2 = class(TInterfacedObject, IStrategy)
public
procedure Algorithm;
end;
procedure TConcreteStrategy2.Algorithm;
begin
Writeln('TConcreteStrategy2.Algorithm');
end;
type
TContext = class
private
FStrategy: IStrategy;
public
procedure ContextMethod;
property Strategy: IStrategy read FStrategy write FStrategy;
end;
procedure TContext.ContextMethod;
begin
FStrategy.Algorithm;
end;
var
Context: TContext;
begin
Context := TContext.Create;
try
Context.Strategy := TConcreteStrategy1.Create;
Context.ContextMethod;
Context.Strategy := TConcreteStrategy2.Create;
Context.ContextMethod;
finally
Context.Free;
end;
end.
Примеры на Javascript
// "интерфейс" Strategy
class Strategy {
exec() {}
}
// реализации Strategy
// показ сообщения в статусной строке браузера
// (поддерживается не всеми браузерами)
class StrategyWindowStatus extends Strategy {
constructor() {
super();
}
exec(message) {
window.status = message;
}
}
// показ сообщения с помощью попапа
// (может быть заблокировано браузером)
class StrategyNewWindow extends Strategy {
constructor() {
super();
}
exec(message) {
const win = window.open("", "_blank");
win.document.write("<html>"+ message +"</html>");
}
}
// показ сообщения с помощью модального окна
class StrategyAlert extends Strategy {
constructor() {
super();
}
exec(message) {
alert(message);
}
}
// Context
class Context {
constructor(strategy) {
this.strategy = undefined;
}
exec(message) {
this.strategy.exec(message);
}
}
// Использование
var showInWindowStatus = new Context( new StrategyWindowStatus() );
var showInNewWindow = new Context( new StrategyNewWindow() );
var showInAlert = new Context( new StrategyAlert() );
showInWindowStatus.exec("сообщение");
showInNewWindow.exec("сообщение");
showInAlert.exec("сообщение");
Примеры на PHP
<?php
interface NamingStrategy
{
function createName($filename);
}
class ZipFileNamingStrategy implements NamingStrategy
{
function createName($filename)
{
return "http://downloads.foo.bar/{$filename}.zip";
}
}
class TarGzFileNamingStrategy implements NamingStrategy
{
function createName($filename)
{
return "http://downloads.foo.bar/{$filename}.tar.gz";
}
}
class Context
{
private $namingStrategy;
function __construct(NamingStrategy $strategy)
{
$this->namingStrategy = $strategy;
}
function execute()
{
$url[] = $this->namingStrategy->createName("Calc101");
$url[] = $this->namingStrategy->createName("Stat2000");
return $url;
}
}
if (strstr($_SERVER["HTTP_USER_AGENT"], "Win"))
$context = new Context(new ZipFileNamingStrategy());
else
$context = new Context(new TarGzFileNamingStrategy());
$context->execute();
?>
Пример на Python 2.7
class People(object):
tool = None
def __init__(self, name):
self.name = name
def setTool(self, tool):
self.tool = tool
def write(self, text):
self.tool.write(self.name, text)
class ToolBase:
"""
Семейство алгоритмов `Инструмент написания`
"""
def write(self, name, text):
raise NotImplementedError()
class PenTool(ToolBase):
"""Ручка"""
def write(self, name, text):
print u'%s (ручкой) %s' % (name, text)
class BrushTool(ToolBase):
"""Кисть"""
def write(self, name, text):
print u'%s (кистью) %s' % (name, text)
class Student(People):
"""Студент"""
tool = PenTool()
class Painter(People):
"""Художник"""
tool = BrushTool()
maxim = Student(u'Максим')
maxim.write(u'Пишу лекцию о паттерне Стратегия')
# Максим (ручкой) Пишу лекцию о паттерне Стратегия
sasha = Painter(u'Саша')
sasha.write(u'Рисую иллюстрацию к паттерну Стратегия')
# Саша (кистью) Рисую иллюстрацию к паттерну Стратегия
# Саша решил стать студентом
sasha.setTool(PenTool())
sasha.write(u'Нет, уж лучше я напишу конспект')
# Саша (ручкой) Нет, уж лучше я напишу конспект
Пример на Ruby
require "interface"
Strategy = interface {
required_methods :use
}
class StrategyOne
def use
puts "Strategy one"
end
implements Strategy
end
class StrategyTwo
def use
puts "Strategy two"
end
implements Strategy
end
class StrategyThree
def use
puts "Strategy three"
end
implements Strategy
end
class Context
attr_accessor :strategy
def initialize strategy
@strategy = strategy
end
def useStrategy
strategy.use
end
end
context = Context.new StrategyOne.new
context.useStrategy
context.strategy = StrategyTwo.new
context.useStrategy
context.strategy = StrategyThree.new
context.useStrategy
Источники информации
править- Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес. Приемы объектно-ориентированного проектирования. Паттерны проектирования = Design Patterns: Elements of Reusable Object-Oriented Software. — СПб.: «Питер», 2007. — С. 366. — ISBN 978-5-469-01136-1. (также ISBN 5-272-00355-1)
- Шаллоуей, Алан, Тротт, Джейм, Р. Шаблоны проектирования. Новый подход к объектно-ориентированному анализу и проектированию: Пер. с англ. —М.: Издательский дом «Вильямс», 2002. —288 с. ISBN 5-8459-0301-7
- Grand, M. Шаблоны проектирования в Java: Пер. с англ.. — М.: Новое знание, 2004. — С. 559. — ISBN 5-94735-047-5.