`
langgufu
  • 浏览: 2305686 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

享元模式-Flyweight(转载)

阅读更多

Flyweight在拳击比赛中指最轻量级,即“蝇量级”或“雨量级”,这里选择使用“享元模式”的意译,是因为这样更能反映模式的用意。享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。


Java中的String类型

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

复制代码
public class Test {

    public static void main(String[] args) {
        
        String a = "abc";
        String b = "abc";
        System.out.println(a==b);
        
    }
}
复制代码

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

 

享元模式的结构

  享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)外蕴状态(External State)。

  一个内蕴状态是存储在享元对象内部的,并且是不会随环境的改变而有所不同。因此,一个享元可以具有内蕴状态并可以共享。

  一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存,并在享元对象被创建之后,在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态,它们是相互独立的。

  享元模式可以分成单纯享元模式复合享元模式两种形式。

单纯享元模式  

  在单纯的享元模式中,所有的享元对象都是可以共享的。

  单纯享元模式所涉及到的角色如下:

  ●  抽象享元(Flyweight)角色 :给出一个抽象接口,以规定出所有具体享元角色需要实现的方法。

  ●  具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定出的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。

  ●  享元工厂(FlyweightFactory)角色 :本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候,享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个合适的享元对象。

源代码

  抽象享元角色类

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

  具体享元角色类ConcreteFlyweight有一个内蕴状态,在本例中一个Character类型的intrinsicState属性代表,它的值应当在享元对象被创建时赋予。所有的内蕴状态在对象创建之后,就不会再改变了。

  如果一个享元对象有外蕴状态的话,所有的外部状态都必须存储在客户端,在使用享元对象时,再由客户端传入享元对象。这里只有一个外蕴状态,operation()方法的参数state就是由外部传入的外蕴状态。

复制代码
public class ConcreteFlyweight implements Flyweight {
    private Character intrinsicState = null;
    /**
     * 构造函数,内蕴状态作为参数传入
     * @param state
     */
    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }
    
    
    /**
     * 外蕴状态作为参数传入方法中,改变方法的行为,
     * 但是并不改变对象的内蕴状态。
     */
    @Override
    public void operation(String state) {
        // TODO Auto-generated method stub
        System.out.println("Intrinsic State = " + this.intrinsicState);
        System.out.println("Extrinsic State = " + state);
    }

}
复制代码

  享元工厂角色类,必须指出的是,客户端不可以直接将具体享元类实例化,而必须通过一个工厂对象,利用一个factory()方法得到享元对象。一般而言,享元工厂对象在整个系统中只有一个,因此也可以使用单例模式。

  当客户端需要单纯享元对象的时候,需要调用享元工厂的factory()方法,并传入所需的单纯享元对象的内蕴状态,由工厂方法产生所需要的享元对象。

复制代码
public class FlyweightFactory {
    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;
    }
}
复制代码

  客户端类

复制代码
public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight fly = factory.factory(new Character('a'));
        fly.operation("First Call");
        
        fly = factory.factory(new Character('b'));
        fly.operation("Second Call");
        
        fly = factory.factory(new Character('a'));
        fly.operation("Third Call");
    }

}
复制代码

  虽然客户端申请了三个享元对象,但是实际创建的享元对象只有两个,这就是共享的含义。运行结果如下:

 

复合享元模式

  在单纯享元模式中,所有的享元对象都是单纯享元对象,也就是说都是可以直接共享的。还有一种较为复杂的情况,将一些单纯享元使用合成模式加以复合,形成复合享元对象。这样的复合享元对象本身不能共享,但是它们可以分解成单纯享元对象,而后者则可以共享。

  

  复合享元角色所涉及到的角色如下:

  ●  抽象享元(Flyweight)角色 :给出一个抽象接口,以规定出所有具体享元角色需要实现的方法。

  ●  具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定出的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。

  ●   复合享元(ConcreteCompositeFlyweight)角色 :复合享元角色所代表的对象是不可以共享的,但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。

  ●   享元工厂(FlyweightFactory)角色 :本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候,享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个 合适的享元对象。

源代码

  抽象享元角色类

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

  具体享元角色类

复制代码
public class ConcreteFlyweight implements Flyweight {
    private Character intrinsicState = null;
    /**
     * 构造函数,内蕴状态作为参数传入
     * @param state
     */
    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }
    
    
    /**
     * 外蕴状态作为参数传入方法中,改变方法的行为,
     * 但是并不改变对象的内蕴状态。
     */
    @Override
    public void operation(String state) {
        // TODO Auto-generated method stub
        System.out.println("Intrinsic State = " + this.intrinsicState);
        System.out.println("Extrinsic State = " + state);
    }

}
复制代码

  复合享元对象是由单纯享元对象通过复合而成的,因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素,这些聚集元素在复合享元对象被创建之后加入,这本身就意味着复合享元对象的状态是会改变的,因此复合享元对象是不能共享的。

  复合享元角色实现了抽象享元角色所规定的接口,也就是operation()方法,这个方法有一个参数,代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的;而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的,不然就没有使用价值了。

复制代码
public class ConcreteCompositeFlyweight implements Flyweight {
    
    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);
        }
        
    }

}
复制代码

  享元工厂角色提供两种不同的方法,一种用于提供单纯享元对象,另一种用于提供复合享元对象。

复制代码
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;
    }
}
复制代码

  客户端角色

复制代码
public class Client {

    public static void main(String[] args) {
        List<Character> compositeState = new ArrayList<Character>();
        compositeState.add('a');
        compositeState.add('b');
        compositeState.add('c');
        compositeState.add('a');
        compositeState.add('b');
        
        FlyweightFactory flyFactory = new FlyweightFactory();
        Flyweight compositeFly1 = flyFactory.factory(compositeState);
        Flyweight compositeFly2 = flyFactory.factory(compositeState);
        compositeFly1.operation("Composite Call");
        
        System.out.println("---------------------------------");        
        System.out.println("复合享元模式是否可以共享对象:" + (compositeFly1 == compositeFly2));
        
        Character state = 'a';
        Flyweight fly1 = flyFactory.factory(state);
        Flyweight fly2 = flyFactory.factory(state);
        System.out.println("单纯享元模式是否可以共享对象:" + (fly1 == fly2));
    }
}
复制代码

 

运行结果如下:

  从运行结果可以看出,一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的。即外运状态都等于Composite Call。

  从运行结果可以看出,一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的。即内蕴状态分别为b、c、a。

  从运行结果可以看出,复合享元对象是不能共享的。即使用相同的对象compositeState通过工厂分别两次创建出的对象不是同一个对象。

  从运行结果可以看出,单纯享元对象是可以共享的。即使用相同的对象state通过工厂分别两次创建出的对象是同一个对象。

享元模式的优缺点

  享元模式的优点在于它大幅度地降低内存中对象的数量。但是,它做到这一点所付出的代价也是很高的:

  ●  享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。

  ●  享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。

 

享元模式另一篇文章:

解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象。比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象。如果有一个1M的文本,那么字母是何其的多,如果每个字母都定义一个对象那么内存早就爆了。那么如果要是每个字母都共享一个对象,那么就大大节约了资源。
  在Flyweight模式中,由于要产生各种各样的对象,所以在Flyweight(享元)模式中常出现Factory模式。Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个对象存储池(Flyweight Pool)来存放内部状态的对象。Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多,下面举个例子:
  先定义一个抽象的Flyweight类:

  1. package Flyweight;  
  2. public abstract class Flyweight{  
  3.  public abstract void operation();  
  4. }  

实现一个具体类:

  1. package Flyweight;  
  2. public class ConcreteFlyweight extends Flyweight{  
  3.  private String string;  
  4.  public ConcreteFlyweight(String str){  
  5.   string = str;  
  6.  }  
  7.  public void operation()  
  8.  {  
  9.   System.out.println("Concrete---Flyweight : " + string);  
  10.  }  
  11. }  

实现一个工厂方法类:

  1. package Flyweight;  
  2. import java.util.Hashtable;  
  3. public class FlyweightFactory{  
  4.  private Hashtable flyweights = new Hashtable();//----------------------------1  
  5.  public FlyweightFactory(){}  
  6.  public Flyweight getFlyWeight(Object obj){  
  7.   Flyweight flyweight = (Flyweight) flyweights.get(obj);//----------------2  
  8.   if(flyweight == null){//---------------------------------------------------3  
  9.    //产生新的ConcreteFlyweight  
  10.    flyweight = new ConcreteFlyweight((String)obj);  
  11.    flyweights.put(obj, flyweight);//--------------------------------------5  
  12.   }  
  13.   return flyweight;//---------------------------------------------------------6  
  14.  }  
  15.  public int getFlyweightSize(){  
  16.   return flyweights.size();  
  17.  }  
  18. }  

这个工厂方法类非常关键,这里详细解释一下:
  在1处定义了一个Hashtable用来存储各个对象;在2处选出要实例化的对象,在6处将该对象返回,如果在Hashtable中没有要选择的对象,此时变量flyweight为null,产生一个新的flyweight存储在Hashtable中,并将该对象返回。
  最后看看Flyweight的调用:

  1. package Flyweight;  
  2. import java.util.Hashtable;  
  3. public class FlyweightPattern{  
  4.  FlyweightFactory factory = new FlyweightFactory();   
  5.  Flyweight fly1;  
  6.  Flyweight fly2;  
  7.  Flyweight fly3;  
  8.  Flyweight fly4;  
  9.  Flyweight fly5;  
  10.  Flyweight fly6;  
  11.  /** *//** Creates a new instance of FlyweightPattern */  
  12.  public FlyweightPattern(){  
  13.   fly1 = factory.getFlyWeight("Google");  
  14.   fly2 = factory.getFlyWeight("Qutr");  
  15.   fly3 = factory.getFlyWeight("Google");  
  16.   fly4 = factory.getFlyWeight("Google");  
  17.   fly5 = factory.getFlyWeight("Google");  
  18.   fly6 = factory.getFlyWeight("Google");  
  19.  }  
  20.  public void showFlyweight(){  
  21.   fly1.operation();  
  22.   fly2.operation();  
  23.   fly3.operation();  
  24.   fly4.operation();  
  25.   fly5.operation();  
  26.   fly6.operation();  
  27.   int objSize = factory.getFlyweightSize();  
  28.   System.out.println("objSize = " + objSize);  
  29.  }  
  30.  public static void main(String[] args){  
  31.   System.out.println("The FlyWeight Pattern!");  
  32.   FlyweightPattern fp = new FlyweightPattern();  
  33.   fp.showFlyweight();  
  34.  }  
  35. }  


下面是运行结果:

  1. Concrete---Flyweight : Google  
  2. Concrete---Flyweight : Qutr  
  3. Concrete---Flyweight : Google  
  4. Concrete---Flyweight : Google  
  5. Concrete---Flyweight : Google  
  6. Concrete---Flyweight : Google  
  7. objSize = 2  


 我们定义了6个对象,其中有5个是相同的,按照Flyweight模式的定义“Google”应该共享一个对象,在实际的对象数中我们可以看出实际的对象却是只有2个。

总结:
  Flyweight(享元)模式是如此的重要,因为它能帮你在一个复杂的系统中大量的节省内存空间。在JAVA语言中,String类型就是使用了享元模式。String对象是final类型,对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的,JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a="abc",其中"abc"就是一个字符串常量。

熟悉java的应该知道下面这个例子:

  1. String a = "hello";  
  2. String b = "hello";  
  3. if(a == b)  
  4.  System.out.println("OK");  
  5. else  
  6.  System.out.println("Error");  

输出结果是:OK。可以看出if条件比较的是两a和b的地址,也可以说是内存空间
核心总结,可以共享的对象,也就是说返回的同一类型的对象其实是同一实例,当客户端要求生成一个对象时,工厂会检测是否存在此对象的实例,如果存在那么直接返回此对象实例,如果不存在就创建一个并保存起来,这点有些单例模式的意思。通常工厂类会有一个集合类型的成员变量来用以保存对象,如hashtable,vector等。在java中,数据库连接池,线程池等即是用享元模式的应用。

分享到:
评论

相关推荐

    设计模式学习笔记--Flyweight享元模式.docx

    享元模式的核心是Flyweight类,它是需要被共享的对象,通常包含两个部分:内在状态(Intrinsic State)和外在状态(Extrinsic State)。内在状态是指对象内部不变的部分,可以在多个对象之间共享;外在状态是随环境...

    c++-设计模式之享元模式(Flyweight)

    享元模式(Flyweight Pattern)是一种结构型设计模式,用于减少创建大量小对象所带来的内存开销。通过共享对象,享元模式能够有效地支持大量细粒度的对象,减少内存使用并提高性能。它常用于需要大量重复对象的场景...

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

    享元模式是设计模式中的一种结构型模式,它主要通过共享已有对象来减少内存中对象的数量,从而提高系统性能。在C#编程中,享元模式尤其适用于那些创建大量相似对象且内存消耗较大的场景。本篇文章将深入探讨享元模式...

    学习php设计模式 php实现享元模式(flyweight)

    享元模式(Flyweight Pattern)是软件设计中的一种结构型设计模式,它通过共享技术来支持大量细粒度的对象,以此来降低内存中对象的数量。在PHP中实现享元模式,可以帮助我们优化程序性能,特别是在对象数目过多时,...

    享元模式flyweight

    享元模式(Flyweight Pattern)是一种结构型设计模式,它能有效地减少系统中对象的数量,从而降低内存消耗,提高性能。这种模式通过共享大量相似对象的内部状态来达到这一目标,而只保留对象的外部状态在外部管理。...

    设计模式专题之(十二)享元模式---设计模式享元模式示例代码(python--c++)

    C++实现中,享元模式可能使用虚基类来定义享元接口,如`class Flyweight`,然后通过继承创建具体享元类,例如`class ConcreteFlyweight : public Flyweight`。为了实现享元对象的共享,可以使用智能指针(如`std::...

    2 享元模式-课程内容.rar

    在享元模式中,通常有一个享元工厂(Flyweight Factory),它的职责是管理享元对象的共享,确保在需要时提供正确的享元实例。工厂会维护一个享元池,里面存储了已经创建的享元对象,当客户端请求时,工厂首先检查池...

    2 享元模式-MOOC课程内容.pdf

    享元模式(Flyweight Pattern)是一种结构型设计模式,旨在通过共享来高效地支持大量细粒度对象的使用,减少内存使用或计算时间。享元模式可以有效地支持大量对象的复用,使程序尽可能减少创建对象的次数,从而降低...

    10-Flyweight.rar

    在软件工程中,当系统中存在大量相似或重复的对象时,享元模式能够通过共享已有对象来达到减少内存消耗的目的。这种模式的核心是共享技术,它可以有效地支持大量细粒度对象的复用。 享元模式主要包含以下角色: 1. ...

    C++设计模式之享元模式(Flyweight)

    C++设计模式之享元模式(Flyweight) C++设计模式之享元模式(Flyweight)是一种结构型设计模式,主要用于解决大量相似对象的创建和操作所带来的内存负载问题。该模式的主要设计目标是通过共享对象来减少内存负载,...

    6.设计模式-享元模式1

    设计模式-享元模式 设计模式是软件设计中的一种解决方案,旨在提高代码的可维护性、灵活性和可重用性。享元模式(Flyweight Pattern)是结构型模式的一种,主要用于减少大量相似对象的内存占用,提高系统的性能和...

    设计模式的享元模式的例子

    享元模式是软件设计模式中的一种结构型模式,它的主要目的是通过共享大量细粒度对象来减少内存的使用,提高系统性能。在许多场景下,尤其是处理大量相似对象时,享元模式能显著减少内存开销。这个压缩包文件...

    设计模式之享元模式

    享元模式的核心概念是“享元对象”(Flyweight),它是一种可共享的对象,能被多个对象同时引用。享元模式分为两种主要实现方式:单纯享元模式和复合享元模式。 1. 单纯享元模式: 在单纯享元模式中,享元对象只...

    C#设计模式之Flyweight

    享元模式通常包含以下关键角色: 1. **享元接口(Flyweight Interface)**:定义了客户程序与享元对象交互的接口,规定了享元对象能提供的公共服务。 2. **具体享元类(Concrete Flyweight)**:实现了享元接口,...

    结构型模式之共享元模式(Flyweight)

    6共享元模式(Flyweight) 用意:以共享的方式高效地支持大量的细粒度对象

    26享元模式.zip

    享元模式的核心是享元对象(Flyweight),它是一个可以被共享的类,存储了对象状态的一部分,这部分状态是可以共享的。享元模式分为内部状态和外部状态,内部状态是对象内部不变的部分,可以共享;外部状态是随环境...

    C#面向对象设计模式纵横谈(12):Flyweight 享元模式(结构型模式) (Level 300)

    享元模式是面向对象设计中的一种结构型模式,它的主要目的是通过共享大量相似对象来减少内存的使用,提高系统的性能。在C#编程语言中,我们可以利用享元模式来优化那些具有大量实例但大部分状态可以共享的对象。在这...

    总结JavaScript设计模式编程中的享元模式使用

    享元模式是软件工程中一种用于优化性能的设计模式,它通过共享相似对象的实例来减少内存使用或者计算的开销。在JavaScript编程中,尤其是处理DOM操作和大量相似对象时,享元模式的使用尤为关键。 享元模式的主要...

    c++设计模式-结构型模式-享元模式

    c++设计模式-结构型模式-享元模式;qt工程;c++简单源码; 享元(Flyweight)模式的定义:运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类...

Global site tag (gtag.js) - Google Analytics