享元模式是一种设计模式，通过共享技术减少相似对象的内存消耗。它区分内部和外部状态，内部状态是可共享的，外部状态是不可共享的。在具体实现中，享元工厂负责对象的创建和管理，确保重复的对象只创建一次。案例如俄罗斯方块游戏，通过享元模式，可以有效管理不同形状的方块对象，降低内存开销。享元模式在需要大量相似对象的场景下能显著提高系统性能，但也会增加程序的复杂性。
享元模式
1 定义
运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。
2 模式的结构
享元（Flyweight ）模式中存在以下两种状态：
1.内部状态，即不会随着环境的改变而改变的可共享部分。
2.外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。
具体结构
抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。
3 实现
public class FlyweightPattern {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight f01 = factory.getFlyweight("a");
Flyweight f02 = factory.getFlyweight("a");
Flyweight f03 = factory.getFlyweight("a");
Flyweight f11 = factory.getFlyweight("b");
Flyweight f12 = factory.getFlyweight("b");
f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
int count = factory.getCount();
System.out.println("count:" + count);
}
}
//非享元角色
class UnsharedConcreteFlyweight {
private String info;
UnsharedConcreteFlyweight(String info) {
this.info = info;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
//抽象享元角色
interface Flyweight {
public void operation(UnsharedConcreteFlyweight state);
}
//具体享元角色
class ConcreteFlyweight implements Flyweight {
private String key;
ConcreteFlyweight(String key) {
this.key = key;
System.out.println("具体享元" + key + "被创建！");
}
public void operation(UnsharedConcreteFlyweight outState) {
System.out.print("具体享元" + key + "被调用，");
System.out.println("非享元信息是:" + outState.getInfo());
}
}
//享元工厂角色
class FlyweightFactory {
private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
public Flyweight getFlyweight(String key) {
Flyweight flyweight = (Flyweight) flyweights.get(key);
if (flyweight != null) {
System.out.println("具体享元" + key + "已经存在，被成功获取！");
} else {
flyweight = new ConcreteFlyweight(key);
flyweights.put(key, flyweight);
}
return flyweight;
}
public int getCount(){
return flyweights.size();
}
}
// 结果
具体享元a被创建！
具体享元a已经存在，被成功获取！
具体享元a已经存在，被成功获取！
具体享元b被创建！
具体享元b已经存在，被成功获取！
具体享元a被调用，非享元信息是:第1次调用a。
具体享元a被调用，非享元信息是:第2次调用a。
具体享元a被调用，非享元信息是:第3次调用a。
具体享元b被调用，非享元信息是:第1次调用b。
具体享元b被调用，非享元信息是:第2次调用b。
count:2
4 案例
4.1 俄罗斯方块
下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。
俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。
public abstract class AbstractBox {
public abstract String getShape();
public void display(String color) {
System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
}
}
接下来就是定义不同的形状了，IBox类、LBox类、OBox类等。
public class IBox extends AbstractBox {
@Override
public String getShape() {
return "I";
}
}
public class LBox extends AbstractBox {
@Override
public String getShape() {
return "L";
}
}
public class OBox extends AbstractBox {
@Override
public String getShape() {
return "O";
}
}
提供了一个工厂类（BoxFactory），用来管理享元对象（也就是AbstractBox子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取形状的方法。
public class BoxFactory {
private static HashMap<String, AbstractBox> map;
private BoxFactory() {
map = new HashMap<String, AbstractBox>();
AbstractBox iBox = new IBox();
AbstractBox lBox = new LBox();
AbstractBox oBox = new OBox();
map.put("I", iBox);
map.put("L", lBox);
map.put("O", oBox);
}
public static final BoxFactory getInstance() {
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder {
private static final BoxFactory INSTANCE = new BoxFactory();
}
public AbstractBox getBox(String key) {
return map.get(key);
}
}
客户端
public class Client {
public static void main(String[] args) {
//获取I图形对象
AbstractBox box1 = BoxFactory.getInstance().getShape("I");
box1.display("灰色");
//获取L图形对象
AbstractBox box2 = BoxFactory.getInstance().getShape("L");
box2.display("绿色");
//获取O图形对象
AbstractBox box3 = BoxFactory.getInstance().getShape("O");
box3.display("灰色");
//获取O图形对象
AbstractBox box4 = BoxFactory.getInstance().getShape("O");
box4.display("红色");
System.out.println("两次获取到的O图形对象是否是同一个对象：" + (box3 == box4));
}
}
4.2 火车票查询
假设一张火车票包含出发站、目的站、价格、座位。现在要求输入出发站和目的站查到相关票的信息
public class TicketTest {
public static void main(String[] args) {
ITicket iTicket1 = TicketFactory.quertTicket("杭州", "无锡");
iTicket1.showInfo("硬座");
ITicket iTicket2 = TicketFactory.quertTicket("杭州", "无锡");
iTicket2.showInfo("软卧");
}
}
interface ITicket{
void showInfo(String bunk);
}
class TrainTicket implements ITicket{
private String from;
private String to;
private int price;
public TrainTicket(String from, String to) {
this.from = from;
this.to = to;
}
public void showInfo(String bunk){
this.price = new Random().nextInt(500);
System.out.println(String.format("%s->%s: %s 价格： %s 元", this.from, this.to, bunk, this.price));
}
}
class TicketFactory{
private static Map<String, ITicket> sTicketPool = new ConcurrentHashMap<String, ITicket>();
public static ITicket quertTicket(String from, String to) {
String key = from + "->" + to;
if(TicketFactory.sTicketPool.containsKey(key)){
System.out.println("使用缓存：" + key);
return TicketFactory.sTicketPool.get(key);
}
System.out.println("首次查询，创建对象：" + key);
ITicket trainTicket = new TrainTicket(from, to);
TicketFactory.sTicketPool.put(key, trainTicket);
return trainTicket;
}
}
// 结果
首次查询，创建对象：杭州->无锡
杭州->无锡: 硬座 价格： 327 元
使用缓存：杭州->无锡
杭州->无锡: 软卧 价格： 113 元
5 优缺点和使用场景
5.1 优点
- 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
- 享元模式中的外部状态相对独立，且不影响内部状态
5.2 缺点
- 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
- 读取享元模式的外部状态会使得运行时间稍微变长。
5.3 使用场景
- 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
- 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
- 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。
扫一扫
232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
