源码地址： GHApplicationMediator

为什么AppDelegate不容易维护

AppDelegate控制着App的主要生命周期，比如App初始化完成后构建主视图，App接收到远程消息回调，Url-Scheme回调，第三方SDK初始化，数据库初始化等等。

基于这个原因，随着App的版本迭代，AppDelegate中的代码量会越来越大。当AppDelegate的代码量到达一定程度时，我们就该开始考虑将AppDelegate中的代码进行模块化封装。

1.0版本

在考虑这个方案的时候，我们的项目刚刚度过了原型期，使用的SDK并不多，业务需求也还没有起来。

在这个背景，我选择用Category封装AppDelegate的方案。

创建一个AppDelegate+XXX的Category，比如下面这个AppDelegate+CEReachability

#import "AppDelegate.h"

@interface AppDelegate (CEReachability)
- (void)setupReachability;
@end
    
@implementation AppDelegate (CEReachability)

- (void)setupReachability
{
    // Allocate a reachability object
    Reachability *reach = [Reachability reachabilityWithHostname:kServerBaseUrl];
    
    // Set the blocks
    reach.reachableBlock = ^(Reachability *reach) {
        
        if (reach.currentReachabilityStatus == ReachableViaWWAN) {
            BLYLogInfo(@"ReachabilityStatusChangeBlock--->蜂窝数据网");
            [CESettingsManager sharedInstance].needNoWifiAlert = YES;
        } else if (reach.currentReachabilityStatus == ReachableViaWiFi) {
            BLYLogInfo(@"ReachabilityStatusChangeBlock--->WiFi网络");
            [CESettingsManager sharedInstance].needNoWifiAlert = NO;
        }
    };
    
    reach.unreachableBlock = ^(Reachability *reach) {
        BLYLogInfo(@"ReachabilityStatusChangeBlock--->未知网络状态");
    };
    
    // Start the notifier, which will cause the reachability object to retain itself!
    [reach startNotifier];   
}

然后在AppDelegate中注册这个模块

#import "AppDelegate+CEReachability.h"

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    [self setupReachability];
    return YES;
}

有同学可能会问，为什么不直接在Category中实现UIApplicationDelegate的方法。

同时import多个Category，并且多个Category都实现了同一个方法（例如：- (void)applicationWillResignActive:(UIApplication *)application），在调用该方法时选用哪个实现是由Category文件的编译顺序来决定（在Build Phases > Complie Sources中指定），最后一个编译的Category文件的方法实现将被使用。与import顺序无关，实际上，当有两个Category实现了同一个方法，无论你imprt的是那个Category，方法的实际实现永远是编译顺序在最后的Category文件的方法实现。

优点：

初步具备模块化，不同模块的注册方法由Category指定。

缺点：

各个Category之间是互斥关系，相同的方法不能在不同的Category中同时实现。
需要在AppDelegate中维护不同功能模块的实现逻辑。

2.0版本

随着业务需求的增加，第三方支付、IM、各种URL-Scheme配置逐渐增加，特别是Open Url和Push Notifications需要有依赖关系，方案一很快就不能满足需求了，各种奇怪的注册方式交织在一起。

迫于求生欲，我决定第二次重构。

这次重构初始动机是由于Category之间的互斥关系，有依赖流程的流程就必须写在AppDelegate中。（比如Open Url，第三方支付用到了，浏览器跳转也用到了）

于是，我增加了ApplicationMediator来管理AppDelegate与模块的通信，实现消息转发到模块的逻辑。

ApplicationMediator

ApplicationMediator是一个单例，用于管理模块的注册与移除。

@interface CEApplicationMediator : UIResponder<UIApplicationDelegate, UNUserNotificationCenterDelegate>

@property (nonatomic, strong) NSHashTable *applicationModuleDelegates;

+ (instancetype)sharedInstance;

+ (void)registerAppilgationModuleDelegate:(id<UIApplicationDelegate>)moduleDelegate;
+ (void)registerNotificationModuleDelegate:(id<UIApplicationDelegate,UNUserNotificationCenterDelegate>)moduleDelegate;
+ (BOOL)removeModuleDelegateByClass:(Class)moduleClass;

@property (nonatomic, assign) UNNotificationPresentationOptions defaultNotificationPresentationOptions;

@end

Module

模块根据需要实现UIApplicationDelegate与UNUserNotificationCenterDelegate就可以加入到UIApplication的生命周期中。

@implementation CEAMWindowDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    UIWindow *window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
    window.backgroundColor = [UIColor whiteColor];
    // 需要将Window赋值给AppDelegate，有多时候会用全局AppDelegate去获取Window。
    [UIApplication sharedApplication].delegate.window = window;
    
    CELaunchPageViewController *launchVC = [[CELaunchPageViewController alloc] init];

    window.rootViewController = launchVC;
    [window makeKeyAndVisible];
    
    return YES;
}
@end

@implementation CEAMReachabilityDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  // Allocate a reachability object
  Reachability *reach = [Reachability reachabilityWithHostname:kServerBaseUrl];
  
  // Set the blocks
  reach.reachableBlock = ^(Reachability *reach) {
    
    if (reach.currentReachabilityStatus == ReachableViaWWAN) {
      BLYLogInfo(@"ReachabilityStatusChangeBlock--->蜂窝数据网");
    } else if (reach.currentReachabilityStatus == ReachableViaWiFi) {
      BLYLogInfo(@"ReachabilityStatusChangeBlock--->WiFi网络");
    }
  };
  
  reach.unreachableBlock = ^(Reachability *reach) {
    BLYLogInfo(@"ReachabilityStatusChangeBlock--->未知网络状态");
  };  
  [reach startNotifier];
  return YES;
}

@end

模块注册

当模块创建完成后，进行注册后即可生效。

@implementation AppDelegate
+ (void)load
{
//    CoreData
    [CEApplicationMediator registerAppilgationModuleDelegate:[[CEAMCoreDataDelegate alloc] init]];
// 		...
}
@end

这里有两种方式进行注册

在AppDelegate的+ (void)load中进行注册
在ApplicationMediator的+ (void)load中进行注册。

两种方式都可以，各有利弊

在AppDelegate中注册，delegate与AppDelegate耦合，但ApplicationMediator与delegate进行解耦，ApplicationMediator则可以作为组件抽离出来，作为中间件使用。
在ApplicationMediator中注册，则与上面正好相反，这样模块的维护就只需要围绕ApplicationMediator进行，代码比较集中。

我采用的是AppDelegate中注册的方式，主要是准备将ApplicationMediator作为组件使用。

消息转发

作为一个键盘侠，我的打字速度还是很快的，不出五分钟我已经写完了五个UIApplicationDelegate中主要生命周期函数的手动转发，但是当我打开UIApplicationDelegate头文件后，我就蒙蔽了，delegate的方法多到让我头皮发麻。

嗯，是的，所以消息转发机制就在这种时候排上了大用处。

AppDelegate

AppDelegate的所有方法都转由ApplicationMediator处理，模块转发逻辑后面介绍。

@implementation AppDelegate

+ (void)load
{
	//注册模块
}

- (BOOL)respondsToSelector:(SEL)aSelector
{
    return [[CEApplicationMediator sharedInstance] respondsToSelector:aSelector];
}


- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
    return [[CEApplicationMediator sharedInstance] methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    [[CEApplicationMediator sharedInstance] forwardInvocation:anInvocation];
}
@end

这样AppDelegate就只需要处理注册模块就可以了。

ApplicationMediator

#pragma mark- Handle Method
/**
 无法通过[super respondsToSelector:aSelector]来检测对象是否从super继承了方法。
 因此调用[super respondsToSelector:aSelector]，相当于调用了[self respondsToSelector:aSelector]
 **/
- (BOOL)respondsToSelector:(SEL)aSelector
{
    BOOL result = [super respondsToSelector:aSelector];
    if (!result) {
        result = [self hasDelegateRespondsToSelector:aSelector];
    }
    return result;
}

/**
 此方法还被用于当NSInvocation被创建的时候，比如在消息传递的时候。
 如果当前Classf可以处理未被直接实现的方法，则必须覆写此方法。
 */
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
    id delegate = [self delegateRespondsToSelector:aSelector];
    if (delegate) {
        return [delegate methodSignatureForSelector:aSelector];
    }
    return [super methodSignatureForSelector:aSelector];
}

/**
 无法识别的消息处理
 */
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    __block BOOL isExec = NO;
    
    NSMethodSignature *methodSignature = anInvocation.methodSignature;
    const char *returnType = methodSignature.methodReturnType;
    // 没有返回值，或者默认返回YES
    if (0 == strcmp(returnType, @encode(void)) ||
        anInvocation.selector == @selector(application:didFinishLaunchingWithOptions:)) {
        [self notifySelectorOfAllDelegates:anInvocation.selector nofityHandler:^(id delegate) {
            [anInvocation invokeWithTarget:delegate];
            isExec = YES;
        }];
    } else if (0 == strcmp(returnType, @encode(BOOL))) {
        // 返回值为BOOL
        [self notifySelectorOfAllDelegateUntilSuccessed:anInvocation.selector defaultReturnValue:NO nofityHandler:^BOOL(id delegate) {
            
            [anInvocation invokeWithTarget:delegate];
            // 获得返回值
            NSUInteger returnValueLenth = anInvocation.methodSignature.methodReturnLength;
            BOOL *retValue = (BOOL *)malloc(returnValueLenth);
            [anInvocation getReturnValue:retValue];

            BOOL result = *retValue;
            return result;
        }];
    } else {
        // 等同于[self doesNotRecognizeSelector:anInvocation.selector];
        [super forwardInvocation:anInvocation];
    }
}

- (BOOL)hasDelegateRespondsToSelector:(SEL)selector
{
    __block BOOL result = NO;
    
    [self.applicationModuleDelegates enumerateObjectsUsingBlock:^(id  _Nonnull delegate, NSUInteger idx, BOOL * _Nonnull stop) {
        if ([delegate respondsToSelector:selector]) {
            result = YES;
            *stop = YES;
        }
    }];
    return result;
}

- (id)delegateRespondsToSelector:(SEL)selector
{
    __block id resultDelegate;
    [self.applicationModuleDelegates enumerateObjectsUsingBlock:^(id  _Nonnull delegate, NSUInteger idx, BOOL * _Nonnull stop) {
        if ([delegate respondsToSelector:selector]) {
            resultDelegate = delegate;
            *stop = YES;
        }
    }];
    return resultDelegate;
}

/**
 通知所有delegate响应方法
 
 @param selector 响应方法
 @param nofityHandler delegated处理调用事件
 */
- (void)notifySelectorOfAllDelegates:(SEL)selector nofityHandler:(void(^)(id delegate))nofityHandler
{
    if (_applicationModuleDelegates.count == 0) {
        return;
    }
    
    [self.applicationModuleDelegates enumerateObjectsUsingBlock:^(id  _Nonnull delegate, NSUInteger idx, BOOL * _Nonnull stop) {
        if ([delegate respondsToSelector:selector]) {
            if (nofityHandler) {
                nofityHandler(delegate);
            }
        }
    }];
}

/**
 通知所有的delegate，当有delegate响应为成功后，中断通知。
 
 @param selector 响应方法
 @param defaultReturnValue 默认返回值（当设置为YES时，即使没有响应对象也会返回YES。）
 @param nofityHandler delegate处理调用事件
 @return delegate处理结果
 */
- (BOOL)notifySelectorOfAllDelegateUntilSuccessed:(SEL)selector defaultReturnValue:(BOOL)defaultReturnValue nofityHandler:(BOOL(^)(id delegate))nofityHandler
{
    __block BOOL success = defaultReturnValue;
    if (_applicationModuleDelegates.count == 0) {
        return success;
    }
    [self.applicationModuleDelegates enumerateObjectsUsingBlock:^(id  _Nonnull delegate, NSUInteger idx, BOOL * _Nonnull stop) {
        if ([delegate respondsToSelector:selector]) {
            if (nofityHandler) {
                success = nofityHandler(delegate);
                if (success) {
                    *stop = YES;
                }
            }
        }
    }];
    return success;
}

这里简单说一下消息转发的流程。

- (BOOL)respondsToSelector:(SEL)aSelector在调用协议方法前，会检测对象是否实现协议方法，如果响应则会调用对应的方法。
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector当调用的方法无法找到时，如果未实现此方法，系统就会调用NSObject的doesNotRecognizeSelector方法，即抛出异常并Crash。当实现了这个方法是，系统会要求返回selector的对应方法实现，这里就可以开启消息转发。
- (void)forwardInvocation:(NSInvocation *)anInvocation当方法完成转发设定后，会进入这个方法，由我们来控制方法的执行。

在步骤三里，实现了自定义的转发方案：

无返回值的delegate方法，以及application:didFinishLaunchingWithOptions:这种只返回YES的方法，转发的时候，进行轮询通知。
BOOL返回值的delegate方法，先开启轮询通知，同时获取每次执行的结果，当结果为YES时，表示有模块完成了处理，则结束轮询。这里需要注意的是，轮询顺序与注册顺序有关，需要注意注册顺序。
有completionHandler的方法，主要是推送消息模块，由于competitionHandler只能调用一次，并且方法还没有BOOL返回值，所以这类方法只能实现在ApplicationMediator中，每个方法手动转发，具体实现请看源码。

还未开始的3.0版本

实现了2.0版本后，新增模块已经比较方便了，不过还有很多值得改进的地方。

比如在AppDelegate中注册模块是根据代码的编写顺序来决定模块之间的依赖关系的，只能是单项依赖。实际使用过程中还是出现过由于依赖模块关系，导致初始化混乱的问题。设计的时候为了减少类继承和协议继承，用的都是系统现有的方案，后续可能会按照责任链的设计思路将这个组件设计的更完善。
AppDelegate有一个默认的UIWindow，大量的第三方库都通过[UIApplication sharedApplication].delegate.window.bounds.size来获取屏幕尺寸，所以在创建或更改Window的时候，需要牢记将Window赋值给AppDelegate。目前只通过了文档约束，后续还会进行改进。