对象拥有状态(属性)和行为(方法),我们将具有相同行为的对象抽象为类(Class),
类可以被看作只保留行为的对象模板,类可以在运行时被重新赋予状态数据从而形成了对象。
在运行时,对象占用一定的内存空间用来存储状态数据。如果不作特殊的处理,
尽管是由同一个类生成的两个对象,而且这两个对象的的状态数据完 全相同,
但在内存中还是会占用两份空间,这样的情况对于程序的功能也许并没有影响,
但如果把状态相同的同一类对象在内存中进行合并,必然会大大减少存储空 间的浪费。
举一个现实中的例子,某淘宝店经营一款畅销女式皮鞋,每天需要处理大量的订单信息,
在订单中需要注明客户购买的皮鞋信息,我们将皮鞋产品抽象出来:
- class Shoe{
- String color;//颜色
- int size;//尺寸
- String position;//库存位置
- public String getColor() {
- return color;
- }
- public void setColor(String color) {
- this.color = color;
- }
- public int getSize() {
- return size;
- }
- public void setSize(int size) {
- this.size = size;
- }
- public String getPosition() {
- return position;
- }
- public void setPosition(String position) {
- this.position = position;
- }
- }
正如上面的代码所描述,皮鞋分为颜色、尺寸和库存位置三项状态数据。
其中颜色和尺寸为皮鞋的自然状态,我们称之为对象内部状态,这些状态数据只与对象本身 有关,
不随外界环境的改变而发生变化。再来看库存位置,我们将这个状态称为对象的外部状态,
外部状态与对象本身无必然关系,外部状态总是因为外界环境的改 变而变化,
也就是说外部状态是由外界环境来决定的。在本例中,皮鞋今天放在A仓库,明天可能放在B仓库,
但无论存放在哪个仓库,同一只皮鞋就是同一只皮 鞋,它的颜色和尺寸不会随着存放位置的不同而发生变化。
享元模式的核心思想就是将内部状态相同的对象在存储时进行缓存。也就是说同一颜色同一尺寸的皮鞋,
我们在内存中只保留一份实例,在访问对象时,我们访问的其实是对象缓存的版本,而不是每次都重新生成对象。
享元模式仍然允许对象具有外部属性,由于我们访问的始终是对象缓存的版本,所以我们在使用对象前,
必须将外部状态重新注入对象。由于享元模式禁止生成新的对象,所以在使用享元模式时,通常伴随着工厂方法的应用。我们来看下面的例子:
- class ShoeFactory {
- Collection<Shoe> shoes = new ArrayList<Shoe>();
- Shoe getSheo(String color, int size, String position) {
- //首先在缓存中查找对象
- for (Shoe shoe : shoes) {
- if (shoe.getColor() == color && shoe.getSize() == size) {
- //在缓存中命中对象后还原对象的外部属性
- shoe.setPosition(position);
- return shoe;
- }
- }
- //如果缓存未命中则新建对象并加入缓存
- Shoe shoe = new Shoe();
- shoe.setColor(color);
- shoe.setSize(size);
- shoe.setPosition(position);
- shoes.add(shoe);
- return shoe;
- }
- }
在面向对象的程序设计语言看来,一切事务都被描述成对象(Object)。
对象拥有状态(属性)和行为(方法),我们将具有相同行为的对象抽象为类(Class),
类可以被看作只保留行为的对象模板,类可以在运行时被重新赋予状态数据从而形成了对象。
在运行时,对象占用一定的内存空间用来存储状态数据。如果不作特殊的处理,
尽管是由同一个类生成的两个对象,而且这两个对象的的状态数据完 全相同,
但在内存中还是会占用两份空间,这样的情况对于程序的功能也许并没有影响,
但如果把状态相同的同一类对象在内存中进行合并,必然会大大减少存储空 间的浪费。
举一个现实中的例子,某淘宝店经营一款畅销女式皮鞋,每天需要处理大量的订单信息,
在订单中需要注明客户购买的皮鞋信息,我们将皮鞋产品抽象出来:
通过ShoeFactory工厂,我们每次拿到的皮鞋都是缓存的版本,如果缓存中没有我们需要的对象,
则新创建对象然后加入缓存中。注意上例中对象的外部属性position是如何注回对象的。
当我们在自己的业务场景中应用享元模式时,一定要注意分清对象的内部状态和外部状态,
享元模式强调缓存的版本只能包含对象的内部状态。
二、定义
采用一个共享来避免大量拥有相同内容对象的开销。
这种开销中最常见、直观的就是内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象。
在名字和定义中都体现出了共享这一个核心概念,
那么怎么来实现共享呢?要知道每个事物都是不同的,但是又有一定的共性,
如果只有完全相同的事物才能共享,那么享元模式可以说就是不可行的;因此我们应该尽量将事物的共性共享,
而又保留它的个性。为了做到这点,享元模式中区分了内蕴状态和外蕴状态。内蕴状态就是共性,外蕴状态就是个性了。
注:共享的对象必须是不可变的,不然一变则全变(如果有这种需求除外)
内蕴状态存 储在享元内部,不会随环境的改变而有所不同,是可以共享的;外蕴状态是不可以共享的,
它随环境的改变而改变的,因此外蕴状态是由客户端来保持(因为环境的 变化是由客户端引起的)。
在每个具体的环境下,客户端将外蕴状态传递给享元,从而创建不同的对象出来。
三、举例
1、
java通用类图:
c++通用类图:
Flyweight 模式中有一个类似 Factory 模式的对象构造工厂FlyweightFactory,
当客户程序员(Client)需要一个对象时候就会向 FlyweightFactory 发出请求对象的消息 GetFlyweight()消息,
FlyweightFactory 拥有一个管理、存储对象的“仓库” (或者叫对象池,vector 实现) ,
GetFlyweight()消息会遍历对象池中的对象,如果已经存在则直接返回给 Client,
否则创建一个新的对象返回给 Client。
2、
(1)
java来实现:
- package test_java_Flyweight;
- public abstract class Order {
- public abstract void sell();
- }
- package test_java_Flyweight;
- public class FlavorOrder extends Order{
- public String flavor;
- public FlavorOrder(String flavor){
- this.flavor = flavor;
- }
- @Override
- public void sell() {
- // TODO Auto-generated method stub
- System.out.println("卖出一份" + flavor + "的咖啡。");
- }
- }
- package test_java_Flyweight;
- import java.util.HashMap;
- import java.util.Map;
- public class FlavorFactory {
- private Map<String, Order> flavorPool =
- new HashMap<String, Order>();
- private static FlavorFactory flavorFactory =
- new FlavorFactory();
- private FlavorFactory(){
- }
- public static FlavorFactory getInstance(){
- return flavorFactory;
- }
- public Order getOrder(String flavor){
- Order order = null;
- // 如果此映射包含指定键的映射关系,则返回 true
- if(flavorPool.containsKey(flavor)){
- order = flavorPool.get(flavor);
- }else{
- order = new FlavorOrder(flavor);
- flavorPool.put(flavor, order);
- }
- return order;
- }
- public int getTotalFlavorsMade(){
- return flavorPool.size();
- }
- }
- package test_java_Flyweight;
- import java.util.ArrayList;
- import java.util.List;
- public class Client {
- private static List<Order> orders = new ArrayList<Order>();
- private static FlavorFactory flavorFactory;
- private static void takeOrders(String flavor){
- orders.add(flavorFactory.getOrder(flavor));
- }
- public static void main(String[] args){
- flavorFactory = FlavorFactory.getInstance();
- // 增加订单
- takeOrders("摩卡");
- takeOrders("卡布奇诺");
- takeOrders("香草星冰乐");
- takeOrders("香草星冰乐");
- takeOrders("拿铁");
- takeOrders("卡布奇诺");
- takeOrders("拿铁");
- takeOrders("卡布奇诺");
- takeOrders("摩卡");
- takeOrders("香草星冰乐");
- takeOrders("卡布奇诺");
- takeOrders("摩卡");
- takeOrders("香草星冰乐");
- takeOrders("拿铁");
- takeOrders("拿铁");
- // 卖咖啡
- for(Order order : orders){
- order.sell();
- }
- System.out.println("\n客户一共买了" + orders.size() + "杯咖啡!");
- System.out.println("共生成了" + flavorFactory.getTotalFlavorsMade() + "个FlavorOrder java对象");
- }
- }
(2)
c++来实现:
- // Flyweight.h
- #ifndef _FLYWEIGHT_H_
- #define _FLYWEIGHT_H_
- #include <string>
- using namespace std;
- class Flyweight
- {
- public:
- virtual ~Flyweight();
- virtual void Operation(const string& extrinsicState);
- string GetIntrinsicState();
- protected:
- Flyweight(string intrinsicState);
- private:
- string _intrinsicState;
- };
- class ConcreteFlyweight:public Flyweight
- {
- public:
- ConcreteFlyweight(string intrinsicState);
- ~ConcreteFlyweight();
- void Operation(const string& extrinsicState);
- protected:
- private:
- };
- #endif // ~_FLYWEIGHT_H_
- // Flyweight.cpp
- #include "Flyweight.h"
- #include <iostream>
- using namespace std;
- Flyweight::Flyweight(string intrinsicState)
- {
- this->_intrinsicState = intrinsicState;
- }
- Flyweight::~Flyweight()
- {
- }
- void Flyweight::Operation(const string& extrinsicState)
- {
- }
- string Flyweight::GetIntrinsicState()
- {
- return this->_intrinsicState;
- }
- ConcreteFlyweight::ConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState)
- {
- cout << "ConcreteFlyweight Build...." << intrinsicState << endl;
- }
- ConcreteFlyweight::~ConcreteFlyweight()
- {
- }
- void ConcreteFlyweight::Operation(const string& extrinsicState)
- {
- cout << "ConcreteFlyweight:" << endl;
- }
- //FlyweightFactory.h
- #ifndef _FLYWEIGHTFACTORY_H_
- #define _FLYWEIGHTFACTORY_H_
- #include"Flyweight.h"
- #include<string>
- #include<vector>
- using namespace std;
- class FlyweightFactory
- {
- public:
- FlyweightFactory();
- ~FlyweightFactory();
- Flyweight* GetFlyweight(const string& key);
- protected:
- private:
- vector<Flyweight*> _fly;
- };
- #endif
- //FlyweightFactory.cpp
- #include "FlyweightFactory.h"
- #include<iostream>
- #include<string>
- #include<cassert>
- using namespace std;
- FlyweightFactory::FlyweightFactory()
- {
- }
- FlyweightFactory::~FlyweightFactory()
- {
- }
- Flyweight* FlyweightFactory::GetFlyweight(const string& key)
- {
- vector<Flyweight*>::iterator it = _fly.begin();
- for(; it != _fly.end(); it++)
- {
- if((*it)->GetIntrinsicState() == key)
- {
- cout << "already create by users.... " << endl;
- return *it;
- }
- }
- Flyweight* fn = new ConcreteFlyweight(key);
- _fly.push_back(fn);
- return fn;
- }
测试代码:
- // main.cpp
- #include"Flyweight.h"
- #include"FlyweightFactory.h"
- #include<iostream>
- using namespace std;
- int main(int argc, char* argv[])
- {
- FlyweightFactory* fc = new FlyweightFactory();
- Flyweight* fw1 = fc->GetFlyweight("hello");
- Flyweight* fw2 = fc->GetFlyweight("world");
- Flyweight* fw3 = fc->GetFlyweight("hello");
- return 0;
- }
代码说明:
Flyweight 模式在实现过程中主要是要为共享对象提供一个存放的“仓库” (对象池) ,
这里是通过 C++ STL中Vector容器,当然就牵涉到 STL 编程的一些问题(Iterator使用等) 。
另外应该注意的就是对对象“仓库” (对象池)的管理策略(查找、插入等) ,这里是通过直
接的顺序遍历实现的。
(3)
Android SDK源码之亨元模式:
Android中SQLiteCompiledSql的使用,其实是很多数据库系统典型的实现。从应用启动,通过各种数据库操作,我们不知道进行了多少次的查询操作,而这些操作中又有相当一部分sql语句是相同的,这些编译后的sql编译对象其实是一样的,是可以共用共享的,其实就是缓存。SQLiteCompiledSql就是这样的一个需要共享的享元对象。
享元对象类SQLiteCompiledSql,主要是内部状态sql语句:
- class SQLiteCompiledSql {
- private String mSqlStmt = null;
- native_compile(sql);
- native_finalize();
- }
- public class SQLiteDatabase{
- Map<String, SQLiteCompiledSql> mCompiledQueries = Maps.newHashMap();
- SQLiteCompiledSql getCompiledStatementForSql(String sql) {
- SQLiteCompiledSql compiledStatement = null;
- boolean cacheHit;
- synchronized(mCompiledQueries) {
- if (mMaxSqlCacheSize == 0) {
- return null;
- }
- cacheHit = (compiledStatement = mCompiledQueries.get(sql)) != null;
- }
- if (cacheHit) {
- mNumCacheHits++;
- } else {
- mNumCacheMisses++;
- }
- return compiledStatement;
- }
- private void deallocCachedSqlStatements() {
- synchronized (mCompiledQueries) {
- for (SQLiteCompiledSql compiledSql : mCompiledQueries.values()) {
- compiledSql.releaseSqlStatement();
- }
- mCompiledQueries.clear();
- }
- }
- void addToCompiledQueries(String sql, SQLiteCompiledSql compiledStatement) {
- //省略具体代码
- }
- }