一、 使用方法簽名和調用

１，NSInvocation
　　
　　An NSInvocation is an Objective-C message rendered static, that is, it is an action turned into an object. NSInvocation objects are used to store and forward messages between objects and between applications, primarily by NSTimer objects and the distributed objects system.

An NSInvocation object contains all the elements of an Objective-C message: a target, a selector, arguments, and the return value. Each of these elements can be set directly, and the return value is set automatically when the NSInvocation object is dispatched.

An NSInvocation object can be repeatedly dispatched to different targets; its arguments can be modified between dispatch for varying results; even its selector can be changed to another with the same method signature (argument and return types). This flexibility makes NSInvocation useful for repeating messages with many arguments and variations; rather than retyping a slightly different expression for each message, you modify the NSInvocation object as needed each time before dispatching it to a new target.

NSInvocation does not support invocations of methods with either variable numbers of arguments or union arguments. You should use the invocationWithMethodSignature: class method to create NSInvocation objects; you should not create these objects using alloc and init.

This class does not retain the arguments for the contained invocation by default. If those objects might disappear between the time you create your instance of NSInvocation and the time you use it, you should explicitly retain the objects yourself or invoke the retainArguments method to have the invocation object retain them itself.

這是文檔中給的解釋。
２，簡單的demo。

  SEL initSel = @selector(init);

  SEL allocSel = @selector(alloc);

  NSMethodSignature *initSig, *allocSig;

  //從實例中請求實例方法簽名

  initSig = [@"String" methodSignatureForSelector:initSel];

  //從類中請求實例方法簽名

  initSig = [NSString instanceMethodSignatureForSelector:initSel];

  //從類中請求實例方法簽名

  allocSig = [NSString methodSignatureForSelector:allocSel];

總結：從實例中與從類中獲取到的方法簽名是相同的。

NSMutableSet *set = [NSMutableSet set];

NSString *stuff = @"Stuff";

SEL selector = @selector(addObject:);

NSMethodSignature *sig = [set methodSignatureForSelector:selector];

NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:sig];

[invocation setTarget:set];

[invocation setSelector:selector];

[invocation setArgument:&stuff atIndex:2];

[invocation invoke];

3，蹦床
　　蹦床把一條消息從一個對象“反彈”到里一個對象。這種技術允許一個代理對象把消息轉移到另一個線程、緩存結果、合并重復的消息或者任何其他中間配置。蹦床一般使用forwardInvocation方法處理消息。如果一個對象在Objective-C提示錯誤之前不響應一個選擇器，它就會創建一個NSInvocation并且傳遞給該對象的forwardInvocation:方法。你可以用它以任何方式轉發消息。在下面這個示例中，你將創建一個叫RNObserverManager的蹦床。任何發送到trampoline（蹦床）的信息都將被轉發到響應選擇器的已注冊的觀察者。
　　我的理解：就是發送到蹦床的方法，蹦床都會找已經注冊的觀察者是不是可以響應發送到蹦床的方法，如果響應了就執行，也就是有100個觀察者，可能同時100個觀察者調用這個方法（上面的話這句話我理解了好久），實現了類似于通知的功能，當觀察者較多的時候速度比較快，個人認為可以理解下這樣的思路，在實際應用中并不常見，以下是蹦床代碼。

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

@interface RNObserverManager : NSObject
- (id)initWithProtocol:(Protocol *)protocol observers:(NSSet          *)observers;
- (void)addObserver:(id)observer;
- (void)removerObserber:(id)observer;
@end


//RNObserverManager.m
#import "RNObserverManager.h"
@interface RNObserverManager()
@property(nonatomic,readonly,strong)NSMutableSet *observers;
@property(nonatomic,readonly,strong)Protocol *protocol;
@end
@implementation RNObserverManager
- (id)initWithProtocol:(Protocol *)protocol observers:(NSSet *)observers{

if (self = [super init]) {
    
    _protocol = protocol;
    
    _observers = [NSMutableSet setWithSet:observers];
}

return self;

}
- (void)addObserver:(id)observer{

    NSAssert([observer conformsToProtocol:self.protocol],@"Observer must conform to protocol.");
    [self.observers addObject:observer];
}

- (void)removerObserber:(id)observer{

    [self.observers removeObject:observer];
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{

  //檢查蹦床本身
  NSMethodSignature *result = [super methodSignatureForSelector:aSelector];

  if (result) {
    
      return result;
  }    


  //查找所需方法
  struct objc_method_description desc = protocol_getMethodDescription(self.protocol, aSelector, YES, YES);

if (desc.name == NULL) {
    
    //找不到  也許他是可選的
      desc = protocol_getMethodDescription(self.protocol, aSelector, NO, YES);
  }

  if (desc.name == NULL) {
    
      //找不到，拋出異常NSInvalidArgumentException
      [self doesNotRecognizeSelector:aSelector];
    
      return nil;
  }

  return [NSMethodSignature signatureWithObjCTypes:desc.types];


 }

- (void)forwardInvocation:(NSInvocation *)anInvocation{

  SEL selector = [anInvocation selector];

  for (id responder in self.observers) {
    
      if ([responder respondsToSelector:selector]) {
        
          [anInvocation setTarget:responder];
        
          [anInvocation invoke];
        }
    }
}

@end

蹦床的使用1：

//ViewController.h
#import <UIKit/UIKit.h>
#import "RNObserverManager.h"
@protocol MyProtocol <NSObject>

- (void)doSomething;

@end
@interface ViewController : UIViewController<MyProtocol>
@property(nonatomic,strong)NSMutableSet *observers;

@end
//ViewController.m
#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    _observers = [NSMutableSet set];

    [_observers addObject:self];

    id observerManager = [[RNObserverManager alloc]initWithProtocol:@protocol(MyProtocol) observers:_observers];

    [observerManager doSomething];

}
- (void)doSomething{

    NSLog(@"doSomthing");

}
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

蹦床的使用2：

//  RNMainThreadTrampoline.h

#import <Foundation/Foundation.h>

@interface RNMainThreadTrampoline : NSObject
@property(nonatomic,readwrite,strong)id target;
- (id)initWithTarget:(id)atarget;
@end

//  RNMainThreadTrampoline.m

#import "RNMainThreadTrampoline.h"

@implementation RNMainThreadTrampoline
-(id)initWithTarget:(id)atarget{

    if (self = [super init]) {
    
        _target = atarget;
    }
return self;

}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{

    return [self.target methodSignatureForSelector:aSelector];

}
-(void)forwardInvocation:(NSInvocation *)anInvocation{

    [anInvocation setTarget:self.target];
    [anInvocation retainArguments];
    [anInvocation performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:NO];

}
@end

解釋：forwardInvocation:方法可以自如地合并重復消息、添加記錄、將消息轉發到其他機器，并且執行多種功能。
問題：這是一個可以將所有消息轉發給主線程的蹦床，那具體的使用場景是什么呢？