Swift-如何使用ObjectMapper读取Flickr JSON

我想使用URL从Flickr的公开提要中使用JSON

我试图使用Alamofire来使用JSON，然后使用ObjectMapper将JSON映射到一个基本的照片数据模型

我遇到的问题是，我无法让它解析JSON，然后映射它

objects=Mapper（）.mapArray（JSONArray:json）

返回：

无法将“JSON”类型的值转换为预期的参数类型“[[String:Any]]”。

我的代码如下

 FlickrAPI.executeRequestURL(url, parameters: parameters) { (success, error, response) in
            if (success) {
                //print ("Response: \(response)")

                if let jsonObject = response?.result.value {
                    let json = JSON(jsonObject)

                    objects = Mapper<Photo>().mapArray(JSONArray: json)!

                }

            }
            else {
                print ("** Error -- \(error?.localizedDescription) **")
                taskCallback(false, error)
            }
        }
// Execute URL request code:
 static func executeRequestURL(_ requestURL: URL, parameters:[String: String], taskCallback: @escaping (Bool, Error?, DataResponse<Any>?) -> ())
    {
        print ("Attempting URL -- \(requestURL)")

        Alamofire.request(requestURL, parameters:["nojsoncallback": "1", "format": "json"])
            .validate(statusCode: 200..<300)
            .validate(contentType: ["application/json"])
            .responseJSON { response in

                switch(response.result) {
                case .success(_):
                    taskCallback(true, nil, response)
                    break

                case .failure(_):
                    print("Error while fetching url: \(response.result.error)")
                    taskCallback(false, response.result.error, nil)
                    break
                }
        }
    }

// Photo model

final class Photo: Object, Mappable {
    private(set) dynamic var uuid: String = UUID().uuidString

    dynamic var name: String = ""
    dynamic var author_id: String = ""
    dynamic var title: String = ""

override public static func primaryKey() -> String? {
        return "uuid"
    }

    required convenience public init?(map: Map) {
        self.init()
    }

    // MARK: - ObjectMapper protocol methods

    public func mapping(map: Map) {
        self.name <- map["name"]
        self.author_id <- map["author_id"]
        self.title <- map["title"]
    }

FlickrAPI.executeRequestURL（url，参数：parameters）{（成功，错误，响应）在
如果（成功）{
//打印（“响应：\（响应）”）
如果让jsonObject=response？.result.value{
让json=json（jsonObject）
objects=Mapper（）.mapArray（JSONArray:json）！
}
}
否则{
打印（“**错误--\（错误？.localizedDescription）**”）
taskCallback（错误，错误）
}
}
//执行URL请求代码：
静态func executeRequestURL（requestURL:URL，参数：[String:String]，taskCallback:@escaping（Bool，Error？，DataResponse？）->（））
{
打印（“正在尝试的URL--\（请求URL）”）
请求（requestURL，参数：[“nojsoncallback”：“1”，“格式”：“json”]）
.validate（状态代码：200..String{
返回“uuid”
}
所需的便利性公共初始化？（映射：映射）{
self.init（）
}
//MARK:-ObjectMapper协议方法
公共函数映射（映射：映射）{
self.name我能够使用AlamofireObject Mapper解决这个问题

首先，创建一个类来保存返回的响应。
其次，确保该类符合映射

// Required to help integrate Alamofire with Objectmapper (via AlamofireObjectMapper)
final class PhotoResponse: Mappable {

    var items: [Photo]?

    required init?(map: Map){

    }

    func mapping(map: Map) {
        items <- map["items"]
    }
}

static func executeRequestURL(_ requestURL: URL, parameters:[String: String], taskCallback: @escaping (Bool, Error?, DataResponse<PhotoResponse>?) -> ())
    {
        print ("Attempting URL -- \(requestURL)\n")

        Alamofire.request(requestURL, parameters:["nojsoncallback": "1", "format": "json"])
            .validate(statusCode: 200..<300)
            .validate(contentType: ["application/json"])
            .responseObject { (response: DataResponse<PhotoResponse>) in

                switch(response.result) {
                case .success(_):
                    taskCallback(true, nil, response)
                    break

                case .failure(_):
                    print("** Error while fetching url: \(response.result.error) **")
                    taskCallback(false, response.result.error, nil)
                    break
                }
        }
    }

let photoResponse = response?.result.value

if let items = photoResponse?.items {
    print ("Items found: #\(items.count)")
   // do something with items here
}