你要知道的NSCopying、NSCoding协议及对象序列化和反序列化都在这里

转载请注明出处 http://www.jianshu.com/p/e5bbf6936c16

本篇文章主要讲解NSCopying协议，以及NSCoding协议实现对象的序列化和反序列化，实际开发中如果要自己造轮子这两个协议还是比较重要的。

NSCopying协议

Foundation框架中为我们提供的基础的类基本都实现了NSCopying协议，因此，我们可以使用copy方法用来获取对象的一个不可变副本对象，可以使用mutableCopy方法用来获取对象的一个可变副本对象，当需要对自定义类调用copy或mutableCopy方法就需要实现NSCopying协议。首先我们看一下NSString类的复制操作。有如下代码:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSString *string = @"Jiaming Chen";
        NSString *copyString = [string copy];
        NSMutableString *mutableCopyString = [string mutableCopy];
        //输出: 0x1000020a8 0x1000020a8 0x10058ccb0
        NSLog(@"%p %p %p", string, copyString, mutableCopyString);
        
        NSMutableString *mutableString = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
        NSString *copyMutableString = [mutableString copy];
        NSMutableString *mutableCopyMutableString = [mutableString mutableCopy];
        //输出: 0x100403f90 0x100403ef0 0x100403fd0
        NSLog(@"%p %p %p", mutableString, copyMutableString, mutableCopyMutableString);
        
        NSString *str = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
        NSString *copyStr = [str copy];
        NSMutableString *mutableCopyStr = [str mutableCopy];
        //输出: 0x100404060 0x7fffa86ddd40 0x1004040a0
        NSLog(@"%p %p %p", str, copyStr, mutableCopyStr);
        
        NSString *errorStr = @"Jiaming Chen";
        NSMutableString *errorMutableStr = errorStr;
        NSString *copyErrorMutableStr = [errorMutableStr copy];
        NSMutableString *mutableCopyErrorMutableStr = [errorMutableStr mutableCopy];
        //输出: 0x100002060 0x100002060 0x100002060 0x10440fbb0
        NSLog(@"%p %p %p %p", errorStr, errorMutableStr, copyErrorMutableStr, mutableCopyErrorMutableStr);
    }
}

上面的栗子，构造了四组实验:

第一组创建了一个NSString类型的对象，接下来使用copy和mutableCopy方法分别获取不可变副本对象和可变副本对象，最后输出三者的地址，可以发现原对象和不可变副本对象的地址一致，而可变对象的地址发生了变化。

第二组创建了一个NSMutableString类型的对象，同样获取了不可变和可变副本对象，输出的结果发现三者的地址都不同了。

第三组实验使用多态的方式创建了一个编译时类型为NSString而运行时为NSMutableString的对象，并获取可变和不可变副本对象，输出地址发现三者的地址都不同了。

第四组实验其实有些问题，errorMutableStr是NSMutableString类型的，但我们将NSString类型的对象赋给了它，所以运行时它的类型仍为NSString类型，但如果运行时调用了errorMutableStr的可变方法如appendString:等就会抛出异常。之所以这样做是为了和第三组实验进行对比，同样来获取可变和不可变副本对象，并输出地址，发现只有mutableCopy的方法的地址不同。

通过对比上面四组实验的mutableCopy复制可变副本对象的结果来看，我们可以发现，不论原对象是否可变，复制可变副本对象都会获取一个全新的对象，因为地址与原对象不同，因此即时修改也互不影响。接下来观察copy不可变副本对象的实验，我们发现如果原对象运行时类型是不可变的使用copy以后获取的是原对象的地址，并没有创建一个全新的对象，因为，原对象本身就是不可变的，复制一个不可变对象没有太大的实际意义，直接使用原对象即可，如果原对象的运行时类型是可变的，使用copy以后获取的是一个全新的对象，这样就可以避免多态时的错误。

可以总结出如下表格:

type	copy	mutableCopy
NS*	浅拷贝，只拷贝指针，地址相同	单层深拷贝，拷贝内容，地址不同
NSMutable*	单层深拷贝，拷贝内容，地址不同	单层深拷贝，拷贝内容，地址不同

由上述表格可以看出，对于不可变类型，使用copy方法时是浅拷贝，只拷贝指针，因为内容是不会变化的。使用mutableCopy时由于返回可变对象因此需要一份拷贝，供其他对象使用。对于可变类型，不管是copy还是mutableCopy均会进行单层深拷贝，所指向指针不同。

对于容器类型的对象，copy和mutableCopy与上述实验效果一直，容器类型的复制不会进行彻底的深拷贝，只会实现单层深拷贝，即创建一个新的容器，但容器里的内容只是对原对象容器的内容进行浅拷贝即只拷贝地址，如果要实现真正的深拷贝需自行实现相关方法。

学习完了Foundation框架提供的类的相关复制操作，接下将针对自定义类型的复制操作进行讲解，如果需要自定义类型支持复制的操作需要实现NSCopying协议，并实现copyWithZone:方法而不是重写copy方法，举个栗子如下:

@interface Account: NSObject <NSCopying>

@property (nonatomic, strong) NSMutableString *accountNumber;
@property (nonatomic, assign) double balance;

@end

@implementation Account

@synthesize accountNumber = _accountNumber;
@synthesize balance = _balance;

- (instancetype)copyWithZone:(NSZone *)zone
{
    //调用NSObject的类方法allocWithZone创建一个新的对象
    Account *account = [[self class] allocWithZone:zone];
    //使用mutableCopy获取一个可变的副本对象实现深拷贝
    //如果不调用mutableCopy而直接赋值，则是浅拷贝，另一个对象的修改会影响到当前对象的值
    account.accountNumber = [self.accountNumber mutableCopy];
    account.balance = self.balance;
    return account;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSMutableString *mutableStr = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
        
        Account *account = [[Account alloc] init];
        account.accountNumber = mutableStr;
        account.balance = 666.66;
        
        Account *accountBak = [account copy];
        
        //输出:0x100407460 0x100407580
        NSLog(@"%p %p", account, accountBak);
        //输出:0x1004074d0 0x100407600 0x100407be0
        NSLog(@"%p %p %p", account.accountNumber, accountBak.accountNumber, mutableStr);

    }
    return 0;
}

上面举的栗子很简单，自定义了一个Account类，其中为了实验方便定义的是NSMutableString类型的accountNumber属性，并且使用了strong修饰符，关于使用copy、strong修饰符的问题有不明白的读者可以阅读本博客另一篇文章iOS @property探究(一): 基础详解，该类遵守NSCopying协议并实现了copyWithZone:方法，在实现方法中首先调用了NSObject类的allocWithZone:方法来创建一个新的对象，如果继承的不是NSObject类，而是继承其他自定义类，如果继承的父类没有实现NSCopying协议这里不能使用allocWithZone:方法来创建新的对象，而应该使用alloc和init方法，如果继承的父类实现了NSCopying协议，这里需要调用父类的方法来初始化，即调用[super copy]方法来创建一个全新的对象，接下来就可以按照需要进行深拷贝或浅拷贝了。

对于NSCopying协议，需要注意的就是可变对象和不可变对象之间的区别，以及父类有没有实现NSCopying协议来确定调用何种方法来创建新对象。

NSCoding协议与对象序列化和反序列化

在开发中可能需要将自定义对象持久化存储在本地的文件中，或将对象转换为NSData类的数据并通过网络发送，要实现这些操作的前提就是自定义对象需要遵守NSCoding协议，NSCoding协议是对象序列化和反序列化的基础，NSCoding协议只定义了两个方法:

/*将对象编码
序列化对象时调用该方法，在该方法中序列化对象的每一个属性
一般使用encodeObject:forKey:方法序列化属性
*/
- (void)encodeWithCoder:(NSCoder *)aCoder;

/*
将数据解码并创建一个对象
反序列化时调用该方法，在该方法中反序列化对象的每一个熟悉
一般使用decodeObject:forKey方法反序列化属性
*/
- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder;

举个栗子如下:

@interface Account: NSObject <NSCoding>

@property (nonatomic, copy) NSString *accountNumber;
@property (nonatomic, assign) double balance;

@end

@implementation Account

@synthesize accountNumber = _accountNumber;
@synthesize balance = _balance;

//反序列化
- (instancetype)initWithCoder:(NSCoder *)aDecoder
{
    /*NSObject没有遵守NSCoding协议，因此调用父类的init构造方法
      如果继承的父类遵守NSCoding协议需要调用父类的initWithCoder:方法
      [super initWithCoder:aDecoder]
    */
    if (self = [super init])
    {
        self.accountNumber = [aDecoder decodeObjectForKey:@"kaccountNumber"];
        self.balance = [aDecoder decodeDoubleForKey:@"kbalance"];
    }
    return self;
}

//序列化
- (void)encodeWithCoder:(NSCoder *)aCoder
{
    //序列化与序列化的顺序不需要保持一致，因为使用了key来检索，可以乱序
    [aCoder encodeObject:self.accountNumber forKey:@"kaccountNumber"];
    [aCoder encodeDouble:self.balance forKey:@"kbalance"];
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        Account *account = [[Account alloc] init];
        account.accountNumber = @"1603121434";
        account.balance = 666.66;
        //输出: <Account: 0x10040c2f0> 1603121434 666.660000
        NSLog(@"%@ %@ %lf", account, account.accountNumber, account.balance);
        //将对象持久化到本地文件
        [NSKeyedArchiver archiveRootObject:account toFile:@"account.archiver"];
        //从本地文件中将数据反序列化创建对象
        Account *a = [NSKeyedUnarchiver unarchiveObjectWithFile:@"account.archiver"];
        //输出: <Account: 0x100506860> 1603121434 666.660000
        NSLog(@"%@ %@ %lf", a, a.accountNumber, a.balance);

    }
    return 0;
}

上面的栗子自定义了一个Account类，遵守NSCoding协议并实现了相关序列化和反序列化方法。栗子比较简单不再赘述。通过对象的序列化其实可以实现真正意义上的深拷贝，因为Foundation提供的数据类型包括集合类型基本都实现了NSCoding协议，因此，都可以实现序列化，序列化时将对象转换为字节码，反序列化时再将字节码反序列化为对应数据类型的数据，通过序列化和反序列化就可以实现真正意义的深拷贝，这里不再举栗子了。

上述举的栗子使用NSKeyedArchiver的archiveRootObject:toFile方法只能将一个对象持久化在一个文件中，如果要持久化多个对象只能分别存放在多个文件中，这样即浪费资源又比较复杂，NSKeyedArchiver提供了使用NSMutableData类的方式来实现多对象持久化到一个NSMutableData中，因此也可以持久化到一个文件中，这里不再举相关栗子了，有需要的读者可以自行查阅。

关于NSCoding协议的使用是比较简单的，需要注意的就是在initWithCoder:方法中调用父类构造函数的方式。

备注

由于作者水平有限，难免出现纰漏，如有问题还请不吝赐教。