NullSafe 的原理

问题场景

后端返回的数据中总会出现一些NSNull类型，当我们一处理程序就会崩溃，因此想到把返回的数据中的NSNull类型全部转换成@""空字符串

（1）原始的json串：后端返回的json串里面包含类型NSString，NSArray，NSDictionary，NSNull类型。

{"status":1,"service_name":null,"service_id":null,"img_url":"http:\/\/api.jgfw.me\/assets\/uploads\/files\/","price":null,"num":3,"service_info":{"service_type":null,"service_time":null,"service_detail":null,"customer_name":null,"customer_phone":null,"customer_address":"","new_jishi":"","old_jishi":null,"lat":null,"lon":null},"order_info":{"order_no":"E15031267469289848688","pay_time":null,"order_time":null,"price":0,"order_state":null}}

（2）用SBJson库:json串转换成字典

NSDictionary *jsonDic = [retString JSONValue];

"<null>" 就是NSNull 类型，直接使用会Crash.

摘要

NullSafe is a simple category on NSNull that returns nil for unrecognised messages instead of throwing an exception.

 //
 //  NullSafe.m
 //
 //  Version 1.2.2
 //
 //  Created by Nick Lockwood on 19/12/2012.
 //  Copyright 2012 Charcoal Design
 //
 //  Distributed under the permissive zlib License
 //  Get the latest version from here:
 //
 //  https://github.com/nicklockwood/NullSafe
 //
 //  This software is provided 'as-is', without any express or implied
 //  warranty.  In no event will the authors be held liable for any damages
 //  arising from the use of this software.
 //
 //  Permission is granted to anyone to use this software for any purpose,
 //  including commercial applications, and to alter it and redistribute it
 //  freely, subject to the following restrictions:
 //
 //  1. The origin of this software must not be misrepresented; you must not
 //  claim that you wrote the original software. If you use this software
 //  in a product, an acknowledgment in the product documentation would be
 //  appreciated but is not required.
 //
 //  2. Altered source versions must be plainly marked as such, and must not be
 //  misrepresented as being the original software.
 //
 //  3. This notice may not be removed or altered from any source distribution.
 //

 //Fix  issue      desc = "<null>";icon = "<null>";

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

 #ifndef NULLSAFE_ENABLED
 #define NULLSAFE_ENABLED 1
 #endif

 #pragma GCC diagnostic ignored "-Wgnu-conditional-omitted-operand"

 @implementation NSNull (NullSafe)

 #if NULLSAFE_ENABLED

 - (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
 {
     @synchronized([self class])
     {
         //look up method signature
         NSMethodSignature *signature = [super methodSignatureForSelector:selector];
         if (!signature)
         {
             //not supported by NSNull, search other classes
             static NSMutableSet *classList = nil;
             static NSMutableDictionary *signatureCache = nil;
             if (signatureCache == nil)
             {
                 classList = [[NSMutableSet alloc] init];
                 signatureCache = [[NSMutableDictionary alloc] init];

                 //get class list
                 int numClasses = objc_getClassList(NULL, );
                 Class *classes = (Class *)malloc(sizeof(Class) * (unsigned long)numClasses);
                 numClasses = objc_getClassList(classes, numClasses);

                 //add to list for checking
                 NSMutableSet *excluded = [NSMutableSet set];
                 for (int i = ; i < numClasses; i++)
                 {
                     //determine if class has a superclass
                     Class someClass = classes[i];
                     Class superclass = class_getSuperclass(someClass);
                     while (superclass)
                     {
                         if (superclass == [NSObject class])
                         {
                             [classList addObject:someClass];
                             break;
                         }
                         [excluded addObject:NSStringFromClass(superclass)];
                         superclass = class_getSuperclass(superclass);
                     }
                 }

                 //remove all classes that have subclasses
                 for (Class someClass in excluded)
                 {
                     [classList removeObject:someClass];
                 }

                 //free class list
                 free(classes);
             }

             //check implementation cache first
             NSString *selectorString = NSStringFromSelector(selector);
             signature = signatureCache[selectorString];
             if (!signature)
             {
                 //find implementation
                 for (Class someClass in classList)
                 {
                     if ([someClass instancesRespondToSelector:selector])
                     {
                         signature = [someClass instanceMethodSignatureForSelector:selector];
                         break;
                     }
                 }

                 //cache for next time
                 signatureCache[selectorString] = signature ?: [NSNull null];
             }
             else if ([signature isKindOfClass:[NSNull class]])
             {
                 signature = nil;
             }
         }
         return signature;
     }
 }

 - (void)forwardInvocation:(NSInvocation *)invocation
 {
     invocation.target = nil;
     [invocation invoke];
 }

 #endif

 @end

当我们给一个NSNull对象发送消息的话，可能会崩溃（null是有内存的），而发送给nil的话，是不会崩溃的。
作者就是使用了这么一个原理，把发送给NSNull的而NSNull又无法处理的消息经过如下几步处理：

1. 创建一个方法缓存，这个缓存会缓存项目中类的所有类名。

2. 遍历缓存，寻找是否已经有可以执行此方法的类。

3. 如果有的话，返回这个NSMethodSignature。

4. 如果没有的话，返回nil,接下来会走forwardInvocation:方法。

5. [invocation invokeWithTarget:nil];将消息转发给nil。

那么，如何判断NSNull无法处理这个消息呢，在OC中，系统如果对某个实例发送消息之后，它（及其父类）无法处理（比如，没有这个方法等），系统就会发送methodSignatureForSelector消息，如果这个方法返回非空，那么就去执行返回的方法，如果为nil,则发送forwardInvocation消息。

这样就完成整个转发链了。

题外话：一般来说，我们不应该在我们的项目中使用NSNull类（大部分NSNull类的来源来自于接口的返回），而使用nil，在来源上，就应该堵上（要么你解析到null进行处理，要么和你的服务端说，不要给我返回null）。

reference：

1.https://segmentfault.com/q/1010000005064181

2.https://github.com/nicklockwood/NullSafe

3.http://blog.sina.com.cn/s/blog_5c91824f0102ve3c.html