需求:给不同的客户做网站
/**
* 网站类
*/
public class WebSite {
private String name = "";
public WebSite(String name) {
this.name = name;
}
public void use() {
System.out.println("网站分类:"+name);
}
}
客户端
public class Client {
public static void main(String[] args) {
WebSite webSite1 = new WebSite("产品展示");
webSite1.use();
WebSite webSite2 = new WebSite("产品展示");
webSite2.use();
WebSite webSite3 = new WebSite("产品展示");
webSite3.use();
WebSite webSite4 = new WebSite("博客");
webSite4.use();
WebSite webSite5 = new WebSite("博客");
webSite5.use();
WebSite webSite6 = new WebSite("博客");
webSite6.use();
}
}
享元模式
享元模式:运用共享技术有效地支持大量细粒度的对象。
Flyweight类
Flyweight类,它是所有具体享元类的超类或接口,通过这个接口,Flyweight可以接受并作用于外部状态。
public abstract class Flyweight {
public abstract void operation(int extrinsicstate);
}
ConcreteFlyweight类
ConcreteFlyweight类是继承Flyweight超类或实现Flyweight接口,并为内部状态增加存储空间。
public class ConcreteFlyweight extends Flyweight {
public void operation(int extrinsicstate) {
System.out.println("具体Flyweight:" + extrinsicstate);
}
}
UnsharedConcreteFlyweight
UnsharedConcreteFlyweight是指那些不需要共享的Flyweight子类,因为Flyweight接口共享成为可能,但它并不强制共享。
public class UnsharedConcreteFlyweight extends Flyweight {
public void operation(int extrinsicstate) {
System.out.println("不共享具体的Flyweight:" + extrinsicstate);
}
}
FlyweightFactory
FlyweightFactory是一个享元工厂,用来创建并管理Flyweight对象。它主要是用来确保合理地共享Flyweight,当用户请求一个Flyweight时,FlyweightFactory对象提供一个已创建的实例或者创建一个(如果不存在的话)。
public class FlyweightFactory {
private Map<String,Object> flyweights = new HashMap<String,Object>();
// 初始化工厂时,先生成3个实例
// 并不是一定需要事先生成对象实例,可以初始化时什么也不做,到需要时,再去判断对象是否为null来决定是否实例化
public FlyweightFactory() {
flyweights.put("X", new ConcreteFlyweight());
flyweights.put("Y", new ConcreteFlyweight());
flyweights.put("Z", new ConcreteFlyweight());
}
// 根据客户端请求,获得已生成的实例
public Flyweight getFlyweight(String key) {
return (Flyweight) flyweights.get(key);
}
}
客户端
public class Client {
public static void main(String[] args) {
int extrinsicstate = 22; // 代码外部状态
FlyweightFactory factory = new FlyweightFactory();
Flyweight fx = factory.getFlyweight("X");
fx.operation(--extrinsicstate);
Flyweight fy = factory.getFlyweight("Y");
fy.operation(--extrinsicstate);
Flyweight fz = factory.getFlyweight("Z");
fz.operation(--extrinsicstate);
Flyweight uf = new UnsharedConcreteFlyweight();
uf.operation(--extrinsicstate);
}
}
网站共享代码
网站抽象类
/**
* 网站抽象类
*/
public abstract class WebSite {
public abstract void use();
}
具体网站类
/**
* 具体网站类
*/
public class ConcreteWebSite extends WebSite {
private String name = "";
public ConcreteWebSite(String name) {
this.name = name;
}
@Override
public void use() {
System.out.println("网站分类:" + name);
}
}
网站工厂类
/**
* 网站工厂类
*/
public class WebSiteFactory {
private Map<String,Object> flyweights = new HashMap<String,Object>();
// 获得网站分类
public WebSite getWebSiteCategory(String key) {
// 判断是否存在这个对象,如果存在,则直接返回,若不存在,则实例化它再返回
if(!flyweights.containsKey(key)) {
flyweights.put(key, new ConcreteWebSite(key));
}
return (WebSite) flyweights.get(key);
}
// 获得网站分类总数
public int getWebSiteCount() {
return flyweights.size();
}
}
客户端
public class Client {
public static void main(String[] args) {
WebSiteFactory factory = new WebSiteFactory();
// 实例化“产品展示”的“网站”对象
WebSite fx = factory.getWebSiteCategory("产品展示");
fx.use();
// 共享上方生成的对象,不再实例化
WebSite fy = factory.getWebSiteCategory("产品展示");
fy.use();
WebSite fz = factory.getWebSiteCategory("产品展示");
fz.use();
WebSite fl = factory.getWebSiteCategory("博客");
fl.use();
WebSite fm = factory.getWebSiteCategory("博客");
fm.use();
WebSite fn = factory.getWebSiteCategory("博客");
fn.use();
// 统计实例化个数,结果应该为2
System.out.println("网站分类总数 " + factory.getWebSiteCount());
}
}
内部状态与外部状态
在享元对象内部并且不会随环境改变而改变的共享部分,可以称为是享元对象的内部状态,而随环境改变而改变的、不可以共享的状态就是外部状态了。
事实上,享元模式可以避免大量非常相似类的开销。在程序设计中,有时需要生成大量细粒度的类来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的,有时就能够受大幅度地减少需要实例化的类的数量。如果能把那些参数移到类实例的外面,在方法调用时将它们传递进来,就可以通过共享大幅度地减少单个实例的数目。
也就是说,享元模式Flyweight执行时所需的状态是有内部的也可能有外部的,内部状态存储于ConcreteFlyweight对象之中,而外部对象则应该考虑由客户端对象存储或计算,当调用Flyweight对象的操作时,将该状态传递给它。
用户类
用户类,用于网站的客户账号,是“网站”类的外部状态。
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
网站抽象类
public abstract class WebSite {
// "使用"方法需要传递“用户”对象
public abstract void use(User user);
}
具体网站类
public class ConcreteWebSite extends WebSite {
private String name = "";
public ConcreteWebSite(String name) {
this.name = name;
}
@Override
public void use(User user) {
System.out.println("网站分类:" + name + " 用户:"+user.getName());
}
}
网站工厂类
public class WebSiteFactory {
private Map<String,Object> flyweights = new HashMap<String,Object>();
// 获得网站分类
public WebSite getWebSiteCategory(String key) {
if(!flyweights.containsKey(key)) {
flyweights.put(key, new ConcreteWebSite(key));
}
return (WebSite) flyweights.get(key);
}
// 获得网站分类总数
public int getWebSiteCount() {
return flyweights.size();
}
}
客户端
public class Client {
public static void main(String[] args) {
WebSiteFactory factory = new WebSiteFactory();
WebSite fx = factory.getWebSiteCategory("产品展示");
fx.use(new User("张无忌"));
WebSite fy = factory.getWebSiteCategory("产品展示");
fy.use(new User("杨过"));
WebSite fz = factory.getWebSiteCategory("产品展示");
fz.use(new User("小龙女"));
WebSite fl = factory.getWebSiteCategory("博客");
fl.use(new User("黄药师"));
WebSite fm = factory.getWebSiteCategory("博客");
fm.use(new User("老顽童"));
WebSite fn = factory.getWebSiteCategory("博客");
fn.use(new User("段正淳"));
System.out.println("网站分类总数 " + factory.getWebSiteCount());
}
享元模式应用
如果一个应用程序使用了大量的对象,而大量的这些对象造成了很大的存储开销时就应该考虑使用;
还有就是对象的大多数状态可以是外部状态,如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象,此时可以考虑使用享元模式。
因为用了享元模式,所以有了共享对象,实例总数就大大减少了,如果共享的对象越多,存储节约也就越多,节约量随着共享状态的增多而增大。
String中就用了享元模式。
享元模式更多的时候是一种底层的设计模式。
围棋、五子棋中,颜色是棋子的内部状态,而方位坐标是棋子的外部状态。围棋361个空位放棋子,不是每盘棋都产生两三百个棋子对象,不然服务器很难支持更多的玩家玩围棋游戏了,因为内存有限。如果用享元模式,棋子对象可以减少到只有两个。
在某些情况下,对象的数量可能会太多,从而导致了运行时的资源与性能损耗。那么我们如何去避免大量细粒度的对象,同时又不影响客户程序,是一个值得去思考的问题,享元模式,可以运用共享技术有效地支持大量细粒度的对象。不过,使用享元模式需要维护一个记录了系统已有的所有享元的列表,而这本身需要耗费资源,另外享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。因此,应当在有足够多的对象实例可供共享时才值得使用享元模式。
注:本文内容源自程杰的《大话设计模式》