Swift4开发：不依赖Firebase，用常规API构建聊天应用可行吗？

Absolutely! You can totally build a chat app in Swift 4 without relying on Firebase—using a custom backend and standard API/real-time communication protocols is completely feasible. Let’s break down the core components, step-by-step implementation, and key considerations to help you get started:

Core Components You’ll Need #

• Custom Backend: A server to handle user authentication, message storage, and real-time message routing. Frameworks like Node.js/Express, Python/Django, or Ruby on Rails work great. For real-time capabilities, WebSockets (e.g., Socket.io for Node.js) are far more efficient than HTTP long-polling.
• Database: To store user data and chat history—PostgreSQL, MongoDB, or SQLite (for smaller apps) all work well.
• Swift 4 Networking Layer: Use native URLSession for HTTP requests, or a lightweight library like Alamofire if you prefer. For WebSocket communication, a pure-Swift library like Starscream is ideal for Swift 4 compatibility.
• APNs Integration: To send push notifications to users when they’re offline.

Step-by-Step Implementation Outline #

1. User Authentication #

First, set up login/register endpoints on your backend. In Swift 4, use URLSession to send authenticated requests, and store the returned auth token (e.g., JWT) securely in the Keychain (never use UserDefaults for sensitive data).

Example Swift 4 code for login:

import Foundation

func loginUser(username: String, password: String, completion: @escaping (Result<String, Error>) -> Void) {
    guard let url = URL(string: "https://your-backend-domain.com/api/auth/login") else {
        completion(.failure(NSError(domain: "InvalidURL", code: 0, userInfo: [NSLocalizedDescriptionKey: "Invalid login endpoint"])))
        return
    }
    
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    
    let loginPayload = ["username": username, "password": password]
    request.httpBody = try? JSONSerialization.data(withJSONObject: loginPayload)
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data,
              let responseJSON = try? JSONSerialization.jsonObject(with: data) as? [String: String],
              let authToken = responseJSON["token"] else {
            completion(.failure(NSError(domain: "AuthError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to retrieve auth token"])))
            return
        }
        
        completion(.success(authToken))
    }.resume()
}

2. Real-Time Messaging with WebSockets #

WebSockets enable bidirectional, real-time communication between your Swift app and backend. Use the Starscream library (compatible with Swift 4) to handle WebSocket connections.

Example WebSocket manager in Swift 4:

import Starscream

class ChatWebSocketManager: WebSocketDelegate {
    private var socket: WebSocket!
    private let authToken: String
    
    init(authToken: String) {
        self.authToken = authToken
        let wsURL = URL(string: "wss://your-backend-domain.com/ws?token=\(authToken)")!
        socket = WebSocket(url: wsURL)
        socket.delegate = self
        socket.connect()
    }
    
    func sendMessage(content: String, recipientId: String) {
        let messagePayload = ["content": content, "recipientId": recipientId, "senderId": "current-user-id"]
        if let payloadData = try? JSONSerialization.data(withJSONObject: messagePayload),
           let payloadString = String(data: payloadData, encoding: .utf8) {
            socket.write(string: payloadString)
        }
    }
    
    // MARK: - WebSocket Delegate Methods
    func websocketDidConnect(socket: WebSocketClient) {
        print("Successfully connected to chat server")
    }
    
    func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
        print("Disconnected from chat server: \(error?.localizedDescription ?? "No error provided")")
        // Add reconnection logic here if needed
    }
    
    func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
        guard let messageData = text.data(using: .utf8),
              let messageJSON = try? JSONSerialization.jsonObject(with: messageData) as? [String: Any] else {
            return
        }
        
        // Update chat UI on the main thread
        DispatchQueue.main.async {
            // Insert the incoming message into your chat UI model
            print("Received message: \(messageJSON)")
        }
    }
    
    func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
        // Handle binary data (e.g., media messages) if needed
    }
}

3. Fetching Chat History #

Add an API endpoint on your backend to retrieve past messages. Use URLSession in Swift 4 to fetch and display historical chat data.

Example code for fetching history:

func fetchChatHistory(recipientId: String, authToken: String, completion: @escaping (Result<[[String: Any]], Error>) -> Void) {
    guard let url = URL(string: "https://your-backend-domain.com/api/chat/\(recipientId)/history") else {
        completion(.failure(NSError(domain: "InvalidURL", code: 0, userInfo: [NSLocalizedDescriptionKey: "Invalid history endpoint"])))
        return
    }
    
    var request = URLRequest(url: url)
    request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization")
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data,
              let messages = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
            completion(.failure(NSError(domain: "FetchError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to load chat history"])))
            return
        }
        
        completion(.success(messages))
    }.resume()
}

4. Offline Push Notifications #

When a user is offline, your backend should send APNs (Apple Push Notification Service) alerts. Configure your Swift 4 app to register for push notifications and send the device token to your backend.

Example AppDelegate setup:

import UIKit
import UserNotifications

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Request push notification authorization
        UNUserNotificationCenter.current().delegate = self
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    application.registerForRemoteNotifications()
                }
            }
        }
        return true
    }
    
    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        // Convert device token to string and send to your backend
        let tokenString = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
        print("APNs Device Token: \(tokenString)")
        // Add code to send token to your backend storage
    }
    
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        // Handle foreground push notifications
        completionHandler([.alert, .sound])
    }
}

Key Considerations #

• Thread Safety: Always update UI elements on the main thread (use DispatchQueue.main.async for WebSocket message handling).
• Security: Use HTTPS/WSS for all communication, store auth tokens in the Keychain, and validate all incoming data on the backend to prevent injection attacks.
• Error Handling: Add retry logic for WebSocket reconnections, show user-friendly alerts for network failures, and handle token expiration gracefully.
• Scalability: For larger user bases, consider using a message broker like Redis to scale WebSocket message broadcasting across multiple backend servers.

内容的提问来源于stack exchange，提问作者Nasser El Arab