iOS板球应用：如何实现JSON数据实时更新App标签？

Hey there! Let's fix that real-time label update issue for your cricket app. I get why using a basic Timer might have let you down—those can be finicky with run loops, especially if you didn't manage them properly. Let's go with a more reliable approach that combines GCD timers (way less prone to skipping triggers) and URLSession for consistent network calls.

The Core Solution #

We'll create a reusable network function to fetch and parse the JSON, then set up a repeating GCD timer to call this function at your desired interval. We'll also make sure UI updates happen on the main thread (critical for avoiding crashes) and clean up the timer to prevent memory leaks.

Step 1: Complete View Controller Implementation #

Here's a ready-to-use code snippet—just adjust the JSON keys and label outlet to match your app's structure:

import UIKit

class CricketScoreViewController: UIViewController {
    // Replace with your actual label outlet
    @IBOutlet weak var liveScoreLabel: UILabel!
    
    // GCD Timer to handle repeated updates
    private var updateTimer: DispatchSourceTimer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupRepeatedUpdateTimer()
        // Fetch immediately instead of waiting for the first timer tick
        fetchAndUpdateScore()
    }
    
    // MARK: - Timer Setup
    private func setupRepeatedUpdateTimer() {
        // Create a timer that fires every 2 seconds (adjust this interval as needed)
        updateTimer = DispatchSource.makeTimerSource(queue: DispatchQueue.global(qos: .background))
        
        // Schedule the timer: start now, repeat every 2 seconds, with 100ms leeway for system scheduling
        updateTimer?.schedule(
            deadline: .now(),
            repeating: .seconds(2),
            leeway: .milliseconds(100)
        )
        
        // Define what happens when the timer fires
        updateTimer?.setEventHandler { [weak self] in
            self?.fetchAndUpdateScore()
        }
        
        // Start the timer
        updateTimer?.resume()
    }
    
    // MARK: - Network & Update Logic
    private func fetchAndUpdateScore() {
        guard let jsonURL = URL(string: "https://your-server-url.com/cricket-live-data.json") else {
            print("Invalid server URL")
            return
        }
        
        let task = URLSession.shared.dataTask(with: jsonURL) { [weak self] data, response, error in
            guard let self = self else { return }
            
            // Handle network errors
            if let error = error {
                print("Network request failed: \(error.localizedDescription)")
                return
            }
            
            // Ensure we received data
            guard let responseData = data else {
                print("No data received from server")
                return
            }
            
            // Parse the JSON (adjust this to match your server's JSON structure)
            do {
                if let scoreData = try JSONSerialization.jsonObject(with: responseData) as? [String: String],
                   let currentScore = scoreData["live_score"] { // Replace "live_score" with your actual JSON key
                    // Update the label on the MAIN THREAD (UI operations can't run in background)
                    DispatchQueue.main.async {
                        self.liveScoreLabel.text = currentScore
                    }
                } else {
                    print("JSON structure doesn't match expected format")
                }
            } catch {
                print("JSON parsing error: \(error.localizedDescription)")
            }
        }
        
        // Start the network task
        task.resume()
    }
    
    // MARK: - Cleanup
    deinit {
        // Cancel the timer when the view controller is deallocated to prevent memory leaks
        updateTimer?.cancel()
        updateTimer = nil
    }
}

Key Improvements Over Basic Timer #

1. GCD Timer Reliability: Unlike NSTimer, GCD timers aren't tied to the main run loop's mode. That means they won't stop firing when the user scrolls a table view or interacts with the UI.
2. Memory Safety: Using [weak self] in the timer's event handler prevents retain cycles, so your view controller can deallocate properly.
3. Immediate First Update: We call fetchAndUpdateScore() once in viewDidLoad() so users don't have to wait for the first timer tick.
4. Proper UI Threading: All label updates happen on the main thread—this avoids crashes from UI operations in background queues.

Additional Tips #

• Adjust the Interval: Change .seconds(2) in setupRepeatedUpdateTimer() to match how often you need to fetch updates (don't set it too short—you don't want to flood your server with requests).
• Cache Control: To ensure you always get the latest JSON, add a cache policy to your request:

  var request = URLRequest(url: jsonURL)
  request.cachePolicy = .reloadIgnoringLocalCacheData
  let task = URLSession.shared.dataTask(with: request) { ... }
  

• Network Reachability: Add a reachability check (use Apple's NWPathMonitor for native support) to pause the timer when the device is offline, then resume it when connectivity returns.

内容的提问来源于stack exchange，提问作者Ravi Kumar