Alamofire Swift：将GET接口JSON结果传入POST接口求助

Got it, let's break down how to properly chain these two requests so you can pass the GET response data into your POST call. Here's a step-by-step implementation with practical best practices:

1. Parse the GET Response Cleanly (Optional but Highly Recommended) #

Using Codable to model your response makes parsing safer and more maintainable than dealing with raw dictionaries. Define these simple structs first:

struct ConstantTableItem: Codable {
    let actionType: Int
    let version: Int
}

struct ConstantTableResponse: Codable {
    let items: [ConstantTableItem]
}

2. Refactor the GET Request to Trigger the POST Call #

Update your GET request to validate the response, parse it with Codable, and then pass the parsed items array directly to your POST request:

let token = "your-auth-token-here" // Replace with your actual token
let getEndpoint = "http://GetConstantTableList"
let headers: HTTPHeaders = [
    "Accept": "application/json",
    "Authorization": "Bearer \(token ?? "")"
]

// Perform GET request
AF.request(getEndpoint, method: .get, headers: headers)
    .validate() // Automatically checks for 200-299 status codes
    .responseDecodable(of: ConstantTableResponse.self) { getResponse in
        switch getResponse.result {
        case .success(let parsedData):
            // Pass the parsed items to the POST request
            self.sendPOSTRequest(with: parsedData.items)
        case .failure(let error):
            print("GET request failed: \(error.localizedDescription)")
            // Add real error handling here (e.g., show alert to user, retry logic)
        }
    }

3. Implement the POST Request with the GET Data #

Create a dedicated method to handle the POST request, converting the parsed items into a format your backend expects. Most APIs expect the data wrapped in a key like "items", but adjust this based on your backend's requirements:

func sendPOSTRequest(with items: [ConstantTableItem]) {
    let postEndpoint = "http://GetConstantTableData"
    let headers: HTTPHeaders = [
        "Accept": "application/json",
        "Authorization": "Bearer \(token ?? "")"
    ]
    
    // Convert Codable items to a dictionary array for POST parameters
    var postParameters: [String: Any] = [:]
    do {
        let itemsData = try JSONEncoder().encode(items)
        guard let itemsDictArray = try JSONSerialization.jsonObject(with: itemsData, options: []) as? [[String: Any]] else {
            print("Failed to convert items to valid parameters")
            return
        }
        postParameters["items"] = itemsDictArray // Match your backend's expected key
    } catch {
        print("Parameter conversion error: \(error.localizedDescription)")
        return
    }
    
    // Perform POST request
    AF.request(postEndpoint, method: .post, parameters: postParameters, encoding: JSONEncoding.default, headers: headers)
        .validate()
        .responseJSON { postResponse in
            switch postResponse.result {
            case .success(let finalData):
                print("POST succeeded! Final data list: \(finalData)")
                // Process your final data list here (e.g., populate a table view)
            case .failure(let error):
                print("POST request failed: \(error.localizedDescription)")
                // Handle POST errors (e.g., network issues, invalid data format)
            }
        }
}

Alternative: Raw JSON Parsing (If You Skip Codable) #

If you prefer to work with raw JSON directly without Codable, here's a simplified version:

// GET request with raw JSON parsing
AF.request(getEndpoint, method: .get, headers: headers)
    .responseJSON { getResponse in
        switch getResponse.result {
        case .success(let rawJSON):
            guard let responseDict = rawJSON as? [String: Any],
                  let items = responseDict["items"] as? [[String: Any]] else {
                print("Invalid GET response format")
                return
            }
            // Pass raw items array to POST
            self.sendRawPOSTRequest(with: items)
        case .failure(let error):
            print("GET failed: \(error)")
        }
    }

// POST request with raw parameters
func sendRawPOSTRequest(with items: [[String: Any]]) {
    let parameters = ["items": items]
    AF.request(postEndpoint, method: .post, parameters: parameters, encoding: JSONEncoding.default, headers: headers)
        .responseJSON { postResponse in
            // Handle POST response here
        }
}

Key Notes to Remember #

• Encoding: Use JSONEncoding.default for POST requests unless your backend explicitly requires form-urlencoded encoding.
• Backend Expectations: If your backend accepts the array directly as the request body (not wrapped in a dictionary), you can pass the encoded items data directly instead of using parameters:

  let itemsData = try JSONEncoder().encode(items)
  AF.request(postEndpoint, method: .post, headers: headers, body: itemsData)
  

• Error Handling: Replace print statements with actual user-facing alerts or logging in production code to improve user experience.

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