iOS开发之将XML转换成树

开发中由于服务端与客户端是两种不同的平台，而且服务端又是老系统，不具备很好的面向对象的性质，所以导致客户端与服务端只好通过一些制定好的xml进行通信。

在iOS中对XML的解析不像donet这么方便。当然也存在一些很方便的开源类库去调用，但是有些开源的类库显得很笨重。这篇文章我将封装一个简单操作XML转换成树的类方便自己操作：首先通过NSXMLParser从服务端获取XML，它可以一边下载，一边解析，然后转换成树形结构，最后我们可以从树形结构中去取值。

使用NSXMLParser解析XML：

NSXMLParser中主要有三个委托方法来解析XML：

1、parser：didStartElement：当解析器对象遇到xml的开始标记时，调用这个方法。

2、parser：didEndElement：当解析器对象遇到xml的结束标记时，调用这个方法。

3、parser：foundCharacters：当解析器找到开始标记和结束标记之间的字符时，调用这个方法。

了解了NSXMLParser机制。然后我们来封装解析XML的类：XMLParser。

#import <CoreFoundation/CoreFoundation.h>
#import "TreeNode.h"
 
@interface XMLParser : NSObject
{
    NSMutableArray      *stack;
}
 
+ (XMLParser *) sharedInstance;
- (TreeNode *) parseXMLFromURL: (NSURL *) url;
- (TreeNode *) parseXMLFromData: (NSData*) data;
@end

shareInstance使用一个单例。

调用parseXMLFromURL方法，需要一个NSURL的参数，返回我们需要的树节点。

调用parseXMLFromData方法，需要一个NSData的参数，返回我们需要的树节点。
在此之前，先定义TreeNode类：

#import <CoreFoundation/CoreFoundation.h>
 
@interface TreeNode : NSObject
{
    TreeNode        *parent;
    NSMutableArray  *children;
    NSString        *key;
    NSString        *leafvalue;
}
@property (nonatomic, retain)   TreeNode        *parent;
@property (nonatomic, retain)   NSMutableArray  *children;
@property (nonatomic, retain)   NSString        *key;
@property (nonatomic, retain)   NSString        *leafvalue;
 
@property (nonatomic, readonly) BOOL            isLeaf;
@property (nonatomic, readonly) BOOL            hasLeafValue;
 
@property (nonatomic, readonly) NSArray         *keys;
@property (nonatomic, readonly) NSArray         *allKeys;
@property (nonatomic, readonly) NSArray         *uniqKeys;
@property (nonatomic, readonly) NSArray         *uniqAllKeys;
@property (nonatomic, readonly) NSArray         *leaves;
@property (nonatomic, readonly) NSArray         *allLeaves;
 
@property (nonatomic, readonly) NSString        *dump;
 
 
+ (TreeNode *) treeNode;
- (NSString *) dump;
- (void) teardown;
 
// Leaf Utils
- (BOOL) isLeaf;
- (BOOL) hasLeafValue;
- (NSArray *) leaves;
- (NSArray *) allLeaves;
 
// Key Utils
- (NSArray *) keys; 
- (NSArray *) allKeys; 
- (NSArray *) uniqKeys;
- (NSArray *) uniqAllKeys;
 
 
// Search Utils
- (TreeNode *) objectForKey: (NSString *) aKey;
- (NSString *) leafForKey: (NSString *) aKey;
- (NSMutableArray *) objectsForKey: (NSString *) aKey;
- (NSMutableArray *) leavesForKey: (NSString *) aKey;
- (TreeNode *) objectForKeys: (NSArray *) keys;
- (NSString *) leafForKeys: (NSArray *) keys;
 
// Convert Utils
- (NSMutableDictionary *) dictionaryForChildren;
@end

TreeNode 实现：

#import "TreeNode.h"
 
// String stripper utility macro
#define STRIP(X)    [X stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]
 
@implementation TreeNode
@synthesize parent;
@synthesize children;
@synthesize key;
@synthesize leafvalue;
 
#pragma mark Create and Initialize TreeNodes
- (TreeNode *) init
{
    if (self = [super init]) 
    {
        self.key = nil;
        self.leafvalue = nil;
        self.parent = nil;
        self.children = nil;
    }
    return self;
}
 
+ (TreeNode *) treeNode
{
    return [[[self alloc] init] autorelease];
}
 
 
#pragma mark TreeNode type routines
- (BOOL) isLeaf
{
    return (self.children.count == 0);
}
 
- (BOOL) hasLeafValue
{
    return (self.leafvalue != nil);
}
 
#pragma mark TreeNode data recovery routines
 
// Return an array of child keys. No recursion
- (NSArray *) keys
{
    NSMutableArray *results = [NSMutableArray array];
    for (TreeNode *node in self.children) [results addObject:node.key];
    return results;
}
 
// Return an array of child keys with depth-first recursion.
- (NSArray *) allKeys
{
    NSMutableArray *results = [NSMutableArray array];
    for (TreeNode *node in self.children) 
    {
        [results addObject:node.key];
        [results addObjectsFromArray:node.allKeys];
    }
    return results;
}
 
- (NSArray *) uniqArray: (NSArray *) anArray
{
    NSMutableArray *array = [NSMutableArray array];
    for (id object in [anArray sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)])
        if (![[array lastObject] isEqualToString:object]) [array addObject:object];
    return array;
}
 
// Return a sorted, uniq array of child keys. No recursion
- (NSArray *) uniqKeys
{
    return [self uniqArray:[self keys]];
}
 
// Return a sorted, uniq array of child keys. With depth-first recursion
- (NSArray *) uniqAllKeys
{
    return [self uniqArray:[self allKeys]];
}
 
// Return an array of child leaves. No recursion
- (NSArray *) leaves
{
    NSMutableArray *results = [NSMutableArray array];
    for (TreeNode *node in self.children) if (node.leafvalue) [results addObject:node.leafvalue];
    return results;
}
 
// Return an array of child leaves with depth-first recursion.
- (NSArray *) allLeaves
{
    NSMutableArray *results = [NSMutableArray array];
    for (TreeNode *node in self.children) 
    {
        if (node.leafvalue) [results addObject:node.leafvalue];
        [results addObjectsFromArray:node.allLeaves];
    }
    return results;
}
 
#pragma mark TreeNode search and retrieve routines
 
// Return the first child that matches the key, searching recursively breadth first
- (TreeNode *) objectForKey: (NSString *) aKey
{
    TreeNode *result = nil;
    for (TreeNode *node in self.children) 
        if ([node.key isEqualToString: aKey])
        {
            result = node;
            break;
        }
    if (result) return result;
    for (TreeNode *node in self.children)
    {
        result = [node objectForKey:aKey];
        if (result) break;
    }
    return result;
}
 
// Return the first leaf whose key is a match, searching recursively breadth first
- (NSString *) leafForKey: (NSString *) aKey
{
    TreeNode *node = [self objectForKey:aKey];
    return node.leafvalue;
}
 
// Return all children that match the key, including recursive depth first search.
- (NSMutableArray *) objectsForKey: (NSString *) aKey
{
    NSMutableArray *result = [NSMutableArray array];
    for (TreeNode *node in self.children) 
    {
        if ([node.key isEqualToString: aKey]) [result addObject:node];
        [result addObjectsFromArray:[node objectsForKey:aKey]];
    }
    return result;
}
 
// Return all leaves that match the key, including recursive depth first search.
- (NSMutableArray *) leavesForKey: (NSString *) aKey
{
    NSMutableArray *result = [NSMutableArray array];
    for (TreeNode *node in [self objectsForKey:aKey]) 
        if (node.leafvalue)
            [result addObject:node.leafvalue];
    return result;
}
 
// Follow a key path that matches each first found branch, returning object
- (TreeNode *) objectForKeys: (NSArray *) keys
{
    if ([keys count] == 0) return self;
     
    NSMutableArray *nextArray = [NSMutableArray arrayWithArray:keys];
    [nextArray removeObjectAtIndex:0];
     
    for (TreeNode *node in self.children)
    {
        if ([node.key isEqualToString:[keys objectAtIndex:0]])
            return [node objectForKeys:nextArray];
    }
     
    return nil;
}
 
// Follow a key path that matches each first found branch, returning leaf
- (NSString *) leafForKeys: (NSArray *) keys
{
    TreeNode *node = [self objectForKeys:keys];
    return node.leafvalue;
}
 
#pragma mark output utilities
 
// Print out the tree
- (void) dumpAtIndent: (int) indent into:(NSMutableString *) outstring
{
    for (int i = 0; i < indent; i++) [outstring appendString:@"--"];
     
    [outstring appendFormat:@"[%2d] Key: %@ ", indent, key];
    if (self.leafvalue) [outstring appendFormat:@"(%@)", STRIP(self.leafvalue)];
    [outstring appendString:@"\n"];
     
    for (TreeNode *node in self.children) [node dumpAtIndent:indent + 1 into: outstring];
}
 
- (NSString *) dump
{
    NSMutableString *outstring = [[NSMutableString alloc] init];
    [self dumpAtIndent:0 into:outstring];
    return [outstring autorelease];
}
 
#pragma mark conversion utilities
// When you're sure you're the parent of all leaves, transform to a dictionary
- (NSMutableDictionary *) dictionaryForChildren
{
    NSMutableDictionary *results = [NSMutableDictionary dictionary];
     
    for (TreeNode *node in self.children)
        if (node.hasLeafValue) [results setObject:node.leafvalue forKey:node.key];
     
    return results;
}
 
#pragma mark invocation forwarding
 
// Invocation Forwarding lets node act like array
- (id)forwardingTargetForSelector:(SEL)sel 
{ 
    if ([self.children respondsToSelector:sel]) return self.children; 
    return nil;
}
 
// Extend selector compliance
- (BOOL)respondsToSelector:(SEL)aSelector
{
    if ( [super respondsToSelector:aSelector] ) return YES;
    if ([self.children respondsToSelector:aSelector]) return YES;
    return NO;
}
 
// Allow posing as NSArray class for children
- (BOOL)isKindOfClass:(Class)aClass
{
    if (aClass == [TreeNode class]) return YES;
    if ([super isKindOfClass:aClass]) return YES;
    if ([self.children isKindOfClass:aClass]) return YES;
     
    return NO;
}
 
#pragma mark cleanup
- (void) teardown
{
    for (TreeNode *node in [[self.children copy] autorelease]) [node teardown];
    [self.parent.children removeObject:self];
    self.parent = nil;
}
 
- (void) dealloc
{
    self.parent = nil;
    self.children = nil;
    self.key = nil;
    self.leafvalue = nil;
     
    [super dealloc];
}
 
@end

从上面的代码可以看出，定义了很多方便的方法来获取数据。

1、teardown：清除所有节点

2、isLeaf：判断是否是叶子节点

3、hasLeafValue：判断节点是否有值

4、- (NSArray *) leaves：返回节点的所有一级子节点值

5、- (NSArray *) allLeaves：返回节点的所有子节点的值

6、keys; 返回节点所有一级子节点名称。
7、 allKeys; 返回节点所有子节点名称。
8、 uniqKeys;返回节点一级子节点名称，不重复。
9、uniqAllKeys;返回节点子节点名称，不重复。

10、- (TreeNode *) objectForKey：根据节点名称查询节点

11、- (NSString *) leafForKey: (NSString *) aKey：根据节点名称查询出节点的值

12、- (NSMutableArray *) objectsForKey: (NSString *) aKey;根据节点名称查询出所以满足条件的节点

13、- (NSMutableArray *) leavesForKey: (NSString *) aKey;根据节点名称查询出所以满足条件的节点的值

14、- (TreeNode *) objectForKeys: (NSArray *) keys;：根据节点名称路径查询出第一个满足条件的节点。

15、- (NSString *) leafForKeys: (NSArray *) keys 根据节点名称路径查询出第一个满足条件的节点的值。

16、- (NSMutableDictionary *) dictionaryForChildren：将树转换成dictionary
树定义好了，下面实现XMLParser类：

#import "XMLParser.h"
 
@implementation XMLParser
 
static XMLParser *sharedInstance = nil;
 
// Use just one parser instance at any time
+(XMLParser *) sharedInstance 
{
    if(!sharedInstance) {
        sharedInstance = [[self alloc] init];
    }
    return sharedInstance;
}
 
// Parser returns the tree root. You may have to go down one node to the real results
- (TreeNode *) parse: (NSXMLParser *) parser
{
    stack = [NSMutableArray array];
     
    TreeNode *root = [TreeNode treeNode];
    root.parent = nil;
    root.leafvalue = nil;
    root.children = [NSMutableArray array];
     
    [stack addObject:root];
     
    [parser setDelegate:self];
    [parser parse];
    [parser release];
     
    // pop down to real root
    TreeNode *realroot = [[root children] lastObject];
    root.children = nil;
    root.parent = nil;
    root.leafvalue = nil;
    root.key = nil;
     
    realroot.parent = nil;
    return realroot;
}
 
 
- (TreeNode *)parseXMLFromURL: (NSURL *) url
{   
    TreeNode *results;
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    NSXMLParser *parser = [[NSXMLParser alloc] initWithContentsOfURL:url];
    results = [self parse:parser];
    [pool drain];
    return results;
}
 
- (TreeNode *)parseXMLFromData: (NSData *) data
{   
    TreeNode *results;
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    NSXMLParser *parser = [[NSXMLParser alloc] initWithData:data];
    results = [self parse:parser];
    [pool drain];
    return results;
}
 
 
 
// Descend to a new element
- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName attributes:(NSDictionary *)attributeDict
{
    if (qName) elementName = qName;
     
    TreeNode *leaf = [TreeNode treeNode];
    leaf.parent = [stack lastObject];
    [(NSMutableArray *)[[stack lastObject] children] addObject:leaf];
     
    leaf.key = [NSString stringWithString:elementName];
    leaf.leafvalue = nil;
    leaf.children = [NSMutableArray array];
     
    [stack addObject:leaf];
}
 
// Pop after finishing element
- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName
{
    [stack removeLastObject];
}
 
// Reached a leaf
- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string
{
    if (![[stack lastObject] leafvalue])
    {
        [[stack lastObject] setLeafvalue:[NSString stringWithString:string]];
        return;
    }
    [[stack lastObject] setLeafvalue:[NSString stringWithFormat:@"%@%@", [[stack lastObject] leafvalue], string]];
}
 
@end

使用这两个类：

　下面看下我们如何使用这个类：

在iis中放下面这个xml：

<?xml version="1.0" encoding="UTF-8"?>
<Login>
<LoginResult>True</LoginResult>
<LoginInfo>恭喜你登录成功</LoginInfo>
<LastLogin>2011-05-09 12:20</LastLogin>
<Right>
<A>1</A>
<B>1</B>
<C>0</C>
</Right>
</Login>

使用下面代码获取web服务器上的xml，并将xml转换成树：

NSURL * url = [[NSURL alloc] initWithString:@"http://10.5.23.117:4444/Login.xml"];

TreeNode *node = [parser parseXMLFromURL:url];

获取xml中的登录结果：

NSString * result = [node leafForKey:@"LoginResult"];

类似xpath去取值：

NSArray *path =[[NSArray alloc]initWithObjects:@"Right",@"A",nil];

NSString * result = [node leafForKeys:path];

将xml显示在tableview上：

@implementation TreeBrowserController
 
@synthesize root;
// Each instance of this controller has a separate root, as
// descending through the tree produces new roots.
- (id) initWithRoot:(TreeNode *) newRoot
{
    if (self = [super init])
    {
        self.root = newRoot;
         
        NSString *s =[newRoot dump];
        if (newRoot.key) self.title = newRoot.key;
    }
    return self;
}
 
- (id)initWithStyle:(UITableViewStyle)style
{
    self = [super initWithStyle:style];
    if (self) {
        // Custom initialization
    }
    return self;
}
 
// The number of rows equals the number of children for a node
- (NSInteger)tableView:(UITableView *)tableView
 numberOfRowsInSection:(NSInteger)section
{
    return [self.root.children count];
}
// Color code the cells that can be navigated through
- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell = [tableView
                             dequeueReusableCellWithIdentifier:@"generic"];
    if (!cell) cell = [[[UITableViewCell alloc]
                        initWithFrame:CGRectZero reuseIdentifier:@"generic"]
                       autorelease];
    TreeNode *child = [[self.root children]
                       objectAtIndex:[indexPath row]];
    // Set text
    if (child.hasLeafValue)
        cell.textLabel.text = [NSString stringWithFormat:@"%@:%@",
                               child.key, child.leafvalue];
    else
        cell.textLabel.text = child.key;
    // Set color
    if (child.isLeaf)
        cell.textLabel.textColor = [UIColor darkGrayColor];
    else
        cell.textLabel.textColor = [UIColor blackColor];
    return cell;
}
// On selection, either push a new controller or show the leaf value
- (void)tableView:(UITableView *)tableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    TreeNode *child =
    [self.root.children objectAtIndex:[indexPath row]];
    if (child.isLeaf)
    {        
        return;
    }
    TreeBrowserController *tbc = [[[TreeBrowserController alloc]
                                   initWithRoot:child] autorelease];
    [self.navigationController pushViewController:tbc animated:YES];
}
// These controllers are ephemeral and need dealloc
- (void) dealloc
{
    self.root = nil;
    [super dealloc];
}
@end