OC学习篇之---归档和解挡

对象编码

预备知识

• 类定义
• 协议

相关文章

• 归档
• 属性表
• 对象生命周期

对象编码把对象的类特征以及对象状态转化某种格式，这种格式可存储，也可在进程间传递。类的类型以及实例数据会被写入到某种字节流里面，当程序结束的时候，该字节流可进行持久化。程序启动的时候，新分配对象可以解码之前保存的自身描述，然后把自己恢复到之前运行时的状态。编码通常需和归档协作。归档将对象图转化成一种可以写进文件系统的格式（档案），解档则是在档案上执行操作。在此过程中，保存在档案的对象对需要自身进行解码。

对象编码也被Mac OS X 系统的分布式对象API用于进程间传输对象。但是归档用得最为普遍，归档和属性表相似，也是一种对象持久化机制。

如何编码解码对象

如果您期望子类实例能够进行编解码，则子类应遵循NSCoding 协议并实现 initWithCoder:以及encodeWithCoder:方法，这些方法会在程序归解档某个对象图的时候被调用。在encodeWithCoder:方法中，我们会编码对象的重要实例变量，而在initWithCoder:方法中，我们则会解码这些值，并将它们重新赋给实例变量。initWithCoder:消息不会触发对象的初始化方法。

initWithCoder:方法和encodeWithCoder:方法都只需要一个NSCoder 对象作为参数，该对象用于执行实际的编解码动作。NSCoder是个抽象类，大部分情况下，编解码对象是下述具体子类的实例：NSKeyedArchiver,NSKeyedUnarchiver,NSArchiver,NSUnarchiver。归档类声明编码对象实例变量的方法，解档类则声明解码实例变量的方法。

NSCoder方法可作用于对象、标量、C数组、结构体、字符串以及指向这些类型的指针。编码自有类实例变量之前，请您务必要先调用超类的initWithCoder:或者encodeWithCoder:实现。当您从字节流解码对象时，也务必要先保持或复制这些对象，然后再把解码出来的值赋给其实例变量。

键归档和顺序归档

NSCoder有两个具体子类，二者各自使用不同的基本实现方式。“键”归档类（NSKeyedArchiver和NSKeyedUnarchiver）将一个编码值和一个字符串键关联在一起。解码的时候 ，键值之间的关联保持 一致。因此， 实例变量可按任意的次序编解码。如使用另一种类型的编解码器（NSKeyedUnarchiver和NSUnarchiver），您需要以某种次序编码实例变量。解码的时候，您仍要使用相同的次序。顺序编解码器只应在遗留代码里面才能使用，新的子类都应使用键归档编解码器。

例子：

1.协议

[plain]  view plain  copy

 

1. @interface untitled : NSObject <NSCoding>{  
2.     NSString *string;  
3.   
4. }  

2.实现协议

-(void) encodeWithCoder: (NSCoder *) aCoder{
    //label.text = @"enconde";
    NSLog(@"encode");
    [aCoder encodeObject:string forKey:@"code"];
}

-(id) initWithCoder: (NSCoder *) aDecoder{
    NSLog(@"initWithCoder");
    
    if (self = [super init]) {
        self.string = [aDecoder decodeObjectForKey:@"code"];
        //注意self不能少，与内存管理有关
    }
    
    
    return (self);
}

3.归档

[plain]  view plain  copy

 

1. NSString *path = [[NSBundle mainBundle] bundlePath];  
2.     path = [[NSString alloc] initWithFormat:@"%@%@",path,@"/code.txt"];  
3. untitled *t;  
4. [NSKeyedArchiver archiveRootObject:coder toFile:path ];  

4.解档

[plain]  view plain  copy

 

1. NSString *path = [[NSBundle mainBundle] bundlePath];  
2.     path = [[NSString alloc] initWithFormat:@"%@%@",path,@"/code.txt"];  
3. untitled *t;  
4.     t = [NSKeyedUnarchiver unarchiveObjectWithFile:path];  

前几篇文章说到了OC中的Foundation框架：http://blog.csdn.net/jiangwei0910410003/article/details/41852835，今天我们来看一下OC中的一个重要知识点：归档

OC中的归档就是将对象写入到一个文件中，Java中的ObjectInputStream和ObjectOutputStream来进行操作的。当然在操作的这些对象都是需要实现一个接口：Serializable,同样的OC中操作的对象也是需要实现一个协议的，后面会说到。

一、已有类型的归档和解档

首先来看一个简单的例子：

[objc]  view plain  copy

 

1. //  
2. //  main.m  
3. //  33_ObjectToFile  
4. //  
5. //  Created by jiangwei on 14-10-13.  
6. //  Copyright (c) 2014年 jiangwei. All rights reserved.  
7. //  
8.   
9. #import <Foundation/Foundation.h>  
10.   
11. //归档：将一个对象写到文件中  
12. int main(int argc, const charchar * argv[]) {  
13.     @autoreleasepool {  
14.        //第一种形式：归档对象  
15.        //对象----》文件  
16.         /* 
17.         NSArray *array = [NSArray arrayWithObjects:@"zhang",@"wangwu",@"lisi",nil]; 
18.         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"]; 
19.          
20.         BOOL success = [NSKeyedArchiver archiveRootObject:array toFile:filePath]; 
21.         if(success){ 
22.             NSLog(@"保存成功"); 
23.         } 
24.          */  
25.         /*解归档 
26.         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"]; 
27.         id array = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath]; 
28.         NSLog(@"%@",array); 
29.          */  
30.           
31.         //第二种方式  
32.         //第一种方式的缺陷是一个对象归档成一个文件  
33.         //但是第二种方式，多个对象可以归档成一个文件  
34.         /* 
35.         NSArray *array = [NSArray arrayWithObjects:@"zhangsan",@"lisi", nil]; 
36.         NSMutableData *data = [NSMutableData data]; 
37.         NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data]; 
38.         //编码 
39.         [archiver encodeObject:array forKey:@"array"]; 
40.         [archiver encodeInt:100 forKey:@"scope"]; 
41.         [archiver encodeObject:@"jack" forKey:@"name"]; 
42.          
43.         //完成编码，将上面的归档数据填充到data中，此时data中已经存储了归档对象的数据 
44.         [archiver finishEncoding]; 
45.         [archiver release]; 
46.          
47.         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"]; 
48.         BOOL success = [data writeToFile:filePath atomically:YES]; 
49.         if(success){ 
50.             NSLog(@"归档成功"); 
51.         } 
52.          */  
53.           
54.         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  
55.         //读取归档数据  
56.         NSData *data = [[NSData alloc] initWithContentsOfFile:filePath];  
57.           
58.         //创建解归档对象，对data中的数据进行解归档  
59.         NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];  
60.           
61.         //解归档  
62.         NSArray *array = [unarchiver decodeObjectForKey:@"array"];  
63.         NSLog(@"%@",array);  
64.           
65.         int value = [unarchiver decodeObjectForKey:@"scope"];  
66.         NSLog(@"%d",value);  
67.           
68.           
69.           
70.   
71.     }  
72.     return 0;  
73. }  

1、归档

[objc]  view plain  copy

 

1. //第一种形式：归档对象  
2. //对象----》文件  
3.  NSArray *array = [NSArray arrayWithObjects:@"zhang",@"wangwu",@"lisi",nil];  
4.  NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  
5.    
6.  BOOL success = [NSKeyedArchiver archiveRootObject:array toFile:filePath];  
7.  if(success){  
8.      NSLog(@"保存成功");  
9.  }  

我们这里将一个NSArray对象写入到一个文件中。

这里说到了创建一个文件的方法：

[objc]  view plain  copy

 

1. NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  

我们可以打印一下filePath的值：

NSHomeDirectory()返回的就是当前用户路径

我们查看一下array.src的内容：

我们看到内容是乱的，但是我们貌似还是能看到一点，比如wangwu/lisi等字眼，说明在归档的时候并没有深入的加密。

2、解档

[objc]  view plain  copy

 

1. //解归档  
2. NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  
3. id array = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];  
4. NSLog(@"%@",array);  

解档也是很简单的，就是返回一个对象，不过这里用了id类型的，因为读出来也不确定是哪种类型的。

3、对多个对象进行归档到一个文件

[objc]  view plain  copy

 

1. //第二种方式  
2. //第一种方式的缺陷是一个对象归档成一个文件  
3. //但是第二种方式，多个对象可以归档成一个文件  
4.  NSArray *array = [NSArray arrayWithObjects:@"zhangsan",@"lisi", nil nil];  
5.  NSMutableData *data = [NSMutableData data];  
6.  NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];  
7.  //编码  
8.  [archiver encodeObject:array forKey:@"array"];  
9.  [archiver encodeInt:100 forKey:@"scope"];  
10.  [archiver encodeObject:@"jack" forKey:@"name"];  
11.    
12.  //完成编码，将上面的归档数据填充到data中，此时data中已经存储了归档对象的数据  
13.  [archiver finishEncoding];  
14.  [archiver release];  
15.    
16.  NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  
17.  BOOL success = [data writeToFile:filePath atomically:YES];  
18.  if(success){  
19.  NSLog(@"归档成功");  
20.  }  

多个对象归档的话，这里要用到一个类： NSMutableData和NSData ，他们两的区别很简单，一个是可变的，一个是不可变的。然后这里还创建了一个归档器：NSKeyedArchiver,这个类负责进行指定类型的编码操作，然后将数据填充到NSMutableData类。归档的时候对每个类型对象用一个key进行对应，这个NSData和NSDirctionary很类似了。

4、对多个对象进行解档操作

[objc]  view plain  copy

 

1. NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];  
2. //读取归档数据  
3. NSData *data = [[NSData alloc] initWithContentsOfFile:filePath];  
4.   
5. //创建解归档对象，对data中的数据进行解归档  
6. NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];  
7.   
8. //解归档  
9. NSArray *array = [unarchiver decodeObjectForKey:@"array"];  
10. NSLog(@"%@",array);  
11.   
12. int value = [unarchiver decodeObjectForKey:@"scope"];  
13. NSLog(@"%d",value);  

我们可以将文件解档出一个NSData对象，然后可以通过key去获取指定的类型对象

二、自定义类型的归档和解档

上面说到了已有类型的归档和解档，下面来看一下自定义类型的归档和解档操作，在开始的时候也说了，如果自定义的类型可以进行归档和解档的话，必须实现一个协议：NSCoding

不多说了，下面来直接看代码解释：

Person.h

[java]  view plain  copy

 

1. //  
2. //  Person.h  
3. //  34_ArchiveProtocol  
4. //  
5. //  Created by jiangwei on 14-10-13.  
6. //  Copyright (c) 2014年 jiangwei. All rights reserved.  
7. //  
8.   
9. #import <Foundation/Foundation.h>  
10.   
11. //类只有实现NSCoding协议才能归档  
12. @interface Person : NSObject<NSCoding>  
13.   
14. @property(nonatomic,copy)NSString *name;  
15. @property(nonatomic,assign)NSInteger age;  
16. @property(nonatomic,retain)NSArray *apples;  
17.   
18. - (NSString *)description;  
19.   
20. @end  

这里自定义了一个Person类型，实现了NSCoding协议，然后他有三个属性，这里我们看到有新的方法去定义属性，这个后面说到内存管理的时候在详细说明。

Person.m

[objc]  view plain  copy

 

1. //  
2. //  Person.m  
3. //  34_ArchiveProtocol  
4. //  
5. //  Created by jiangwei on 14-10-13.  
6. //  Copyright (c) 2014年 jiangwei. All rights reserved.  
7. //  
8.   
9. #import "Person.h"  
10.   
11. @implementation Person  
12.   
13. //解归档的时候调用  
14. //也是一个初始化方法  
15. - (id)initWithCoder:(NSCoder *)aDecoder{  
16.     NSLog(@"initWithCoder");  
17.     self = [super init];  
18.     if(self != nil){  
19.         /* 
20.         _name = [aDecoder decodeObjectForKey:@"name"]; 
21.         _age = [aDecoder decodeObjectForKey:@"age"]; 
22.         _apples = [aDecoder decodeObjectForKey:@"apples"]; 
23.          */  
24.         //一般我们将key定义成宏，这样就不会出错  
25.         _name = [[aDecoder decodeObjectForKey:@"name"] copy];  
26.         self.age = [aDecoder decodeObjectForKey:@"age"];  
27.         self.apples = [aDecoder decodeObjectForKey:@"apples"];  
28.           
29.     }  
30.     return self;  
31. }  
32.   
33. //归档时调用此方法  
34. - (void)encodeWithCoder:(NSCoder *)aCoder{  
35.     NSLog(@"encodeWithCoder");  
36.     [aCoder encodeObject:_name forKey:@"name"];//一般key和属性名是取一样的  
37.     [aCoder encodeInteger:_age forKey:@"age"];  
38.     [aCoder encodeObject:_apples forKey:@"apples"];  
39. }  
40.   
41. - (NSString *)description{  
42.     NSString *string = [NSString stringWithFormat:@"name=%@,age=%d,apples=%@",_name,_age,_apples];  
43.     return string;  
44. }  
45.   
46. @end  

在Person.m文件中，我们需要实现协议中的两个方法：

initWithCoder

encodeWithCoder

这两个方法一个是用于归档操作时会调用的方法，还有一个是用于解档操作时会调用的方法

1、解档的时候用到的方法

[objc]  view plain  copy

 

1. - (id)initWithCoder:(NSCoder *)aDecoder{  
2.     NSLog(@"initWithCoder");  
3.     self = [super init];  
4.     if(self != nil){  
5.         /* 
6.         _name = [aDecoder decodeObjectForKey:@"name"]; 
7.         _age = [aDecoder decodeObjectForKey:@"age"]; 
8.         _apples = [aDecoder decodeObjectForKey:@"apples"]; 
9.          */  
10.         //一般我们将key定义成宏，这样就不会出错  
11.         _name = [[aDecoder decodeObjectForKey:@"name"] copy];  
12.         self.age = [aDecoder decodeObjectForKey:@"age"];  
13.         self.apples = [aDecoder decodeObjectForKey:@"apples"];  
14.           
15.     }  
16.     return self;  
17. }  

这个是一个初始化的方法，同时他也是一个解档操作时会调用的方法，所以在这里我们既要写一下初始化方法的特定代码，还要写上解档的代码，这里主要看解档的代码

其实很简单，就是对属性重新写一下值，然后对每个属性指定一个key就可以了。这个有点类似于Android中的Parcel

(这里我们看到，在解档name属性的时候，用到了copy的一个方法，这个在后面会说到，有浅拷贝和深拷贝之分)

2、归档的时候用到的方法

[objc]  view plain  copy

 

1. //归档时调用此方法  
2. - (void)encodeWithCoder:(NSCoder *)aCoder{  
3.     NSLog(@"encodeWithCoder");  
4.     [aCoder encodeObject:_name forKey:@"name"];//一般key和属性名是取一样的  
5.     [aCoder encodeInteger:_age forKey:@"age"];  
6.     [aCoder encodeObject:_apples forKey:@"apples"];  
7. }  

归档和解档的操作正好相反的，但是要注意的是：他们属性的key一定要保持一致

3、重写description方法

[objc]  view plain  copy

 

1. - (NSString *)description{  
2.     NSString *string = [NSString stringWithFormat:@"name=%@,age=%d,apples=%@",_name,_age,_apples];  
3.     return string;  
4. }  

在之前的文章中我说道过，我们在使用NSLog方法打印对象的值的时候，其实是调用对象的description方法，而这个方法是NSObject类中的，我们可以重写他，这样我们就可以打印我们想要的信息了。和Java中的toString方法一样。

下面就来看一下使用方法了

main.m

[objc]  view plain  copy

 

1. //  
2. //  main.m  
3. //  34_ArchiveProtocol  
4. //  
5. //  Created by jiangwei on 14-10-13.  
6. //  Copyright (c) 2014年 jiangwei. All rights reserved.  
7. //  
8.   
9. #import <Foundation/Foundation.h>  
10.   
11. #import "Person.h"  
12. int main(int argc, const charchar * argv[]) {  
13.     @autoreleasepool {  
14.           
15.         Person *p = [[Person alloc] init];  
16.         p.name = @"张三";  
17.         p.age = 20;  
18.         p.apples = @[@"iphone",@"ipad"];  
19.           
20.         //归档  
21.         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"person.archiver"];  
22.         BOOL success = [NSKeyedArchiver archiveRootObject:p toFile:filePath];  
23.         if(success){  
24.             NSLog(@"归档成功");  
25.         }  
26.           
27.         //解归档  
28.         Person *person = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];  
29.         NSLog(@"%@",person);  
30.           
31.           
32.     }  
33.     return 0;  
34. }  

我们可以看到，使用起来是很简单的和上面的方式一样，运行结果：

看到了，我们自定义的description方法，打印了我们自己想要的结果~~

总结

这一篇文章我们就说了OC中的归档和解档的相关概念和操作，其实说白了就是将对象写入到文件，和从文件中读取对象。