享元模式

问题的引入
不同网站具体数据和模板不同，核心代码和数据库是共享的。假如有如下需求:有多个客户想要使用同样的网站但要求不太一样，有的希望是博客形式的，有的希望是产品图片说明形式的。
简单代码实现如下:

//网站
class WebSite{
	private String name="";
	public WebSite(String name) {
		this.name=name;
	}
	public void Use() {
		System.out.println("网站分类："+name);
	}
}
public class Main
{
	public static void main(String[] args) {
		WebSite fx=new WebSite("产品展示");fx.Use();
		WebSite fy=new WebSite("产品展示");fy.Use();
		WebSite fz=new WebSite("产品展示");fz.Use();
		WebSite fl=new WebSite("博客");fl.Use();
		WebSite fm=new WebSite("博客");fm.Use();
		WebSite fn=new WebSite("博客");fn.Use();
	}
}

上面的写法如果要做三个产品展示，三个博客的网站，就需要六个网站类的实例，其实它们本质上都是一样的代码，如果网站增多，实例也就随着增多，这对服务器的资源浪费得很严重。
享元模式( Flyweight) :运用共享技术有效地支持大量细粒度的对象。

import java.util.HashMap;
abstract class Flyweight{
	public String intrinsic;
	protected final String extrinsic;
	public Flyweight(String extrinsic) {
		this.extrinsic=extrinsic;
	}
	public abstract void operate(int extrinsic);
	public String getIntrinsic() {
		return intrinsic;	
	}
	public void setIntrinsic(String intrinsic) {
		this.intrinsic=intrinsic;
	}
}
class ConcreteFlyweight extends Flyweight{
	public ConcreteFlyweight(String extrinsic) {
		super(extrinsic);
	}

	@Override
	public void operate(int extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("具体Flyweight："+extrinsic);
	}
	
}
class UnsharedConcreteFlyweight extends Flyweight{
	public UnsharedConcreteFlyweight(String extrinsic) {
		super(extrinsic);
	}
	@Override
	public void operate(int extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("不共享的具体Flyweight："+extrinsic);
	}
	
}
class FlyweightFactory{
	private static HashMap<String,Flyweight>pool=new HashMap<String,Flyweight>();
	public static Flyweight getFlyweight(String extrinsic) {
		Flyweight flyweight=null;
		if(pool.containsKey(extrinsic)) {
			flyweight=pool.get(extrinsic);
			System.out.print("已有"+extrinsic+"直接从池中取——>");
		}
		else {
			flyweight=new ConcreteFlyweight(extrinsic);
			pool.put(extrinsic, flyweight);
			System.out.print("创建"+extrinsic+"并从池中取出——>");
		}
		return flyweight;
	}
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int extrinsic=22;
		FlyweightFactory f=new FlyweightFactory();
		Flyweight flyweightX=f.getFlyweight("X");
		flyweightX.operate(--extrinsic);
		Flyweight flyweightY=f.getFlyweight("Y");
		flyweightY.operate(--extrinsic);
		Flyweight flyweightZ=f.getFlyweight("Z");
		flyweightZ.operate(--extrinsic);
		Flyweight flyweightReX=f.getFlyweight("X");
		flyweightReX.operate(--extrinsic);
		Flyweight unsharedFlyweight=new UnsharedConcreteFlyweight("X");
		unsharedFlyweight.operate(--extrinsic);
	}

}

输出结果：

创建X并从池中取出——>具体Flyweight：21
创建Y并从池中取出——>具体Flyweight：20
创建Z并从池中取出——>具体Flyweight：19
已有X直接从池中取——>具体Flyweight：18
不共享的具体Flyweight：17

第一次创建X、Y、Z时，都是先创建再从池中取出，而第二次创建X时，因为池中已经存在了，所以直接从池中取出，这就是享元模式。

import java.util.HashMap;
abstract class WebSite{
	public abstract void Use();
}
class ConcreteWebSite extends WebSite{
	private String name="";
	public ConcreteWebSite(String name) {
		this.name=name;
	}
	@Override
	public void Use() {
		// TODO Auto-generated method stub
		System.out.println("网站分类："+name);
	}	
}
class WebSiteFactory{
	private static HashMap<String,WebSite>flyweights=new HashMap<String,WebSite>();
	public WebSite GetWebSiteCategory(String key) {
		if(!flyweights.containsKey(key)) {
			WebSite flyweight=new ConcreteWebSite(key);
			flyweights.put(key,flyweight);		
		}	
		return (flyweights.get(key));
	}
	public int GetWebSiteCount() {
			return flyweights.size();
		}
}
public class Web {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WebSiteFactory f=new WebSiteFactory();
		WebSite fx=f.GetWebSiteCategory("产品展示");
		fx.Use();
		WebSite fy=f.GetWebSiteCategory("产品展示");
		fy.Use();
		WebSite fz=f.GetWebSiteCategory("产品展示");
		fz.Use();
		WebSite fl=f.GetWebSiteCategory("博客");
		fl.Use();
		WebSite fm=f.GetWebSiteCategory("博客");
		fm.Use();
		WebSite fn=f.GetWebSiteCategory("博客");
		fn.Use();
		System.out.println("网站分类总数为："+f.GetWebSiteCount());
	}

}

输出结果：

网站分类：产品展示
网站分类：产品展示
网站分类：产品展示
网站分类：博客
网站分类：博客
网站分类：博客
网站分类总数为：2

这样基本算是实现了享元模式的共享对象目的，体现了它们共享的部分:
不管建几个网站,

• 只要是‘产品展示’，都是一样的,
• 只要是“博客’，也是完全相同的

实际上这样写没有体现对象间的不同:
给企业建的网站不是一家企业，它们的数据不会相同,所以至少它们都应该有不同的账号。

import java.util.HashMap;

class User
{//外部状态，用户类
	private String name;
	User(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void setName(String name)
	{
		this.name=name;
	}
}
abstract class WebSite
{
	public abstract  void Use(User user);
	
}
class ConcreteWebSite extends WebSite
{
	private String name="";
	public ConcreteWebSite(String name)
	{
		this.name=name;
	}
	public void Use(User user)
	{
		System.out.println("网站分类:"+name+"用户:"+user.getName());
	}
}
class WebSiteFactory
{
	//定义一个池容器
	private static HashMap<String,WebSite> flyweights=new HashMap<String,WebSite>();
	//获得网站分类
	public WebSite GetWebSiteCategory(String key)
	{
		if(!flyweights.containsKey(key))
		{
			 WebSite flyweight=new ConcreteWebSite(key);
			 flyweights.put(key, flyweight);
		}
		return (flyweights.get(key));
		
	}
	public int GetWebSiteCount()//获得网站分类总数
	{
		return flyweights.size();
	}
}
public class Web
{
	public static void main(String[] args) {
		WebSiteFactory f=new WebSiteFactory();
		WebSite fx=f.GetWebSiteCategory("产品展示");fx.Use(new User("小菜"));
		WebSite fy=f.GetWebSiteCategory("产品展示");fy.Use(new User("大鸟"));
		WebSite fz=f.GetWebSiteCategory("产品展示");fz.Use(new User("娇娇"));
		WebSite fl=f.GetWebSiteCategory("博客");fl.Use(new User("老顽童"));
		WebSite fm=f.GetWebSiteCategory("博客");fm.Use(new User("桃谷六仙"));
		WebSite fn=f.GetWebSiteCategory("博客");fn.Use(new User("南海神鳄"));
	  System.out.println("网站分类总数为"+f.GetWebSiteCount());
	  }
}

输出结果：

网站分类:产品展示用户:小菜
网站分类:产品展示用户:大鸟
网站分类:产品展示用户:娇娇
网站分类:博客用户:老顽童
网站分类:博客用户:桃谷六仙
网站分类:博客用户:南海神鳄
网站分类总数为2

享元模式应当在什么情况下使用

• 一个系统有大量的对象。
• 这些对象耗费大量的内存。
• 这些对象的状态中的大部分都可以外部化。
• 这些对象可以按照内部状态分成很多的组，当把外部对象从对象中剔除时，每一个组都可以仅用一个对象代替。

满足以上的这些条件的系统可以使用享元对象。使用享元模式需要维护一个记录了系统已有的所有享元的表，而这需要耗费资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。

享元模式的优点和缺点
优点：

大幅度地降低内存中对象的数量，节省内存空间。

缺点:

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