上一篇《原型模式》 下一篇《责任链模式》
简介：
享元模式，它是一种结构型设计模式，旨在有效地支持大量细粒度的对象共享，通过共享对象来减少内存消耗和提高性能。享元模式将对象的状态分为内部状态和外部状态。内部状态是对象的固定部分，可以在多个对象之间共享，而外部状态是对象的变化部分，需要在使用时传递给对象。享元模式将内部状态存储在享元对象中，并将外部状态作为参数传递给方法。
享元模式包含以下几个关键组件：
1、享元接口：定义了享元对象的通用接口，通过该接口可以获取内部状态和操作享元对象。
2、具体享元：实现了享元接口，并包含内部状态。具体享元对象需要是可共享的，也就是说它们可以在多个上下文中共享。
3、享元工厂：负责创建和管理享元对象。它维护一个享元池，用于存储已经创建的享元对象，以便在需要时进行复用。当客户端需要使用享元对象时，可以通过享元工厂获取对象的实例。如果享元池中已经存在相应的对象实例，则直接返回该实例；如果不存在，则创建一个新的享元对象并添加到享元池中。这样可以确保相同的对象在多个地方共享使用，减少内存消耗。
需要注意的是，当对象数量太多时，享元模式会导致运行代价过高，带来性能下降等问题。因此，在使用享元模式时，要根据实际情况慎重考虑。
享元模式的使用场景：
1、系统中存在大量的相似对象。
2、细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。
3、需要缓冲池的场景。
享元模式通过共享对象来减少内存消耗和提高性能，适用于存在大量相似对象的场景，特别是当对象的内部状态较少并且可以共享时。它常用于系统底层的开发，解决系统的性能问题，比如数据库连接池、String常量池、缓冲池等都是享元模式的使用。
虽然可以使用享元模式来实现对象池，但是这两者还是有比较大的差异。对象池着重在对象的复用上，池中的每个对象是可替换的，从同一个池中获得A对象和B对象对客户端来说是完全相同的；而享元模式主要解决的对象的共享问题，如何建立多个可共享的细粒度对象是其主要关注的重点。
享元模式的创建步骤：
1、定义抽象享元类：这是一个抽象类，内部状态和外部状态的定义，以及抽象方法的定义。抽象类通常用于声明享元工厂类和用户调用中涉及的对象类型。
2、定义内部状态：内部状态是多个细粒度对象共享的信息。这些信息是在对象池中维护一个享元对象的共享信息。当多个细粒度对象从享元工厂类中获取该享元对象时，它们获取的都是相同的享元对象。
3、定义外部状态：外部状态很重要，它作为从对象池中获取对象的依据。外部状态相等的两个对象说明它们是相同的。
4、创建享元工厂：负责维护享元池，用于存储具有相同内部状态的享元对象。享元模式中共享的仅仅是享元对象，外部状态是需要通过环境类设置的。
在实际使用中，能共享的内部状态不是很多的，所以设计享元对象是比较小的，也就是细粒度对象。所以说享元模式就是通过共享技术实现大量细粒度对象的复用。
享元模式的优点，主要包括：
1、减少内存消耗：享元模式通过共享对象实例来减少内存消耗，特别是在存在大量相似对象的场景中，可以显著降低内存消耗。
2、提高性能：由于享元对象是被共享的，所以它可以减少内存占用，从而降低系统的开销。同时，享元模式还可以提高系统的性能和效率。
3、提高系统的灵活性：享元模式将对象的内部状态和外部状态分离开来，使得系统更加易于扩展和维护。
享元模式的缺点，主要包括：
1、维护一个享元池需要引入额外的复杂性。在享元模式中，需要维护一个存储享元对象的享元池，这可能会增加系统的复杂性和开销。
2、为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长。这可能会对系统的性能产生一定的影响。
3、享元模式使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。这可能会增加开发人员的工作量和开发难度。
4、享元模式不适用于所有情况。在某些情况下，使用享元模式可能会导致系统的设计和实现变得复杂化和难以理解，从而增加开发和维护的成本。
示例：
一、C#享元模式
以下是一个示例，展示了如何在C#中实现享元模式：
using System;
using System.Collections.Generic;
public abstract class Shape
{
protected int _x;
protected int _y;
public Shape(int x, int y)
{
_x = x;
_y = y;
}
public virtual void Draw()
{
Console.WriteLine("Drawing Shape at ({0}, {1})", _x, _y);
}
}
public class Circle : Shape
{
public Circle(int x, int y) : base(x, y) { }
public override void Draw()
{
Console.WriteLine("Drawing Circle at ({0}, {1})", _x, _y);
}
}
public class Rectangle : Shape
{
public Rectangle(int x, int y) : base(x, y) { }
public override void Draw()
{
Console.WriteLine("Drawing Rectangle at ({0}, {1})", _x, _y);
}
}
public class ShapeFactory
{
private Dictionary<string, Shape> _shapes = new Dictionary<string, Shape>();
public Shape GetShape(string shapeType)
{
if (_shapes.ContainsKey(shapeType))
{
return _shapes[shapeType];
}
else
{
Shape shape = null;
switch (shapeType)
{
case "Circle":
shape = new Circle(0, 0);
break;
case "Rectangle":
shape = new Rectangle(0, 0);
break;
default:
Console.WriteLine("Unsupported shape type: {0}", shapeType);
break;
}
_shapes[shapeType] = shape;
return shape;
}
}
}
public class Program
{
public static void Main(string[] args)
{
ShapeFactory factory = new ShapeFactory();
Shape circle = factory.GetShape("Circle");
circle.Draw();
}
}二、java享元模式
享元模式通常通过以下方式实现：
import java.util.HashMap;
import java.util.Map;
// 抽象享元类
abstract class AbstractFlyweight {
protected int color;
protected int size;
// 外部传入的颜色和大小值
public void set(int color, int size) {
this.color = color;
this.size = size;
}
// 内部方法，用于展示对象的状态
public void display() {
System.out.println("Color: " + color + ", Size: " + size);
}
}
// 具体享元类1
class ConcreteFlyweight1 extends AbstractFlyweight {
public ConcreteFlyweight1(int color, int size) {
set(color, size);
}
}
// 具体享元类2
class ConcreteFlyweight2 extends AbstractFlyweight {
public ConcreteFlyweight2(int color, int size) {
set(color, size);
}
}
// 享元工厂类
class FlyweightFactory {
private Map<String, AbstractFlyweight> flyweights;
public FlyweightFactory() {
this.flyweights = new HashMap<>();
}
public AbstractFlyweight getFlyweight(String key) {
if (flyweights.containsKey(key)) {
return flyweights.get(key);
} else {
ConcreteFlyweight1 concreteFlyweight1 = new ConcreteFlyweight1(0, 0); // default values for testing purpose only. 0,0 would not be a valid values in real scenarios.
flyweights.put(key, concreteFlyweight1);
return concreteFlyweight1;
}
}
}
public class FlyweightPatternDemo {
public static void main(String[] args) {
FlyweightFactory flyweightFactory = new FlyweightFactory();
AbstractFlyweight flyweight1 = flyweightFactory.getFlyweight("Object1"); // for the first time this object is created. It will be shared across multiple requests.
AbstractFlyweight flyweight2 = flyweightFactory.getFlyweight("Object2"); // for the second time this object is not created again. It will be retrieved from the flyweights map.
flyweight1.display();
flyweight2.display();
}
}三、javascript享元模式
在JavaScript中，享元实现方式如下：
// 抽象享元类
class AbstractFlyweight {
constructor(color, size) {
this.color = color;
this.size = size;
}
display() {
console.log(`Color: ${this.color}, Size: ${this.size}`);
}
}
// 具体享元类1
class ConcreteFlyweight1 extends AbstractFlyweight {
constructor(color, size, additionalInfo) {
super(color, size);
this.additionalInfo = additionalInfo;
}
display() {
super.display();
console.log(`Additional Info: ${this.additionalInfo}`);
}
}
// 具体享元类2
class ConcreteFlyweight2 extends AbstractFlyweight {
constructor(color, size, additionalInfo) {
super(color, size);
this.additionalInfo = additionalInfo;
}
display() {
super.display();
console.log(`Additional Info: ${this.additionalInfo}`);
}
}
// 享元工厂类
class FlyweightFactory {
constructor() {
this.flyweights = new Map(); // 使用 Map 存储享元对象，方便查找和管理
}
getFlyweight(key) {
if (this.flyweights.has(key)) {
return this.flyweights.get(key); // 如果已经存在，直接返回已有的享元对象
} else {
const flyweight = new ConcreteFlyweight1(0, 0, 'New Flyweight'); // 默认创建一个新的享元对象，0,0 和 New Flyweight 是示例值，实际使用时需要替换为真实值或随机值等
this.flyweights.set(key, flyweight); // 将新创建的享元对象存储到 Map 中，以便后续重复使用
return flyweight; // 返回新创建的享元对象给调用方使用
}
}
}四、C++享元模式
以下是在C++中实现享元模式：
#include <iostream>
#include <map>
// 抽象享元类
class AbstractFlyweight {
public:
virtual void operation() = 0;
};
// 具体享元类1
class ConcreteFlyweight1 : public AbstractFlyweight {
public:
void operation() override {
std::cout << "ConcreteFlyweight1 operation" << std::endl;
}
};
// 具体享元类2
class ConcreteFlyweight2 : public AbstractFlyweight {
public:
void operation() override {
std::cout << "ConcreteFlyweight2 operation" << std::endl;
}
};
// 享元工厂类
class FlyweightFactory {
private:
std::map<int, AbstractFlyweight*> flyweights; // 使用 map 存储享元对象，方便查找和管理
public:
AbstractFlyweight* getFlyweight(int key) {
if (flyweights.count(key) > 0) { // 如果已经存在，直接返回已有的享元对象
return flyweights[key];
} else { // 否则，创建一个新的享元对象，并将其存储到 map 中
AbstractFlyweight* flyweight = new ConcreteFlyweight1(); // 默认创建一个 ConcreteFlyweight1 对象作为享元对象，也可以根据需要创建 ConcreteFlyweight2 对象或其他对象作为享元对象
flyweights[key] = flyweight; // 将新创建的享元对象存储到 map 中，以便后续重复使用
return flyweight; // 返回新创建的享元对象给调用方使用
}
}
};
int main() {
FlyweightFactory factory; // 创建享元工厂对象
AbstractFlyweight* flyweight1 = factory.getFlyweight(1); // 从工厂中获取一个享元对象，可以是 ConcreteFlyweight1 或 ConcreteFlyweight2 等其他对象，这里假设是 ConcreteFlyweight1 对象，并将其指针保存到 flyweight1 中
flyweight1->operation(); // 调用享元对象的 operation 方法，输出 "ConcreteFlyweight1 operation" 到控制台中
AbstractFlyweight* flyweight2 = factory.getFlyweight(2); // 从工厂中获取另一个享元对象，同样可以是 ConcreteFlyweight1 或 ConcreteFlyweight2 等其他对象，这里假设是 ConcreteFlyweight2 对象，并将其指针保存到 flyweight2 中
flyweight2->operation(); // 调用享元对象的 operation 方法，输出 "ConcreteFlyweight2 operation" 到控制台中，由于 flyweight2 是新创建的 ConcreteFlyweight2 对象，因此输出结果与之前的 flyweight1 不相同
return 0;
}五、python享元模式
以下是在python中实现享元模式：
from abc import ABC, abstractmethod
# 享元类
class Flyweight(ABC):
@abstractmethod
def operation(self):
pass
# 具体享元类1
class ConcreteFlyweight1(Flyweight):
def operation(self):
super().operation()
print("ConcreteFlyweight1 operation")
# 具体享元类2
class ConcreteFlyweight2(Flyweight):
def operation(self):
super().operation()
print("ConcreteFlyweight2 operation")
# 享元工厂类
class FlyweightFactory:
_flyweights = {}
def get_flyweight(self, key):
if key in self._flyweights:
return self._flyweights[key]
else:
flyweight = ConcreteFlyweight1() # 或者 ConcreteFlyweight2 等其他具体享元类
self._flyweights[key] = flyweight
return flyweight
def put_flyweight(self, key, flyweight):
self._flyweights[key] = flyweight
#使用示例：
factory = FlyweightFactory()
flyweight1 = factory.get_flyweight(1) # 返回一个 ConcreteFlyweight1 对象，key 为 1 的对象已经存在则直接返回，否则创建一个新的对象并存储到字典中
flyweight2 = factory.get_flyweight(2) # 返回一个 ConcreteFlyweight1 对象，key 为 2 的对象已经存在则直接返回，否则创建一个新的对象并存储到字典中
flyweight1.operation() # 输出 "ConcreteFlyweight1 operation"
flyweight2.operation() # 输出 "ConcreteFlyweight1 operation" 六、go享元模式
以下是一个示例，展示了如何在go中实现享元模式：
package main
import (
"fmt"
)
// Flyweight 接口定义了享元对象的行为
type Flyweight interface {
Operation()
}
// ConcreteFlyweight1 和 ConcreteFlyweight2 是具体的享元对象
type ConcreteFlyweight1 struct {
// 共享状态
state1 string
}
func (f *ConcreteFlyweight1) Operation() {
fmt.Println("ConcreteFlyweight1 operation with state1:", f.state1)
}
type ConcreteFlyweight2 struct {
// 共享状态
state2 int
}
func (f *ConcreteFlyweight2) Operation() {
fmt.Println("ConcreteFlyweight2 operation with state2:", f.state2)
}
// FlyweightFactory 是享元工厂，用于创建和管理享元对象
type FlyweightFactory struct {
flyweights map[string]Flyweight
}
func NewFlyweightFactory() *FlyweightFactory {
return &FlyweightFactory{
flyweights: make(map[string]Flyweight),
}
}
func (f *FlyweightFactory) GetFlyweight(key string) Flyweight {
if flyweight, ok := f.flyweights[key]; ok {
return flyweight // 如果已存在，则直接返回已有的享元对象
} else {
// 如果不存在，则创建一个新的享元对象，并将其存储到 flyweights 中
switch key {
case "state1":
flyweight := &ConcreteFlyweight1{state1: "shared state 1"}
f.flyweights[key] = flyweight
return flyweight
case "state2":
flyweight := &ConcreteFlyweight2{state2: 42}
f.flyweights[key] = flyweight
return flyweight
default:
return nil
}
}
}
func main() {
factory := NewFlyweightFactory() // 创建享元工厂对象
flyweight1 := factory.GetFlyweight("state1") // 从工厂中获取一个享元对象，这里使用 key 为 "state1" 的 ConcreteFlyweight1 对象作为示例，并将其指针保存到 flyweight1 中
flyweight1.Operation() // 调用享元对象的 Operation 方法，输出 "ConcreteFlyweight1 operation with state1: shared state 1" 到控制台中
flyweight2 := factory.GetFlyweight("state2") // 从工厂中获取另一个享元对象，这里使用 key 为 "state2" 的 ConcreteFlyweight2 对象作为示例，并将其指针保存到 flyweight2 中
}七、PHP享元模式
以下是一个示例，展示了如何在PHP中实现享元模式：
<?php
// 享元接口
interface Flyweight {
public function operation();
}
// 具体享元类1
class ConcreteFlyweight1 implements Flyweight {
private $state1;
public function operation() {
// 具体操作
$this->state1 = "shared state 1";
echo "ConcreteFlyweight1 operation with state1: " . $this->state1 . "\n";
}
}
// 具体享元类2
class ConcreteFlyweight2 implements Flyweight {
private $state2;
public function operation() {
// 具体操作
$this->state2 = 42;
echo "ConcreteFlyweight2 operation with state2: " . $this->state2 . "\n";
}
}
// 享元工厂类
class FlyweightFactory {
private $flyweights;
public function __construct() {
$this->flyweights = [];
}
public function getFlyweight($key) {
if (isset($this->flyweights[$key])) {
return $this->flyweights[$key]; // 如果已存在，则直接返回已有的享元对象
} else {
// 如果不存在，则创建一个新的享元对象，并将其存储到 flyweights 中
switch ($key) {
case "state1":
$flyweight = new ConcreteFlyweight1();
$this->flyweights["state1"] = $flyweight;
return $flyweight;
case "state2":
$flyweight = new ConcreteFlyweight2();
$this->flyweights["state2"] = $flyweight;
return $flyweight;
default:
return null;
}
}
}
}
// 使用享元模式示例
$factory = new FlyweightFactory(); // 创建享元工厂对象
$flyweight1 = $factory->getFlyweight("state1"); // 从工厂中获取一个享元对象，这里使用 key 为 "state1" 的 ConcreteFlyweight1 对象作为示例，并将其指针保存到 $flyweight1 中
$flyweight1->operation(); // 调用享元对象的 Operation 方法，输出 "ConcreteFlyweight1 operation with state1: shared state 1" 到控制台中
$flyweight2 = $factory->getFlyweight("state2"); // 从工厂中获取另一个享元对象，这里使用 key 为 "state2" 的 ConcreteFlyweight2 对象作为示例，并将其指针保存到 $flyweight2 中
$flyweight2->operation(); // 调用享元对象的 Operation 方法，输出 "ConcreteFlyweight2 operation with state2: 42" 到控制台中
?>《完结》
上一篇《原型模式》 下一篇《责任链模式》
