NSProxy 使用总结

NSProxy是一个虚类。它有什么用处呢？
OC中类是不支持多继承的，要想实现多继承一般是有protocol的方式，还有一种就是利用NSProxy。有同学可能会问为什么不用NSObject来做？同样都是基类，都支持NSObject协议，NSProxy 有的NSObject 都有。但是点进NSProxy .h可以看见NSProxy没有init方法，而且NSProxy自身的方法很少，是一个很干净的类。这点很重要，因为NSObject自身的分类特别多，而消息转发的机制是当接收者无法处理时才会通过forwardInvocation:来寻求能够处理的对象.在日常使用时，我们很难避免不使用NSObject 的分类方法比如valueForKey这个方法NSObject就不会转发。详解可见https://www.jianshu.com/p/5bfcc32c21c0

---

然后我们具体来看看NSProxy 都用来做什么。

1.多继承

虚基类本身就是为了解决继承问题而生，而OC的动态特性使得我们可以利用NSProxy做多继承：
首先我们新建两个基类如下：

@implementation classA
-(void)infoA{
    NSLog(@"这里 是 classA ，我是卖水的");
    
}
@end

@implementation classB
-(void)infoB{
    NSLog(@"这里 是 classB 我是卖饭的");
}
@end

classA 卖水 classB 卖饭，但是分开买太麻烦，所以我找了一个代理如下

@interface ClassProxy : NSProxy
@property(nonatomic,strong,readonly)NSMutableArray *targetArray;
-(void)target:(id)target;
-(void)handleTargets:(NSArray *)targets;
@end

NSProxy 必须以子类的形式出现。
因为考虑到很可能还有其他的卖衣服的，卖鞋子的需要ClassProxy来代理，这边做了一个数组来存放需要代理的类

@interface ClassProxy()
@property(nonatomic,strong)NSMutableArray *targetArray;//多个targets皆可代理
@property(nonatomic,strong)NSMutableDictionary *methodDic;
@property(nonatomic,strong)id target;
@end

然后target 和 相对应的method demo做了一个字典来存储，方便获取

-(void)registMethodWithTarget:(id)target{
    unsigned int countOfMethods = 0;
    Method *method_list = class_copyMethodList([target class], &countOfMethods);
    for (int i = 0; i<countOfMethods; i++) {
        Method method = method_list[i];
        //得到方法的符号
        SEL sel = method_getName(method);
        //得到方法的符号字符串
        const char *sel_name = sel_getName(sel);
        //得到方法的名字
        NSString *method_name = [NSString stringWithUTF8String:sel_name];
        self.methodDic[method_name] = target;
    }
    free(method_list);
}

然后就是最主要的两个方法

-(void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = invocation.selector;
    NSString *methodName = NSStringFromSelector(sel);
    id target = self.methodDic[methodName];
    if (target) {
        [invocation invokeWithTarget:target];
    }
    
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    NSMethodSignature *Method;
    NSString *methodName = NSStringFromSelector(sel);
    id target = self.methodDic[methodName];
    if (target) {
        Method =  [target methodSignatureForSelector:sel];
    }else{
        Method = [super methodSignatureForSelector:sel];
    }
    return Method;
}

methodSignatureForSelector:得到对应的方法签名，通过forwardInvocation：转发
下面看一下调用和打印结果

- (void)viewDidLoad {
    [super viewDidLoad];
//    [self analysis];
    [self classInheritance];
    // Do any additional setup after loading the view, typically from a nib.
}
//多继承
-(void)classInheritance{
    classA *A = [[classA alloc]init];
    classB *B = [[classB alloc]init];
    ClassProxy *proxy = [ClassProxy alloc];
    [proxy handleTargets:@[A,B]];
    [proxy performSelector:@selector(infoA)];
    [proxy performSelector:@selector(infoB)];
    
}
2018-12-27 18:02:34.445 NSProxyStudy[18975:4587631] 这里 是 classA ，我是卖水的
2018-12-27 18:02:34.446 NSProxyStudy[18975:4587631] 这里 是 classB 我是卖饭的

以上就是利用NSProxy 实现多继承。

2.避免循环应用

这里举了比较常见了一个例子NSTimer.
由于目前苹果在iOS10以上，已经给出了timer 的block方式，已经可以解决循环引用的问题。所以demo举例只是说明利用NSProxy如何解决循环引用，大家在使用的时候可直接使用系统的方法。
首先因为NSTimer创建的时候需要传入一个target，并且持有它，而target本身也会持有timer所以会造成循环引用。所以我们将target 用NSProxy的子类代替如下

-(void)viewDidLoad{
    [super viewDidLoad];
    self.timer = [NSTimer timerWithTimeInterval:1
                                         target:[WeakProxy proxyWithTarget:self]
                                       selector:@selector(invoked:)
                                       userInfo:nil
                                        repeats:YES];
    [[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
}
- (void)invoked:(NSTimer *)timer{
    NSLog(@"1");
}

在WeakProxy中我们设定target 为弱引用如下

@interface WeakProxy ()
@property(nonatomic,weak)id target;
@end

@implementation WeakProxy
-(instancetype)initWithTarget:(id)target{
    self.target = target;
    return self;
}
+(instancetype)proxyWithTarget:(id)target{
    return [[self alloc] initWithTarget:target];
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    return [self.target methodSignatureForSelector:sel];
}
-(void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = invocation.selector;
    if ([self.target respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.target];
    }
}
@end

然后同样利用上述两个方法进行消息转发即可。

AOP面向切片编程

iOS中面向切片编程一般有两种方式 ，一个是直接基于runtime 的method-Swizzling.还有一种就是基于NSProxy
我们先创建一个子类AOPProxy

typedef void(^proxyBlock)(id target,SEL selector);

NS_ASSUME_NONNULL_BEGIN

@interface AOPProxy : NSProxy
+(instancetype)proxyWithTarget:(id)target;
-(void)inspectSelector:(SEL)selector preSelTask:(proxyBlock)preTask endSelTask:(proxyBlock)endTask;
@end

-(void)inspectSelector:(SEL)selector preSelTask:(proxyBlock)preTask endSelTask:(proxyBlock)endTask;
第一个参数是需要hook的方法名字 后面两个分别是hook 该方法后 执行前需要执行的block 和 执行后的需要执行的block

@interface AOPProxy ()
@property(nonatomic,strong)id target;
@property(nonatomic,strong)NSMutableDictionary *preSelTaskDic;
@property(nonatomic,strong)NSMutableDictionary *endSelTaskDic;
@end

然后创建两个字典，分别存放 不同selector 对应的执行block（可能一个target有好几个方法需要被hook）
然后我们来看一下执行

-(void)inspect{
    NSMutableArray *targtArray = [AOPProxy proxyWithTarget:[NSMutableArray arrayWithCapacity:1]];
    [(AOPProxy *)targtArray inspectSelector:@selector(addObject:) preSelTask:^(id target, SEL selector) {
        [target addObject:@"-------"];
        NSLog(@"%@我加进来之前",target);
    } endSelTask:^(id target, SEL selector) {
        [target addObject:@"-------"];
        NSLog(@"%@我加进来之后",target);
    }];
    [targtArray addObject:@"我是一个元素"];
}

结果为

2018-12-28 11:57:05.590 NSProxyStudy[23812:4840464] (
    "-------"
)我加进来之前
2018-12-28 11:57:05.591 NSProxyStudy[23812:4840464] (
    "-------",
    "\U6211\U662f\U4e00\U4e2a\U5143\U7d20",
    "-------"
)我加进来之后

demo地址