art机制 ios
2019-04-13 17:43:52 baidu_30306909 阅读数 50

App:Photo Frames Art

Describe:

Photo Frames Art is one of the best photo editor
And beautiful frames to your photos.
Choose photo from Album and select a frame and generate your photo frames.Enjoy the best photo frames in App Store.

Frame with lots of beautiful art frames can quick combine photos into cool art frame. In your life, you have a lots of beautiful memories event: a party, birthday, congratulations event,… with a lots of photos, with this app you can save all your memories event into beautiful art frame and share to your friends, your family,…
All frames into this software is designed with high resolution, creative and not similar with another apps in store. Hope you love this app. With Frame you has awesome photo edit application which you can easy way to edit your photos and share!

Email:yuezhangveq8@163.com
TEl: +1-718-723-3922

2019-04-23 23:35:00 weixin_34400525 阅读数 11

在Objective-C中,方法的调用理解为对象接受消息。

运行时调用的方法告诉对象要干什么,给对象传递一个消息。发送消息后,编译器将其转换为对应的一条C语言消息发送原语

void objc_msgSend( id self , SEL cmd , ... )

第一个参数代表消息的接收者,第二个参数代表消息选择子。

objc_msgSend通过接收者的isa指针在接收者类对象的方法列表中找,名称为选择子的方法。找到则执行,否则就到父类中查找,都找不到说明接收者无法响应改消息,触发消息转发机制。

消息转发机制有三道防线,任何一道起作用都可以传递消息。按照先后顺序依次为:

1、动态补加方法

+ (BOOL)resolveInstanceMethod:(SEL)sel

+ (BOOL)resolveClassMethod:(SEL)sel

2、直接返回消息给另一个对象处理

- (id)forwardingTargetForSelector:(SEL)aSelector

3、手动生成签名方法并抓发给另一个对象

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sSelector

- (void)forwardInvocation:(NSInvocation *)anInvocation

转载于:https://www.jianshu.com/p/76162edf9c64

2015-06-18 17:47:40 u013682799 阅读数 545

iOS ARC 内存自动管理机制,目前,几乎好多的项目都会用ARC去,因为,它把内存释放这个体力活给干了,不过,虽然ARC很好,我们仍然不能完全把内存管理这回事儿抛在脑后。

ARC的工作原理:

ARC是一个编译前的步骤,它为我们的代码自动加上retain/release/autorelease语句。
ARC并不是垃圾收集,而且,引用计数也没有消失,只是变成自动而已。听起来像是事后追加的这么一个功能,不过,只要我们想一想Objective-C有多少功能是通过对源文件的预处理来实现的,就不会这么想了。
//下面是一个例子:
当我们用ARC的时候是这样

  NSObject *obj = [[NSObject alloc]init];
    // Do any additional setup after loading the view, typically from a nib.

用ARC是这样

 NSObject *obj = [[NSObject alloc]init];
 [obj release];

这里有官方的一些介绍
ARC 出现后随后又来了些新的规则:(来源
1. 对象的Alloc/Init创建对象的方法跟以前一样,但你一定不能调用retain/release/autorelease/retainCount。也不能通过selector偷偷地调用它们: 禁止使用@selector(retain)和@selector(release)。
2. dealloc方法
ARC为自动为你调用,一定不能直接调用dealloc。不过,如果你需要释放实例变量以外的资源,还是可以创建自定义的dealloc方法。但在这个方法里,不要调用[super dealloc]。因为ARC会帮你调。
3. 声明的属性
在ARC之前,我们是用@property指令中的assign/retain/copy参数来告诉编译器,如何管理这些属性的内存。用了ARC之后,这些参数就作废了,改用weak/strong这两个参数。
4. C结构中的对象指针
同样禁止使用。文档里建议不要把它们放在结构了,改放到类里去。否则ARC就不认识它们了。可能会出现一些移植上的问题。不过,ARC是可以以文件为单位来关闭的。参考下文的“引入不兼容ARC的代码”。
5. 以@autoreleasepool代替NSAutoReleasePool
兼容ARC的代码不能再使用NSAutoReleasePool对象,而要改用@autoreleasepool{}块。一个很好的例子:

int main(int argc, char *argv[])
{
  @autoreleasepool {
    return UIApplicationMain(argc, argv, nil, NSStringFromClass([ExampleAppDelegate class]));
  }
}
  1. 其它
    基于Zone的内存已经没了(在运行时里也没了)。不能再使用NSAllocateObject和NSDeallocateObject。
    7.不能以new为开头给一个属性命名
    OK !在说说ARC限定符-声明的属性,在我们开发的时候,我们会根据具体需求,去确定自己定自己使用的对象属性。
    在ARC 下,一般都是strong,week,就说强应用,和弱引用,
    strong 强引用 :@property(strong)UIView *bgView;
    相当与该对象的所有属性,也就是只有当该对象的strong 属性 释放掉后该对象才销毁。

本人目前在研究web前端开发,买了一些视频,筛选出讲好的,自己在淘宝上出售:https://item.taobao.com/item.htm?id=540946716944(自己的淘宝店,请多多支持)

2013-12-20 15:36:43 wsxzk123 阅读数 625

今天开发中用到了并行,代码如下:

dispatch_group_t group = dispatch_group_create();
        dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
            // 初始化mainDB
            [[WBDBMan DBMan] prepareMainDB];
        });
        dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
            // 释放内置资源到沙盒
            [self builtInCacheFile];
        });
        dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{
            // 汇总结果
        });
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        dispatch_release(group);

参考资料如下:

http://blog.devtang.com/blog/2012/02/22/use-gcd/


使用GCD

FEB 22ND, 2012

什么是GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。该方法在Mac OS X 10.6雪豹中首次推出,并随后被引入到了iOS4.0中。GCD是一个替代诸如NSThread, NSOperationQueue, NSInvocationOperation等技术的很高效和强大的技术,它看起来象就其它语言的闭包(Closure)一样,但苹果把它叫做blocks。

应用举例

让我们来看一个编程场景。我们要在iphone上做一个下载网页的功能,该功能非常简单,就是在iphone上放置一个按钮,点击该按钮时,显示一个转动的圆圈,表示正在进行下载,下载完成之后,将内容加载到界面上的一个文本控件中。

不用GCD前

虽然功能简单,但是我们必须把下载过程放到后台线程中,否则会阻塞UI线程显示。所以,如果不用GCD, 我们需要写如下3个方法:

  • someClick 方法是点击按钮后的代码,可以看到我们用NSInvocationOperation建了一个后台线程,并且放到NSOperationQueue中。后台线程执行download方法。
  • download 方法处理下载网页的逻辑。下载完成后用performSelectorOnMainThread执行download_completed 方法。
  • download_completed 进行clear up的工作,并把下载的内容显示到文本控件中。

这3个方法的代码如下。可以看到,虽然 开始下载 -> 下载中 -> 下载完成 这3个步骤是整个功能的三步。但是它们却被切分成了3块。他们之间因为是3个方法,所以还需要传递数据参数。如果是复杂的应用,数据参数很可能就不象本例子中的NSString那么简单了,另外,下载可能放到Model的类中来做,而界面的控制放到View Controller层来做,这使得本来就分开的代码变得更加散落。代码的可读性大大降低。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
static NSOperationQueue * queue;

- (IBAction)someClick:(id)sender {
    self.indicator.hidden = NO;
    [self.indicator startAnimating];
    queue = [[NSOperationQueue alloc] init];
    NSInvocationOperation * op = [[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download) object:nil] autorelease];
    [queue addOperation:op];
}

- (void)download {
    NSURL * url = [NSURL URLWithString:@"http://www.youdao.com"];
    NSError * error;
    NSString * data = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
    if (data != nil) {
        [self performSelectorOnMainThread:@selector(download_completed:) withObject:data waitUntilDone:NO];
    } else {
        NSLog(@"error when download:%@", error);
        [queue release];
    }
}

- (void) download_completed:(NSString *) data {
    NSLog(@"call back");
    [self.indicator stopAnimating];
    self.indicator.hidden = YES;
    self.content.text = data;
    [queue release];
}

使用GCD后

如果使用GCD,以上3个方法都可以放到一起,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 原代码块一
self.indicator.hidden = NO;
[self.indicator startAnimating];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 原代码块二
    NSURL * url = [NSURL URLWithString:@"http://www.youdao.com"];
    NSError * error;
    NSString * data = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
    if (data != nil) {
        // 原代码块三
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.indicator stopAnimating];
            self.indicator.hidden = YES;
            self.content.text = data;
        });
    } else {
        NSLog(@"error when download:%@", error);
    }
});

首先我们可以看到,代码变短了。因为少了原来3个方法的定义,也少了相互之间需要传递的变量的封装。

另外,代码变清楚了,虽然是异步的代码,但是它们被GCD合理的整合在一起,逻辑非常清晰。如果应用上MVC模式,我们也可以将View Controller层的回调函数用GCD的方式传递给Modal层,这相比以前用@selector的方式,代码的逻辑关系会更加清楚。

GCD的定义

简单GCD的定义有点象函数指针,差别是用 ^ 替代了函数指针的 * 号,如下所示:

1
2
3
4
5
6
7
8
9
 // 申明变量
 (void) (^loggerBlock)(void);
 // 定义

 loggerBlock = ^{
      NSLog(@"Hello world");
 };
 // 调用
 loggerBlock();

但是大多数时候,我们通常使用内联的方式来定义它,即将它的程序块写在调用的函数里面,例如这样:

1
2
3
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // something
 });

从上面大家可以看出,block有如下特点:

  1. 程序块可以在代码中以内联的方式来定义。
  2. 程序块可以访问在创建它的范围内的可用的变量。

系统提供的dispatch方法

为了方便地使用GCD,苹果提供了一些方法方便我们将block放在主线程 或 后台线程执行,或者延后执行。使用的例子如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 //  后台执行:
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // something
 });
 // 主线程执行:
 dispatch_async(dispatch_get_main_queue(), ^{
      // something
 });
 // 一次性执行:
 static dispatch_once_t onceToken;
 dispatch_once(&onceToken, ^{
     // code to be executed once
 });
 // 延迟2秒执行:
 double delayInSeconds = 2.0;
 dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
 dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
     // code to be executed on the main queue after delay
 });

dispatch_queue_t 也可以自己定义,如要要自定义queue,可以用dispatch_queue_create方法,示例如下:

1
2
3
4
5
dispatch_queue_t urls_queue = dispatch_queue_create("blog.devtang.com", NULL);
dispatch_async(urls_queue, ^{
     // your code
});
dispatch_release(urls_queue);

另外,GCD还有一些高级用法,例如让后台2个线程并行执行,然后等2个线程都结束后,再汇总执行结果。这个可以用dispatch_group, dispatch_group_async 和 dispatch_group_notify来实现,示例如下:

1
2
3
4
5
6
7
8
9
10
 dispatch_group_t group = dispatch_group_create();
 dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
      // 并行执行的线程一
 });
 dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
      // 并行执行的线程二
 });
 dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{
      // 汇总结果
 });

修改block之外的变量

默认情况下,在程序块中访问的外部变量是复制过去的,即写操作不对原变量生效。但是你可以加上 __block来让其写操作生效,示例代码如下:

1
2
3
4
5
6
 __block int a = 0;
 void  (^foo)(void) = ^{
      a = 1;
 }
 foo();
 // 这里,a的值被修改为1

后台运行

GCD的另一个用处是可以让程序在后台较长久的运行。在没有使用GCD时,当app被按home键退出后,app仅有最多5秒钟的时候做一些保存或清理资源的工作。但是在使用GCD后,app最多有10分钟的时间在后台长久运行。这个时间可以用来做清理本地缓存,发送统计数据等工作。

让程序在后台长久运行的示例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// AppDelegate.h文件
@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundUpdateTask;

// AppDelegate.m文件
- (void)applicationDidEnterBackground:(UIApplication *)application
{
    [self beingBackgroundUpdateTask];
    // 在这里加上你需要长久运行的代码
    [self endBackgroundUpdateTask];
}

- (void)beingBackgroundUpdateTask
{
    self.backgroundUpdateTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
        [self endBackgroundUpdateTask];
    }];
}

- (void)endBackgroundUpdateTask
{
    [[UIApplication sharedApplication] endBackgroundTask: self.backgroundUpdateTask];
    self.backgroundUpdateTask = UIBackgroundTaskInvalid;
}

总结

总体来说,GCD能够极大地方便开发者进行多线程编程。如果你的app不需要支持iOS4.0以下的系统,那么就应该尽量使用GCD来处理后台线程和UI线程的交互。

参考资料:

http://blog.csdn.net/ericsuper/article/details/6998856

#define kBgQueue dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)


- (void)viewDidLoad

{

    [super viewDidLoad];

    dispatch_async(kBgQueue, ^{

        NSData* data = [NSData dataWithContentsOfURL: kLatestKivaLoansURL];

        [self performSelectorOnMainThread:@selector(fetchedData:) withObject:datawaitUntilDone:YES];

    });

}


dispatch_async会向kBgQueue队列中添加新的任务去执行,这里kBgQueue队列使用dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)获得。


Dispatch Queues

Dispatch Queues从使用的角度将更象另一种形式的Operation Queues只是 Operation Queuse是用ObjectC的Dispatch Queues是C的

dispatch Queues有serial Queues 也被称为私有dispatch Queues,一个时间只能运行一个task,顺序运行

dispatch_queue_t queue;
queue = dispatch_queue_create("myQueue", NULL);  

dispatch_async(queue, ^{
        printf("Do some work here.\n");
    });
    printf("The first block may or may not have run.\n");
    dispatch_sync(queue, ^{
        printf("Do some more work here.\n");
    });
    printf("Both blocks have completed.\n");

这里使用了同步dispatch和异步dispatch,推荐使用dispatch_async这样才能真正体现其中的优势同步相当于WaitUntil = YES

 

 

还有一种就是Concurrent Queues每个程序系统自动提供了3个Concurrent Queues

dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_queue_t aHQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
 dispatch_queue_t aLQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);

啥意思一看就明白,3个优先级别的concurrent queues

 

最后一个特殊的Dispatch Queue就是main dispatch Queue 也是程序启动自动生成

dispatch_queue_t mainQueue = dispatch_get_main_queue();

 

concurrent queues和main queue 都是由系统生成而且 dispatch_suspend, dispatch_resume, dispatch_set_context,这些函数对他们无效

 

但是我们的应用不是简单的同步也异步的运行,应用经常是混合的

比如我们要task1 task2 task3 都运行完成后才能异步运行task4 task5 task6我们该怎么做呢?这里我们可以引入group的概念

 

    dispatch_queue_t aDQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    // Add a task to the group
    dispatch_group_async(group, aDQueue, ^{
        printf("task 1 \n");
    });
    dispatch_group_async(group, aDQueue, ^{
        printf("task 2 \n");
    });
    dispatch_group_async(group, aDQueue, ^{
        printf("task 3 \n");
    });
    printf("wait 1 2 3 \n");
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    printf("task 1 2 3 finished \n");
    dispatch_release(group);
    group = dispatch_group_create();
    // Add a task to the group
    dispatch_group_async(group, aDQueue, ^{
        printf("task 4 \n");
    });
    dispatch_group_async(group, aDQueue, ^{
        printf("task 5 \n");
    });
    dispatch_group_async(group, aDQueue, ^{
        printf("task 6 \n");
    });
    printf("wait 4 5 6 \n");
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    printf("task 4 5 6 finished \n");
    dispatch_release(group);

 

有时候我们也可以将设定一个数据在queue中 也可以定义一个结束函数

dispatch_set_finalizer_f 是在dispatch_release时候被调用

    dispatch_queue_t serialQueue = dispatch_queue_create("com.example.CriticalTaskQueue", NULL);
    if (serialQueue)
    {
        dispatch_set_context(serialQueue, self);
        dispatch_set_finalizer_f(serialQueue, &myFinalizerFunction);
    }
    
    dispatch_group_t group = dispatch_group_create();
    
    // Add a task to the group
    dispatch_group_async(group, serialQueue, ^{
        printf("task 1 \n");
    });
    
    dispatch_group_async(group, serialQueue, ^{
        printf("task 2 \n");
    });
    
    dispatch_group_async(group, serialQueue, ^{
        printf("task 3 \n");
    });
    printf("wait 1 2 3 \n");
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);  
    dispatch_release(group);
    dispatch_release(serialQueue);

2016-05-09 17:59:53 weixin_34367845 阅读数 3

    在Objective-C中,使用对象进行方法调用是一个消息发送的过程(Objective-C采用“动态绑定机制”,所以所要调用的方法直到运行期才能确定)。

    方法在调用时,系统会查看这个对象能否接收这个消息(查看这个类有没有这个方法,或者有没有实现这个方法。),如果不能并且只在不能的情况下,就会调用下面这几个方法,给你“补救”的机会,你可以先理解为几套防止程序crash的备选方案,我们就是利用这几个方案进行消息转发,注意一点,前一套方案实现后一套方法就不会执行。如果这几套方案你都没有做处理,那么程序就会报错crash。

    OC的运行时在程序崩溃前提供了三次拯救程序的机会:

方案一:

1
+ (BOOL)resolveInstanceMethod:(SEL)sel
1
+ (BOOL)resolveClassMethod:(SEL)sel

方案二:

1
- (id)forwardingTargetForSelector:(SEL)aSelector

方案三:

1
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
1
- (void)forwardInvocation:(NSInvocation *)anInvocation;

211220_TxEr_580523.jpg


    上图显示了消息转发的具体流程,接收者在每一步中均有机会处理消息。步骤越往后处理消息的代价越大。首先,会调用

+ (BOOL)resolveInstanceMethod:(SEL)sel。若方法返回YES,则表示可以处理该消息。在这个过程,可以动态地给消息增加方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Person.m
 
// 不自动生成getter和setter方法
@dynamic name; 
 
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
    if (sel == @selector(name)) {
        // BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types)
        class_addMethod(self, sel, (IMP)GetterName, "@@:");
        return YES;
    }
    if (sel == @selector(setName:)) {
        class_addMethod(self, sel, (IMP)SetterName, "v@:@");
        return YES;
    }
     
    return [super resolveInstanceMethod:sel];
}
 
// (用于类方法)
//+ (BOOL)resolveClassMethod:(SEL)sel
//{
//    NSLog(@"resolveClassMethod called %@", NSStringFromSelector(sel));
//    
//    return [super resolveClassMethod:sel];
//}
 
id GetterName(id self, SEL cmd)
{
    NSLog(@"%@, %s", [self class], sel_getName(cmd));
 
    return @"Getter called";
}
 
void SetterName(id self, SEL cmd, NSString *value)
{
    NSLog(@"%@, %s, %@", [self class], sel_getName(cmd), value);
     
    NSLog(@"SetterName called"
);

签名符号含义:

*          代表  char * 
char BOOL  代表  c
:          代表  SEL 
^type      代表  type *
@          代表  NSObject * 或 id
^@         代表  NSError ** 
#          代表  NSObject 
v          代表  void
1
2
3
4
5
6
7
8
9
// main.m
/* 现在在main.m中给Person发送setName:和name消息,由于Person中未实现这两个方法,就会经消息转发调用GetterName和SetterName方法
*/
 
Person *person = [[Person alloc] init];
         
[person setName:@"Jake"];
         
NSLog(@"%@", [person name]);
1
2
3
4
5
6
// 输出结果:
 
Person, setName:, Jake
SetterName called
Person, name
Getter called

    

    若方法返回NO,则进行消息转发的第二步,查找是否有其它的接收者。对应的处理函数是:

- (id)forwardingTargetForSelector:(SEL)aSelector。可以通过该函数返回一个可以处理该消息的对象。

    现在新建一个类Child,在Child中实现一个eat方法,在Person类中定义eat方法但不实现它。

1
2
3
4
5
6
// Child.m
 
- (void)eat
{
    NSLog(@"Child method eat called");
}

    然后在Person类中实现forwardingTargetForSelector:方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
// Person.m
// 当调用Person中的eat方法时,由于Person中并未实现该方法,就会经下面的方法将消息转发给可以处理eat方法的对象
 
- (id)forwardingTargetForSelector:(SEL)aSelector
{
    NSString *selStr = NSStringFromSelector(aSelector);
     
    if ([selStr isEqualToString:@"eat"]) {
        return [[Child alloc] init];        // 这里返回Child类对象,让Child去处理eat消息
    }
 
    return [super forwardingTargetForSelector:aSelector];
}
1
2
3
// main.m
 
[person eat];
1
2
3
// 输出结果:
 
Child method eat called

    通过此方案,我们可以用“组合”来模拟出“多重继承”的某些特性。在一个对象内部,可能还有一系列其他对象,该对象可以经由此方法将能够处理某选择子的相关内部对象返回,这样的话,在外界看来好像是该对象亲自处理了这些消息。

    伪多继承与真正的多继承的区别在于,真正的多继承是将多个类的功能组合到一个对象中,而消息转发实现的伪多继承,对应的功能仍然分布在多个对象中,但是将多个对象的区别对消息发送者透明。


    若第二步返回nil,则进入消息转发的第三步。调用

- (void)forwardInvocation:(NSInvocation *)anInvocation。这个方法实现得很简单。只需要改变调用目标,使消息在新目标上得以调用即可。不过,如果采用这种方式,实现的效果与第二步的消息转发是一致的。所以比较有用的实现方式是:先以某种方式改变消息内容,比如追加另外一个参数,或者改换选择子,等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Person.m
 
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
     NSString *sel = NSStringFromSelector(aSelector);
    // 判断要转发的SEL
    if ([sel isEqualToString:@"sleep"]) {
        // 为转发的方法手动生成签名
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
     
    return [super methodSignatureForSelector:aSelector]; 
}
 
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    SEL selector = [anInvocation selector];
    // 新建需要转发消息的对象
    Child *child = [[Child alloc] init];
    if ([child respondsToSelector:selector]) {
        // 唤醒这个方法
        [anInvocation invokeWithTarget:child];
    }
}
1
2
3
4
5
6
7
8
9
10
11
// Child.h
 
#import <Foundation/Foundation.h>
 
@interface Child : NSObject
 
- (void)eat;
 
- (void)sleep;
 
@end
1
2
3
4
5
6
// Child.m
 
- (void)sleep
{
    NSLog(@"Child method sleep called");
}
1
2
3
// 输出结果:
 
Child method sleep called

    

    有时候服务器很烦不靠谱,老是不经意间返回null,可以重写NSNull的消息转发方法, 让他能处理这些异常的方法,达到解决问题的目的。

iOS runtime机制

阅读数 96

IOS消息转发机制

阅读数 961

iOS消息传递机制

阅读数 1

IOS 消息转发机制

阅读数 369

没有更多推荐了,返回首页