OC 归档和解档

╰半橙微兮° 2022-03-30 03:52 214阅读 0赞

1 #import <Foundation/Foundation.h>
     2 #define PATH @"/Users/mac/Desktop/file.txt"
     3 int main(int argc, const char * argv[]) {
     4     @autoreleasepool {
     5 /*----------------------------归档对象-----------------------------*/
     6         // 1.一个对象-XML属性列表归档
     7 
     8         /*
     9         NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:@"one",@"1",@"two",@"2", nil];
    10         // 归档
    11         [dict writeToFile:PATH atomically:YES];
    12         // 解档
    13         NSMutableDictionary *dict1 = [[NSMutableDictionary alloc] initWithContentsOfFile:PATH];
    14         
    15         NSLog(@"%@",dict1);
    16          */
    17         
    18         
    19         /*
    20         // 2.一个对象-NSKeyedArchiver归档(带键值编码归档)
    21         NSArray *arr = @[@"one",@"two",@"three",@"four"];
    22         // 归档
    23         [NSKeyedArchiver archiveRootObject:arr toFile:PATH];
    24         // 解档
    25         NSArray *tempArr = [NSKeyedUnarchiver unarchiveObjectWithFile:PATH];
    26         NSLog(@"%@",tempArr);
    27          */
    28 
    29         // 3.多个对象-NSKeyedArchiver归档
    30         NSArray *oldArray = @[@"one",@"two",@"three",@"four"];
    31         NSDictionary *oldDict = @{
        @"student":@"Bowen",@"teacher":@"shang",@"laoDa":@"frank"};
    32         
    33         NSMutableData *oldData = [[NSMutableData alloc] init];
    34         NSKeyedArchiver *archer = [[NSKeyedArchiver alloc] initForWritingWithMutableData:oldData];
    35         // 编码
    36         [archer encodeObject:oldArray forKey:@"oldArray"];
    37         [archer encodeObject:oldDict forKey:@"oldDict"];
    38         // 完成编码，将以上文件归档到data中
    39         [archer finishEncoding];
    40         
    41         BOOL flag = [oldData writeToFile:PATH atomically:YES];
    42         if (flag) {
    43             NSLog(@"归档成功");
    44         }
    45         
    46         //解档
    47         NSData *newData = [[NSData alloc] initWithContentsOfFile:PATH];
    48         NSKeyedUnarchiver *unArchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:newData];
    49         NSDictionary *newDict = [unArchiver decodeObjectForKey:@"oldDict"];
    50         NSLog(@"%@",newDict);
    51         
    52     }
    53     return 0;
    54 }

1 #import <Foundation/Foundation.h>
     2 
     3 @interface Human : NSObject<NSCopying>
     4 
     5 @property (copy, nonatomic) NSString *name;
     6 @property (assign, nonatomic) NSInteger age;
     7 @property (retain, nonatomic) Human *child;
     8 
     9 @end
    10 
    11 
    12 #import "Human.h"
    13 
    14 @implementation Human
    15 
    16 // 归档
    17 - (void) encodeWithCoder:(NSCoder *)aCoder
    18 {
    19     [aCoder encodeInteger:self.age forKey:@"age"];
    20     [aCoder encodeObject:self.name forKey:@"name"];
    21     [aCoder encodeObject:self.child forKey:@"child"];
    22 }
    23 // 解档
    24 - (instancetype)initWithCoder:(NSCoder *)coder
    25 {
    26     self = [super init];
    27     if (self) {
    28         self.age = [coder decodeIntegerForKey:@"age"];
    29         self.name = [coder decodeObjectForKey:@"name"];
    30         self.child = [coder decodeObjectForKey:@"child"];
    31     }
    32     return self;
    33 }
    34 
    35 - (NSString *)description
    36 {
    37     return [NSString stringWithFormat:@"name:%@ age:%ld child:%@", self.name,self.age,self.child];
    38 }
    39 
    40 @end
    41 
    42 
    43 #import <Foundation/Foundation.h>
    44 #import "Human.h"
    45 #define PATH @"/Users/mac/Desktop/file.txt"
    46 int main(int argc, const char * argv[]) {
    47     @autoreleasepool {
    48 
    49 
    50       
    51 /*----------------------------归档自定义对象-----------------------------*/
    52         
    53         Human *human1 = [[Human alloc] init];
    54         Human *human2 = [[Human alloc] init];
    55         human1.age = 20;
    56         human1.name = @"Bowen";
    57         human2.age = 1;
    58         human2.name = @"baoBei";
    59         human1.child = human2;
    60         
    61         
    62         NSData *oldData = [NSKeyedArchiver archivedDataWithRootObject:human1];
    63         [oldData writeToFile:PATH atomically:YES];
    64         
    65         NSData *newData = [NSData dataWithContentsOfFile:PATH];
    66         Human *human3 = [NSKeyedUnarchiver unarchiveObjectWithData:newData];
    67         
    68         NSLog(@"%@",human3);
    69         
    70     }
    71     return 0;
    72 }

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

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

**\[objc\]** [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

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

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

**2、解档**

**\[objc\]** [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

**\[objc\]** [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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中的归档和解档的相关概念和操作，其实说白了就是将对象写入到文件，和从文件中读取对象。

[view plain]: http://blog.csdn.net/jiangwei0910410003/article/details/41872551
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/549601
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/549601/fork