一起学设计模式 - 享元模式

享元模式(Flyweight Pattern)属于结构型模式的一种,又称轻量级模式,通过共享技术有效地实现了大量细粒度对象的复用…

<!– more –>

概述

两种结构状态

  • 内部状态:享元对象内部不随外界环境改变而改变的共享部分。

  • 外部状态:享元对象内部环境的改变而改变,不能够共享的状态就是外部状态。

结构图

《一起学设计模式 - 享元模式》

存在的角色

  • Flyweight(抽象享元类):通常是一个接口或抽象类,向外界提供享元对象的内部数据(内部状态)或外部数据(外部状态)。

  • ConcreteFlyweight(具体享元类):实现了Flyweight(抽象享元类)也称为享元对象,指定内部状态,为内部状态增加存储空间。通常我们可以结合单例模式来设计具体享元类,为每一个具体享元类提供唯一的享元对象。

  • UnsharedConcreteFlyweight(非共享具体享元类):指不需要共享的Flyweight子类。

  • FlyweightFactory(享元工厂类):用于创建并管理享元对象,针对抽象享元类编程,将各种类型的具体享元对象存储在一个享元池中,享元池一般设计为键值对的集合(也可以是其他类型的集合),同时可以结合工厂模式进行设计。

享元模式的核心在于享元工厂类,享元工厂类的作用在于提供一个用于存储享元对象的享元池,用户需要对象时,首先从享元池中获取,如果享元池中不存在,则创建一个新的享元对象返回给用户,并在享元池中保存该新增对象。

案例

案例UML图如下:

《一起学设计模式 - 享元模式》

1.创建Flyweight接口/抽象类

interface Flyweight {
    void operation(String name);

    String getType();
}

2.创建ConcreteFlyweight(享元对象),实现了Flyweight接口

class ConcreteFlyweight implements Flyweight {
    private String type;

    public ConcreteFlyweight(String type) {
        this.type = type;
    }

    @Override
    public void operation(String name) {
        System.out.printf("[类型(内在状态)] - [%s] - [名字(外在状态)] - [%s]\n", type, name);
    }

    @Override
    public String getType() {
        return type;
    }
}

3.创建FlyweightFactory(享元工厂类),用来维护享元池

class FlyweightFactory {
    private static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();

    public static Flyweight getFlyweight(String type) {
        if (FLYWEIGHT_MAP.containsKey(type)) {
            return FLYWEIGHT_MAP.get(type);
        } else {
            ConcreteFlyweight flyweight = new ConcreteFlyweight(type);
            FLYWEIGHT_MAP.put(type, flyweight);
            return flyweight;
        }
    }

    public static int total() {
        return FLYWEIGHT_MAP.size();
    }
}

4.创建Client(测试类)

public class Client {

    public static void main(String[] args) {
        Flyweight fw0 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw1 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw2 = FlyweightFactory.getFlyweight("法师");
        Flyweight fw3 = FlyweightFactory.getFlyweight("坦克");
        fw1.operation("瑞文");
        fw1.operation("鳄鱼");
        fw2.operation("光辉");
        fw3.operation("泰坦");
        fw3.operation("盖伦");
        System.out.printf("[结果(对象对比)] - [%s]\n", fw0 == fw1);
        System.out.printf("[结果(内在状态)] - [%s]\n", fw1.getType());
        System.out.printf("一共召唤 %s 种类型英雄\n", FlyweightFactory.total());
    }
}

5.运行结果,从结果中可以发现,只生成了3个不同的类

[类型(内在状态)] - [战士] - [名字(外在状态)] - [瑞文]
[类型(内在状态)] - [战士] - [名字(外在状态)] - [鳄鱼]
[类型(内在状态)] - [法师] - [名字(外在状态)] - [光辉]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [泰坦]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [盖伦]
[结果(对象对比)] - [true]
[结果(内在状态)] - [战士]
一共召唤 3 种类型英雄

JDK中使用

在JAVA语言中,String类型就是使用了享元模式。String对象是final类型,对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的,JAVA会确保一个字符串常量在常量池中只有一个拷贝。

public class Client {
    public static void main(String[] args) {
        String a = "盖伦";
        String b = "盖伦";
        System.out.println(a==b);// 返回 true
    }
}

上面的例子中结果为:true,这就说明a和b两个引用都指向了常量池中的同一个字符串常量。这样设计的目的就是:为了避免在创建多相同对象时,所产生的不必要的资源消耗。

总结

如果程序里使用大量相同或者相似的对象,造成内存的大量耗费,且大多都是外部状态,这时候就应该考虑使用享元模式了,比如围棋、五子棋等小游戏

优点

  • 能够极大的减少系统中对象的个数。

  • 外部状态相对独立,不会影响到内部状态,能够使享元对象在不同的环境被共享。

缺点

  • 由于享元模式需要区分外部状态和内部状态,使得程序在某种程度上来说更加复杂化了。

  • 为了使对象可以共享,享元模式需要将享元对象的状态外部化,而读取外部状态使得运行时间变长。

– 说点什么

全文代码:https://gitee.com/battcn/design-pattern/tree/master/Chapter9/battcn-flyweight

  • 个人QQ:1837307557

  • battcn开源群(适合新手):391619659

微信公众号:battcn(欢迎调戏)

    原文作者:设计模式
    原文地址: https://segmentfault.com/a/1190000012037596
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞