设计模式----享元模式（JAVA）

享元模式

/**
 * 
 */
/**
 * 享元模式：运用共享技术有效地支持大量细粒度的对象
 * 使用场景
 * 1、系统有大量相似对象。 2、需要缓冲池的场景。 
 * 解决的问题
 * 在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
 * 关键点：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。
* 优点：
 * 大大减少对象的创建，降低系统的内存，使效率提高。
 * 缺点：
 * 提高了系统的复杂度，需要分离出外部状态和内部状态，
 * 而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。
 * 
 * 注意
 *  1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。 
 *  2、这些类必须有一个工厂对象加以控制。
 * 
 * 
 * @author 
 *
 */

import java.util.HashMap;
import java.util.Map;

public class Demo {
	public static void main(String[] args) {
		String extrinsic1="享元1";
		String extrinsic2="享元2";
		String unshare = "不共享";
		Flyweight fy1 = FectoryFlyweight.GetFlyweight(extrinsic1);
		fy1.Operation(extrinsic1);
		Flyweight fy2 = FectoryFlyweight.GetFlyweight(extrinsic2);
		fy2.Operation(extrinsic2);
		Flyweight fy3 =new UnshareFlyweight();
		fy3.Operation(unshare);
	}
}
interface Flyweight {
	void Operation(String extrinsic );
}
class ConcreteFlyweight implements Flyweight{

	@Override
	public void Operation(String extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("具体Flyweight:"+extrinsic);
	}
	
}
class UnshareFlyweight implements Flyweight{

	@Override
	public void Operation(String extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("不共享的具体Flyweight:"+extrinsic);
	}
	
}
class FectoryFlyweight{
	private static Map<String,Flyweight> Flyweights = new HashMap<String,Flyweight>();
	
	public static Flyweight GetFlyweight(String extrinsic) {
		Flyweight flyweight = null;
		if(Flyweights.containsKey(extrinsic)) {
			flyweight = Flyweights.get(extrinsic);
		}else {
			flyweight = new ConcreteFlyweight();
			Flyweights.put(extrinsic, flyweight);
		}
		return flyweight;
	}
}

具体应用—网站共享问题

不同网站具体数据和模板不同，核心代码和数据库是共享的

/*
 * 一般写法
 * 
 */
public class Demo2 {
	public static void main(String[] args) {
		WebSite web1= new WebSite("产品展示");
		web1.Use();
		WebSite web2= new WebSite("产品展示");
		web2.Use();
		WebSite web3= new WebSite("产品展示");
		web3.Use();
		WebSite web4= new WebSite("博客");
		web4.Use();
		WebSite web5= new WebSite("博客");
		web5.Use();
		WebSite web6= new WebSite("博客");
		web6.Use();
	}
}
class WebSite
{
	private String name="";
	public WebSite(String name)
	{
		this.name=name;
	}
	public void Use()
	{
		System.out.println("网站分类："+name);
	}
}
/*
 *问题：
 *虽然有多个网站，但他们本质上是一样的代码，随着网站的增多，实例也会增多
 *对服务器资源浪费很严重。 
 * 
 */

/*
 * 享元模式
 */
import java.util.HashMap;
import java.util.Map;

public class Demo3 {
	public static void main(String[] args) {
		String e1="猫";
		String e2="狗";
		String e3="老鼠";
		FlyweightWeb f1 =FectoryWeb.GetWeb(e1);
		f1.Use(e1);
		FlyweightWeb f2 =FectoryWeb.GetWeb(e2);
		f2.Use(e2);
		FlyweightWeb f3 =FectoryWeb.GetWeb(e3);
		f3.Use(e3);
		
	}
}
 
interface FlyweightWeb{
	void Use(String extrinsic);
}

class ConcreteWeb implements FlyweightWeb{

	@Override
	public void Use(String extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("网站分类："+extrinsic);
	}
}
class UnshareWeb implements FlyweightWeb{

	@Override
	public void Use(String extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("网站分类："+extrinsic);
	}
	
}
class FectoryWeb{
	private static Map<String ,FlyweightWeb> webs = new HashMap<String,FlyweightWeb>();
	public static FlyweightWeb GetWeb(String extrinsci) {
		FlyweightWeb fw = null;
		if(webs.containsKey(extrinsci)) {
			fw = webs.get(extrinsci);
		}else {
			fw = new ConcreteWeb();
			webs.put(extrinsci, fw);
		}
		return fw;
	}
}