| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
////////使用时需要导入下面的文件 //#import "SBJSON.h" //#import "NSObject+SBJSON.h" //#import "NSString+SBJSON.h"
-(void)viewDidLoad { [superviewDidLoad]; NSString* filePath= [[NSBundlemainBundle]pathForResource:@"CITY"ofType:@"json"]; NSLog(@"filePath=%@",filePath); NSString* jsonData= [NSStringstringWithContentsOfFile:filePathencoding:NSUTF8StringEncodingerror:nil]; NSMutableDictionary* dic= [jsonDataJSONValue]; NSLog(@"dic = %@",dic); } //通过JSONValue就可以将数据解析为我们数值的数组或者字典形式了！ |
@H_364_301@
SBJson是一个开源的json库，结构如下：
结构主要分为：主头文件SBJson.h，一个对象类别扩展NSObject+SBJson.h，一个json解析包Parser，一个json编写包Writer
任何使用SBJson库的地方都要导入SBJson.h头文件
#import "SBJson.h"
1.JSON转Objective-C，方法如下：
null -> NSNull
string -> NSString
array -> NSMutableArray
object -> NSMutableDictionary
true -> NSNumber's -numberWithBool:YES
false -> NSNumber's -numberWithBool:NO
integer up to 19 digits -> NSNumber's -numberWithLongLong:
all other numbers -> NSDecimalNumber
true或false转为 [NSNumber numberWithBool:YES]或[NSNumber numberWithBool:NO]
integer整数长度19位，表现为LongLong类型，［NSNumber numberWithLongLong：］
json允许大的离谱的数字，为避免任何精度损失，将其他复杂数变成NSDecimalNumber实例
2.Objective-C转JSON，方法如下：
NSNull -> null
NSString -> string
NSArray -> array
NSDictionary -> object
NSNumber's -initWithBool:YES -> true
NSNumber's -initWithBool:NO -> false
NSNumber -> number
注意：JSON中对象的键key必须是字符串
NSDictionary中的键key，可能不是字符串，所以当拥有非字符串的键的NSDictionary转为json时会抛出异常
主要两个接口：
[NSObjectJSONRepresentation]
[NSStringJSONValue]
一.NSObject+SBJson.h
1.把objc对象编码成json字符串
通过类别，为NSObject添加新方法：[NSObjectJSONRepresentation]
1 @interface NSObject (NSObject_SBJsonWriting)
2 /**
3 虽然定义成NSObject的类别，但仅对NSArray和NSDictionary有效
4 返回：已编码的json对象，或nil
5 */
6 - (NSString *)JSONRepresentation;
7 @end
2.把json对象解析为objc对象
通过类别，为NSString添加新方法：[NSStringJSONValue]
1 @interface NSString (NSString_SBJsonParsing)
3 返回：NSDictionary或NSArray对象，或nil
4 */
5 - (id)JSONValue;
6 @end
二.NSObject+SBJson.m
导入头文件
1 #import "NSObject+SBJson.h"
2 #import "SBJsonWriter.h"
3 #import "SBJsonParser.h"
1.通过json编写器SBJsonWriter，的stringWithObject: 方法，实现[NSObjectJSONRepresentation]编码逻辑
1 @implementation NSObject (NSObject_SBJsonWriting)
2
3 //objc2json
4 - (NSString *)JSONRepresentation {
5 SBJsonWriter *writer = [[SBJsonWriter alloc] init];
6 NSString *json = [writer stringWithObject:self];
7 if (!json)
8 NSLog(@"-JSONRepresentation Failed. Error is: %@",writer.error);
9 return json;
10 }
11
12 @end
2.通过json解析器SBJsonParser，的objectWithString: 方法，实现[NSStringJSONValue]解析逻辑
1 @implementation NSString (NSString_SBJsonParsing)
3 //json2objc
4 - (id)JSONValue {
5 SBJsonParser *parser = [[SBJsonParser alloc] init];
6 id repr = [parser objectWithString:self];
7 if (!repr)
8 NSLog(@"-JSONValue Failed. Error is: %@",parser.error);
9 return repr;
10 }
12 @end
SBJsonWriter：json编写器类
内部使用了json流编写器：SBJsonStreamWriter类，和json流编写累加器：SBJsonStreamWriterAccumulator类
主要有4个属性：
1 /**
2 @最大递归深度，默认为32
3 如果嵌套的太深，大于32被视为恶意解析，返回nil，并发送一个错误信号
可以通过设置maxDepth为0,来取消此安全功能
5 */
6 @property NSUInteger maxDepth;
7
8 /**
9 @返回一个出错信息，如果没错误，返回为nil
10 */
11 @property (readonly,copy) NSString *error;
12
13 /**
14 @是否为人类可读的json
15 默认为NO，产生的json没有任何空白
16 如果设为YES，换行后，每个数组值和字典键／值对缩进两个空格
17 */
18 @property BOOL humanReadable;
19
20 /**
21 @输出时字典键是否排序
22 默认为NO，如果设为YES，排序json输出的字典键
23 如果你需要比较两个结构时候很有用
24 */
25 @property BOOL sortKeys;
注意：上面的error属性为只读的（readonly）
属性实现在SBJsonWriter.m文件中：
1 @synthesize sortKeys;
2 @synthesize humanReadable;
3 @synthesize error;
4 @synthesize maxDepth;
其中error通过类别声明为私有可写，如下：
1 @interface SBJsonWriter ()
2 @property (copy) NSString *error;
3 @end
此类有3个转json表述的方法：
1 /**
2 @objc转成NSString
3 返回给定objc对象的json表示
返回一个字符串，或nil
5 如果返回nil，则SBJsonWriter的error属性不为空，可以通过error的信息知道出错原因
6 其中的参数value，是任何可以用json表述的对象
7 */
8 - (NSString*)stringWithObject:(id)value;
9
10 /**
11 @objc转成NSData
12 返回给定objc对象的json表示，用UTF8编码
13 返回一个NSData对象，或nil
14 */
15 - (NSData*)dataWithObject:(id)value;
16
17 /**
18 @返回给定objc对象的json表示（或片段）
19 返回字符串，或nil
20 */
21 - (NSString*)stringWithObject:(id)value
22 error:(NSError**)error;
三个方法的具体实现在SBJsonWriter.m文件中
1 //把objc转成NSData，再通过UTF8编码把NSData转成字符串
2 - (NSString*)stringWithObject:(id)value {
3 NSData *data = [self dataWithObject:value];
4 if (data)
5 return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
6 return nil;
7 }
8
9 - (NSString*)stringWithObject:(id)value error:(NSError**)error_ {
10 NSString *tmp = [self stringWithObject:value];
11 if (tmp)
12 return tmp;
13
14 if (error_) {
15 NSDictionary *ui = [NSDictionary dictionaryWithObjectsAndKeys:error,NSLocalizedDescriptionKey,nil];
16 *error_ = [NSError errorWithDomain:@"org.brautaset.SBJsonWriter.ErrorDomain" code:0 userInfo:ui];
17 }
18
19 return nil;
20 }
21
22 /**
初始化一个json流编写器，设置参数
24 初始化一个json流编写叠加器，把它设为SBJsonStreamWriter的代理（delegate）
25 把ojbc对象转变为NSData，通过调用SBJsonStreamWriter的writeObject:方法，或writeArray:方法，
26 或递归调用dataWithObject:方法，参数为[object proxyForJson]返回的代理对象
27 其中SBJsonStreamWriter的各种write方法，是把基本数据写成二进制bytes
28 然后通过叠加器SBJsonStreamWriterAccumulator，把二进制bytes拼装成NSData对象
29 返回叠加器的data属性变量
30 */
31 - (NSData*)dataWithObject:(id)object {
32 self.error = nil;
33
34 SBJsonStreamWriterAccumulator *accumulator = [[SBJsonStreamWriterAccumulator alloc] init];
35
36 SBJsonStreamWriter *streamWriter = [[SBJsonStreamWriter alloc] init];
37 streamWriter.sortKeys = self.sortKeys;
38 streamWriter.maxDepth = self.maxDepth;
39 streamWriter.humanReadable = self.humanReadable;
40 streamWriter.delegate = accumulator;
41
42 BOOL ok = NO;
43 if ([object isKindOfClass:[NSDictionary class]])
44 ok = [streamWriter writeObject:object];
45
46 else if ([object isKindOfClass:[NSArray class]])
47 ok = [streamWriter writeArray:object];
48
49 else if ([object respondsToSelector:@selector(proxyForJson)])
50 return [self dataWithObject:[object proxyForJson]];
51 else {
52 self.error = @"Not valid type for JSON";
53 return nil;
54 }
55
56 if (ok)
57 return accumulator.data;
58
59 self.error = streamWriter.error;
60 return nil;
61 }
json流编写器
允许传入一个消息流对象，把它写入到SBJsonStreamWriterAccumulator的data里.
1.里面含有个新的NSObject类别，把objc对象转成json允许的对象类型
1 @interface NSObject (SBProxyForJson)
3 /**
4 json只支持NSArray和NSDictionary等类型
5 所以转换之前先把特定objc对象转成这两种类型的形式
如果你有一个自定义类，要把它转成json，需要实现该方法
7 例子如下：
8 @code
9 - (id)proxyForJson {
10 return [NSDictionary dictionaryWithObjectsAndKeys:
11 name,@"name",
12 phone,@"phone",0)"> 13 email,@"email",0)"> 14 nil];
15 }
16 @endcode
17 */
18
19 - (id)proxyForJson;
20
21 @end
2.里面定义了个json流编写器代理协议：
1 //在json流编写叠加器SBJsonStreamWriterAccumulator里实现
2 @protocol SBJsonStreamWriterDelegate
3
4 - (void)writer:(SBJsonStreamWriter*)writer appendBytes:(const void *)bytes length:(NSUInteger)length;
5
6 @end
3.定义了一个私有属性：
NSMutableDictionary *cache;
4.定义了7个公有属性：
1 @property (nonatomic,unsafe_unretained) SBJsonStreamWriterState *state; // Internal
2 @property (nonatomic,readonly,strong) NSMutableArray *stateStack; // Internal
3
4 //json输出流的代理
5 @property (unsafe_unretained) id<SBJsonStreamWriterDelegate> delegate;
6
7 /**
8 @最大递归深度，默认为512.
10功能
11 */
12 @property NSUInteger maxDepth;
13
14 /**
15 @是否为人类可读的json
17 如果设为YES，换行后，每个数组值和字典键／值对缩进两个空格
18 */
19 @property BOOL humanReadable;
20
21 /**
24 如果你需要比较两个结构时候很有用
25 */
26 @property BOOL sortKeys;
27
28 /**
@返回一个出错信息，如果没错误，返回为nil
30 */
31 @property (copy) NSString *error;
5.定义了10个公有方法：
2 把NSDictionary对象写到JSON输出流
3 返回YES,表示成功
4 */
5 - (BOOL)writeObject:(NSDictionary*)dict;
7 /**
8 把NSArray对象写入JSON输出流
9 返回YES,表示成功
10 */
11 - (BOOL)writeArray:(NSArray *)array;
14 开始写一个obj对象到JSON输出流
15 返回YES,表示成功
16 */
17 - (BOOL)writeObjectOpen;
18
19 /**
20 结束写obj对象到JSON输出流
21 返回YES,表示成功
22 */
23 - (BOOL)writeObjectClose;
24
25 /**
26 开始写一个Array对象到JSON输出流
27 返回YES,表示成功
28 */
29 - (BOOL)writeArrayOpen;
30
31 /**
32 结束写Array对象到JSON输出流
33 返回YES,表示成功
34 */
35 - (BOOL)writeArrayClose;
36
37 /**
38 把null对象写入JSON输出流
39 返回YES,表示成功
40 */
41 - (BOOL)writeNull;
42
43 /**
44 把boolean对象写入JSON输出流
45 返回YES,表示成功
46 */
47 - (BOOL)writeBool:(BOOL)x;
48
49 /**
50 把Number对象写入JSON输出流
51 返回YES,表示成功
52 */
53 - (BOOL)writeNumber:(NSNumber*)n;
54
55 /**
56 把String对象写入JSON输出流
57 返回YES,表示成功
58 */
59 - (BOOL)writeString:(NSString*)s;
6.有个类别，定义了两个私有方法：
1 @interface SBJsonStreamWriter (Private)
2 - (BOOL)writeValue:(id)v;
3 - (void)appendBytes:(const void *)bytes length:(NSUInteger)length;
4 @end
json流编写叠加器，拥有个可变data对象
1 @interface SBJsonStreamWriterAccumulator : NSObject <SBJsonStreamWriterDelegate>
2
3 @property (readonly,copy) NSMutableData* data;
4
5 @end
具体实现：
1 @implementation SBJsonStreamWriterAccumulator
2
3 @synthesize data;
4
5 - (id)init {
6 self = [super init];
7 if (self) {
8 data = [[NSMutableData alloc] initWithCapacity:8096u];
9 }
10 return self;
11 }
12
13
14 #pragma mark SBJsonStreamWriterDelegate
15
16 //实现SBJsonStreamWriterDelegate协议，把二进制数据添加到data
17
18 - (void)writer:(SBJsonStreamWriter *)writer appendBytes:(const void *)bytes length:(NSUInteger)length {
19 [data appendBytes:bytes length:length];
20 }
21
22 @end
json解析器
2 json转objc
3 解析json字符串和NSData对象
4 内部使用了SBJsonStreamParser类
5 */
6
7 @interface SBJsonParser : NSObject
8
9 /**
1112功能
13 */
14 @property NSUInteger maxDepth;
16 /**
@返回一个出错信息，如果没错误，返回为nil
18 */
19 @property(copy) NSString *error;
21 /**
22 json转objc
23 @返回给定的NSData所代表的对象
24 参数data必须为UTF8编码
25 返回NSArray或NSDictionary对象，如果返回nil，表示出现错误
26 */
27 - (id)objectWithData:(NSData*)data;
28
29 /**
30 json转objc
31 @返回给定字符串所代表的对象
32 此方法内部实现是：把参数用UTF8编码成NSData，然后调用objectWithData：方法，转成NSArray或NSDictionary，或nil
33 */
34 - (id)objectWithString:(NSString *)repr;
35
36 /**
37 json转objc
38 @返回给定字符串所代表的对象
39 */
40
41 - (id)objectWithString:(NSString*)jsonText
42 error:(NSError**)error;
43
44 @end
实现在SBJsonParser.m文件中：
1 #import "SBJsonParser.h"
2 #import "SBJsonStreamParser.h"
3 #import "SBJsonStreamParserAdapter.h"
4 #import "SBJsonStreamParserAccumulator.h"
5
6 @implementation SBJsonParser
7
8 @synthesize maxDepth;
9 @synthesize error;
10
11 - (id)init {
12 self = [super init];
13 if (self)
14 self.maxDepth = 32u;
15 return self;
16 }
17
18 #pragma mark Methods
20 /**
21 调用流解析器SBJsonStreamParser的parse:方法，把NSData转成NSArray或NSDictionary对象
22 */
23 - (id)objectWithData:(NSData *)data {
24
25 if (!data) {
26 self.error = @"Input was 'nil'";
27 return nil;
28 }
29
30 //初始化一个json流解析叠加器
31 SBJsonStreamParserAccumulator *accumulator = [[SBJsonStreamParserAccumulator alloc] init];
32
33 //初始化一个json流解析配置器
34 SBJsonStreamParserAdapter *adapter = [[SBJsonStreamParserAdapter alloc] init];
35 //把叠加器设为配置器的代理（delegate）
36 adapter.delegate = accumulator;
37
//初始化一个json流解析器，设置参数
39 SBJsonStreamParser *parser = [[SBJsonStreamParser alloc] init];
40 parser.maxDepth = self.maxDepth;
41 //把配置器设为解析器的代理（delegate）
42 parser.delegate = adapter;
43
44 switch ([parser parse:data]) {
45 case SBJsonStreamParserComplete:
46 return accumulator.value;
47 break;
48
49 case SBJsonStreamParserWaitingForData:
50 self.error = @"Unexpected end of input";
51 break;
52
53 case SBJsonStreamParserError:
54 self.error = parser.error;
55 break;
56 }
57
58 return nil;
59 }
60
61 //NSString用UTF8编码成NSData，再把NSData转成NSArray或NSDictionary对象
62 - (id)objectWithString:(NSString *)repr {
63 return [self objectWithData:[repr dataUsingEncoding:NSUTF8StringEncoding]];
64 }
65
66 - (id)objectWithString:(NSString*)repr error:(NSError**)error_ {
67 id tmp = [self objectWithString:repr];
68 if (tmp)
69 return tmp;
70
71 if (error_) {
72 NSDictionary *ui = [NSDictionary dictionaryWithObjectsAndKeys:error,nil];
73 *error_ = [NSError errorWithDomain:@"org.brautaset.SBJsonParser.ErrorDomain" code:0 userInfo:ui];
74 }
75
76 return nil;
77 }
78
79 @end
json数据流解析器
1.定义了一个枚举值表示解析状态：
1 typedef enum {
2 SBJsonStreamParserComplete,
3 SBJsonStreamParserWaitingForData,
4 SBJsonStreamParserError,
5 } SBJsonStreamParserStatus;
2.定义了一个json流解析代理协议：
2 由SBJsonStreamParserAdapter类实现
3 */
4 @protocol SBJsonStreamParserDelegate
5
6 //当找到obj时调用
7 - (void)parserFoundObjectStart:(SBJsonStreamParser*)parser;
9 //当找到obj对象key时调用
10 - (void)parser:(SBJsonStreamParser*)parser foundObjectKey:(NSString*)key;
11
12 //当obj结束时调用
13 - (void)parserFoundObjectEnd:(SBJsonStreamParser*)parser;
14
15 //当找到array对象时调用
16 - (void)parserFoundArrayStart:(SBJsonStreamParser*)parser;
17
18 //当array对象结束时调用
19 - (void)parserFoundArrayEnd:(SBJsonStreamParser*)parser;
21 //当找到boolean值时调用
22 - (void)parser:(SBJsonStreamParser*)parser foundBoolean:(BOOL)x;
23
24 //当找到null时调用
25 - (void)parserFoundNull:(SBJsonStreamParser*)parser;
26
27 //当找到number时调用
28 - (void)parser:(SBJsonStreamParser*)parser foundNumber:(NSNumber*)num;
29
30 //当找到字符串对象时调用
31 - (void)parser:(SBJsonStreamParser*)parser foundString:(NSString*)string;
32
33 @end
3.属性和声明的方法：
2 @json数据流解析器
3 把json数据流解析成NSArray或NSDictionary对象
使用这个类，可以边下载边解析（在整个文件被全部下载之前进行解析）
用这个类对磁盘上的大文件解析也有好处，不用全部加载到内存
6 具体实现可查看SBJsonStreamParserAdapter类
7 */
8 @interface SBJsonStreamParser : NSObject {
9 @private
10 SBJsonTokeniser *tokeniser;
11 }
12
13 @property (nonatomic,unsafe_unretained) SBJsonStreamParserState *state; // Private
14 @property (nonatomic,strong) NSMutableArray *stateStack; // Private
是否用空格隔开多个文件
18 当设置为YES,解析器就不会返回SBJsonStreamParserComplete
19 默认为NO，一但返回SBJsonStreamParserComplete，解析器不会解析更多数据
20 */
21 @property BOOL supportMultipleDocuments;
22
23 /**
@流解析代理对象
25 通常是指SBJsonStreamParserAdapter
26 也可以是实现了SBJsonStreamParserDelegate解析代理协议的任何对象
27 */
28 @property (unsafe_unretained) id<SBJsonStreamParserDelegate> delegate;
30 /**
32 如果嵌套的太深，大于32被视为恶意解析，返回nil，并发送一个错误信号
33 */
34 @property NSUInteger maxDepth;
36 //保存BJsonStreamParserError后返回的错误信息
37 @property (copy) NSString *error;
38
39 /**
40 解析json数据
41 参数是UTF8编码的json数据（NSData）
42 返回一个枚举值，流解析状态：
43 SBJsonStreamParserComplete表示：解析了全部数据
44 SBJsonStreamParserWaitingForData表示：等待获得更多数据
45 SBJsonStreamParserError表示：解析出错
46 */
47 - (SBJsonStreamParserStatus)parse:(NSData*)data;
48
49 @end
json流解析配置器
1.定义了一个枚举配置器类型：
1 typedef enum {
2 SBJsonStreamParserAdapterNone,
3 SBJsonStreamParserAdapterArray,
4 SBJsonStreamParserAdapterObject,
5 } SBJsonStreamParserAdapterType;
2.定义了一个json流解析配置器代理协议：
@json流解析配置器代理协议
从流解析配置器获得obj或array对象的代理
4 由流解析叠加器SBJsonStreamParserAccumulator实现
5 */
6 @protocol SBJsonStreamParserAdapterDelegate
如果发现一个json数组，则调用此方法
10 */
11 - (void)parser:(SBJsonStreamParser*)parser foundArray:(NSArray*)array;
13 /**
14 如果发现一个json对象，则调用此方法
15 */
16 - (void)parser:(SBJsonStreamParser*)parser foundObject:(NSDictionary*)dict;
17
18 @end
3.类定义和属性：
1 @interface SBJsonStreamParserAdapter : NSObject <SBJsonStreamParserDelegate> {
2 @private
3 NSUInteger depth;
4 NSMutableArray *array;
5 NSMutableDictionary *dict;
6 NSMutableArray *keyStack;
7 NSMutableArray *stack;
8
9 SBJsonStreamParserAdapterType currentType;
10 }
12 /**
13 如何跳过多个层级
当文件太大了或链接缓慢，此方法相当有用
15 如果设置此为N,它会跳过外面的N层，为每个内层对象，直接调用-parser:foundArray:或-parser:foundObject:方法
16 */
17 @property NSUInteger levelsToSkip;
20 实现SBJsonStreamParserAdapterDelegate代理协议的对象
21 */
22 @property (unsafe_unretained) id<SBJsonStreamParserAdapterDelegate> delegate;
23
24 @end
/**
默认的委托，当一个文件完全解析，只会调用一个-parser:foundArray:方法或-parser:foundObject:的方法
如果设置SBJsonStreamParser的supportMultipleDocuments属性为YES,
就可以支持多个json顶级对象的解析
例子如下：
@code
SBJsonStreamParserAdapter *adapter = [[[SBJsonStreamParserAdapter alloc] init] autorelease];
adapter.delegate = self;
SBJsonStreamParser *parser = [[[SBJsonStreamParser alloc] init] autorelease];
parser.delegate = adapter;
parser.supportMultipleDocuments = YES;
// 注意：此输入包含多个顶级json对象
NSData *json = [@"[]{}[]{}" dataWithEncoding:NSUTF8StringEncoding];
[parser parse:data];
@endcode
self调用它的顺序如下：
@li -parser:foundArray:
@li -parser:foundObject:
@li -parser:foundArray:
@li -parser:foundObject:
下面是跳过第一个或多个封装对象：
@code
SBJsonStreamParserAdapter *adapter = [[[SBJsonStreamParserAdapter alloc] init] autorelease];
adapter.delegate = self;
adapter.levelsToSkip = 1;
SBJsonStreamParser *parser = [[[SBJsonStreamParser alloc] init] autorelease];
parser.delegate = adapter;
// 注意：此输入包含一个单一的顶级json对象
NSData *json = [@"[[],{},[],{}]" dataWithEncoding:NSUTF8StringEncoding];
[parser parse:data];
@endcode
*/
json流解析叠加器
1 //实现了流解析配置代理协议
2 @interface SBJsonStreamParserAccumulator : NSObject <SBJsonStreamParserAdapterDelegate>
3
//声明的value对象，表示解析完成后的objc对象
5 @property (copy) id value;
6
7 @end
json流解析叠加器
7 @end
实现了配置代理协议SBJsonStreamParserAdapterDelegate的两个方法：
2 返回NSArray或NSDictionary对象
3 */
4 - (void)parser:(SBJsonStreamParser*)parser foundArray:(NSArray *)array {
5 value = array;
6 }
7
8 - (void)parser:(SBJsonStreamParser*)parser foundObject:(NSDictionary *)dict {
9 value = dict;
10 }
