定义

采用一个共享来避免大量拥有相同内容对象的开销。这种开销中最常见、直观的就是内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象。

在名字和定义中都体现出了共享这一个核心概念，那么怎么来实现共享呢？要知道每个事物都是不同的，但是又有一定的共性，如果只有完全相同的事物才能共享，那么享元模式可以说就是不可行的；因此我们应该尽量将事物的共性共享，而又保留它的个性。为了做到这点，享元模式中区分了内蕴状态和外蕴状态。内蕴状态就是共性，外蕴状态就是个性了。

注：共享的对象必须是不可变的，不然一变则全变（如果有这种需求除外）。

内蕴状态存储在享元内部，不会随环境的改变而有所不同，是可以共享的；外蕴状态是不可以共享的，它随环境的改变而改变的，因此外蕴状态是由客户端来保持（因为环境的变化是由客户端引起的）。在每个具体的环境下，客户端将外蕴状态传递给享元，从而创建不同的对象出来。

---

角色

• 抽象享元角色
• 具体享元角色
• 享元工厂角色
• 客户端角色

---

解决问题

在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

---

使用场景

1、系统中有大量对象。
2、这些对象消耗大量内存。
3、这些对象的状态大部分可以外部化。
4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。
5、系统不依赖于这些对象身份，这些对象是不可分辨的。

---

关键代码

用 HashMap 存储这些对象。

---

优点

大大减少对象的创建，降低系统的内存，使效率提高

缺点

提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

---

注意事项：

1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。
2、这些类必须有一个工厂对象加以控制。

---

分类

• 单纯享元模式
• 符合享元模式

---

在单纯享元模式中，所有的享元对象都是可以共享的，即所有抽象享元类的子类都可共享，不存在非共享具体享元类。（属性的值一次设定好了就不会再改变了，我这个例子把属性放在了.h 中是不太对的，正常应该在.m 中，并且初始化的时候给其赋值）

单纯 享元模式UML 图

单纯享元模式UML 图

简单代码

#import <Foundation/Foundation.h>
#import "FlyWeight.h"
#import "ConcreteFlyWeight.h"

@interface FlyweightFactory : NSObject
-(id<FlyWeight>)factory:(NSNumber*)state;
@end

#import <Foundation/Foundation.h>
#import "FlyWeight.h"
@interface ConcreteFlyWeight : NSObject<FlyWeight>
@property (nonatomic,strong) NSNumber *state;
@end

#import "ConcreteFlyWeight.h"

@implementation ConcreteFlyWeight
-(void)openation:(NSString *)state{
    NSLog(@"address %@  %@ ",self,self.state);
    NSLog(@"可变部分值 %@ ",state);
}
@end

#import <Foundation/Foundation.h>
#import "FlyWeight.h"
#import "ConcreteFlyWeight.h"

@interface FlyweightFactory : NSObject
-(id<FlyWeight>)factory:(NSNumber*)state;
@end

#import "FlyweightFactory.h"

@interface FlyweightFactory()
@property (nonatomic,strong) NSMutableDictionary  *flyweights;
@end
@implementation FlyweightFactory
- (instancetype)init
{
    self = [super init];
    if (self) {
        self.flyweights = [NSMutableDictionary dictionary];
    }
    return self;
}
-(id<FlyWeight>)factory:(NSNumber *)state{
    id<FlyWeight> flyweight=[self.flyweights objectForKey:state];
    if (!flyweight) {
        ConcreteFlyWeight *weight = [ConcreteFlyWeight new];
        weight.state = state;
        [self.flyweights setObject:weight forKey:state];
        flyweight = weight;
    }
    return flyweight;
}
@end

客户端（测试代码）

 FlyweightFactory * factory= [FlyweightFactory new];
   id<FlyWeight> flyweight= [factory factory:@1];
    [flyweight openation:@"print one"];
    flyweight= [factory factory:@2];
    [flyweight openation:@"print tow"];
    flyweight= [factory factory:@1];
    [flyweight openation:@"print three"];

测试结果

2018-04-09 14:48:31.887403+0800 结构型设计模式-享元模式[40506:7608175] address <ConcreteFlyWeight: 0x600000006d90>  1
2018-04-09 14:48:31.887602+0800 结构型设计模式-享元模式[40506:7608175] 可变部分值 print one 
2018-04-09 14:48:31.887832+0800 结构型设计模式-享元模式[40506:7608175] address <ConcreteFlyWeight: 0x600000006d80>  2
2018-04-09 14:48:31.888200+0800 结构型设计模式-享元模式[40506:7608175] 可变部分值 print tow 
2018-04-09 14:48:31.888569+0800 结构型设计模式-享元模式[40506:7608175] address <ConcreteFlyWeight: 0x600000006d90>  1
2018-04-09 14:48:31.888721+0800 结构型设计模式-享元模式[40506:7608175] 可变部分值 print three 

发现生成的第一个对象和第三个对象的地址是相同的，说明内存中只有一份。

---

复合享元模式

复合享元模式：将一些单纯享元使用组合模式加以组合，可以形成复合享元对象，这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。

复合模式的UML 图

复合模式的UML 图

简单代码

新增代码

#import <Foundation/Foundation.h>
#import "FlyWeight.h"
@interface ConcreteCompositeFlyweight : NSObject<FlyWeight>
- (instancetype)init;
-(void)add:(id<FlyWeight>)flyWeight key:(NSNumber*)key;
@end

#import "ConcreteCompositeFlyweight.h"
@interface ConcreteCompositeFlyweight()
@property (nonatomic,strong) NSMutableDictionary * states;
@end
@implementation ConcreteCompositeFlyweight
- (instancetype)init
{
    self = [super init];
    if (self) {
        self.states = [NSMutableDictionary dictionary];
    }
    return self;
}
-(void)add:(id<FlyWeight>)flyWeight key:(NSNumber*)key{
    [self.states setObject:flyWeight forKey:key];
}


-(void)openation:(NSString *)state{
    for (NSNumber *number in self.states.allKeys) {
      id<FlyWeight> flyweight= [self.states objectForKey:number];
        [flyweight openation:state];
    }
}
@end

修改代码FlyweightFactory
新增加一个方法

FlyweightFactory.h
///复合模式
-(id<FlyWeight>)factorys:(NSArray*)numbers;

FlyweightFactory.m
-(id<FlyWeight>)factorys:(NSArray*)numbers{
    ConcreteCompositeFlyweight * flyWeights= [[ConcreteCompositeFlyweight alloc]init];
    for (NSNumber *num in numbers) {
       id<FlyWeight> flyWeight= [self factory:num];
        [flyWeights add:flyWeight key:num];
    }
    return flyWeights;
   
}

测试代码

    FlyweightFactory * factory= [FlyweightFactory new];
    NSArray * aray=@[@1,@2,@3,@1,@3];
   id<FlyWeight> flyWeight= [factory factorys:aray];
    [flyWeight openation:@"Composite Call"];
    
    flyWeight =[factory factory:@1];
    [flyWeight openation:@"print one"];

测试结果

2018-04-09 15:32:24.064677+0800 结构型设计模式-享元模式[41290:7640719] address <ConcreteFlyWeight: 0x6040002003e0>  3
2018-04-09 15:32:24.064823+0800 结构型设计模式-享元模式[41290:7640719] 可变部分值 Composite Call 
2018-04-09 15:32:24.064937+0800 结构型设计模式-享元模式[41290:7640719] address <ConcreteFlyWeight: 0x6040002003a0>  1
2018-04-09 15:32:24.065054+0800 结构型设计模式-享元模式[41290:7640719] 可变部分值 Composite Call 
2018-04-09 15:32:24.065169+0800 结构型设计模式-享元模式[41290:7640719] address <ConcreteFlyWeight: 0x6040002003d0>  2
2018-04-09 15:32:24.065268+0800 结构型设计模式-享元模式[41290:7640719] 可变部分值 Composite Call 
2018-04-09 15:32:24.065353+0800 结构型设计模式-享元模式[41290:7640719] address <ConcreteFlyWeight: 0x6040002003a0>  1
2018-04-09 15:32:24.065433+0800 结构型设计模式-享元模式[41290:7640719] 可变部分值 print one 

通过打印能看出来，至少key 是1 的地址都是相同的，没有任何变化。
我们还可以通过复合模式批量处理对象。

---

1.在享元模式的享元工厂类中通常提供一个静态的工厂方法用于返回享元对象，使用 简单工厂模式来生成享元对象；
2.在一个系统中，通常只有唯一一个享元工厂，因此享元工厂类可以使用单例模式进行设计；（使用单例设计，注意，字典中的对象始终是没有释放掉的，还要设计一套释放内存的代码）
3.享元模式可以结合组合模式形成复合享元模式，统一对享元对象设置外部状态。

---

借鉴博客
借鉴博客
借鉴博客
源代码地址
下一篇博客
结构型设计模式-代理模式