[精通Objective-C]进阶技巧：使用运行时系统API

参考书籍：《精通Objective-C》【美】 Keith Lee

什么是运行时系统？

目录

动态加载可选包

下面是使用NSbundle API动态加载自己编写的框架包的示例，共需要创建两个工程，一个命令行程序和一个可选包。

创建命令行程序：

创建一个协议和一个遵守该协议的类用于测试：

Greeter协议：

#import <Foundation/Foundation.h>

@protocol Greeter <NSObject>

-(NSString *)greeting:(NSString *)salutation;

@end

BasicGreeter类：

#import <Foundation/Foundation.h>
#import "Greeter.h"

@interface BasicGreeter : NSObject <Greeter>

@end

#import "BasicGreeter.h"

@implementation BasicGreeter

-(NSString *) greeting:(NSString *)salutation{
    return [NSString stringWithFormat:@"%@,World!",salutation];
}

@end

创建可选包

新建工程中选择OS X->Framework&Library->Bundle：

先将Greeter.h添加到可选包中。再创建一个遵守Greeter协议的类

CustomGreeter类：

#import <Foundation/Foundation.h>
#import "Greeter.h"

@interface CustomGreeter : NSObject <Greeter>

@end

#import "CustomGreeter.h"

@implementation CustomGreeter

-(NSString *)greeting:(NSString *)salutation{
    return [NSString stringWithFormat:@"%@,Universe!", salutation];
}

@end

传入包路径

接下需要将可选包的路径作为参数传入命令行程序的main函数中：

选择工程中的bundle文件（记得先编译一次，不然bundle文件是红色的，无法使用），然后将图中标记的bundle文件完整路径复制下来：

回到命令行程序，点击下图中标记处，选择Edit Scheme：

在弹出窗口的下图标记位置粘贴刚刚复制的bundle文件路径：

这样就完成了参数的传入。

使用可选包

最后在main.m中进行测试：

#import <Foundation/Foundation.h>
#import "BasicGreeter.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 声明一个类型为id并且遵循Greeter协议的变量并进行测试
        id<Greeter> greeter = [[BasicGreeter alloc] init];
        NSLog(@"%@",[greeter greeting:@"Hello"]);

        // 在指定路径（通过输入参数获得）创建一个包
        NSString *bundlePath;
        // argc设置了程序的参数数量，而argv[]数组存储了参数值，数组第一个参数存储了程序的名称，因此argc大于或等于1，这里传递了一个参数（包的路径），所以argc应该等于2.
        if (argc != 2) {
            // 没有获得包路径，退出
            NSLog(@"Please provide a path for the bundle");
        }
        else{
            // 获取包的路径并创建一个NSBundle对象
            bundlePath = [NSString stringWithUTF8String:argv[1]];
            NSBundle *greeterBundle = [NSBundle bundleWithPath:bundlePath];
            if (greeterBundle == nil) {
                NSLog(@"Bundle not found at path");
            }
            else{
                // 以动态方式加载包
                NSError *error;
                BOOL isLoaded = [greeterBundle loadAndReturnError:&error];
                if (!isLoaded) {
                    NSLog(@"Error = %@",[error localizedDescription]);
                }
                else{
                    // 加载包后，使用该包创建一个对象，并向这个对象发送一条消息
                    Class greeterClass = [greeterBundle classNamed:@"CustomGreeter"];
                    greeter = [[greeterClass alloc] init];
                    NSLog(@"%@",[greeter greeting:@"Hello"]);

                    // 使用完以动态方式加载的包后进行卸载
                    // 先释放所有用包中的类创建的对象！
                    greeter = nil;
                    BOOL isUnloaded = [greeterBundle unload];
                    if (!isUnloaded) {
                        NSLog(@"Couldn‘t unload bundle");
                    }
                }
            }
        }
    }
    return 0;
}

运行结果：

2016-07-08 14:10:26.774 DynaLoader[12966:141636] Hello,World!
2016-07-08 14:10:26.802 DynaLoader[12966:141636] Hello,Universe!

可以看到动态加载的可选包中类可以跟工程中自带的类同样地工作。

运行时系统API

下面示例代码是对运行时系统API的使用：
定义了一个方法的实现函数，创建并注册了一个类，创建了一个类实例，最后以动态方式向该实例添加了一个变量；

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>

// 用于显示选择器的方法实现函数
static void display(id self, SEL _cmd){
    NSLog(@"Invoking method with selector %@ on %@ instance", NSStringFromSelector(_cmd), [self className]);
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建一个类对（类与元类）
        Class WidgetClass = objc_allocateClassPair([NSObject class], "Widget", 0);

        // 向这个类添加一个方法
        const char *types = "v@:";
        // class_addMethod的4个参数分别添加方法的目标类、新方法的选择器、函数的地址（数据类型为IMP）和描述方法参数的数据类型的字符串（字符串里的内容分别依次为函数返回值类型和每个参数类型，在这里v表示void，@表示selector，：表示IMP）
        class_addMethod(WidgetClass, @selector(display), (IMP)display, types);

        // 向这个类添加一个实例变量
        const char *height = "height";
        class_addIvar(WidgetClass, height, sizeof(id), rint(log2(sizeof(id))), @encode(id));

        // 注册这个类
        objc_registerClassPair(WidgetClass);

        // 创建一个widget实例，并设置实例变量的值
        id widget = [[WidgetClass alloc] init];
        id value = [NSNumber numberWithInt:15];
        [widget setValue:value forKey:[NSString stringWithUTF8String:height]];
        // @encode(type)返回的是type的类型（用C语言 char *的表示）
        NSLog(@"Widget instance height = %@", [widget valueForKey:[NSString stringWithUTF8String:height]]);

        // 向widget实例发送一条消息
        objc_msgSend(widget, NSSelectorFromString(@"display"));

        // 以动态方式向widget实例添加一个变量（关联对象）
        // 由于Objective-C中不能向对象添加实例变量，使用关联对象来模拟该功能
        NSNumber *width = [NSNumber numberWithInt:10];
        objc_setAssociatedObject(widget, @"width", width, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

        // 获取该变量的值并显示它
        id result = objc_getAssociatedObject(widget, @"width");
        NSLog(@"Widget instance width = %@", result);
    }
    return 0;
}

注意：在目前版本的Xcode中，需要将 Apple LLVM X.X（版本号） - Preprocessing 中的 Enable Strict Checking of objc_msgSend Calls 设置为No，不然编译会失败。

动态代理

下面是一个动态代理的实现示例。使用Foundation框架中的NSInvocation和NSProxy类实现动态的标准转发功能（另一种消息转发方式为快速转发，在[精通Objective-C]对象和消息传递中有具体实现过程）。

将标准转发功能与NSProxy类一起使用，可以在Objective-C中获得不错的面向切面编程（AOP）机制，AOP是一种编程范式，其目的是通过横切将依赖或影响程序其他部分的功能和程序中的其他组成部分分割开，提高程序的模块化程度。

创建实现横切功能的协议和类

Invoker协议：

#import <Foundation/Foundation.h>

@protocol Invoker <NSObject>

@required // 必要方法（必须实现）
-(void)preInvoke:(NSInvocation *)inv withTarget:(id) target;
@optional // 可选方法
-(void)postInvoke:(NSInvocation *)inv withTarget:(id) target;
@end

AuditingInvoker类：

#import <Foundation/Foundation.h>
#import "Invoker.h"

@interface AuditingInvoker : NSObject<Invoker>

@end

#import "AuditingInvoker.h"

@implementation AuditingInvoker

-(void) preInvoke:(NSInvocation *)inv withTarget:(id)target{
    NSLog(@"Creating audit log before sending message with selector %@ to %@ object",NSStringFromSelector([inv selector]),[target className]);
}

-(void) postInvoke:(NSInvocation *)inv withTarget:(id)target{
    NSLog(@"Creating audit log after sending message with selector %@ to %@ object",NSStringFromSelector([inv selector]),[target className]);
}
@end

编写代理类

AspectProxy类：

#import <Foundation/Foundation.h>
#import "Invoker.h"

@interface AspectProxy : NSProxy

@property(strong) id proxyTarget;  // 代理的对象
@property(strong) id<Invoker> invoker; // 实现横切的对象
@property(readonly) NSMutableArray *selectors; // 已注册选择器的集合

-(id)initWithObject:(id)object andInvoker:(id<Invoker>)invoker;
-(id)initWithObject:(id)object selectors:(NSArray *)selectors andInvoker:(id<Invoker>)invoker;
-(void)registerSelector:(SEL)selector;
@end

#import "AspectProxy.h"

@implementation AspectProxy
// 父类为NSProxy，是一个基类，所以方法开头没有调用[super init]
-(id)initWithObject:(id)object selectors:(NSArray *)selectors andInvoker:(id<Invoker>)invoker{
    _proxyTarget = object;
    _invoker = invoker;
    _selectors = [selectors mutableCopy];
    return self;
}

-(id)initWithObject:(id)object andInvoker:(id<Invoker>)invoker{
    return [self initWithObject:object selectors:nil andInvoker:invoker];
}

// 为目标对象中被调用的方法返回一个NSMethodSignature对象。运行时系统要求在执行标准转发时实现这个方法。
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    return [self.proxyTarget methodSignatureForSelector:sel];
}

-(void)forwardInvocation:(NSInvocation *)invocation{
    // 在调用目标方法前执行横切功能
    if ([self.invoker respondsToSelector:@selector(preInvoke:withTarget:)]) {
        if (self.selectors != nil) {
            SEL methodSel = [invocation selector];
            for (NSValue *selValue in self.selectors) {
                if (methodSel == [selValue pointerValue]) {
                    [[self invoker] preInvoke:invocation withTarget:self.proxyTarget];
                    break;
                }
            }
        }
        else{
            [[self invoker] preInvoke:invocation withTarget:self.proxyTarget];
        }
    }

    // 调用目标方法
    [invocation invokeWithTarget:self.proxyTarget];

    // 在调用目标方法后执行横切功能
    if ([self.invoker respondsToSelector:@selector(postInvoke:withTarget:)]) {
        if (self.selectors != nil) {
            SEL methodSel = [invocation selector];
            for (NSValue *selValue in self.selectors) {
                if (methodSel == [selValue pointerValue]) {
                    [[self invoker] postInvoke:invocation withTarget:self.proxyTarget];
                }
            }
        }
        else{
            [[self invoker] postInvoke:invocation withTarget:self.proxyTarget];
        }
    }
}

// 向已注册选择器的集合添加一个选择器
-(void)registerSelector:(SEL)selector{
    NSValue *selValue = [NSValue valueWithPointer:selector];
    [self.selectors addObject:selValue];
}

@end

添加代理的目标类

使用之前章节创建的Calculator类，代码如下：

#import <Foundation/Foundation.h>

@interface Calculator : NSObject

-(NSNumber *) sumAddend1:(NSNumber *)adder1 addend2:(NSNumber *)adder2;
-(NSNumber *) sumAddend1:(NSNumber *)adder1 :(NSNumber *)adder2;
@end

#import "Calculator.h"

@implementation Calculator

-(NSNumber *) sumAddend1:(NSNumber *)adder1 addend2:(NSNumber *)adder2{
    NSLog(@"Invoking method on %@ object with selector %@", [self className], NSStringFromSelector(_cmd));
    return [NSNumber numberWithInteger:[adder1 integerValue] + [adder2 integerValue]];
}

-(NSNumber *) sumAddend1:(NSNumber *)adder1 :(NSNumber *)adder2{
    NSLog(@"Invoking method on %@ object with selector %@", [self className], NSStringFromSelector(_cmd));
    return [NSNumber numberWithInteger:[adder1 integerValue] + [adder2 integerValue]];
}

@end

测试动态代理程序

#import <Foundation/Foundation.h>
#import "AspectProxy.h"
#import "AuditingInvoker.h"
#import "Calculator.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建Calculator对象
        id calculator = [[Calculator alloc] init];
        NSNumber *addend1 = [NSNumber numberWithInteger:-25];
        NSNumber *addend2 = [NSNumber numberWithInteger:10];

        // 为该对象创建代理
        NSValue* selValue = [NSValue valueWithPointer:@selector(sumAddend1:addend2:)];
        NSArray *selvalues = @[selValue];
        AuditingInvoker *invoker = [[AuditingInvoker alloc] init];
        id calculatorProxy = [[AspectProxy alloc] initWithObject:calculator selectors:selvalues andInvoker:invoker];

        // 使用指定的选择器向该代理发送消息
        [calculatorProxy sumAddend1:addend1 addend2:addend2];

        // 使用没有特殊处理要求的其他选择器向这个代理发送消息
        [calculatorProxy sumAddend1:addend1 :addend2];

        // 为这个代理注册另一个选择器并再次向其发送消息
        [calculatorProxy registerSelector:@selector(sumAddend1::)];
        [calculatorProxy sumAddend1:addend1 :addend2];
    }
    return 0;
}

运行结果：

2016-07-08 17:37:40.146 AspectProxy[23532:243497] Creating audit log before sending message with selector sumAddend1:addend2: to Calculator object
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Invoking method on Calculator object with selector sumAddend1:addend2:
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Creating audit log after sending message with selector sumAddend1:addend2: to Calculator object
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Invoking method on Calculator object with selector sumAddend1::
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Creating audit log before sending message with selector sumAddend1:: to Calculator object
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Invoking method on Calculator object with selector sumAddend1::
2016-07-08 17:37:40.147 AspectProxy[23532:243497] Creating audit log after sending message with selector sumAddend1:: to Calculator object

分析结果可以看到，调用Calculator对象的代理中的sumAddend1:addend2:方法，会使该代理调用AuditingInvoker中的两个方法和真正目标（Calculator对象）中的sumAddend1:addend2:方法。因为该方法是通过Calculator对象的代理注册的。然后调用Calculator对象中的sumAddend1::方法，因为该方法还没有通过这个代理注册，所以程序仅会将调用该方法的消息转发给Calculator对象，而不会调用AuditingInvoker方法。最后对sumAddend1::方法进行注册之后，然后程序再次调用了它，程序就调用了AuditingInvoker对象中的AOP方法和真正目标（Calculator对象）中的sumAddend1::方法。