设计模式应用场景之Model设计中可以用到的设计模式

在开发中，不同的场景适用不同的设计模式。对于开发建模方面，可以根据模型的抽象类型设计成简单属性模式和复杂组合模式。

因为组合模式中的属性为多种类型对象，可操作性也比较灵活。

而针对这种复杂数据结构，有两种设计模式可以使用：

1.组合模式

2.迭代器模式

 

组合模式篇

组合模式简介：

1.组合模式就是一个树形数据结构

2.对组合对象的查询，访问都是递归操作。

3.所有的节点都会实现同一套接口或者继承自 同一个抽象父类。

4.每个对象都是其中的一个节点，无论叶子节点和组件节点都有相同的接口。只是叶子节点的接口返回为空，组件节点的接口实现接口。

5.组合模式让我们把相同基类型的对象组合到树状结构中，其中父节点包含同类型的子节点

 

组合模式的对象图如下：

aComposite:组件节点，下面包含子节点

aLeaf:叶子节点，下面没有子节点。

 

组合模式的类图如下：

aComposite:组件节点中包含的动作如下：

1.基本操作

2.对子节点的各种操作（增，删，查）

 

aLeaf:叶子节点总包含的动作如下：

1.基本操作

因为叶子节点是最底层，最简单的节点，所以它所包含的动作也是最简单的，只有作用节点最基本的operation功能。

 

组合模式的作用：

1.将对象组合成树形结构，以表示“整体-部分”的层次结构

2.组合模式使得客户端对单个对象和组合对象的操作具有一致性。使客户端对组件节点和叶子节点进行处理时，能够对它们的区别无感知，好像它们都是同样的简单对象。

 

组合模式的实际使用例子：

线段轨迹这个抽象事物为例子，这个抽象例子中包含三种模型：

1.线段，它是一个组合模式模型，里面可以包含子线段，连接点，点。

2.连接点，它是线段（或子线段）中的内容连接部分。

3.点，只有一个点的线段或者长度为0的线段。

 

这三种抽象事物的类UML图如下：

 

这三种抽象事物的对象UML图如下：

 

代码实现如下：

 1.先定义这三个类所共同遵守的协议：Mark协议

@protocol Mark <NSObject,NSCopying>
@property (nonatomic, strong) UIColor *color;
@property (nonatomic, assign) CGSize size;
@property (nonatomic, assign) CGPoint location;
- (void)addMark:(id<Mark>)mark;
- (void)removeMark:(id<Mark>)mark;
- (void)removeAllMarks;
- (id<Mark>)childAtIndex:(int)index;
- (id<Mark>)lastChild;
- (NSUInteger)count;
@end

2.Stroke类实现Mark协议如下：

@interface Stroke()
@property (nonatomic, strong) NSMutableArray<id<Mark>> *markArray;
@end

@implementation Stroke
@synthesize color,location,size;
#pragma mark - 属性操作
- (void)setLocation:(CGPoint)location {}
- (CGPoint)location {
    if (_markArray.count) {
        return [[_markArray firstObject] location];
    } else {
        return CGPointZero;
    }
}
#pragma mark - Mark操作
- (NSMutableArray<id<Mark>> *)markArray {
    if (!_markArray) {
        _markArray = @[].mutableCopy;
    }
    return _markArray;
}

- (void)addMark:(id<Mark>)mark {
    [self.markArray addObject:mark];
}

- (void)removeMark:(id<Mark>)mark {
    //在当前节点中，就从当前节点删除，不在当前节点，就深度查找子节点
    if ([_markArray containsObject:mark]) {
        [self.markArray removeObject:mark];
    } else {
        [_markArray makeObjectsPerformSelector:@selector(removeMark:) withObject:mark];
    }
}

- (void)removeAllMarks {
    [self.markArray removeAllObjects];
}

- (id<Mark>)childAtIndex:(int)index {
    if (self.markArray.count == ) {
        return nil;
    } else {
        return self.markArray[index];
    }
}

- (id<Mark>)lastChild {
    return self.markArray.lastObject;
}

- (NSUInteger)count {
    return self.markArray.count;
}

3.Vertex实现Mark协议如下：

@implementation Vertex
@synthesize location;
@dynamic color,size;

- (instancetype)initWithLocation:(CGPoint)location {
    self = [super init];
    if (self) {
        self.location = location;
    }
    return self;
}

#pragma mark - 属性操作
- (UIColor *)color{return nil;}
- (void)setColor:(UIColor *)color{}
- (CGSize)size{return CGSizeZero;}
- (void)setSize:(CGSize)size{}

#pragma mark - Mark操作
- (void)addMark:(id<Mark>)mark {}
- (void)removeMark:(id<Mark>)mark {}
- (void)removeAllMarks {}
- (id<Mark>)childAtIndex:(int)index {return nil;}
- (id<Mark>)lastChild {return nil;}
- (NSUInteger)count {return ;}

4.Dot类实现Mark协议如下：

@interface Dot : Vertex
@end

@implementation Dot
@synthesize color,size;

因为Dot类基础自Vertex,所以对象Mark对象的操作使用父类的就好了

迭代器模式篇

迭代器模式简介：

1.迭代器提供了一种 顺序访问聚合对象（集合）中元素的方法，而无需暴露聚合对象（集合）的底层表示和结构细节。

2. 为聚合对象（集合）配置迭代器后，遍历集合元素的任务从集合 转移给了迭代器对象。

3.请问啥叫迭代器模式？

答：针对抽象集合的迭代行为 而采用的设计模式，叫做迭代器模式

 

迭代器模式的对象图如下：

 

简单表示，迭代器持有着聚合对象

 

标准表示：

1.抽象聚合体Aggregate中定义了创建迭代器的接口，实例聚合类ConcreteAggregate实现创建迭代器的接口，返回自己类型的迭代器。

2.抽象迭代器Iterator定义了通用迭代方法，实例迭代器ConcreteIterator实现迭代方法接口。

 

迭代器模式的种类：

1.外部迭代器

由聚合对象直接将自己的迭代器返回给调用者，调用者进行灵活使用，举例如下：

NSEnumerator *enumerator = [self enumerator];
    id <Mark> mark;
    while (mark = [enumerator nextObject]) {
        [mark lastChild]
    }

2.内部迭代器

由聚合体提供一个迭代接口，这个迭代接口中有一个参数，该参数需要传递一个供聚合体内部在遍历时调用的“代码块”。这样在

聚合体内部遍历时，就将每个对象执行传递过来的预先定义好的函数。

举例如下：

    self.stroke = [Stroke new];
    [self.stroke enumerateMarksUsingBlock:^(id<Mark> mark, BOOL *stop) {

    }]

迭代器模式的实际使用例子：

现在继续使用刚才使用举的抽象事物“线段轨迹”

这个抽象例子中包含三种模型：线段，连接点，点。

 

 在Mark协议中定义迭代器接口，返回外部迭代器

 

代码实现如下：

Mark协议接口定义

@protocol Mark <NSObject,NSCopying>
@property (nonatomic, strong) UIColor *color;
@property (nonatomic, assign) CGSize size;
@property (nonatomic, assign) CGPoint location;
- (void)addMark:(id<Mark>)mark;
- (void)removeMark:(id<Mark>)mark;
- (void)removeAllMarks;
- (id<Mark>)childAtIndex:(int)index;
- (id<Mark>)lastChild;
- (NSUInteger)count;
- (instancetype)copy;
//迭代器
- (NSEnumerator *)enumerator;
@end;

Stroke类接口实现

@interface Stroke()
@property (nonatomic, strong) NSMutableArray<id<Mark>> *markArray;
@end

@implementation Stroke
@synthesize color,location,size;
#pragma mark - 属性操作
- (void)setLocation:(CGPoint)location {}
- (CGPoint)location {
    if (_markArray.count) {
        return [[_markArray firstObject] location];
    } else {
        return CGPointZero;
    }
}
#pragma mark - Mark操作
- (NSMutableArray<id<Mark>> *)markArray {
    if (!_markArray) {
        _markArray = @[].mutableCopy;
    }
    return _markArray;
}

- (void)addMark:(id<Mark>)mark {
    [self.markArray addObject:mark];
}

- (void)removeMark:(id<Mark>)mark {
    //在当前节点中，就从当前节点删除，不在当前节点，就深度查找子节点
    if ([_markArray containsObject:mark]) {
        [self.markArray removeObject:mark];
    } else {
        [_markArray makeObjectsPerformSelector:@selector(removeMark:) withObject:mark];
    }
}

- (void)removeAllMarks {
    [self.markArray removeAllObjects];
}

- (id<Mark>)childAtIndex:(int)index {
    if (self.markArray.count == ) {
        return nil;
    } else {
        return self.markArray[index];
    }
}

- (id<Mark>)lastChild {
    return self.markArray.lastObject;
}

- (NSUInteger)count {
    return self.markArray.count;
}

#pragma mark - 迭代器
- (NSEnumerator *)enumerator {
    return [[ZHFMarkEnumerator alloc] initWithMark:self];
}

 在Mark协议中定义内部迭代器接口：

 

 

代码实现如下：

Mark协议接口定义

@protocol Mark <NSObject,NSCopying>
@property (nonatomic, strong) UIColor *color;
@property (nonatomic, assign) CGSize size;
@property (nonatomic, assign) CGPoint location;
- (void)addMark:(id<Mark>)mark;
- (void)removeMark:(id<Mark>)mark;
- (void)removeAllMarks;
- (id<Mark>)childAtIndex:(int)index;
- (id<Mark>)lastChild;
- (NSUInteger)count;
- (instancetype)copy;
//迭代器
- (NSEnumerator *)enumerator;
//内部迭代器
- (void)enumerateMarksUsingBlock:(void (^) (id <Mark> mark, BOOL *stop))block;
@end;

Stroke类接口实现

@interface Stroke()
@property (nonatomic, strong) NSMutableArray<id<Mark>> *markArray;
@end

@implementation Stroke
@synthesize color,location,size;
#pragma mark - 属性操作
- (void)setLocation:(CGPoint)location {}
- (CGPoint)location {
    if (_markArray.count) {
        return [[_markArray firstObject] location];
    } else {
        return CGPointZero;
    }
}
#pragma mark - Mark操作
- (NSMutableArray<id<Mark>> *)markArray {
    if (!_markArray) {
        _markArray = @[].mutableCopy;
    }
    return _markArray;
}

- (void)addMark:(id<Mark>)mark {
    [self.markArray addObject:mark];
}

- (void)removeMark:(id<Mark>)mark {
    //在当前节点中，就从当前节点删除，不在当前节点，就深度查找子节点
    if ([_markArray containsObject:mark]) {
        [self.markArray removeObject:mark];
    } else {
        [_markArray makeObjectsPerformSelector:@selector(removeMark:) withObject:mark];
    }
}

- (void)removeAllMarks {
    [self.markArray removeAllObjects];
}

- (id<Mark>)childAtIndex:(int)index {
    if (self.markArray.count == ) {
        return nil;
    } else {
        return self.markArray[index];
    }
}

- (id<Mark>)lastChild {
    return self.markArray.lastObject;
}

- (NSUInteger)count {
    return self.markArray.count;
}

#pragma mark - 迭代器
- (NSEnumerator *)enumerator {
    return [[ZHFMarkEnumerator alloc] initWithMark:self];
}

- (void)enumerateMarksUsingBlock:(void (^)(id<Mark>, BOOL *stop))block {
    NSEnumerator *enumerator = [self enumerator];
    id <Mark> mark;
    BOOL *stop = NO;
    for (id <Mark> mark in enumerator) {
        block(mark, &stop);
        if (stop) {
            break;
        }
    }
}

熟练使用设计模式是编写高扩展，高稳定，高复用，三高代码很重要的一项技能。愿你我一同砥砺前行。

完整的项目代码地址如下：

https://github.com/zhfei/Objective-C_Design_Patterns

目前项目还没有完全结束，处于持续完善中...