iOS组件化第二步:使用中间者模式(CTMediator)

在项目模块划分开来之后，模块间的通信成了一大问题，模块A直接访问模块B必然会增加模块间的耦合性，这也与组件化的初衷相违背，经过一番查阅之后，对中间者这种架构颇有好感。它通过一个中间者来统一管理，控制各个模块间的通信，这样一来，每个模块间没有关联，可以最大限度的解耦。下面套用一张戴铭老师的插图，这幅图非常生动的描述来中间者模式。 中间者模式

那么如何去实现这个中间者模式呢，casa 大神的CTMediator可以很好的解决这个问题。CTMediator通过runtime实现各个模块间的通信，不过想要更好的去使用CTMediator，最好先了解一下CTMediator是如何实现的，CTMediator的实现也不复杂，下面我将贴上CTMediator的源码。

extern NSString * const kCTMediatorParamsKeySwiftTargetModuleName;

@interface CTMediator : NSObject

+ (instancetype)sharedInstance;

// 远程App调用入口
- (id)performActionWithUrl:(NSURL *)url completion:(void(^)(NSDictionary *info))completion;
// 本地组件调用入口
- (id)performTarget:(NSString *)targetName action:(NSString *)actionName params:(NSDictionary *)params shouldCacheTarget:(BOOL)shouldCacheTarget;
- (void)releaseCachedTargetWithTargetName:(NSString *)targetName;

@end

我们主要来关注本地组件调用入口的源码

- (id)performTarget:(NSString *)targetName action:(NSString *)actionName params:(NSDictionary *)params shouldCacheTarget:(BOOL)shouldCacheTarget
{
    NSString *swiftModuleName = params[kCTMediatorParamsKeySwiftTargetModuleName];
    
    // generate target
    NSString *targetClassString = nil;
    if (swiftModuleName.length > 0) {
        targetClassString = [NSString stringWithFormat:@"%@.Target_%@", swiftModuleName, targetName];
    } else {
        targetClassString = [NSString stringWithFormat:@"Target_%@", targetName];
    }
    NSObject *target = self.cachedTarget[targetClassString];
    if (target == nil) {
        Class targetClass = NSClassFromString(targetClassString);
        target = [[targetClass alloc] init];
    }

    // generate action
    NSString *actionString = [NSString stringWithFormat:@"Action_%@:", actionName];
    SEL action = NSSelectorFromString(actionString);
    
    if (target == nil) {
        // 这里是处理无响应请求的地方之一，这个demo做得比较简单，如果没有可以响应的target，就直接return了。实际开发过程中是可以事先给一个固定的target专门用于在这个时候顶上，然后处理这种请求的
        [self NoTargetActionResponseWithTargetString:targetClassString selectorString:actionString originParams:params];
        return nil;
    }
    
    if (shouldCacheTarget) {
        self.cachedTarget[targetClassString] = target;
    }

    if ([target respondsToSelector:action]) {
        return [self safePerformAction:action target:target params:params];
    } else {
        // 这里是处理无响应请求的地方，如果无响应，则尝试调用对应target的notFound方法统一处理
        SEL action = NSSelectorFromString(@"notFound:");
        if ([target respondsToSelector:action]) {
            return [self safePerformAction:action target:target params:params];
        } else {
            // 这里也是处理无响应请求的地方，在notFound都没有的时候，这个demo是直接return了。实际开发过程中，可以用前面提到的固定的target顶上的。
            [self NoTargetActionResponseWithTargetString:targetClassString selectorString:actionString originParams:params];
            [self.cachedTarget removeObjectForKey:targetClassString];
            return nil;
        }
    }
}

然后将一些判断和缓存之类的代码去掉，留下核心代码:

    //  外部传入的swift模块名
    NSString *swiftModuleName = params[kCTMediatorParamsKeySwiftTargetModuleName];
    NSString *targetClassString = nil;
    if (swiftModuleName.length > 0) {
        //  swiftModuleName.length > 0说明是swift的类，需要加上模块名
        targetClassString = [NSString stringWithFormat:@"%@.Target_%@", swiftModuleName, targetName];
    } else {
        //  否则是oc的类
        targetClassString = [NSString stringWithFormat:@"Target_%@", targetName];
    }
    //  下面两行代码是根据传入的字符串生成对象
    Class targetClass = NSClassFromString(targetClassString);
    NSObject *target = target = [[targetClass alloc] init];
    //  格式化方法名字符串
    NSString *actionString = [NSString stringWithFormat:@"Action_%@:", actionName];
    //  获取方法
    SEL action = NSSelectorFromString(actionString);
    //  target通过CTMediator一个安全方法去执行action方法
    return [self safePerformAction:action target:target params:params];

这样一看来是不是就很清晰了，本质上其实就是通过runtime去执行target对象的action方法，但是需要注意的是，这里target对象的类名需要加上Target_前缀，要执行的那个方法也要加上Action_的前缀，具体这样做的好处是什么，希望有大神可以指出。下面让我们通过一个案例来实践一下。这个案例最终实现点击ViewController界面的按钮之后跳转的A_Controller。项目结构如下: 项目结构

Target_A在这里充当一个信使的角色，代码如下,

//  前面源码阅读中了解到CTMediator调用对象的类名必须加上Target_前缀，调用的方法必须加上Action_前缀
class Target_A: NSObject {

    @objc func Action_GetController(_ params: [AnyHashable: Any]) -> UIViewController {
        if let callback = params["callback"] as? ((String)->Void) {
            callback("success")
        }
        let vc = A_Controller()
        return vc
    }
    
}

为CTMediator添加extension,这里添加一个getAController方法，这样ViewController中可以直接调用这个方法来获取到想要跳转的控制器

extension CTMediator {
    
    @objc func getAController(callback:@escaping (String) -> Void) -> UIViewController? {
        //CTTest是这个项目中的模块名
        let params = [
            "callback":callback,
            kCTMediatorParamsKeySwiftTargetModuleName:"CTTest"
            ] as [AnyHashable : Any]
        //  A在CTMediator会被格式化成Target_A GetController会被格式化成Action_ GetController
        if let viewController = self.performTarget("A", action: "GetController", params: params, shouldCacheTarget: false) as? UIViewController {
            return viewController
        }
        return nil
    }
    
}

ViewController中放入一个按钮，点击后执行如下代码

let controller = CTMediator.sharedInstance()?.getAController(callback: { (str) in
    print(str)
})
navigationController?.pushViewController(controller!, animated: true)

这样一来，ViewController与A_Controller一点关联也没有，但也能正常的与其通信。不过这样一来随着模块数量的增加，通信代码也会随之增加，另外直接传入字符串的方式也比较容易出错，但是总的来说是非常不错的。如有错误，欢迎指出!