设计模式之享元模式(Flyweight Pattern)

最新推荐文章于 2024-09-15 22:03:14 发布

敲代码的小小酥

最新推荐文章于 2024-09-15 22:03:14 发布

阅读量122

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/qq1309664161/article/details/115050813

版权

设计模式专栏收录该内容

15 篇文章 5 订阅

订阅专栏

1.概念

运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

在享元模式中可以共享的相同内容称为 内部状态(Intrinsic State)，而那些需要外部环境来设置的不能共享的内容称为 外部状态(Extrinsic State)，其中外部状态和内部状态是相互独立的，外部状态的变化不会引起内部状态的变化。由于区分了内部状态和外部状态，因此可以通过设置不同的外部状态使得相同的对象可以具有一些不同的特征，而相同的内部状态是可以共享的。也就是说，享元模式的本质是分离与共享：分离变与不变，并且共享不变。把一个对象的状态分成内部状态和外部状态，内部状态即是不变的，外部状态是变化的；然后通过共享不变的部分，达到减少对象数量并节约内存的目的。

在享元模式中通常会出现工厂模式，需要创建一个享元工厂来负责维护一个享元池(Flyweight Pool)（用于存储具有相同内部状态的享元对象）。在享元模式中，共享的是享元对象的内部状态，外部状态需要通过环境来设置。在实际使用中，能够共享的内部状态是有限的，因此享元对象一般都设计为较小的对象，它所包含的内部状态较少，这种对象也称为细粒度对象。
享元模式的目的就是使用共享技术来实现大量细粒度对象的复用。

2.角色

Flyweight：享元接口，通过这个接口传入外部状态并作用于外部状态；
ConcreteFlyweight：具体的享元实现对象，必须是可共享的，需要封装享元对象的内部状态；
UnsharedConcreteFlyweight：非共享的享元实现对象，并不是所有的享元对象都可以共享，非共享的享元对象通常是享元对象的组合对象；
FlyweightFactory：享元工厂，主要用来创建并管理共享的享元对象，并对外提供访问共享享元的接口；

3.代码实现

3.1单纯享元模式
在单纯享元模式中，所有的享元对象都是可以共享的，即所有抽象享元类的子类都可共享，不存在非共享具体享元类。
首先，我们创建享元接口Flyweight:

/**
 * 抽象享元角色
 */
public interface Flyweight {

    //一个示意性方法，参数state是外蕴状态
    public void operation(String state);
}

然后，我们实现享元接口，实现类也是享元对象,

/**
 * 具体享元角色类，有一个内蕴状态intrinsicState为成员属性，它的值应该在享元对象被创建时赋予，
 * 所有的内蕴状态在对象创建后，就不会再改变。如果享元对象有外蕴的话，都是储存在客户端的。
 */
public class ConcreteFlyweight implements Flyweight{
    private Character intrinsicState=null;

    /**
     * 构造函数，内蕴状态作为参数传入，在对象初始化时传入
     * @param state
     */
    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }
    //外蕴状态,不改变内蕴装态
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic State = " + this.intrinsicState);
        System.out.println("Extrinsic State = " + state);
    }
}

然后，我们定义工厂类，工厂类根据内蕴状态，产出享元对象

/**
 * 享元工厂角色，也可以使用单例模式实现此角色。客户端传入所需共享对象的内蕴状态，来获得享元对象。
 */
public class FlyweightFactory {
    //key为内蕴状态，value为享元对象，files存储享元对象。当需要享元对象时，传入key值，获得对象。
    //当对象不存在时，新建对象，并存入files中，这样，再有人用这个对象时，直接取即可。这就是共享。
    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
   //获取享元对象
    public Flyweight factory(Character state){
        //先从缓存中查找对象
        Flyweight fly = files.get(state);
        if(fly == null){
            //如果对象不存在则创建一个新的Flyweight对象
            fly = new ConcreteFlyweight(state);
            //把这个新的Flyweight对象添加到缓存中
            files.put(state, fly);
        }
        return fly;
    }
}

这样，就实现了共享。我们可以看到，对于内蕴状态而言，就是共享一个的，而对于外蕴状态而言，客户端是可以自己定义的。
3.2复合享元模式
将一些单纯享元使用组合模式加以组合，可以形成复合享元对象，这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。
在复合模式中，增加了一个复合实现类，在这个实现类里，要提供聚集方法，来聚集单纯享元对象。

/**
 * 符合模式享元角色类,由单纯的享元对象复合而成，复合享元对象是不能被共享的
 */
public class ConcreteCompositeFlyweight implements Flyweight{
    //将单纯享元对象聚集到Map集合中
    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
    /**
     * 增加一个新的单纯享元对象到聚集中
     */
    public void add(Character key , Flyweight fly){
        files.put(key,fly);
    }
    /**
     * 外蕴状态作为参数传入到方法中
     */
    @Override
    public void operation(String state) {
        Flyweight fly = null;
        for(Object o : files.keySet()){
            fly = files.get(o);
            fly.operation(state);
        }

    }
}

在享元工厂中，也相应的需要增加产出复合享元对象的方法，代码如下：


```java
public class FlyweightFactory {
    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
    /**
     * 复合享元工厂方法
     */
    public Flyweight factory(List<Character> compositeState){
        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();

        for(Character state : compositeState){
            compositeFly.add(state,this.factory(state));
        }

        return compositeFly;
    }
    /**
     * 单纯享元工厂方法
     */
    public Flyweight factory(Character state){
        //先从缓存中查找对象
        Flyweight fly = files.get(state);
        if(fly == null){
            //如果对象不存在则创建一个新的Flyweight对象
            fly = new ConcreteFlyweight(state);
            //把这个新的Flyweight对象添加到缓存中
            files.put(state, fly);
        }
        return fly;
    }
}