blocks|key|3058678|text|load消息|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3058679|在类对象加载到进程的地址空间后不久，运行库将load消息发送到每个类对象。对于属于程序可执行文件的类，运行库在进程生命周期的早期发送load消息。对于共享(动态加载)库中的类，运行库在将共享库加载到进程的地址空间后立即发送加载消息。|3058680|此外，只有类对象本身实现了load方法，运行库才会向该类对象发送load。示例：|3058681|@interface+Superclass+:+NSObject
@end

@interface+Subclass+:+Superclass
@end

@implementation+Superclass

%2B+(void)load+{
++++NSLog(@"in+Superclass+load");
}

@end

@implementation+Subclass

//+...+load+not+implemented+in+this+class

@end|code-block|syntax|javascript|3058682|运行库向Superclass类对象发送load消息。它不会向Subclass类对象发送load消息，即使Subclass继承了Superclass的方法也是如此。|3058683|运行库在将load消息发送到类的所有超类对象(如果这些超类对象实现了load)和您链接到的共享库中的所有类对象之后，将load消息发送到类对象。但是您还不知道您自己的可执行文件中的哪些其他类已经收到了load。|3058684|您的进程加载到其地址空间中的每个类都将收到一条load消息，只要它实现了load方法，而不管您的进程是否使用该类的任何其他用途。|3058685|您可以看到运行时如何在objc-runtime-new.mm的_class_getLoadMethod中将load方法作为一个特例进行查找，并在objc-loadmethod.mm中直接从call_class_loads调用它。|3058686|运行库还会运行它加载的每个类别的load方法，即使同一个类上的多个类别实现了load。“这是不寻常的。通常情况下，如果两个类别在同一个类上定义了相同的方法，则其中一个方法将“获胜”并被使用，而另一个方法将永远不会被调用。|3058687|initialize方法|3058688|运行库在将第一条消息(+load或initialize除外)发送到类对象或类的任何实例之前，对类对象调用initialize方法。这条消息是使用普通机制发送的，所以如果您的类没有实现initialize，而是继承自一个实现了的类，那么您的类将使用它的超类的initialize。运行库将首先向类的所有超类发送initialize+(如果超类尚未发送initialize)。|3058689|示例：|3058690|@interface+Superclass+:+NSObject
@end

@interface+Subclass+:+Superclass
@end

@implementation+Superclass

%2B+(void)initialize+{
++++NSLog(@"in+Superclass+initialize;+self+=+%25@",+self);
}

@end

@implementation+Subclass

//+...+initialize+not+implemented+in+this+class

@end

int+main(int+argc,+char+*argv[])+{
++++@autoreleasepool+{
++++++++Subclass+*object+=+[[Subclass+alloc]+init];
++++}
++++return+0;
}|3058691|此程序打印两行输出：|3058692|2012-11-10+16:18:38.984+testApp[7498:c07]+in+Superclass+initialize;+self+=+Superclass
2012-11-10+16:18:38.987+testApp[7498:c07]+in+Superclass+initialize;+self+=+Subclass|3058693|由于系统延迟地发送initialize方法，因此除非您的程序实际向类(或子类，或类或子类的实例)发送消息，否则类不会接收消息。当您收到initialize时，流程中的每个类都应该已经收到了load+(如果合适的话)。|3058694|实现initialize的规范方法是：|3058695|@implementation+Someclass

%2B+(void)initialize+{
++++if+(self+==+[Someclass+class])+{
++++++++//+do+whatever
++++}
}|3058696|这种模式的要点是，当它有一个不实现initialize的子类时，避免Someclass重新初始化自身。|3058697|运行库在objc-initialize.mm的_class_initialize函数中发送initialize消息。您可以看到它使用objc_msgSend发送消息，这是正常的消息发送函数。|3058698|进一步阅读|3058699|请查看有关此主题的Mike+Ash's+Friday+Q&A。|3058700|entityMap|0|LINK|mutability|MUTABLE|url|http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-runtime-new.mm|1|http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-loadmethod.mm|2|http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-initialize.mm|3|http://www.mikeash.com/pyblog/friday-qa-2009-05-22-objective-c-class-loading-and-initialization.html^0|0|4|0|M|4|1U|4|0|D|4|W|4|0|0|4|A|J|4|U|8|17|4|1G|8|1R|A|0|5|4|Y|4|1N|4|2S|4|0|N|4|10|4|0|B|J|V|K|1H|4|20|I|2M|G|B|J|0|20|I|1|0|G|4|12|4|0|0|A|0|C|4|H|A|1G|A|2J|A|3K|A|4A|A|4U|A|0|0|0|0|0|9|A|1V|A|2M|4|0|2|A|0|0|H|A|Y|9|0|4|I|N|H|19|A|1U|C|4|I|2|0|0|9|L|3|0^^$0|@$1|2|3|4|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|25|8|@$9|26|A|27|B|C]|$9|28|A|29|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|2F|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|2G|8|@$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|32|8|@$9|33|A|34|B|C]|$9|35|A|36|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|37|8|@$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|C]|$9|3G|A|3H|B|C]]|D|@$9|3I|A|3J|1|3K]|$9|3L|A|3M|1|3N]]|E|$]]|$1|W|3|X|5|6|7|3O|8|@$9|3P|A|3Q|B|C]|$9|3R|A|3S|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|3T|8|@$9|3U|A|3V|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|3W|8|@$9|3X|A|3Y|B|C]|$9|3Z|A|40|B|C]|$9|41|A|42|B|C]|$9|43|A|44|B|C]|$9|45|A|46|B|C]|$9|47|A|48|B|C]|$9|49|A|4A|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|4B|8|@]|D|@]|E|$]]|$1|14|3|15|5|L|7|4C|8|@]|D|@]|E|$M|N]]|$1|16|3|17|5|6|7|4D|8|@]|D|@]|E|$]]|$1|18|3|19|5|L|7|4E|8|@]|D|@]|E|$M|N]]|$1|1A|3|1B|5|6|7|4F|8|@$9|4G|A|4H|B|C]|$9|4I|A|4J|B|C]|$9|4K|A|4L|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|4M|8|@$9|4N|A|4O|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|L|7|4P|8|@]|D|@]|E|$M|N]]|$1|1G|3|1H|5|6|7|4Q|8|@$9|4R|A|4S|B|C]|$9|4T|A|4U|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|4V|8|@$9|4W|A|4X|B|C]|$9|4Y|A|4Z|B|C]|$9|50|A|51|B|C]|$9|52|A|53|B|C]]|D|@$9|54|A|55|1|56]]|E|$]]|$1|1K|3|1L|5|6|7|57|8|@]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|58|8|@]|D|@$9|59|A|5A|1|5B]]|E|$]]|$1|1O|3|-4|5|6|7|5C|8|@]|D|@]|E|$]]]|1P|$1Q|$5|1R|1S|1T|E|$1U|1V]]|1W|$5|1R|1S|1T|E|$1U|1X]]|1Y|$5|1R|1S|1T|E|$1U|1Z]]|20|$5|1R|1S|1T|E|$1U|21]]]]

<h2>The <code>load</code> message</h2>

The runtime sends the <code>load</code> message to each class object, very soon after the class object is loaded in the process's address space. For classes that are part of the program's executable file, the runtime sends the <code>load</code> message very early in the process's lifetime. For classes that are in a shared (dynamically-loaded) library, the runtime sends the load message just after the shared library is loaded into the process's address space.

Furthermore, the runtime only sends <code>load</code> to a class object if that class object itself implements the <code>load</code> method. Example:

<pre><code>@interface Superclass : NSObject
@end

@interface Subclass : Superclass
@end

@implementation Superclass

+ (void)load {
 NSLog(@"in Superclass load");
}

@end

@implementation Subclass

// ... load not implemented in this class

@end
</code></pre>

The runtime sends the <code>load</code> message to the <code>Superclass</code> class object. It does not send the <code>load</code> message to the <code>Subclass</code> class object, even though <code>Subclass</code> inherits the method from <code>Superclass</code>.

The runtime sends the <code>load</code> message to a class object after it has sent the <code>load</code> message to all of the class's superclass objects (if those superclass objects implement <code>load</code>) and all of the class objects in shared libraries you link to. But you don't know which other classes in your own executable have received <code>load</code> yet.

Every class that your process loads into its address space will receive a <code>load</code> message, if it implements the <code>load</code> method, regardless of whether your process makes any other use of the class.

You can see how the runtime looks up the <code>load</code> method as a special case in the <code>_class_getLoadMethod</code> of <a href="http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-runtime-new.mm" rel="noreferrer"><code>objc-runtime-new.mm</code></a>, and calls it directly from <code>call_class_loads</code> in <a href="http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-loadmethod.mm" rel="noreferrer"><code>objc-loadmethod.mm</code></a>.

The runtime also runs the <code>load</code> method of every category it loads, even if several categories on the same class implement <code>load</code>.  This is unusual.  Normally, if two categories define the same method on the same class, one of the methods will “win” and be used, and the other method will never be called.

<h2>The <code>initialize</code> Method</h2>

The runtime calls the <code>initialize</code> method on a class object just before sending the first message (other than <code>load</code> or <code>initialize</code>) to the class object or any instances of the class. This message is sent using the normal mechanism, so if your class doesn't implement <code>initialize</code>, but inherits from a class that does, then your class will use its superclass's <code>initialize</code>. The runtime will send the <code>initialize</code> to all of a class's superclasses first (if the superclasses haven't already been sent <code>initialize</code>).

Example:

<pre><code>@interface Superclass : NSObject
@end

@interface Subclass : Superclass
@end

@implementation Superclass

+ (void)initialize {
 NSLog(@"in Superclass initialize; self = %@", self);
}

@end

@implementation Subclass

// ... initialize not implemented in this class

@end

int main(int argc, char *argv[]) {
 @autoreleasepool {
 Subclass *object = [[Subclass alloc] init];
 }
 return 0;
}
</code></pre>

This program prints two lines of output:

<pre><code>2012-11-10 16:18:38.984 testApp[7498:c07] in Superclass initialize; self = Superclass
2012-11-10 16:18:38.987 testApp[7498:c07] in Superclass initialize; self = Subclass
</code></pre>

Since the system sends the <code>initialize</code> method lazily, a class won't receive the message unless your program actually sends messages to the class (or a subclass, or instances of the class or subclasses). And by the time you receive <code>initialize</code>, every class in your process should have already received <code>load</code> (if appropriate).

The canonical way to implement <code>initialize</code> is this:

<pre><code>@implementation Someclass

+ (void)initialize {
 if (self == [Someclass class]) {
 // do whatever
 }
}
</code></pre>

The point of this pattern is to avoid <code>Someclass</code> re-initializing itself when it has a subclass that doesn't implement <code>initialize</code>.

The runtime sends the <code>initialize</code> message in the <code>_class_initialize</code> function in <a href="http://opensource.apple.com/source/objc4/objc4-532.2/runtime/objc-initialize.mm" rel="noreferrer"><code>objc-initialize.mm</code></a>. You can see that it uses <code>objc_msgSend</code> to send it, which is the normal message-sending function. 

<h2>Further reading</h2>

Check out <a href="http://www.mikeash.com/pyblog/friday-qa-2009-05-22-objective-c-class-loading-and-initialization.html" rel="noreferrer">Mike Ash's Friday Q&amp;A</a> on this topic.

blocks|key|210023|text|它的意思是不要覆盖类别中的%2Binitialize，你可能会破坏一些东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|210024|只要加载了实现%2Bload的类或类别，就会对该类或类别调用一次%2Bload。当它说“静态链接”时，它意味着编译到你的应用程序二进制文件中。这样编译的类上的%2Bload方法将在应用程序启动时执行，可能在应用程序进入main()之前执行。当它说“动态加载”时，它意味着通过插件包或调用dlopen()加载。如果你用的是iOS，你可以忽略这种情况。|210025|%2Binitialize在第一次向该类发送消息时被调用，就在该类处理该消息之前。这(显然)只会发生一次。如果覆盖类别中的%2Binitialize，将发生以下三种情况之一：|210026|210027|你的类别实现会被调用，类的实现也会被调用；|unordered-list-item|210028|你写的任何东西都不会加载你的类别，而且它的实现永远不会被调用。|210029|210030|这就是为什么你永远不应该覆盖一个类别中的%2Binitialize+-事实上，尝试替换一个类别中的任何方法都是非常危险的，因为你永远不能确定你要替换的是什么，或者你自己的替换本身是否会被另一个类别替换掉。|210031|顺便说一句，使用%2Binitialize要考虑的另一个问题是，如果有人对你进行子类化，你的类可能会被调用一次，每个子类都会被调用一次。如果您正在执行诸如设置static变量之类的操作，则需要防止发生这种情况:使用dispatch_once()或测试self+==+[MyClass+class]。|210032|entityMap^0|D|B|0|7|5|U|5|23|5|2V|6|3T|8|0|0|B|1N|B|0|0|0|0|0|K|B|0|8|B|25|6|2X|F|3F|N|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|1G|8|@]|D|@]|E|$]]|$1|N|3|O|5|M|7|1H|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|V|$]]

What it means is don't override <code>+initialize</code> in a category, you'll probably break something.

<code>+load</code> is called once per class or category that implements <code>+load</code>, as soon as that class or category is loaded. When it says "statically linked" it means compiled into your app binary. The <code>+load</code> methods on classes thus compiled will be executed when your app launches, probably before it enters <code>main()</code>. When it says "dynamically loaded", it means loaded via plugin bundles or a call to <code>dlopen()</code>. If you're on iOS, you can ignore that case.

<code>+initialize</code> is called the first time a message is sent to the class, just before it handles that message. This (obviously) only happens once. If you override <code>+initialize</code> in a category, one of three things will happen:

<ul>
<li>your category implementation gets called and the class's implementation doesn't</li>
<li>someone else's category implementation gets called; nothing you wrote does</li>
<li>your category hasn't been loaded yet and its implementation never gets called.</li>
</ul>

This is why you should never override <code>+initialize</code> in a category - in fact it's quite dangerous to try and replace any method in a category because you're never sure what you're replacing or whether your own replacement will itself be switched out by another category.

BTW, another issue to consider with <code>+initialize</code> is that if someone subclasses you, you'll potentially get called once for your class and once for each subclass. If you're doing something like setting up <code>static</code> variables, you'll want to guard against that: either with <code>dispatch_once()</code> or by testing <code>self == [MyClass class]</code>.

I'm interested in understanding the circumstances leading a developer to override +initialize or +load. Documentation makes it clear these methods are called for you by the Objective-C runtime, but that's really all that is clear from the documentation of those methods. :-)

My curiosity comes from looking at Apple's example code - MVCNetworking. Their model class has a <code>+(void) applicationStartup</code> method. It does some housekeeping on the filesystem, reads NSDefaults, etc etc... and, after trying to grok NSObject's class methods, it seems like this janitorial work might be okay to put into +load.

I did modify the MVCNetworking project, removing the call in App Delegate to +applicationStartup, and putting the housekeeping bits into +load... my computer didn't catch fire, but that doesn't mean it's correct! I'm hoping to gain an understanding of any subtleties, gotchas, and whatnots around a custom setup method you have to call versus +load or +initialize.

<hr>

For +load documentation says:

<blockquote>
 The load message is sent to classes and categories that are both
 dynamically loaded and statically linked, but only if the newly loaded
 class or category implements a method that can respond.
</blockquote>

This sentence is kludgey and difficult to parse if you don't know the precise meaning of all the words. Help!

<ul>
<li>What is meant by "both dynamically loaded and statically linked?" Can something be dynamically loaded AND statically linked, or are they mutually exclusive?</li>
<li>"...the newly loaded class or category implements a method that can respond" What method? Respond how?</li>
</ul>

<hr>

As for +initialize, documentation says:

<blockquote>
 initialize it is invoked only once per class. If you want to perform
 independent initialization for the class and for categories of the
 class, you should implement load methods.
</blockquote>

I take this to mean, "if your trying to setup the class... don't use initialize." Okay, fine. When or why would I override initialize then?

NSObject +load and +initialize - What do they do?

我对了解导致开发人员覆盖+初始化或+加载的情况很感兴趣。文档清楚地说明了这些方法是由Objective-C运行时为您调用的，但从这些方法的文档中可以清楚地看到这一点。:-)我的好奇心来自于查看苹果的示例代码- MVCNetworking。他们的模型类有一个+(void) applicationStartup方法。它在文...

问NSObject +load和+initialize -它们做什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NSObject +load和+initialize -它们做什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NSObject +load和+initialize -它们做什么？
EN