设计模式之禅笔记——亨元模式

最新推荐文章于 2024-07-27 18:05:15 发布

yaoming168

最新推荐文章于 2024-07-27 18:05:15 发布

阅读量2.9k

点赞数

分类专栏：设计模式文章标签：设计模式 uml

本文链接：https://blog.csdn.net/yaoming168/article/details/11530613

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

谢谢设计模式之禅的详细讲解，但是只提供了java代码实现，我想借学习设计模式打开c++的大门，所以就想到通过c++跟java两种语言来实现同一种设计模式，希望大家多提意见，共同学习。

由于能力有限，我只能转载师傅们的博客，在这里只是学习探讨只用，请谅解！

一、引言

1、

java中String类型的对象一旦被创造就不可改变，当两个String对象所包含的内容相同的时候，JVM只创建一个String对象对应这两个不同的对象引用。

public class TestPattern {
       public static void main(String[] args){
              String n = "I Love Java";
              String m = "I Love Java";            
              System.out.println(n==m);
       }
}

这段代码会告诉你n==m是true，这就说明了在JVM中n和m两个引用了同一个String对象。
在系统输出之前加入一行代码“m = m + "hehe";”，这时候n==m结果为false，为什么刚才两个还是引用相同的对象，现在就不是了呢？原因就是在执行后添加语句时，m指向了一个新创建的String对象，而不是修改引用的对象。
String类型的设计避免了在创建N多的String对象时产生的不必要的资源损耗，可以说是享元模式应用的范例。

2、

在面向对象的程序设计语言看来，一切事务都被描述成对象（Object）。
对象拥有状态（属性）和行为（方法），我们将具有相同行为的对象抽象为类（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;
	}
}

享元模式强调缓存的版本只能包含对象的内部状态。

二、定义
采用一个共享来避免大量拥有相同内容对象的开销。
这种开销中最常见、直观的就是内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象。
在名字和定义中都体现出了共享这一个核心概念，
那么怎么来实现共享呢？要知道每个事物都是不同的，但是又有一定的共性，
如果只有完全相同的事物才能共享，那么享元模式可以说就是不可行的；因此我们应该尽量将事物的共性共享，
而又保留它的个性。为了做到这点，享元模式中区分了内蕴状态和外蕴状态。内蕴状态就是共性，外蕴状态就是个性了。
注：共享的对象必须是不可变的，不然一变则全变（如果有这种需求除外)
内蕴状态存储在享元内部，不会随环境的改变而有所不同，是可以共享的；外蕴状态是不可以共享的，
它随环境的改变而改变的，因此外蕴状态是由客户端来保持（因为环境的变化是由客户端引起的）。
在每个具体的环境下，客户端将外蕴状态传递给享元，从而创建不同的对象出来。

三、举例

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) {
         //省略具体代码
    }
}

参考文档：

http://www.blogjava.net/qileilove/archive/2012/12/14/393015.html

yaoming168

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之禅笔记——亨元模式

谢谢设计模式之禅的详细讲解，但是只提供了java代码实现，我想借学习设计模式打开c++的大门，所以就想到通过c++跟java两种语言来实现同一种设计模式，希望大家多提意见，共同学习。以上是c++的亨元UML图，下面我们先用c++来实现一下：
复制链接

扫一扫

专栏目录