iOS分层架构设计-实战篇

Posted on | Edited on

一、前言

iOS的应用一般情况下，无非就是用户与界面间交互，形成操作指令，然后对数据进行增删改查。当业务过于复杂时，我们就可以采用分层架构设计。这样可以最大程度上解耦，这里，我们主要介绍最经典的三层架构设计模型。大体上，分别为：应用层、服务层、数据层。

Tips: 我们常用的MVC、MVP、MVVM等都是属于应用层内的架构，也就是说，它们主要是为应用层解耦等。而本文提到的分层架构是针对整个项目而言。

二、案例分析

本篇主要以代码实例为主，我们将通过一个简单案例来展示分层架构设计。

此例主要是模拟了打印机输入端的业务逻辑。

我们的主要业务逻辑为打印和复印，流程框图如下：👇👇👇

主要逻辑流程框图.png

基本步骤如下：

  • 用户选择服务类型：打印或者复印？

  • 如果用户选择打印，则让用户输入要打印的内容，输入完成后点击提交。

  • 如果用户选择复印，则让用户提供原件，操作完成后点击提交。

  • 提交后，系统生成打印输出预览，用户确认无误后点击立刻打印。

  • 提交数据给打印机，开始打印。

三、代码实现

首先我们看一下目录结构👇👇👇

目录结构.png

  • 应用层 - ApplicationLayer - MVC

数据模型 - Model
PrintModel.h

1
@property (nonatomic, copy) NSString *content;

视图模型 - View
PrintView
CopyView

控制器 - Controller
MainController
PrintController
PreviewController

这一层就不多解释了，采用里MVC架构，主要用于与用户间的交互，接收操作指令等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
PrintController

- (void)configClient {

if (self.type == OptionPrint) {
[self configPrintClient];
} else if (self.type == OptionCopy) {
[self configCopyClient];
}
}

- (void)configPrintClient {

NSString *userInput = [self.printView getContent];

PrintModel *model = [[ServiceFactory sharedInstance].printService buildPrintModelWithContent:userInput];

NSLog(@"我要打印了 %@", model);
}

- (void)configCopyClient {

PrintModel *model1 = [[ServiceFactory sharedInstance].copyService getCopyPrintModel1];
PrintModel *model2 = [[ServiceFactory sharedInstance].copyService getCopyPrintModel2];
PrintModel *model3 = [[ServiceFactory sharedInstance].copyService getCopyPrintModel3];

NSLog(@"我要复印了 %@ \n %@ \n %@", model1, model2, model3);
}
  • 服务层 - ServiceLayer

此层的所有服务由ServiceFactory来同一调配。ServiceFactory是一个单例，持有服务层的所有服务。由服务层来接触数据层。应用层则接触服务层。

此处包含了两个服务：打印服务（PrintService）和复印服务（CopyService）
注：如果后续有新的服务，则只需要在ServiceFactory中注册一下即可。

ServiceFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
#import <Foundation/Foundation.h>
#import "PrintService.h"
#import "CopyService.h"

@interface ServiceFactory : NSObject

+ (instancetype)sharedInstance;

@property (nonatomic, strong) PrintService *printService;

@property (nonatomic, strong) CopyService *copyService;

@end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#import "ServiceFactory.h"

@implementation ServiceFactory

+ (instancetype)sharedInstance {

static ServiceFactory *instance = nil;

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [ServiceFactory new];
});
return instance;
}

- (instancetype)init {
self = [super init];
if (self) {
[self configFoundation];
}
return self;
}

- (void)configFoundation {
self.printService = [PrintService new];
self.copyService = [CopyService new];
}

PrintService

1
2
3
4
5
6
7
8
9
#import <Foundation/Foundation.h>

@class PrintModel;

@interface PrintService : NSObject

- (PrintModel *)buildPrintModelWithContent:(NSString *)content;

@end

1
2
3
4
5
6
7
8
9
10
11
#import "PrintService.h"
#import "DataAccessFactory.h"

@implementation PrintService

- (PrintModel *)buildPrintModelWithContent:(NSString *)content {
PrintModel *model = [[DataAccessFactory sharedInstance].printDao buildPrintModelWithContent:content];
return model;
}

@end

CopyService

1
2
3
4
5
6
7
8
9
10
11
12
13
#import <Foundation/Foundation.h>

@class PrintModel;

@interface CopyService : NSObject

- (PrintModel *)getCopyPrintModel1;

- (PrintModel *)getCopyPrintModel2;

- (PrintModel *)getCopyPrintModel3;

@end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#import "CopyService.h"
#import "DataAccessFactory.h"

@implementation CopyService

- (PrintModel *)getCopyPrintModel1 {
PrintModel *model = [[DataAccessFactory sharedInstance].copyDao getCopyPrintModel1];
return model;
}

- (PrintModel *)getCopyPrintModel2 {
PrintModel *model = [[DataAccessFactory sharedInstance].copyDao getCopyPrintModel2];
return model;
}

- (PrintModel *)getCopyPrintModel3 {
PrintModel *model = [[DataAccessFactory sharedInstance].copyDao getCopyPrintModel3];
return model;
}

@end
  • 数据层 - DataAccessLayer

此层由DataAccessFactory来同一调配。DataAccessFactory是一个单例，持有数据层的所有资源。由数据层来直接接触数据。

此处包含了两个数据资源：打印（PrintDAO）和复印（CopyDAO）
注：如果后续有新的数据层，则只需要在DataAccessFactory中注册一下即可。

DataAccessFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
#import <Foundation/Foundation.h>
#import "PrintDAO.h"
#import "CopyDAO.h"

@interface DataAccessFactory : NSObject

+ (instancetype)sharedInstance;

@property (nonatomic, strong) PrintDAO *printDao;

@property (nonatomic, strong) CopyDAO *copyDao;

@end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#import "DataAccessFactory.h"

@implementation DataAccessFactory

+ (instancetype)sharedInstance {

static DataAccessFactory *instance = nil;

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [DataAccessFactory new];
});
return instance;
}

- (instancetype)init {
self = [super init];
if (self) {
[self configFoundation];
}
return self;
}

- (void)configFoundation {

self.printDao = [PrintDAO new];

self.copyDao = [CopyDAO new];
}

@end

PrintDAO

1
2
3
4
5
6
7
8
9
#import <Foundation/Foundation.h>

@class PrintModel;

@interface PrintDAO : NSObject

- (PrintModel *)buildPrintModelWithContent:(NSString *)content;

@end

1
2
3
4
5
6
7
8
9
10
11
12
#import "PrintDAO.h"
#import "PrintModel.h"

@implementation PrintDAO

- (PrintModel *)buildPrintModelWithContent:(NSString *)content {
PrintModel *model = [[PrintModel alloc] init];
model.content = content;
return model;
}

@end

CopyDAO

1
2
3
4
5
6
7
8
9
10
11
12
13
#import <Foundation/Foundation.h>

@class PrintModel;

@interface CopyDAO : NSObject

- (PrintModel *)getCopyPrintModel1;

- (PrintModel *)getCopyPrintModel2;

- (PrintModel *)getCopyPrintModel3;

@end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#import "CopyDAO.h"
#import "PrintModel.h"

@implementation CopyDAO

- (PrintModel *)getCopyPrintModel1 {
PrintModel *model = [[PrintModel alloc] init];
model.content = @"Hello world";
return model;
}

- (PrintModel *)getCopyPrintModel2 {
PrintModel *model = [[PrintModel alloc] init];
model.content = @"Where there is a will, there is a way";
return model;
}

- (PrintModel *)getCopyPrintModel3 {
PrintModel *model = [[PrintModel alloc] init];
model.content = @"We will, we will rock you";
return model;
}

@end

四、结论分析

  • 分层架构设计最明显的特点就是，结构分层，且不可跨层访问，比如，应用层不能直接访问数据，仅有数据层能直接操作数据，也就是说，应用层必须先经由服务层访问数据层，再由数据层操作数据。这样有人就要问了，为什么要这么复杂？在应用层导入PrintModel.h，直接操作不就行了？

  • 当然是行的，一样可以达到效果，但是，如果业务逻辑发生变动或新增逻辑，我们就必须修改或重写应用层，这是我们最不愿看到的，再或者，另一个模块也要用到类似的业务逻辑，比如有了一台高级打印机，在打印和复印功能上是一样的，那我们是不是要再复制一份普通打印机应用层的逻辑呢？这些都是很严重的问题。

  • 从这里，我们不难看出，首先我们是将可见与不可见分层，再将公用的形成模块沉底，使每层间能相互独立，有清晰的依赖关系，这就是分层架构的目的。

五、写在最后

这样一个简单的案例肯定不能完成的覆盖分层架构，但已经明确的体现了分层架构的核心，在实际开发中，我们要根据实际的业务逻辑来定义服务层和数据层，应用层基本通用。看似简单，但需要大量的实战经验才能完美吸收，也希望读者能多动手。

  • 有需要源码的可以联系我~