Go和Java实现享元模式

下面通过一个实例来说明享元模式的使用。

1、享元模式

享元模式主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提

供了减少对象数量从而改善应用所需的对象结构的方式。

享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

意图：运用共享技术有效地支持大量细粒度的对象。
主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请

求，直接返回在内存中已有的对象，避免重新创建。
何时使用：1、系统中有大量对象。 2、这些对象消耗大量内存。 3、这些对象的状态大部分可以外部化。 4、

这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来

代替。 5、系统不依赖于这些对象身份，这些对象是不可分辨的。
如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。
关键代码：用 HashMap 存储这些对象。
应用实例：1、JAVA 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。 2、

数据库的连接池。
优点：大大减少对象的创建，降低系统的内存，使效率提高。
缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着

内部状态的变化而变化，否则会造成系统的混乱。
使用场景：1、系统有大量相似对象。 2、需要缓冲池的场景。
注意事项：1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。 2、这些类必须有一个工厂对

象加以控制。
适用性：

一个应用程序使用了大量的对象。

完全由于使用大量的对象，造成很大的存储开销。

对象使大多数状态都可变为外部状态。

如果删除对象的外部状态，那么可以使相对较少的共享对象取代很多组对象。

应用程序不依赖于对象标识，由于 Flyweight 对象可以被共享，对于概念上明显有别的对象，标识测试将返回

真值。

2、Go实现享元模式

go 复制代码

package flyweight

// ========== Flyweight ==========
type Flyweight interface {
	Action(arg int)
}

go 复制代码

package flyweight

import "fmt"

// ========== FlyweightImpl ==========
type FlyweightImpl struct {
}

func (flyweightImpl *FlyweightImpl) Action(arg int) {
	fmt.Println("参数值: ", arg)
}

go 复制代码

package flyweight

// ========== FlyweightFactory ==========
type FlyweightFactory struct {
	flyweights map[string]Flyweight
}

func NewFlyweightFactory() FlyweightFactory {
	return FlyweightFactory{
		flyweights: map[string]Flyweight{},
	}
}

func (flyweightFactory *FlyweightFactory) GetFlyweight(key string) Flyweight {
	if flyweightFactory.flyweights[key] == nil {
		flyweightFactory.flyweights[key] = new(FlyweightImpl)
	}
	return flyweightFactory.flyweights[key]
}

func (flyweightFactory *FlyweightFactory) GetSize() int {
	return len(flyweightFactory.flyweights)
}

go 复制代码

package main

import (
	"fmt"
	. "proj/flyweight"
)

func main() {
	flyWeight := NewFlyweightFactory()
	fly1 := flyWeight.GetFlyweight("a")
	fly1.Action(1)
	fly2 := flyWeight.GetFlyweight("a")
	fmt.Println(fly1 == fly2)
	fly3 := flyWeight.GetFlyweight("b")
	fly3.Action(2)
	fly4 := flyWeight.GetFlyweight("c")
	fly4.Action(3)
	fly5 := flyWeight.GetFlyweight("d")
	fly5.Action(4)
	fmt.Println(flyWeight.GetSize())
}

shell 复制代码

# 输出
参数值:  1
true
参数值:  2
参数值:  3
参数值:  4
4

3、Java实现享元模式

java 复制代码

package flyweight;

// ========== Flyweight ==========
public interface Flyweight {
    void action(int arg);
}

java 复制代码

package flyweight;

// ========== FlyweightImpl ==========
public class FlyweightImpl implements Flyweight {
    @Override
    public void action(int arg) {
        System.out.println("参数值: " + arg);
    }
}

java 复制代码

package flyweight;

import java.util.HashMap;
import java.util.Map;

// ========== FlyweightFactory ==========
public class FlyweightFactory {

    private final static Map<String,Flyweight> FLY_WEIGHTS = new HashMap<>();

    public FlyweightFactory(String arg) {
        FLY_WEIGHTS.put(arg, new FlyweightImpl());
    }

    public static Flyweight getFlyweight(String key) {
        if (FLY_WEIGHTS.get(key) == null) {
            FLY_WEIGHTS.put(key,new FlyweightImpl());
        }
        return FLY_WEIGHTS.get(key);
    }

    public static int getSize() {
        return FLY_WEIGHTS.size();
    }
}

java 复制代码

package flyweight;

public class Test {

    public static void main(String[] args) {

        Flyweight fly1 = FlyweightFactory.getFlyweight("a");
        fly1.action(1);

        Flyweight fly2 = FlyweightFactory.getFlyweight("a");
        System.out.println(fly1 == fly2);
        fly2.action(2);

        Flyweight fly3 = FlyweightFactory.getFlyweight("b");
        fly3.action(3);

        Flyweight fly4 = FlyweightFactory.getFlyweight("c");
        fly4.action(4);

        Flyweight fly5 = FlyweightFactory.getFlyweight("d");
        fly5.action(5);

        System.out.println(FlyweightFactory.getSize());
    }
}

shell 复制代码

# 输出
参数值: 1
true
参数值: 2
参数值: 3
参数值: 4
参数值: 5
4