文档章节

java23中设计模式——结构模式——Flyweight(享元)

邓竣
 邓竣
发布于 2016/03/19 11:33
字数 3942
阅读 5
收藏 0

面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得

很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,

无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封

装可以被共享的类,另外,还有一些特性是取决于应用(context),是不可共享的,这也

Flyweight 中两个重要概念内部状态 intrinsic 和外部状态 extrinsic 之分。

说白点,就是先捏一个的原始模型,然后随着不同场合和环境,再产生各具特征的具体

模型,很显然,在这里需要产生不同的新对象,所以 Flyweight 模式中常出现 Factory 模

式.Flyweight 的内部状态是用来共享的,Flyweight factory 负责维护一个

Flyweight pool(模式池)来存放内部状态的对象.

Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应

用场合很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,

那么我们可以将这些字符串储存在Flyweight池(pool)中.

flyweight0

享元模式(Flyweight):运用共享的技术有效地支持大量细粒度的对象。

       抽象享元角色(Flyweight):此角色是所有的具体享元类的超类,为这些类规定出需要实现的公共接口或抽象类。那些需要外部状态(External State)的操作可以通过方法的参数传入。抽象享元的接口使得享元变得可能,但是并不强制子类实行共享,因此并非所有的享元对象都是可以共享的。

       具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定的接口。如果有内部状态的话,必须负责为内部状态提供存储空间。享元对象的内部状态必须与对象所处的周围环境无关,从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享元角色,因为复合享元角色是由单纯具体享元角色通过复合而成的

       复合享元(UnsharableFlyweight)角色:复合享元角色所代表的对象是不可以共享的,但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称做不可共享的享元对象。这个角色一般很少使用。

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

       客户端(Client)角色:本角色还需要自行存储所有享元对象的外部状态。

       内部状态与外部状态:在享元对象内部并且不会随着环境改变而改变的共享部分,可以称之为享元对象的内部状态,反之随着环境改变而改变的,不可共享的状态称之为外部状态。

       现在让我们通过一个面向对象的文本编辑器设计来说明享元模式的应用。假设我们要设计一个文本编辑器,而且它必须创建字符对象来表示文档中的每个字符,现在让我们考虑字符对象保持什么信息呢?如:字体、字体大小和位置等等信息。

       一个文档通常包含许多字符对象,它们需要大容量的内存。值得我们注意的是一般字符都是由数字、字母和其他字符组成的(它们是固定的,可知的),这些字符对象可以共享字体和字体大小等信息,现在它们专有属性只剩下位置了,每个字符对象只需保持它们在文档中的位置就OK了,通过分析我们已经降低了编辑器的内存需求。

 

 

flyweight1 flyweight2

图2 享元模式(Flyweight)共享对象

 

/// <summary>
/// The 'Flyweight' class./// </summary>public class Character{    // intrinsic state    protected char _symbol;    protected int _size;    protected string _font;    // extrinsic state    protected Position _position;    public void Display(Position position)
    {        Console.WriteLine(            String.Format("Symbol: {0} Size: {1} Font: {2} Position: {3} {4}",
            _symbol, _size, _font, position._x, position._y));
    }

}

 

       现在我们定义了一个字符享元类,其中符合、字体和字体大小都是内部状态,而位置则是外部状态。

 

/// <summary>
/// A 'ConcreteFlyweight' class/// </summary>public class CharacterA : Character{    public CharacterA()
    {
        _symbol = 'A';
        _size = 10;
        _font = "宋体";        //_position = new Position(0, 1);    }
}

       接着我们定义具体字符A的享元类,并且对内部状态符号、字体和字体大小进行初始化,而且其他字符B到Z享元类都类似。

 

flyweight3 

图3具体享元模式(ConcreteFlyweight)设计

 

 

/// <summary>
/// The 'FlyweightFactory' class/// </summary>public class CharacterFactory{    // Keeps the character object by specifying key/value.    private Dictionary<char, Character> _characters =        new Dictionary<char, Character>();    public Character this[char key]
    {        get        {            Character character = null;            // Checked the character whether existed or not,
            // if the character existed, then directly returns,
            // otherwise, instantiates a character object.            if (_characters.ContainsKey(key))
            {
                character = _characters[key];
            }            else            {                string name = this.GetType().Namespace + "." +                              "Character" + key.ToString();
                    character = Activator.CreateInstance(                        Type.GetType(name)) as Character;
                _characters.Add(key, character);
            }            return character;
        }
    }
}

 

       现在我们定义了一间字符工厂,通过一个Dictionary<Tkey, Tvalue>来保存字符对象,使用字符值来查找字符对象是否已经创建了,如果查找的字符对象已经存在,那么直接返回该对象,反之就创建字符对象实例。

 

/// <summary>
/// The client./// </summary>
/// <param name="args">The args.</param>[STAThread]static void Main(string[] args)
{    Application.EnableVisualStyles();    Application.SetCompatibleTextRenderingDefault(false);    Application.Run(new FrmFlyweight());    string text = "ABZABBZZ";    char[] letters = text.ToCharArray();    var characterFactory = new CharacterFactory();    // Creates random position ranges 0 to 100.    var rd = new Random();    foreach (char c in letters)
    {        Character character = characterFactory[c];        var p = new Position(rd.Next(0, 100), rd.Next(0, 100));
        character.Display(p);
    }    Console.ReadKey();
}

 

flyweight4

图4享元模式(ConcreteFlyweight)测试结果

 

       接着让我们实现一个享元模式的绘图程序,假设我们的程序要画各种各样的圆,而且圆的属性有形状,位置和颜色,其中形状和颜色是内部状态,而位置是外部状态。

设计分析:

1.提供一个抽象类Shape,让具体的形状如:Circle继承于它

2.定义一个位置结构图记录每个图形的位置

3.设计一间享元图形工厂用来创建图形对象

       以上就是我们的享元模式的绘图程序的设计,接下来让我们实现享元模式的绘图程序吧!

 

/// <summary>
/// Shape can be inherited by Circle, Retangle or triangle and so forth./// Includes a color property and Draw methods./// </summary>public abstract class Shape{    public Color Color { get; set; }    public abstract void Draw(Graphics graphics, Position position);
}

       上述示意代码定义了一个抽象类Shape,我们的具体图形都必须继承于该类。

 

/// <summary>
/// Circle implements Shape./// </summary>public class Circle : Shape{    public Circle(Color color)
    {
        Color = color;
    }    /// <summary>
    /// Draws circle with the specified graphics and position.    /// </summary>
    /// <param name="graphics">The graphics.</param>
    /// <param name="position">The position of circle.</param>    public override void Draw(Graphics graphics, Position position)
    {        var pen = new Pen(Color);
        graphics.DrawEllipse(pen, position.X - position.R,
            position.Y - position.R,
            position.R, position.R);
    }
}

      接着我们定义具体图形类Circle,它实现Draw()方法通过Graphics调用DrawEllipse()方法来实现画圆。

 

/// <summary>
/// Generate the position of concrete shape./// </summary>public struct Position{    private int _x;    private int _y;    private int _r;    public Position GetPosition(Form form)
    {        var rd = new Random();
        _x = rd.Next(0, form.Width);
        _y = rd.Next(0, form.Height);        float r = _x < _y ? _x : _y;
        _r = rd.Next(0, (int)r);        return this;
    }    public Position(Graphics graphics, int x, int y, int r)
    {        if (x > graphics.DpiX)            throw new ArgumentOutOfRangeException("x");        if (y > graphics.DpiY)            throw new ArgumentOutOfRangeException("y");        if (r > graphics.DpiY && r > graphics.DpiX)            throw new ArgumentOutOfRangeException("r");

        _x = x;
        _y = y;
        _r = r;
    }    public int X
    {        get { return _x; }
    }    public int Y
    {        get { return _y; }
    }    public int R
    {        get { return _r; }
    }
}

       接着我们定义享元工厂负责创建图形对象,如果图形对象不存在就创建该对象,反正直接返回该图形对象。

 

/// <summary>
/// The flyweight factory/// Generates the instance of shape if object not exists,/// otherwish returns the object directly./// </summary>public class ShapeFactory{    // Saves the shape object in Dictionary<Color, Shape>    private static readonly Dictionary<Color, Shape> Shapes =        new Dictionary<Color, Shape>();    // Gets the object in Dictionray.    public Shape this[Color key]
    {        get        {            Shape shape = null;            // if the object exists return directly.
            // otherwish generates anew one.            if (Shapes.ContainsKey(key))
            {
                shape = Shapes[key];
            }            else            {
                shape = new Circle(key);
                Shapes.Add(key, shape);
            }            return shape;
        }
    }
}

        现在我们已经完成了享元图形类,由于图形的外部状态包括位置和颜色,前面我们通过随机函数生成随机位置,我们要设计一个拾色板来提供用户选择自定义颜色。

 

flyweight5

 图5拾色板设计

 

       由于时间的关系我们已经把拾色板的界面设置,接下来让我们实现拾色板的具体功能。

       首先我们新建一个用户自定义控件命名为ColorPanel,接着我们要处理用户点击选择颜色的事件

 

// Sets the default color.private Color _color = Color.Black;public delegate void ColorChangedHandler(object sender, ColorChangedEventArgs e);public event ColorChangedHandler ColorChanged;/// <summary>
/// Raises the <see cref="E:ColorChanged"/> event./// </summary>
/// <param name="e">The color changed event arguments.</param>protected virtual void OnColorChanged(ColorChangedEventArgs e)
{    if (null != ColorChanged)
        ColorChanged(this, e);
}

       上述示意代码定义了一个委托ColorChangedHandler,当颜色值发现改变时相应具体处理方法和一个事件ColorChangedHandler,其实事件是对委托的封装,犹如字段和属性的关系,具体委托和事件的介绍请参看这里这里

 

flyweight6

图6自定义事件

 

       我们先介绍一下EventArgs这个的类型。其实这个类并没有太多的功能,它主要是作为一个基类让其他类去实现具体的功能和定义,当我们自定义事件参数时都必须继承于该类。

       现在回到我们自定义事件参数ColorChangedEventArgs,其中包含初始化颜色值的方法和获取颜色值的属性。

 

 

/// <summary>
/// The color changed event arguments./// </summary>public class ColorChangedEventArgs : EventArgs{    private readonly Color _color;    /// <summary>
    /// Initializes a new instance of the <see cref="ColorChangedEventArgs"/> class.    /// </summary>
    /// <param name="color">The color.</param>    public ColorChangedEventArgs(Color color)
    {
        _color = color;
    }    /// <summary>
    /// Gets the color.    /// </summary>    public Color Color
    {        get { return _color; }
    }
}

 

       现在我们终于完成了拾色板的基本功能了,接着只需把拾色板控件添加到我们的应用程序中就OK了。

 

 flyweight7

图6享元模式绘图程序界面

 

       由于时间的关系我们已经把程序的界面设计好了,接下来让我们实现一系列的事件处理方法。

 

/// <summary>
/// Handles the Click event of the btnDrawCircle control./// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
///  instance containing the event data.</param>private void btnDrawCircle_Click(object sender, EventArgs e)
{    Graphics graphics = Graphics.FromImage(_drawArea);    
    // Gets shape object with specified color in flyweight object.    Shape shape = _factory[colorPanel1.Color];
    shape.Draw(graphics, _position.GetPosition(this));    this.Invalidate();
}/// <summary>
/// Handles the Click event of the btnClear control./// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> 
/// instance containing the event data.</param>private void btnClear_Click(object sender, EventArgs e)
{    Graphics graphics = Graphics.FromImage(_drawArea);
    graphics.Clear(Color.SkyBlue);
    graphics.Dispose();    this.Invalidate();
}

 

       上面我们定义了处理绘图点击方法和清除图形的方法,当用户选择颜色值时,我们的程序到享元工厂中获取该对象实例,这个对象可能是新建的,也可能是已经存在的。

 

flyweight8

图7绘图程序效果

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

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  1. package Flyweight;  

  2. public abstract class Flyweight{  

  3.  public abstract void operation();  

  4. }  

实现一个具体类:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  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. }  

实现一个工厂方法类:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  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的调用:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  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. }  


下面是运行结果:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  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的应该知道下面这个例子:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

  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中,数据库连接池,线程池等即是用享元模式的应用。


本文转载自:

共有 人打赏支持
邓竣
粉丝 2
博文 30
码字总数 43557
作品 0
成都
程序员
私信 提问
《JavaScript设计模式与开发实践》最全知识点汇总大全

系列文章: 《JavaScript设计模式与开发实践》基础篇(1)—— this、call 和 apply 《JavaScript设计模式与开发实践》基础篇(2)—— 闭包和高阶函数 《JavaScript设计模式与开发实践》模式...

嗨呀豆豆呢
01/04
0
0
《PHP设计模式大全》系列分享专栏

《PHP设计模式大全》已整理成PDF文档,点击可直接下载至本地查阅 https://www.webfalse.com/read/201739.html 文章 php设计模式介绍之编程惯用法第1/3页 php设计模式介绍之值对象模式第1/5页...

kaixin_code
2018/11/06
0
0
《JavaScript设计模式与开发实践》原则篇(2)—— 最少知识原则

最少知识原则(LKP)说的是一个软件实体应当尽可能少地与其他实体发生相互作用。这 里的软件实体是一个广义的概念,不仅包括对象,还包括系统、类、模块、函数、变量等。 单一职责原则指导我们...

嗨呀豆豆呢
2018/12/30
0
0
EasyToLearnDesignPattern

简单上手设计模式 GITHUB:https://github.com/Fisher-Joe/EasyToLearnDesignPattern 本文旨在使用最简单的语言,最简单的代码让人学习设计模式(最起码是我) 说明: 本文的所有内容都是基于...

芝麻开门
今天
0
0
《JavaScript设计模式与开发实践》模式篇(12)—— 装饰者模式

在传统的面向对象语言中,给对象添加功能常常使用继承的方式,但是继承的方式并不灵活, 还会带来许多问题:一方面会导致超类和子类之间存在强耦合性,当超类改变时,子类也会随之 改变;另一方...

嗨呀豆豆呢
2018/12/25
0
0

没有更多内容

加载失败,请刷新页面

加载更多

js算法总结

数列求和 等差数列求和 function sum(a0,d,n){//a0->首项,d->公差,n->项数//(首项+末项)*项数/2return (a1+(a1+d*n))*n/2;} 等比数列求和 function sum(a0,q,n){//a0->首项,q->公......

祖达
37分钟前
1
0
小白?转型?毕业生?外行学习快速入行大数据开发指南

这篇文章中,本文将针对三种不同的、想要进入数据科学领域的人群,给出自己的经验,帮助他们迅速有效入行。 虽然没有适合每个人的万能解决方案,但这三类建议值得想转行的你一看。 第1类:新...

董黎明
44分钟前
1
0
好文 | MySQL 索引B+树原理,以及建索引的几大原则

MySQL事实上使用不同的存储引擎也是有很大区别的,下面猿友们可以了解一下。 一、存储引擎的比较 注:上面提到的B树索引并没有指出是B-Tree和B+Tree索引,但是B-树和B+树的定义是有区别的。 ...

Java爬坑之路
47分钟前
1
0
mysql group by 和 Order By 执行顺序

1.在写统计的时候,我们会用到统计首单,这样里面设计到排序。写子查询的方式当然可以实现, 但是我们有时候,需要创建视图,视图不支持带子查询的。 加了排序后会返回,排序后的哪个第一条数...

kuchawyz
52分钟前
2
0
Spring Boot 2.X 如何添加拦截器?

最近使用SpringBoot2.X搭建了一个项目,大部分接口都需要做登录校验,所以打算使用注解+拦截器来实现,在此记录下实现过程。 一、实现原理 1. 自定义一个注解@NeedLogin,如果接口需要进行登...

花漾年华
今天
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部