iOS - 如何实现弱引用字典

引言

我们都有用过 UIButton 的这个方法：
- (void)addTarget:(nullable id)target action:(SEL)action forControlEvents:(UIControlEvents)controlEvents;
不知道大家是否有去想过里面的实现原理。addTarget:action:forControlEvents 方法是用什么来保存这个target呢？
显然，里面不是用的数组就是用的字典来保存target，而target和action又是一一对应的，所以我猜其内部是用一个字典来保存。

但是，我们都知道 NSMutableDictionary 的 - setObject:forKey: 方法会强引用对象，这样就会很容易造成循环引用。下面举个例子来说明一下。

例如，我们有一个viewController，viewController上有对 UIButton 的强引用，UIButton 调用 addTarget:action:forControlEvents 中这个target又是viewController，示例代码如下：

@interface ViewController ()

@property (strong, nonatomic) UIButton *button;


@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.button = [[UIButton alloc] initWithFrame:CGRectMake(50, 50, 100, 32)];
    [self.button setTitle:@"Button" forState:UIControlStateNormal];
    [self.button setBackgroundColor:[UIColor redColor]];
    self.button.titleLabel.font = [UIFont systemFontOfSize:19];
    
    [self.button addTarget:self action:@selector(touchButton:) forControlEvents:UIControlEventTouchUpInside];
}

- (void)touchButton:(UIButton *)button {
    NSLog(@"touchButton");
}

@end

按照常规的逻辑，会形成如下图的一个循环引用。

但是实际上并没有形成循环引用，说明苹果内部做了处理。
接下来，我会介绍有哪些方法可以实现弱引用字典。

方法一：NSValue

- (nullable id)objectForKey:(id<NSCopying>)aKey {
    NSValue *value = [self objectForKey:aKey];
    
    return value.nonretainedObjectValue;
}

- (void)fm_setObject:(id)anObject forKey:(id <NSCopying>)aKey {
    NSValue *value = [NSValue valueWithNonretainedObject:anObject];
    [self setObject:value forKey:aKey];
}

- (void)fm_setDictionary:(NSDictionary *)otherDictionary {
    [otherDictionary enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key,
                                                         id  _Nonnull obj,
                                                         BOOL * _Nonnull stop) {
        [self fm_setObject:obj forKey:key];
    }];
}

分别用到了 NSValue 的 + valueWithNonretainedObject: 和 nonretainedObjectValue 方法来存取对象。

方法二：用block封装与解封

下面的代码是从 HXImage 拿过来的。

利用block封装一个对象, 且block中对象的持有操作是一个弱引用指针. 而后将block当做对象放入容器中. 容器直接持有block, 而不直接持有对象. 取对象时解包block即可得到对应对象.

第一步，封装与解封装

typedef id (^WeakReference)(void);

WeakReference makeWeakReference(id object) {
    __weak id weakref = object;
    return ^{
        return weakref;
    };
}

id weakReferenceNonretainedObjectValue(WeakReference ref) {
    return ref ? ref() : nil;
}

第二步，改造原容器

- (void)weak_setObject:(id)anObject forKey:(NSString *)aKey {
    [self setObject:makeWeakReference(anObject) forKey:aKey];
}

- (void)weak_setObjectWithDictionary:(NSDictionary *)dic {
    for (NSString *key in dic.allKeys) {
        [self setObject:makeWeakReference(dic[key]) forKey:key];
    }
}

- (id)weak_getObjectForKey:(NSString *)key {
    return weakReferenceNonretainedObjectValue(self[key]);
}

方法三：使用NSProxy 的子类

像YYKit 这套框架就是用的这种方法，完整可以参见 YYWeakProxy 这个类。
下面摘取了部分代码：
YYWeakProxy.h 文件.

@interface YYWeakProxy : NSProxy

/**
 The proxy target.
 */
@property (nullable, nonatomic, weak, readonly) id target;

/**
 Creates a new weak proxy for target.
 @param target Target object.
 @return A new proxy object.
 */
- (instancetype)initWithTarget:(id)target;

+ (instancetype)proxyWithTarget:(id)target;

@end

YYWeakProxy.m 文件.

@implementation YYWeakProxy

- (instancetype)initWithTarget:(id)target {
    _target = target;
    return self;
}

+ (instancetype)proxyWithTarget:(id)target {
    return [[YYWeakProxy alloc] initWithTarget:target];
}

- (id)forwardingTargetForSelector:(SEL)selector {
    return _target;
}

- (void)forwardInvocation:(NSInvocation *)invocation {
    void *null = NULL;
    [invocation setReturnValue:&null];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
    return [NSObject instanceMethodSignatureForSelector:@selector(init)];
}

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

//... 

@end

具体使用的示例代码：

@implementation MyView {
    NSTimer *_timer;
}

- (void)initTimer {
    YYWeakProxy *proxy = [YYWeakProxy proxyWithTarget:self];
    _timer = [NSTimer timerWithTimeInterval:0.1
                                     target:proxy
                                   selector:@selector(tick:)
                                   userInfo:nil
                                    repeats:YES];
}

- (void)tick:(NSTimer *)timer {...}
@end

你可能会问前面两个方法不是很简单吗，干嘛要搞得这么麻烦？
其实，这主要是为了利用 NSProxy 来实现代理模式，使用 NSProxy 的消息转发机制让它来调用其他类的方法。 这样做和前面两个方法有一个不一样的地方：前面两个方法都要存取对象，要把对象从容器中取出来才能用；第三个方法利用了NSProxy消息转发机制就不需要这样做了。

更多的 NSProxy 使用 可以参考 NSProxy使用笔记。

总结：三种方法都可以实现弱引用字典，具体用哪种方法就看你个人喜好咯。当然，用上面三种方法也可以实现弱引用数组。
我这里用第一种方法简单的封装了下弱引用数组和弱引用字典：https://github.com/lexiaoyao20/WeakDictionary/tree/master/WeakDictionary/WeakObject