23种设计模式(21)java享元模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述享元(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通过工厂分别两次创建出的对象是同一个对象。

享元模式的优缺点

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

享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。
享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • Java设计模式之共享模式/享元模式(Flyweight模式)介绍
  • 轻松掌握Java享元模式
  • 详解Java设计模式编程中的Flyweight享元模式的开发结构
  • Java设计模式之装饰者模式详解和代码实例
  • Java设计模式之工厂模式(Factory模式)介绍
  • Java设计模式之模板模式(Template模式)介绍
  • Java设计模式之状态模式(State模式)介绍
  • java设计模式之建造者模式学习
  • 实例解析观察者模式及其在Java设计模式开发中的运用
  • java设计模式之单例模式学习
  • Java设计模式之享元模式实例详解
(0)

相关推荐

  • Java设计模式之共享模式/享元模式(Flyweight模式)介绍

    Flyweight定义:避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类). 为什么使用共享模式/享元模式 面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被共享的类,另外,还有一些特性是取决于应用(context),是不可共享的,这也Flyweight中两个重要概念内

  • 实例解析观察者模式及其在Java设计模式开发中的运用

    一.观察者模式(Observer)的定义: 观察者模式又称为订阅-发布模式,在此模式中,一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知.这通常透过呼叫各观察者所提供的方法来实现.此种模式通常被用来事件处理系统. 1.观察者模式的一般结构 首先看下观察者模式的类图描述: 观察者模式的角色如下: Subject(抽象主题接口):定义了主题类中对观察者列表的一系列操作, 包括增加,删除, 通知等. Concrete Subject(具体主题类): Observer(抽象

  • 轻松掌握Java享元模式

    定义:它使用共享物件,用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件:它适合用于只是因重复而导致使用无法令人接受的大量内存的大量物件. 特点:大大减少对象的创建,降低系统的内存,使效率提高. 企业级开发及常用框架中的应用:数据库的连接池,String的常量缓存池 具体代码实例: import java.util.HashMap; import java.util.Map; import java.util.Random; public class Demo { public stati

  • Java设计模式之状态模式(State模式)介绍

    State的定义:不同的状态,不同的行为:或者说,每个状态有着相应的行为. 何时使用状态模式 State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else 进行状态切换, 如果针对状态的这样判断切换反复出现,我们就要联想到是否可以采取State模式了. 不只是根据状态,也有根据属性.如果某个对象的属性不同,对象的行为就不一样,这点在数据库系统中出现频率比较高,我们经常会在一个数据表的尾部,加上property属性含义的字段,用以标识记录中一些特殊

  • Java设计模式之工厂模式(Factory模式)介绍

    工厂模式定义:提供创建对象的接口. 为何使用工厂模式 工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑实用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量. 我们以类Sample为例,

  • java设计模式之单例模式学习

    1 概述 单例模式有几个好处: (1)某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销. (2)省去了new操作符,降低了系统内存的使用频率,减轻GC压力. (3)有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了. 2 详解 单例模式常用的写法有如下这么两种. 2.1 饿汉式 如果应用程序总是创建并使用单例模式,或者在创建和运行时压力不是很大的情况下,可以使用一个私有静态变量,提前把对象创建好. 复制代码 代码如下: package org.sc

  • 详解Java设计模式编程中的Flyweight享元模式的开发结构

    享元(Flyweight)模式:通过共享技术以便有效的支持大量细粒度的对象. 享元模式在阎宏的<java与模式>中分为单纯享元模式和复合享元模式,复合模式的复合享元是不可以共享的,享元对象能做到共享的关键是区分内蕴态(Internal State)和外蕴态( External State).这两个"蕴态"翻译的太难懂,我不是说翻译的不好,可能是我理解能力差,还是<Design Pattern Elements of Reusable Object-Oriented S

  • Java设计模式之模板模式(Template模式)介绍

    Template模式定义:定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中. 其实Java的抽象类本来就是Template模式,因此使用很普遍.而且很容易理解和使用,我们直接以示例开始: 复制代码 代码如下: public abstract class Benchmark { /** * 下面操作是我们希望在子类中完成 */ public abstract void benchmark(); /** * 重复执行benchmark次数 */ public final long repea

  • Java设计模式之装饰者模式详解和代码实例

    装饰者模式可以给已经存在的对象动态的添加能力.下面,我将会用一个简单的例子来演示一下如何在程序当中使用装饰者模式. 1.装饰者模式 让我们来假设一下,你正在寻找一个女朋友.有很多来自不同国家的女孩,比如:美国,中国,日本,法国等等,他们每个人都有不一样的个性和兴趣爱好,如果需要在程序当中模拟这么一种情况的话,假设每一个女孩就是一个Java类的话,那么就会有成千上万的类,这样子就会造成类的膨胀,而且这样的设计的可扩展性会比较差.因为如果我们需要一个新的女孩,就需要创建一个新的Java类,这实际上也

  • Java设计模式之享元模式实例详解

    本文实例讲述了Java设计模式之享元模式.分享给大家供大家参考,具体如下: 解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象.比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象.如果有一个1M的文本,那么字母是何其的多,如果每个字母都定义一个对象那么内存早就爆了.那么如果要是每个字母都共享一个对象,那么就大大节约了资源. 在Flyweight模式中,由于要产生各种各样的对象,所以在Flyweigh

  • java设计模式之建造者模式学习

    1 概述建造者模式(Builder Pattern)主要用于"分步骤构建一个复杂的对象",在这其中"分步骤"是一个稳定的算法,而复杂对象的各个部分则经常变化.因此, 建造者模式主要用来解决"对象部分"的需求变化. 这样可以对对象构造的过程进行更加精细的控制. 2 示例以生产手机为例,每个手机分为屏幕Screen.CPU.Battery.现在要生产两种手机,苹果机和三星. 苹果: 复制代码 代码如下: package org.scott.build

随机推荐