Hura! Mamy wreszcie przyjemność udostępnić wam polską wersję! Zapraszamy do przesyłania wiadomości z waszymi uwagami i informacjami o zauważonych błędach.
Strategia

Strategia w języku Go

Strategia to behawioralny wzorzec projektowy zakładający przekształcenie zestawu zachowań w obiekty, które można stosować zamiennie w pierwotnym obiekcie.

Pierwotny obiekt, zwany kontekstem, przechowuje odniesienie do obiektu-strategii i deleguje mu działania związane z danym zachowaniem. Aby zmienić sposób, w jaki kontekst wykonuje swą pracę, należy zamienić bieżąco przypisany obiekt strategii na inny.

Przykład koncepcyjny

Przypuśćmy, że tworzymy schowek w obrębie pamięci. Skoro znajduje się w pamięci, to ma pewien ograniczony rozmiar. Gdy ilość danych w schowku wyczerpie dostępną pamięć, niektóre wpisy muszą zostać z niego usunięte aby zwolnić miejsce. Może się to odbywać według kilku algorytmów, z których najpopularniejsze to:

  • Najrzadziej ostatnio używane (LRU): usuwa wpis który był ostatnio najrzadziej potrzebny.
  • Pierwszy na wejściu, pierwszy na wyjściu (FIFO): usuwa najwcześniejszy wpis.
  • Najrzadziej używane (LFU): usuwa najrzadziej używany wpis.

Problemem jest teraz rozsprzęgnięcie naszej klasy pamięci podręcznej i powyższych algorytmów tak, aby można było wybrać odpowiedni w trakcie działania programu. Ponadto, klasa pamięci podręcznej nie powinna ulegać zmianom gdy dodawany jest nowy algorytm.

Tu właśnie z pomocą przychodzi nam wzorzec Strategia. Proponuje on utworzenie rodziny algorytmów z których każdy z nich będzie osobną klasą. Każda z tych klas będzie zgodna pod względem interfejsu, co pozwoli na wymianę jednego algorytmu na inny. Powiedzmy, że nazwą wspólnego interfejsu jest evictionAlgo.

Od tego momentu nasza główna klasa pamięci podręcznej będzie zawierała interfejs evictionAlgo. Zamiast implementować wszystkie algorytmy zwalniania przestrzeni w klasie, będzie ona delegować te zadania interfejsowi evictionAlgo. Skoro evictionAlgo jest interfejsem, możemy wybrać stosowany algorytm (LRU, FIFO, LFU) w trakcie działania programu bez konieczności zmiany w klasie pamięci podręcznej.

evictionAlgo.go: Interfejs strategii

package main

type evictionAlgo interface {
	evict(c *cache)
}

fifo.go: Konkretna strategia

package main

import "fmt"

type fifo struct {
}

func (l *fifo) evict(c *cache) {
	fmt.Println("Evicting by fifo strtegy")
}

lru.go: Konkretna strategia

package main

import "fmt"

type lru struct {
}

func (l *lru) evict(c *cache) {
	fmt.Println("Evicting by lru strtegy")
}

lfu.go: Konkretna strategia

package main

import "fmt"

type lfu struct {
}

func (l *lfu) evict(c *cache) {
	fmt.Println("Evicting by lfu strtegy")
}

cache.go: Kontekst

package main

type cache struct {
	storage      map[string]string
	evictionAlgo evictionAlgo
	capacity     int
	maxCapacity  int
}

func initCache(e evictionAlgo) *cache {
	storage := make(map[string]string)
	return &cache{
		storage:      storage,
		evictionAlgo: e,
		capacity:     0,
		maxCapacity:  2,
	}
}

func (c *cache) setEvictionAlgo(e evictionAlgo) {
	c.evictionAlgo = e
}

func (c *cache) add(key, value string) {
	if c.capacity == c.maxCapacity {
		c.evict()
	}
	c.capacity++
	c.storage[key] = value
}

func (c *cache) get(key string) {
	delete(c.storage, key)
}

func (c *cache) evict() {
	c.evictionAlgo.evict(c)
	c.capacity--
}

main.go: Kod klienta

package main

func main() {
	lfu := &lfu{}
	cache := initCache(lfu)

	cache.add("a", "1")
	cache.add("b", "2")

	cache.add("c", "3")

	lru := &lru{}
	cache.setEvictionAlgo(lru)

	cache.add("d", "4")

	fifo := &fifo{}
	cache.setEvictionAlgo(fifo)

	cache.add("e", "5")

}

output.txt: Wynik działania

Evicting by lfu strtegy
Evicting by lru strtegy
Evicting by fifo strtegy
Na podstawie: Golang By Example

Strategia w innych językach

Wzorce projektowe: Strategia w języku Java Wzorce projektowe: Strategia w języku C# Wzorce projektowe: Strategia w języku C++ Wzorce projektowe: Strategia w języku PHP Wzorce projektowe: Strategia w języku Python Wzorce projektowe: Strategia w języku Ruby Wzorce projektowe: Strategia w języku Swift Wzorce projektowe: Strategia w języku TypeScript