利用forwardInvocation实现消息重定向

时间：2023-03-08 15:21:30
利用forwardInvocation实现消息重定向

在obj-c中我们可以向一个实例发送消息，相当于c/c++ java中的方法调用，只不过在这儿是说发送消息，实例收到消息后会进行一些处理。比如我们想调用一个方法，便向这个实例发送一个消息，实例收到消息后，如果能respondsToSelector，那么就会调用相应的方法。如果不能respond一般情况下会crash。今天要的，就是不让它crash。

首先说一下向一个实例发送一个消息后，系统是处理的流程：

1. 发送消息如：[self startwork]

2. 系统会check是否能response这个消息

3. 如果能response则调用相应方法，不能则抛出异常

在第二步中，系统是如何check实例是否能response消息呢？如果实例本身就有相应的response,那么就会相应之，如果没有系统就会发出methodSignatureForSelector消息，寻问它这个消息是否有效？有效就返回对应的方法地址之类的，无效则返回nil。如果是nil就会crash， 如果不是nil接着发送forwardInvocation消息。

所以我们在重写methodSignatureForSelector的时候就人工让其返回有效实例。  文字说不清，还是用代码说明

我们定义了这样一个类

  1. @interface TargetProxy : NSProxy {
  2. id realObject1;
  3. id realObject2;
  4. }
  5. - (id)initWithTarget1:(id)t1 target2:(id)t2;
  6. @end

实现：

  1. @implementation TargetProxy
  2. - (id)initWithTarget1:(id)t1 target2:(id)t2 {
  3. realObject1 = [t1 retain];
  4. realObject2 = [t2 retain];
  5. return self;
  6. }
  7. - (void)dealloc {
  8. [realObject1 release];
  9. [realObject2 release];
  10. [super dealloc];
  11. }
  12. // The compiler knows the types at the call site but unfortunately doesn't
  13. // leave them around for us to use, so we must poke around and find the types
  14. // so that the invocation can be initialized from the stack frame.
  15. // Here, we ask the two real objects, realObject1 first, for their method
  16. // signatures, since we'll be forwarding the message to one or the other
  17. // of them in -forwardInvocation:.  If realObject1 returns a non-nil
  18. // method signature, we use that, so in effect it has priority.
  19. - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
  20. NSMethodSignature *sig;
  21. sig = [realObject1 methodSignatureForSelector:aSelector];
  22. if (sig) return sig;
  23. sig = [realObject2 methodSignatureForSelector:aSelector];
  24. return sig;
  25. }
  26. // Invoke the invocation on whichever real object had a signature for it.
  27. - (void)forwardInvocation:(NSInvocation *)invocation {
  28. id target = [realObject1 methodSignatureForSelector:[invocation selector]] ? realObject1 : realObject2;
  29. [invocation invokeWithTarget:target];
  30. }
  31. // Override some of NSProxy's implementations to forward them...
  32. - (BOOL)respondsToSelector:(SEL)aSelector {
  33. if ([realObject1 respondsToSelector:aSelector]) return YES;
  34. if ([realObject2 respondsToSelector:aSelector]) return YES;
  35. return NO;
  36. }
  37. @end

现在我们还用这个类，注意向它发送的消息：

  1. // Create a proxy to wrap the real objects.  This is rather
  2. // artificial for the purposes of this example -- you'd rarely
  3. // have a single proxy covering two objects.  But it is possible.
  4. id proxy = [[TargetProxy alloc] initWithTarget1:string target2:array];
  5. // Note that we can't use appendFormat:, because vararg methods
  6. // cannot be forwarded!
  7. [proxy appendString:@"This "];
  8. [proxy appendString:@"is "];
  9. [proxy addObject:string];
  10. [proxy appendString:@"a "];
  11. [proxy appendString:@"test!"];
  12. NSLog(@"count should be 1, it is: %d", [proxy count]);
  13. if ([[proxy objectAtIndex:0] isEqualToString:@"This is a test!"]) {
  14. NSLog(@"Appending successful.");
  15. } else {
  16. NSLog(@"Appending failed, got: '%@'", proxy);
  17. }

运行的结果是：

count should be 1, it is:  1

Appending successful.

TargetProxy声明中是没有appendString与addObject消息的，在这儿却可以正常发送，不crash，原因就是发送消息的时候，如果原本类没有这个消息响应的时候，转向询问methodSignatureForSelector，接着在forwardInvocation将消息重定向。 上面也说了多参数的消息是不能重定向的。不过貌似要实现这个要关掉ARC。

相关文章