问题的直接答案：

// Heavily based on the video I recommended. Watch it for a great explanation
struct Resource<A>{
    let url: NSURL
    let parse: (NSData) -> [A]?
}

extension Book {

    // You could figure a way to dynamically populate this based on limiting
    static let urls = [NSURL(string: "http://example.website.nl/books/highlighted")!,
                       NSURL(string: "http://example.website.nl/books/highlighted2")!]

    // Creates an array of Requests passing in each url for the url, but the same parse function
    static let requests = urls.map { Resource<Book>(url: $0, parse: Book.parse) }

    // Used by Webservice (from the Resource struct) to parse the data into a Book
    static let parse: (NSData?) -> [Book]? = { data in
        guard let data = data else { return nil }

        guard let json = try? NSJSONSerialization.JSONObjectWithData(data, options: .AllowFragments) else {
            print("Error deserializing json.")
            return nil
        }
        var books: [Book]? = nil
        guard let jsonBooks = json["books"] as? [[String: AnyObject]] else { return nil }
        for jsonBook in jsonBooks {
            guard let book = Book(fromJson: jsonBook) else { continue } // skips nil books from failable initializer, depends on how you want to handle that
            books = books ?? [Book]() // if nil create a new array, if not use the old one
            books!.append(book)
        }
        return books
    }
}

class Webservice {

    // A stands for a generic type. You could add a type called Publisher later and use the same function
    // This adopted from the video I showed you so it's a little more in depth
    func loadAll<A>(resources: [Resource<A>], completion: [A] -> ()) {
        let session = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())
        var currentRequest = 0 // used to keep track of asynchronous callback order
        var allA = [A]()
        for resource in resources {
            session.dataTaskWithURL(resource.url) { (data, _, _) in
                defer {
                    currentRequest += 1 // marks that we're done with one request

                    // This check ensures that we only call the completion handler
                    // after we're done with the last request
                    if currentRequest == resources.count {
                        completion(allA)
                    }
                }
                guard let data = data else { return }

                // this parse function comes from the resource struct passed in.
                // It converts the data we get back from one request into an array of books.
                guard let manyA = resource.parse(data) else { return }

                // This is the total running tally of books from all our requests.
                allA.appendContentsOf(manyA)
            }
        }
    }
}

class TableViewController: UITableViewController {

    var books = [Book]() {
        didSet { tableView.reloadData() }
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        // Call site
        Webservice().loadAll(Book.requests) { [weak self] (books) in
            dispatch_async(dispatch_get_main_queue()) {
                self?.books.appendContentsOf(books)
            }
        }

    }

    //... all your normal methods for cells and stuff
}

额外的

我为Book基于JSON对象的类创建了一个失败的初始化程序，因此您的类方法不必进行大量的解析。您可能希望您的Book类型为astruct以获取成员初始化程序并通过值语义传递）

充分利用guard let else控制语句，以免因可选的展开而导致厄运金字塔。

defer不管您如何退出范围（避免重复代码），语句对于调用完成处理程序都是很有用的。

我强烈推荐这个视频，展示一个Web服务api设计。它有点高级，但是它向您展示了一种从Web服务初始化模型对象的好方法。

class Book {

    var id: Int
    var title: String
    let description: String
    var coverImage: String
    var isbn: String
    var publisherID: Int
    var publisherName: String
    var authorID: Int
    var authorFirstName: String
    var authorLastName: String

    init(id: Int, title: String, description: String, coverImage: String, isbn: String, publisherID: Int, publisherName: String, authorID: Int, authorFirstName: String, authorLastName: String) {

        self.id = id
        self.title = title
        self.description = description
        self.coverImage = coverImage
        self.isbn = isbn
        self.publisherID = publisherID
        self.publisherName = publisherName
        self.authorID = authorID
        self.authorFirstName = authorFirstName
        self.authorLastName = authorLastName
    }

    typealias JSONDictionary = [String: AnyObject] // syntactic sugar, makes it clearer

    convenience init?(fromJson json: JSONDictionary) {
        let bookID = json["id"] as! Int
        let bookTitle = json["title"] as! String
        let bookDescription = json["description"] as! String
        let bookCoverImage = json["cover_url"] as! String
        let bookISBN = json["isbn"] as! String

        // I would use guard let else statements here to avoid the pyramid of doom but it's stylistic
        if let bookPublisher = json["publisher"] as? [String: AnyObject] {
            let bookPublisherID = bookPublisher["id"] as! Int
            let bookPublisherName = bookPublisher["name"] as! String
            if let bookAuthor = json["author"] as? [String: AnyObject] {
                let bookAuthorID = bookAuthor["id"] as! Int
                let bookAuthorFirstname = bookAuthor["first_name"] as! String
                let bookAuthorLastName = bookAuthor["last_name"] as! String
                self.init(id: bookID, title: bookTitle, description: bookDescription, coverImage: bookCoverImage, isbn: bookISBN, publisherID: bookPublisherID, publisherName: bookPublisherName, authorID: bookAuthorID, authorFirstName: bookAuthorFirstname, authorLastName: bookAuthorLastName)
                return

            }
        }
        return nil
    }

}

extension Book {

    class func getDataFromJson(completionHandler: ([Book]) -> ()) {

        var books = [Book]()

        let session = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

        let request = NSURLRequest(URL: NSURL(string: "http://example.website.nl/books/highlighted")!)

        let task: NSURLSessionDataTask = session.dataTaskWithRequest(request) { (data, response, error) -> Void in

            defer { // no matter how you exit the scope this will be called
                dispatch_async(dispatch_get_main_queue()) {
                    completionHandler(books)
                }
            }

            guard let data = data else { return } // still will call the deferred completion handler

            guard let json = try? NSJSONSerialization.JSONObjectWithData(data, options: .AllowFragments) else {
                print("Error deserializing json.")
                return // still will call the deferred completion handler
            }

            if let jsonBooks = json["books"] as? [[String: AnyObject]] {
                for jsonBook in jsonBooks {
                    guard let book = Book(fromJson: jsonBook) else { continue } // skips nil books from failable initializer, depends on how you want to handle that
                    books.append(book)
                }
                print(books.count)
            }
        }
        task.resume()
        // call the deferred completion handler after leaving scope
    }
}