Flyweight en Go

Flyweight es un patrón de diseño estructural que permite a los programas soportar grandes cantidades de objetos manteniendo un bajo uso de memoria.

El patrón lo logra compartiendo partes del estado del objeto entre varios objetos. En otras palabras, el Flyweight ahorra memoria RAM guardando en caché la misma información utilizada por distintos objetos.

Aprende más sobre el patrón Flyweight

Ejemplo conceptual

En un juego de contraataque, el terrorista y el contraterrorista tienen distintos tipos de vestimenta. Por simplificar, asumamos que terrorista y contraterrorista tienen un tipo de vestimenta cada uno. El objeto vestimenta está integrado en el objeto jugador, como se ve a continuación.

A continuación se encuentra la estructura de un jugador. Podemos ver que el objeto vestimenta está integrado en la estructura del jugador:

type player struct {
    dress      dress
    playerType string // Puede ser T o CT
    lat        int
    long       int
}

Digamos que hay 5 terroristas y 5 contraterroristas, de modo que hay un total de 10 jugadores. Hay dos opciones en lo que respecta a la vestimenta.

Cada uno de los 10 objetos jugador crea un objeto vestimenta diferente y lo integra. Se creará un total de 10 objetos de vestimenta.
Creamos dos objetos de vestimenta:
- Objeto único de vestimenta de terrorista: Lo compartirán 5 terroristas.
- Objeto único de vestimenta de contraterrorista: Lo compartirán 5 contraterroristas.

Como puedes ver en la solución 1, se crea un total de 10 objetos de vestimenta, mientras que en la solución 2 solo se crean 2 objetos de vestimenta. La segunda solución es la que empleamos en el patrón de diseño Flyweight. Los dos objetos de vestimenta que creamos se denominan objetos flyweight.

El patrón Flyweight extrae las partes comunes y crea objetos flyweight. Estos objetos flyweight (vestimenta) pueden ser compartidos por muchos objetos (jugador). Esto reduce drásticamente el número de objetos de vestimenta y lo bueno es que, aunque crees más jugadores, será suficiente con dos objetos de vestimenta.

En el patrón Flyweight almacenamos los objetos flyweight en el campo mapa. Cuando se crean los otros objetos que comparten los objetos flyweight, los objetos flyweight se extraen del mapa.

Veamos qué partes de este sistema serán estados intrínsecos y extrínsecos:

Estado intrínseco: Vestimenta en el estado intrínseco, ya que puede ser compartido por varios objetos de terrorista y contraterrorista.
Estado extrínseco: La ubicación y el arma del jugador son un estado extrínseco, ya que son diferentes para cada objeto.

dressFactory.go: Fábrica flyweight

package main

import "fmt"

const (
	//TerroristDressType terrorist dress type
	TerroristDressType = "tDress"
	//CounterTerrroristDressType terrorist dress type
	CounterTerrroristDressType = "ctDress"
)

var (
	dressFactorySingleInstance = &DressFactory{
		dressMap: make(map[string]Dress),
	}
)

type DressFactory struct {
	dressMap map[string]Dress
}

func (d *DressFactory) getDressByType(dressType string) (Dress, error) {
	if d.dressMap[dressType] != nil {
		return d.dressMap[dressType], nil
	}

	if dressType == TerroristDressType {
		d.dressMap[dressType] = newTerroristDress()
		return d.dressMap[dressType], nil
	}
	if dressType == CounterTerrroristDressType {
		d.dressMap[dressType] = newCounterTerroristDress()
		return d.dressMap[dressType], nil
	}

	return nil, fmt.Errorf("Wrong dress type passed")
}

func getDressFactorySingleInstance() *DressFactory {
	return dressFactorySingleInstance
}

dress.go: Interfaz flyweight

package main

type Dress interface {
	getColor() string
}

terroristDress.go: Objeto concreto flyweight

package main

type TerroristDress struct {
	color string
}

func (t *TerroristDress) getColor() string {
	return t.color
}

func newTerroristDress() *TerroristDress {
	return &TerroristDress{color: "red"}
}

counterTerroristDress.go: Objeto concreto flyweight

package main

type CounterTerroristDress struct {
	color string
}

func (c *CounterTerroristDress) getColor() string {
	return c.color
}

func newCounterTerroristDress() *CounterTerroristDress {
	return &CounterTerroristDress{color: "green"}
}

player.go: Contexto

package main

type Player struct {
	dress      Dress
	playerType string
	lat        int
	long       int
}

func newPlayer(playerType, dressType string) *Player {
	dress, _ := getDressFactorySingleInstance().getDressByType(dressType)
	return &Player{
		playerType: playerType,
		dress:      dress,
	}
}

func (p *Player) newLocation(lat, long int) {
	p.lat = lat
	p.long = long
}

game.go

package main

type game struct {
	terrorists        []*Player
	counterTerrorists []*Player
}

func newGame() *game {
	return &game{
		terrorists:        make([]*Player, 1),
		counterTerrorists: make([]*Player, 1),
	}
}

func (c *game) addTerrorist(dressType string) {
	player := newPlayer("T", dressType)
	c.terrorists = append(c.terrorists, player)
	return
}

func (c *game) addCounterTerrorist(dressType string) {
	player := newPlayer("CT", dressType)
	c.counterTerrorists = append(c.counterTerrorists, player)
	return
}

main.go: Código cliente

package main

import "fmt"

func main() {
	game := newGame()

	//Add Terrorist
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)

	//Add CounterTerrorist
	game.addCounterTerrorist(CounterTerrroristDressType)
	game.addCounterTerrorist(CounterTerrroristDressType)
	game.addCounterTerrorist(CounterTerrroristDressType)

	dressFactoryInstance := getDressFactorySingleInstance()

	for dressType, dress := range dressFactoryInstance.dressMap {
		fmt.Printf("DressColorType: %s\nDressColor: %s\n", dressType, dress.getColor())
	}
}

output.txt: Resultado de la ejecución

DressColorType: ctDress
DressColor: green
DressColorType: tDress
DressColor: red

Basado en: Golang By Example