iOS开发swift 中json解析

实现工具类：
import Foundation
public class JSONDecoder {
    var value: AnyObject?
    
    ///print the description of the JSONDecoder
    public var description: String {
        return self.print()
    }
    ///convert the value to a String
    public var string: String? {
        return value as? String
    }
    ///convert the value to an Int
    public var integer: Int? {
        return value as? Int
    }
    ///convert the value to an UInt
    public var unsigned: UInt? {
        return value as? UInt
    }
    ///convert the value to a Double
    public var double: Double? {
        return value as? Double
    }
    ///convert the value to a float
    public var float: Float? {
        return value as? Float
    }
    ///treat the value as a bool
    public var bool: Bool {
        if let str = self.string {
            let lower = str.lowercaseString
            if lower == "true" || lower.toInt() > 0 {
                return true
            }
        } else if let num = self.integer {
            return num > 0
        } else if let num = self.double {
            return num > 0.99
        } else if let num = self.float {
            return num > 0.99
        }
        return false
    }
    //get  the value if it is an error
    public var error: NSError? {
        return value as? NSError
    }
    //get  the value if it is a dictionary
    public var dictionary: Dictionary<String,JSONDecoder>? {
        return value as? Dictionary<String,JSONDecoder>
    }
    //get  the value if it is an array
    public var array: Array<JSONDecoder>? {
        return value as? Array<JSONDecoder>
    }
    //pull the raw values out of an array
    public func getArray<T>(inout collect: Array<T>?) {
        if let array = value as? Array<JSONDecoder> {
            if collect == nil {
                collect = Array<T>()
            }
            for decoder in array {
                if let obj = decoder.value as? T {
                    collect?.append(obj)
                }
            }
        }
    }
    ///pull the raw values out of a dictionary.
    public func getDictionary<T>(inout collect: Dictionary<String,T>?) {
        if let dictionary = value as? Dictionary<String,JSONDecoder> {
            if collect == nil {
                collect = Dictionary<String,T>()
            }
            for (key,decoder) in dictionary {
                if let obj = decoder.value as? T {
                    collect?[key] = obj
                }
            }
        }
    }
    ///the init that converts everything to something nice
    public init(_ raw: AnyObject) {
        var rawObject: AnyObject = raw
        if let data = rawObject as? NSData {
            var error: NSError?
            var response: AnyObject? = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions(), error: &error)
            if error != nil || response == nil {
                value = error
                return
            }
            rawObject = response!
        }
        if let array = rawObject as? NSArray {
            var collect = [JSONDecoder]()
            for val: AnyObject in array {
                collect.append(JSONDecoder(val))
            }
            value = collect
        } else if let dict = rawObject as? NSDictionary {
            var collect = Dictionary<String,JSONDecoder>()
            for (key,val: AnyObject) in dict {
                collect[key as! String] = JSONDecoder(val)
            }
            value = collect
        } else {
            value = rawObject
        }
    }
    ///Array access support
    public subscript(index: Int) -> JSONDecoder {
        get {
            if let array = self.value as? NSArray {
                if array.count > index {
                    return array[index] as! JSONDecoder
                }
            }
            return JSONDecoder(createError("index: \(index) is greater than array or this is not an Array type."))
        }
    }
    ///Dictionary access support
    public subscript(key: String) -> JSONDecoder {
        get {
            if let dict = self.value as? NSDictionary {
                if let value: AnyObject = dict[key] {
                    return value as! JSONDecoder
                }
            }
            return JSONDecoder(createError("key: \(key) does not exist or this is not a Dictionary type"))
        }
    }
    ///private method to create an error
    func createError(text: String) -> NSError {
        return NSError(domain: "JSONJoy", code: 1002, userInfo: [NSLocalizedDescriptionKey: text]);
    }
    
    ///print the decoder in a JSON format. Helpful for debugging.
    public func print() -> String {
        if let arr = self.array {
            var str = "["
            for decoder in arr {
                str += decoder.print() + ","
            }
            str.removeAtIndex(advance(str.endIndex, -1))
            return str + "]"
        } else if let dict = self.dictionary {
            var str = "{"
            for (key, decoder) in dict {
                str += "\"\(key)\": \(decoder.print()),"
            }
            str.removeAtIndex(advance(str.endIndex, -1))
            return str + "}"
        }
        if value != nil {
            if let str = self.string {
                return "\"\(value!)\""
            }
            return "\(value!)"
        }
        return ""
    }
}
///Implement this protocol on all objects you want to use JSONJoy with
public protocol JSONJoy {
    init(_ decoder: JSONDecoder)
}
使用实例：
1.建立数据的发射对象，字段名必须一致啊！列如：
struct UserEntity
 {
    
    var userid: Int?
    var userName: String?
    var name: String?
    var true_name: String?
    var roleid: Int?
    var cellPhone: String?
    var telePhone: String?
    var statusInfo: String?
    var status: Int?
    var guide: Bool?
    var networkId: Int?
    
    var yxb_authority: Int?
    
    init(){}
   
    init(_ decoder: JSONDecoder) {
        userid = decoder["userid"].integer
        userName = decoder["userName"].string
        name = decoder["name"].string
        true_name = decoder["true_name"].string
        roleid = decoder["roleid"].integer
        cellPhone = decoder["cellPhone"].string
        telePhone = decoder["telePhone"].string
        statusInfo = decoder["statusInfo"].string
        status = decoder["status"].integer
        networkId = decoder["networkId"].integer
        guide = decoder["guide"].bool
        
         yxb_authority = decoder["yxb_authority"].integer
    }
}
 struct LoginEntity {
    
    var msgCode: Int?
    var message: String?
    var field: String?
    var data = UserEntity()
    init(){}
    init(_ decoder: JSONDecoder)
    {
        msgCode = decoder["msgCode"].integer
        message = decoder["message"].string
        field = decoder["field"].string
        data = UserEntity(decoder["data"])
    }
}
2.解析：输出对象data为json串，把String->自定义对象
  let data = dataStr.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion:false)
        
  let testJsonStruct:LoginEntity = LoginEntity(JSONDecoder(data!))