Стратегия (шаблон проектирования)

Материал из Википедии — свободной энциклопедии
Перейти к навигации Перейти к поиску
У этого термина существуют и другие значения, см. Стратегия (значения).
Стратегия
Strategy
Представление структуры шаблона Strategy
Представление структуры шаблона Strategy
Тип поведенческий
Назначение позволяет использовать различные бизнес-правила или алгоритмы в зависимости от контекста.
Применяется в случаях когда в одном и том же месте в зависимости от текущего состояния системы (или её окружения) должны использоваться различные алгоритмы
Плюсы
  • инкапсуляция реализации различных алгоритмов, система становится независимой от возможных изменений бизнес-правил;
  • вызов всех алгоритмов одним стандартным образом;
  • отказ от использования переключателей и/или условных операторов.
Минусы создание дополнительных классов
Родственные шаблоны Мост, Шаблонный метод, Адаптер
Описан в Design Patterns Да

Стратегия (англ. Strategy) — поведенческий шаблон проектирования, предназначенный для определения семейства алгоритмов, инкапсуляции каждого из них и обеспечения их взаимозаменяемости. Это позволяет выбирать алгоритм путём определения соответствующего класса. Шаблон Strategy позволяет менять выбранный алгоритм независимо от объектов-клиентов, которые его используют.

Основные характеристики[править | править код]

Задача[править | править код]

По типу клиента (или по типу обрабатываемых данных) выбрать подходящий алгоритм, который следует применить. Если используется правило, которое не подвержено изменениям, нет необходимости обращаться к шаблону «стратегия».

Мотивы[править | править код]

  • Программа должна обеспечивать различные варианты алгоритма или поведения
  • Нужно изменять поведение каждого экземпляра класса
  • Необходимо изменять поведение объектов на стадии выполнения
  • Введение интерфейса позволяет классам-клиентам ничего не знать о классах, реализующих этот интерфейс и инкапсулирующих в себе конкретные алгоритмы

Способ решения[править | править код]

Отделение процедуры выбора алгоритма от его реализации. Это позволяет сделать выбор на основании контекста.

Участники[править | править код]

  • Класс 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

	function Strategy() {
		this.exec = function() {};
	};


// реализации Strategy

	// показ сообщения в статусной строке браузера
	// (поддерживается не всеми браузерами)
	function StrategyWindowStatus() {
		this.exec = function(message) {
			window.status = message;
		};
	};
	StrategyWindowStatus.prototype = new Strategy();
	StrategyWindowStatus.prototype.constructor = StrategyWindowStatus;

	// показ сообщения с помощью попапа
	// (может быть заблокировано браузером)
	function StrategyNewWindow() {
		this.exec = function(message) {
			var win = window.open("", "_blank");
			win.document.write("<html>"+ message +"</html>");
		};
	};
	StrategyNewWindow.prototype = new Strategy();
	StrategyNewWindow.prototype.constructor = StrategyNewWindow;

	// показ сообщения с помощью модального окна
	function StrategyAlert() {
		this.exec = function(message) {
			alert(message);
		};
	};
	StrategyAlert.prototype = new Strategy();
	StrategyAlert.prototype.constructor = StrategyAlert;


// Context

	function Context(strategy) {
		this.exec = function(message) {
			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.


Источник — https://ru.wikipedia.org/w/index.php?title=Стратегия_(шаблон_проектирования)&oldid=114418332