JAVA设计模式学习14——享元模式

享元（Flyweight）模式：通过共享技术以便有效的支持大量细粒度的对象。

享元模式在阎宏的《java与模式》中分为单纯享元模式和复合享元模式，复合模式的复合享元是不可以共享的，享元对象能做到共享的关键是区分内蕴态（Internal State）和外蕴态( External State)。这两个“蕴态”翻译的太难懂，我不是说翻译的不好，可能是我理解能力差，还是《Design Pattern Elements of Reusable Object-Oriented Software》的翻译版《设计模式可复用面向对象软件的基础》一书总翻译为内部对象和外部对象，相对直白，对概念性的东西文学气味太强了就觉得很别扭。这里的角色也采用《设计模式可复用面向对象软件的基础》的说法，不区分单纯模式和复合模式，而是有一个UnSharedConcreteFlyweight（在《java与模式》里称复合享元，指明复合享元不能共享），我们这里称它不可以共享享元角色，这样享元模式的角色有：

抽象享元（Flyweight）角色：是给实现享元提供的接口。

具体享元（ConcreteFlyweight）角色：实现抽象角色，此对象必须是共享的，所含的状态必须是内部状态。

不共享享元（UnSharedConcreteFlyweight）角色：此对象不可共享，不是所有实现抽象享元接口的的对象都要共享，此对象通常将ConcreteFlyweight作为组成元素。

享元工厂（FlyweightFactory）角色：负责创建和管理享元角色，确保合理共享。

客户端（Client）角色：维持一个Flyweight对象的引用，计算或存储一个（多个）外部存储状态。享元模式的类的机构图如下：

享元模式在java.lang.String设计上的使用，我们知道java中字符串始终保持共享一份，如下面代码片段：

String m = "a";

String n = "a";

System.out.println(m==n);

这样会输出true,说明m和n指向了同一个实例，内存中也只有一个"a"。这就是享元模式在String上的使用。

 

 

享元模式在文字编辑存贮过程中的使用，这里假定文章由行对象组成，行对象由若干个字符对象组成，但是如果每个字符都保存自己的对象，那么一篇文章成千上万个字符对象，这样严重消耗系统内存，造成不可接受的运行时开销，好的方法是利用享元模式，只保存ASCII字符编码值，作为内部不变的状态，对当个字符对象进行共享，而相对字符颜色、大小这样的格式化数据作为外部状态，由客户端维护，运行时由外部传入即可。每个行作为不可共享享元对象，它是由享元对象（字符对象）组合而成的。

 举例代码如下：

package flyWeight;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午4:52:41
 *描述：抽象享元
 */
public interface Glyph {

	public void draw(Context context);

}

 

package flyWeight;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午4:53:12
 *描述：具体享元
 */
public class Character implements Glyph {

	private char c;
	private int size;
	@Override
	public void draw(Context context) {
		// TODO Auto-generated method stub
		this.size = context.getSize();
		System.out.println(size+"号"+c+"被画出！");
	}
	public char getC() {
		return c;
	}
	public void setC(char c) {
		this.c = c;
	}
	public Character(char c) {
		super();
		this.c = c;
		System.out.println(c+"被创建！");
	}
}

 

package flyWeight;

import java.util.ArrayList;
import java.util.List;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午4:52:26
 *描述：行 不可共享享元
 */
public class Row implements Glyph {

	private List<Character> list = new ArrayList<>();
	
	@Override
	public void draw(Context context) {
		
	}

	public Row() {
	}

	public void setCharacter(Glyph r){
		list.add((Character) r);
	}

	public int getSize(){
		return list.size();
	}
	
	public String getRow(){
		StringBuilder sb = new StringBuilder();
		for(Character g:list){
			sb.append(g.getC());
		}
		return sb.toString();
	}

}

 

package flyWeight;

import java.util.HashMap;
import java.util.Map;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午4:52:08
 *描述：享元工厂
 */
public class GlyphFactory {

	private Map<String,Glyph> map = new HashMap<>();
	
	public Glyph getGlyph(Context context){
		String cStr = context.getC()+"";
        Glyph gl = map.get(cStr);
        if(gl == null){
        	 gl = new Character(context.getC());
             map.put(cStr, gl);
        }
        gl.draw(context);
		return gl;
	}

}

 

package flyWeight;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午3:34:57
 *描述：数据类
 */
public class Context {

	private int size;
	private char c;
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
	public char getC() {
		return c;
	}
	public void setC(char c) {
		this.c = c;
	}
	public Context(int size, char c) {
		super();
		this.size = size;
		this.c = c;
	}

}

 

package flyWeight;
/**
 * 
 *作者：alaric
 *时间：2013-7-27下午4:56:01
 *描述：客户端 为了简单 就直接写main方法里的
 */
public class Client {

	
	/**
	 *作者：alaric
	 *时间：2013-7-27下午4:20:08
	 *描述：测试
	 */
	public static void main(String[] args) {
		Row r =new Row();
		GlyphFactory factory = new GlyphFactory();
		Context context1= new Context(12, 'a');
		Glyph gly1 = factory.getGlyph(context1);
		r.setCharacter(gly1);
		
		Context context2= new Context(13, 'a');
		Glyph gly2 = factory.getGlyph(context2);
		r.setCharacter(gly2);
		
		Context context3= new Context(13, 'b');
		Glyph gly3 = factory.getGlyph(context3);
		r.setCharacter(gly3);
		
		System.out.println(r.getRow());
		
	}
}

 运行结果：

a被创建！

12号a被画出！

13号a被画出！

b被创建！

13号b被画出！

aab

 

可以看出a创建了一次 ，a的大小12 ，13是外部状态所以是外部传入，外部状态不能在享元内保存，而a字符是内部状态，行Row是有字符Character 组成，Row虽然实现了抽象享元接口，但是并没有再工厂中体现共享，因为他是不可共享的享元。

 

 

设计模式系列目录：

JAVA设计模式学习1——统一建模语言UML

JAVA设计模式学习2——面向对象设计原则

JAVA设计模式学习3——设计模式概述

JAVA设计模式学习4——简单工厂模式

JAVA设计模式学习5——工厂方法模式

JAVA设计模式学习6——抽象工厂模式

JAVA设计模式学习7——单例模式

JAVA设计模式学习8——建造模式

JAVA设计模式学习9——原型模式

JAVA设计模式学习10——组合模式

JAVA设计模式学习11——适配器模式

JAVA设计模式学习12——装饰器模式

JAVA设计模式学习13——代理模式

JAVA设计模式学习14——享元模式

JAVA设计模式学习15——门面模式

JAVA设计模式学习16——桥梁模式

JAVA设计模式学习17——策略模式

JAVA设计模式学习18——模版方法模式

JAVA设计模式学习19——观察者模式

JAVA设计模式学习20——责任链模式

JAVA设计模式学习21——命令模式

JAVA设计模式学习22——备忘录模式

JAVA设计模式学习23——状态模式

JAVA设计模式学习24——访问者模式

JAVA设计模式学习25——迭代器模式