如何用Alamofire和Swift 4编写Clarifai API的POST请求？

Hey there! I see you're already halfway there with your Codable structures—great job! The main issue you're running into is mixing up HTTP headers with request parameters. Let's fix that and get your request working properly.

First: Correct Your Request Setup #

Your current parameters dictionary is actually holding HTTP headers, not request body parameters. Those need to be set separately in Alamofire. Here's how to structure everything correctly:

Step 1: Keep Your Codable Structures (They're Good!) #

First, let's keep the Codable types you've already created—they match the Clarifai API's expected JSON structure perfectly:

struct ImageObj: Codable {
    let base64: String
}

struct DataObj: Codable {
    let image: ImageObj
}

struct InputObj: Codable {
    let data: DataObj
}

struct InputsContainerObj: Codable {
    let inputs: [InputObj]
}

Step 2: Convert Your Image to Base64 (Swift Version) #

Instead of using the terminal base64 command, let's handle this in Swift. Here's a helper function to convert a local image file to a base64 string:

func imageToBase64(imagePath: String) -> String? {
    guard let imageData = try? Data(contentsOf: URL(fileURLWithPath: imagePath)) else {
        print("Failed to load image file")
        return nil
    }
    return imageData.base64EncodedString()
}

Step 3: Build the Full Alamofire Request #

Now let's put it all together. We'll set the correct HTTP headers, encode your Codable object into the request body, and send the POST request:

import Alamofire

// Replace with your actual API key
let apiKey = "YOUR_API_KEY"
// Replace with your image file path
let imagePath = "/home/user/image.png"

// 1. Get the base64 string of your image
guard let base64Image = imageToBase64(imagePath: imagePath) else {
    return
}

// 2. Create your request body object
let imageObj = ImageObj(base64: base64Image)
let dataObj = DataObj(image: imageObj)
let inputObj = InputObj(data: dataObj)
let inputsContainer = InputsContainerObj(inputs: [inputObj])

// 3. Set up HTTP headers
let headers: HTTPHeaders = [
    "Authorization": "Key \(apiKey)",
    "Content-Type": "application/json"
]

// 4. Send the POST request with Alamofire
let clarifaiURL = "https://api.clarifai.com/v2/models/aaa03c23b3724a16a56b629203edc62c/outputs"

AF.request(clarifaiURL,
           method: .post,
           parameters: inputsContainer,
           encoder: JSONParameterEncoder.default,
           headers: headers)
    .validate()
    .responseDecodable(of: [String: Any].self) { response in
        switch response.result {
        case .success(let result):
            print("Request successful! Response: \(result)")
            // Parse the result further based on Clarifai's response structure
        case .failure(let error):
            print("Request failed with error: \(error.localizedDescription)")
            // Handle error (e.g., network issues, invalid API key, etc.)
        }
    }

Key Fixes & Explanations #

• Headers vs Parameters: The Authorization and Content-Type values are HTTP headers, so we pass them in the headers parameter of AF.request(), not as request body parameters.
• JSON Encoding: Using JSONParameterEncoder.default lets Alamofire automatically encode your Codable inputsContainer object into the correct JSON request body—no need to manually encode it with JSONEncoder (though you could if you wanted to).
• Response Handling: Using responseDecodable makes it easy to parse the API's JSON response. You can even create a Codable structure for Clarifai's response if you want to parse it more cleanly instead of using [String: Any].

Troubleshooting Tips #

• Double-check your API key to make sure it's correct.
• Verify that your image path is valid and the image file exists.
• If you get encoding errors, ensure your Codable structures exactly match the JSON schema expected by Clarifai (yours look spot-on right now!).

内容的提问来源于stack exchange，提问作者Thijs van der Heijden