BlocksKit(2)-DynamicDelegate
动态代理可以说是这个Block里面最精彩的一部分了，可以通过自己给一个类的的协议方法指定对应的block来实现让这个协议的回调都直接在block里面去执行，那么为什么要这样做呢？从功能的实现上来说，其实所实现的功能是一样，但是在代码的结构上却是非常大的区别。在平常是delegate的时候，我们把一个对象的delegate交给一个弱引用的对象，最常见的就是tableview的实现，然后在这个tableview里面去实现这些协议，对比使用blockkit的方式，代码明显要集中，当一个对象要实现很多个委托的时候，这个时候就会写很多的代码。通过BlockKit的这种实现方式，能够让代码集中起来，而且在比如MVVM或者是函数式编程的风格中，很明显都是更好的选择。这是我个人对为什么要做这个动态代理功能实现的一点体会，知识有限，希望有大侠能够指点出更深层次的东西。那么来看一下这个动态代理到底是怎么实现的呢？
A2DynamicDelegate
以UIAlertView为例来看一下：
[dd implementMethod:@selector(alertView:willDismissWithButtonIndex:) withBlock:^(UIAlertView *alertView, NSInteger buttonIndex) {
NSLog(@"You pushed button #%ld (%@)", buttonIndex, [alertView buttonTitleAtIndex:buttonIndex]);
}];
这个地方用用一个block实现了alertView:willDismissWithButtonIndex:这个协议方法的回调，这里面有个implementMethod:withBlock:这个方法，看一下具体的实现：
- (void)implementMethod:(SEL)selector withBlock:(id)block
{
NSCAssert(selector, @"Attempt to implement or remove NULL selector");
BOOL isClassMethod = self.isClassProxy;
if (!block) {
[self.invocationsBySelectors bk_removeObjectForSelector:selector];
return;
}
struct objc_method_description methodDescription = protocol_getMethodDescription(self.protocol, selector, YES, !isClassMethod);
if (!methodDescription.name) methodDescription = protocol_getMethodDescription(self.protocol, selector, NO, !isClassMethod);
A2BlockInvocation *inv = nil;
if (methodDescription.name) {
NSMethodSignature *protoSig = [NSMethodSignature signatureWithObjCTypes:methodDescription.types];
inv = [[A2BlockInvocation alloc] initWithBlock:block methodSignature:protoSig];
} else {
inv = [[A2BlockInvocation alloc] initWithBlock:block];
}
[self.invocationsBySelectors bk_setObject:inv forSelector:selector];
}
- 先是判断是不是类方法，接着判断参数block是否为空
- 然后根据协议里面selector去取关于这个method的相关的参数信息
- 如果说名字存在，那么根据这个method的types信息来生成一个方法签名，如果不存在那么就用另外一个初始化方法来初始化一个A2BlockInvocation对象，两个初始化方法的区别后面再进行比较
- 最后一步把A2BlockInvocation对象作为object，selector作为key的NSHashMap中去，这里面为什么要要用NSHashMap呢，主要这个里面有内存管理的条件选项，并且可以指定一下描述、是否相等的方法，用起来比NSMutableSet要强大的多，再一点要说明额是selector作为key实际是先被包装成一个指针类型，然后再通过桥接成id的方式去生成一个对象，单纯的selector不是对象，是不能作为key来存在的
上面的这段代码就是为了创建一个A2BlockInvocation对象，到这里看到这个对象的名字，想到了为什么动态转发的实际实现其实就是把根据Runtime里面消息转发的规则，然后去拦截，重新生成新的调用对象和方法签名，那继续看文件里面有没有实现消息转发的两个方法呢？果然存在：
- (void)forwardInvocation:(NSInvocation *)outerInv；
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
验证了我们的想法，所以上面的那一步就是在为这个一步做准备。看一下这两个方法的具体的实现：
- (void)forwardInvocation:(NSInvocation *)outerInv
{
SEL selector = outerInv.selector;
A2BlockInvocation *innerInv = nil;
if ((innerInv = [self.invocationsBySelectors bk_objectForSelector:selector])) {
[innerInv invokeWithInvocation:outerInv];
} else if ([self.realDelegate respondsToSelector:selector]) {
[outerInv invokeWithTarget:self.realDelegate];
}
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
A2BlockInvocation *invocation = nil;
if ((invocation = [self.invocationsBySelectors bk_objectForSelector:aSelector]))
return invocation.methodSignature;
else if ([self.realDelegate methodSignatureForSelector:aSelector])
return [self.realDelegate methodSignatureForSelector:aSelector];
else if (class_respondsToSelector(object_getClass(self), aSelector))
return [object_getClass(self) methodSignatureForSelector:aSelector];
return [[NSObject class] methodSignatureForSelector:aSelector];
}
这两个里面都是根据Selector去到self.invocationsBySelectors里面去拿A2BlockInvocation或者methodSignature，如果取不到A2BlockInvocation的话，就走self.realDelegate来进行处理，如果方法签名拿不到就转发给类方法，再不行就用NSObject来生成一个。
还有A2DynamicDelegate类是继承自NSProxy，这个类本身就是一个处理消息转发的东西并且遵守NSObject的协议，这里面有实现了一些常用的方法：
- (BOOL)conformsToProtocol:(Protocol *)aProtocol
{
return protocol_isEqual(aProtocol, self.protocol) || [super conformsToProtocol:aProtocol];
}
- (BOOL)respondsToSelector:(SEL)selector
{
return [self.invocationsBySelectors bk_objectForSelector:selector] || class_respondsToSelector(object_getClass(self), selector) || [self.realDelegate respondsToSelector:selector];
}
- (void)doesNotRecognizeSelector:(SEL)aSelector
{
[NSException raise:NSInvalidArgumentException format:@"-[%s %@]: unrecognized selector sent to instance %p", object_getClassName(self), NSStringFromSelector(aSelector), (__bridge void *)self];
}
这个文件里面，还有A2DynamicClassDelegate这个类，其实原理是一样的，这里就不再说明，另外有一个获取用户协议的方法有意思：
static Protocol *a2_classProtocol(Class _cls, NSString *suffix, NSString *description)
{
Class cls = _cls;
while (cls) {
NSString *className = NSStringFromClass(cls);
NSString *protocolName = [className stringByAppendingString:suffix];
Protocol *protocol = objc_getProtocol(protocolName.UTF8String);
if (protocol) return protocol;
cls = class_getSuperclass(cls);
}
NSCAssert(NO, @"Specify protocol explicitly: could not determine %@ protocol for class %@ (tried <%@>)", description, NSStringFromClass(_cls), [NSStringFromClass(_cls) stringByAppendingString:suffix]);
return nil;
}
这里面是一个while的循环，就是在本类上去找又没有这个协议，如果没有就继续向上在父类的里面去找，如果还是是在找不到那就走断言。
这差不多就把A2DynamicDelegate这个类讲的差不多了。
A2BlockInvocation
上面的多次提到这个类，现在就这个类来讨论一下，这个类主要是用来干啥的呢？就是存储方法签名和block的方法签名具体执行的block的一个类。刚刚说到两个初始化方法的区别，就是差一个签名参数没传，这个签名参数是要被block代替的那个selector的方法。那如果是自己生成和穿进去的区别就是，这个block没有拦截消息的事件，他本身就是他本身。如以下代码：
- (instancetype)initWithBlock:(id)block
{
//如果不传进来，怎么办，那就自己生成一个
NSParameterAssert(block);
NSMethodSignature *blockSignature = [[self class] typeSignatureForBlock:block];
NSMethodSignature *methodSignature = [[self class] methodSignatureForBlockSignature:blockSignature];
NSAssert(methodSignature, @"Incompatible block: %@", block);
return (self = [self initWithBlock:block methodSignature:methodSignature blockSignature:blockSignature]);
}
- (instancetype)initWithBlock:(id)block methodSignature:(NSMethodSignature *)methodSignature
{
NSParameterAssert(block);
NSMethodSignature *blockSignature = [[self class] typeSignatureForBlock:block];
if (![[self class] isSignature:methodSignature compatibleWithSignature:blockSignature]) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Attempted to create block invocation with incompatible signatures" userInfo:@{A2IncompatibleMethodSignatureKey: methodSignature}];
}
return (self = [self initWithBlock:block methodSignature:methodSignature blockSignature:blockSignature]);
}
这里面有几个方法的实现是我们不常见的，比如
typeSignatureForBlock:block和isSignature:compatibleWithSignature:blockSignature这个连个方法，一个是根据block来生成一个方法签名，另一个是判断协议方法签名和block的方法签名是否兼容。要想明白这个两个方法的实现，就需要了解block内部的数据结构到底是什么样子的。看一下代码：
// block的内存结构，在苹果官方的源码中能够找到具体的数据结构，BK的作者只是写了一个
// 一样的结构体
typedef struct _BKBlock {
__unused Class isa;
BKBlockFlags flags;
__unused int reserved;
void (__unused *invoke)(struct _BKBlock *block, ...);
struct {
unsigned long int reserved;
unsigned long int size;
// requires BKBlockFlagsHasCopyDisposeHelpers
void (*copy)(void *dst, const void *src);
void (*dispose)(const void *);
// requires BKBlockFlagsHasSignature
const char *signature;
const char *layout;
} *descriptor;
// imported variables
} *BKBlockRef;
+ (NSMethodSignature *)typeSignatureForBlock:(id)block __attribute__((pure, nonnull(1)))
{
BKBlockRef layout = (__bridge void *)block;
// 通过flag标记来判断是够拥有签名
if (!(layout->flags & BKBlockFlagsHasSignature))
return nil;
// 存在的话就行就去到descriptor里面去找
void *desc = layout->descriptor;
desc += 2 * sizeof(unsigned long int);
if (layout->flags & BKBlockFlagsHasCopyDisposeHelpers)
desc += 2 * sizeof(void *);
if (!desc)
return nil;
//上面通过位移来找到signature的指针
const char *signature = (*(const char **)desc);
// 生成NSMethodSignature
return [NSMethodSignature signatureWithObjCTypes:signature];
}
// 通过参数的数量和返回值判断block的签名和协议方法签名事是否能够兼容
+ (BOOL)isSignature:(NSMethodSignature *)signatureA compatibleWithSignature:(NSMethodSignature *)signatureB __attribute__((pure))
{
if (!signatureA || !signatureB) return NO;
if ([signatureA isEqual:signatureB]) return YES;
if (signatureA.methodReturnType[0] != signatureB.methodReturnType[0]) return NO;
NSMethodSignature *methodSignature = nil, *blockSignature = nil;
if (signatureA.numberOfArguments > signatureB.numberOfArguments) {
methodSignature = signatureA;
blockSignature = signatureB;
} else if (signatureB.numberOfArguments > signatureA.numberOfArguments) {
methodSignature = signatureB;
blockSignature = signatureA;
} else {
return NO;
}
NSUInteger numberOfArguments = methodSignature.numberOfArguments;
for (NSUInteger i = 2; i < numberOfArguments; i++) {
if ([methodSignature getArgumentTypeAtIndex:i][0] != [blockSignature getArgumentTypeAtIndex:i - 1][0])
return NO;
}
return YES;
}
/// Creates a method signature compatible with a given block signature.
+ (NSMethodSignature *)methodSignatureForBlockSignature:(NSMethodSignature *)original
{
if (!original) return nil;
if (original.numberOfArguments < 1) {
return nil;
}
if (original.numberOfArguments >= 2 && strcmp(@encode(SEL), [original getArgumentTypeAtIndex:1]) == 0) {
return original;
}
// initial capacity is num. arguments - 1 (@? -> @) + 1 (:) + 1 (ret type)
// optimistically assuming most signature components are char[1]
NSMutableString *signature = [[NSMutableString alloc] initWithCapacity:original.numberOfArguments + 1];
const char *retTypeStr = original.methodReturnType;
// 返回类型，id 类型(self @)，选择子类型(SEL :)
[signature appendFormat:@"%s%s%s", retTypeStr, @encode(id), @encode(SEL)];
// signature = (返回类型)@:根据具体的类型继续拼接如@"TableView"
for (NSUInteger i = 1; i < original.numberOfArguments; i++) {
const char *typeStr = [original getArgumentTypeAtIndex:i];
NSString *type = [[NSString alloc] initWithBytesNoCopy:(void *)typeStr length:strlen(typeStr) encoding:NSUTF8StringEncoding freeWhenDone:NO];
[signature appendString:type];
}
return [NSMethodSignature signatureWithObjCTypes:signature.UTF8String];
}
接下来看一下一个消息收到之后是如何被转发到block上的
- (BOOL)invokeWithInvocation:(NSInvocation *)outerInv returnValue:(out NSValue **)outReturnValue setOnInvocation:(BOOL)setOnInvocation
{
NSParameterAssert(outerInv);
NSMethodSignature *sig = self.methodSignature;
if (![outerInv.methodSignature isEqual:sig]) {
NSAssert(0, @"Attempted to invoke block invocation with incompatible frame");
return NO;
}
NSInvocation *innerInv = [NSInvocation invocationWithMethodSignature:self.blockSignature];
void *argBuf = NULL;
// 由于self.methodSignature的隐藏参数有两个就从2开始
// 然后循环参数传递给block的参数列列表
for (NSUInteger i = 2; i < sig.numberOfArguments; i++) {
const char *type = [sig getArgumentTypeAtIndex:i];
NSUInteger argSize;
NSGetSizeAndAlignment(type, &argSize, NULL);
if (!(argBuf = reallocf(argBuf, argSize))) {
return NO;
}
[outerInv getArgument:argBuf atIndex:i];
//block的Signature签名参数只有一个隐藏，所以要减一
[innerInv setArgument:argBuf atIndex:i - 1];
}
// 调用的target设置为block
[innerInv invokeWithTarget:self.block];
// 设置返回值
NSUInteger retSize = sig.methodReturnLength;
if (retSize) {
if (outReturnValue || setOnInvocation) {
if (!(argBuf = reallocf(argBuf, retSize))) {
return NO;
}
[innerInv getReturnValue:argBuf];
if (setOnInvocation) {
[outerInv setReturnValue:argBuf];
}
if (outReturnValue) {
*outReturnValue = [NSValue valueWithBytes:argBuf objCType:sig.methodReturnType];
}
}
} else {
if (outReturnValue) {
*outReturnValue = nil;
}
}
free(argBuf);
return YES;
}
设置了参数和返回值，然后调用，我们block就跑起来，完成了刚开开始的目的。