Use URLSession to obtain RSS XML data asynchronously; 2. Parses XML through XMLParserDelegate and extracts title, link, description and other fields; 3. Update the UI to display the parsed RSSItem array in the main thread to complete the complete process from network request to data display.

If you're building an iOS app in Swift and want to pull in content from an RSS feed—like blog posts, news headlines, or podcast updates—you'll need to fetch the XML data and parse it efficiently. Here's how to do it cleanly and practically.

? 1. Fetch the RSS Feed Using URLSession

Start by creating a simple function to download the XML content from a given URL:

 func fetchRSSFeed(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            Return
        }

        guard let data = data else {
            completion(.failure(NSError(domain: "NoDataError", code: -1, userInfo: nil)))
            Return
        }

        completion(.success(data))
    }.resume()
}

This is a standard async network call—nothing RSS-specific yet. Just make sure your app has App Transport Security (ATS) exceptions if you're using HTTP instead of HTTPS.

? 2. Parse the XML with XMLParser

Swift doesn't have a built-in RSS parser, but Foundation 's XMLParser works great for this. Create a custom parser class:

 class RSSParser: NSObject {
    private var parser: XMLParser!
    private var items = [RSSItem]()
    private var currentElement = ""
    private var currentTitle = ""
    private var currentLink = ""
    private var currentDescription = ""

    func parse(data: Data, completion: @escaping ([RSSItem]) -> Void) {
        parser = XMLParser(data: data)
        parser.delegate = self
        parser.parse()
        completion(items)
    }
}

// MARK: - XMLParserDelegate
extension RSSParser: XMLParserDelegate {
    func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String: String] = [:]) {
        currentElement = elementName

        if elementName == "item" {
            currentTitle = ""
            currentLink = ""
            currentDescription = ""
        }
    }

    func parser(_ parser: XMLParser, foundCharacters string: String) {
        switch currentElement {
        case "title":
            currentTitle = string.trimmingCharacters(in: .whitespacesAndNewlines)
        case "link":
            currentLink = string.trimmingCharacters(in: .whitespacesAndNewlines)
        case "description":
            currentDescription = string.trimmingCharacters(in: .whitespacesAndNewlines)
        default:
            break
        }
    }

    func parser(_ parser: XMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
        if elementName == "item" {
            let item = RSSItem(
                title: currentTitle,
                link: currentLink,
                description: currentDescription
            )
            items.append(item)
        }
    }
}

? Note: This handles basic RSS feeds (like <item><title>...</title></item> ). If your feed has <pubDate> , <author> , or CDATA sections, expand the parser logic accordingly.

You'll also need a simple model:

 struct RSSItem {
    let title: String
    let link: String
    let description: String
}

? 3. Putting It All Together in a View Controller

Here's how to use it in a UIViewController or ViewModel :

 let feedURL = URL(string: "https://example.com/feed")!

fetchRSSFeed(from: feedURL) { result in
    switch result {
    case .success(let data):
        let parser = RSSParser()
        parser.parse(data: data) { items in
            DispatchQueue.main.async {
                // Update your UI (eg, reload a table view)
                print("Fetched \(items.count) items")
            }
        }
    case .failure(let error):
        print("Failed to fetch RSS: $error)")
    }
}

Make sure to dispatch UI updates to the main queue since parsing happens on a background thread.

? Tips & Gotchas

• CDATA blocks : RSS feeds often wrap descriptions in . XMLParser automatically handles this—you don't need special logic unless you see malformed output.
• Async parsing : Keep parsing off the main thread. XMLParser is synchronous but fast for typical RSS sizes.
• Error handling : Real-world feeds might be malformed—add logging or fallbacks.
• Caching : Consider caching parsed results (eg, with UserDefaults or FileManager ) to reduce network calls.

That's it! You now have a working RSS fetcher and parser in Swift—no third-party libraries needed.
It's lightweight, native, and perfect for simple feeds. If you're dealing with Atom or JSON feeds later, the same pattern apply—just swap the parser.

The above is the detailed content of Fetching and Parsing an RSS Feed in a Swift iOS Application. For more information, please follow other related articles on the PHP Chinese website!