когда каждый байт на счету!
Перечень паттернов можно найти здесь.
Что такое паттерн проектирования Flyweight?
Вы когда-нибудь задумывались о том, как игры справляются с огромным количеством объектов? Представьте себе поле битвы в World of Warcraft – тысячи юнитов, деревьев, камней… Хранить информацию о каждом из них отдельно было бы просто нереально. Вот тут-то и приходит на помощь паттерн проектирования Flyweight (дословно – “легковес”).
В двух словах, Flyweight позволяет экономить память за счет разделения неизменяемых частей объекта от его изменяемой части. Звучит сложно? Сейчас разберемся!
Зачем вообще нужен этот Flyweight?
Представьте себе фабрику по производству карандашей. Каждый карандаш имеет общие характеристики: дерево, грифель, ластик (если есть). Но каждый карандаш может быть разного цвета и длины. Вместо того чтобы хранить информацию о дереве, грифеле и ластике для каждого карандаша отдельно, фабрика хранит их один раз как “общий ресурс”. А цвет и длину она запоминает индивидуально для каждого конкретного карандаша.
Вот это и есть суть Flyweight! Мы разделяем объект на две части:
- Внутреннее состояние: Неизменяемые данные, которые можно разделить между множеством объектов (например, дерево, грифель).
- Внешнее состояние: Изменяемые данные, которые уникальны для каждого объекта (например, цвет, длина).
Это позволяет значительно сократить потребление памяти, особенно когда у вас много похожих объектов. А вы знали, что это может существенно повысить производительность вашего приложения?
Как это работает на практике?
Давайте рассмотрим пример с деревьями в игре. У нас есть множество деревьев разных типов: сосна, береза, дуб… Все они имеют общие характеристики: текстура коры, форма листьев. Но каждое дерево имеет свою позицию и размер.
Вместо того чтобы хранить информацию о текстуре коры и форме листьев для каждого дерева отдельно, мы создаем класс TreeType (внутреннее состояние), который содержит эту информацию. А позицию и размер мы храним в отдельном классе Tree.
Flyweight на Swift
class TreeType {
let texture: String
let leafShape: String
init(texture: String, leafShape: String) {
self.texture = texture
self.leafShape = leafShape
}
}
class Tree {
let type: TreeType
var positionX: Int
var positionY: Int
var size: Int
init(type: TreeType, positionX: Int, positionY: Int, size: Int) {
self.type = type
self.positionX = positionX
self.positionY = positionY
self.size = size
}
}
// Фабрика деревьев
class TreeFactory {
private var treeTypes: [String: TreeType] = [:]
func getTreeType(texture: String, leafShape: String) -> TreeType {
if let type = treeTypes[texture + leafShape] {
return type
} else {
let newType = TreeType(texture: texture, leafShape: leafShape)
treeTypes[texture + leafShape] = newType
return newType
}
}
func createTree(texture: String, leafShape: String, positionX: Int, positionY: Int, size: Int) -> Tree {
let type = getTreeType(texture: texture, leafShape: leafShape)
return Tree(type: type, positionX: positionX, positionY: positionY, size: size)
}
}
// Использование
let factory = TreeFactory()
let tree1 = factory.createTree(texture: "Rough", leafShape: "Needle", positionX: 10, positionY: 20, size: 5)
let tree2 = factory.createTree(texture: "Smooth", leafShape: "Broadleaf", positionX: 30, positionY: 40, size: 8)
В этом примере TreeType – это наш Flyweight, а Tree – объект, который использует его. Фабрика TreeFactory заботится о том, чтобы не создавать одинаковые типы деревьев повторно. Честно говоря, это очень удобно!
Flyweight на Java
class TreeType {
private final String texture;
private final String leafShape;
public TreeType(String texture, String leafShape) {
this.texture = texture;
this.leafShape = leafShape;
}
public String getTexture() {
return texture;
}
public String getLeafShape() {
return leafShape;
}
}
class Tree {
private final TreeType type;
private int positionX;
private int positionY;
private int size;
public Tree(TreeType type, int positionX, int positionY, int size) {
this.type = type;
this.positionX = positionX;
this.positionY = positionY;
this.size = size;
}
// Геттеры и сеттеры...
}
class TreeFactory {
private final Map<String, TreeType> treeTypes = new HashMap<>();
public TreeType getTreeType(String texture, String leafShape) {
String key = texture + leafShape;
return treeTypes.computeIfAbsent(key, k -> new TreeType(texture, leafShape));
}
public Tree createTree(String texture, String leafShape, int positionX, int positionY, int size) {
TreeType type = getTreeType(texture, leafShape);
return new Tree(type, positionX, positionY, size);
}
}
Flyweight на JavaScript
class TreeType {
constructor(texture, leafShape) {
this.texture = texture;
this.leafShape = leafShape;
}
}
class Tree {
constructor(type, positionX, positionY, size) {
this.type = type;
this.positionX = positionX;
this.positionY = positionY;
this.size = size;
}
}
class TreeFactory {
treeTypes = {};
getTreeType(texture, leafShape) {
const key = texture + leafShape;
if (!this.treeTypes[key]) {
this.treeTypes[key] = new TreeType(texture, leafShape);
}
return this.treeTypes[key];
}
createTree(texture, leafShape, positionX, positionY, size) {
const type = this.getTreeType(texture, leafShape);
return new Tree(type, positionX, positionY, size);
}
}
Flyweight на Python
class TreeType:
def __init__(self, texture, leaf_shape):
self.texture = texture
self.leaf_shape = leaf_shape
class Tree:
def __init__(self, type, position_x, position_y, size):
self.type = type
self.position_x = position_x
self.position_y = position_y
self.size = size
class TreeFactory:
tree_types = {}
def get_tree_type(self, texture, leaf_shape):
key = texture + leaf_shape
if key not in self.tree_types:
self.tree_types[key] = TreeType(texture, leaf_shape)
return self.tree_types[key]
def create_tree(self, texture, leaf_shape, position_x, position_y, size):
type = self.get_tree_type(texture, leaf_shape)
return Tree(type, position_x, position_y, size)
Когда стоит использовать Flyweight?
- Когда у вас много похожих объектов.
- Когда хранение информации об этих объектах требует большого количества памяти.
- Когда неизменяемые части объекта можно разделить между множеством объектов.
В чём же дело? Не всегда нужно применять этот паттерн! Если у вас небольшое количество объектов, то использование Flyweight может только усложнить код и снизить производительность.
Подведём итоги
Паттерн проектирования Flyweight – это мощный инструмент для экономии памяти и повышения производительности вашего приложения. Он позволяет разделить неизменяемые части объекта от его изменяемой части, что особенно полезно при работе с большим количеством похожих объектов. Помните, что как и любой другой паттерн, Flyweight нужно использовать обдуманно и только тогда, когда это действительно необходимо. А вы знали, что этот паттерн можно комбинировать с другими паттернами для достижения ещё лучших результатов?





