How do I handle different content types in responses with Reqwest?

When using the reqwest library in Rust, handling different content types in responses requires inspecting the Content-Type header and then parsing the response body accordingly. Reqwest provides convenient methods to handle common content types like JSON, but for others, you may need to parse the content manually.

Here's a step-by-step example of how you might handle different content types with reqwest:

1. Send Request: Use reqwest to make an HTTP request to the desired URL.
2. Check Content-Type: Inspect the Content-Type header in the response to determine how to parse the body.
3. Parse Response: Depending on the Content-Type, use the appropriate method to parse the response body.

Example in Rust with Reqwest

First, add reqwest to your Cargo.toml:

[dependencies]
reqwest = { version = "0.11", features = ["json", "blocking"] }

Here is an example function that sends a GET request and handles different content types:

use reqwest::blocking::Client;
use reqwest::header;
use reqwest::Error;

fn fetch_and_handle_content(url: &str) -> Result<(), Error> {
    let client = Client::new();
    let response = client.get(url).send()?;

    // Ensure the request was successful
    let response = response.error_for_status()?;

    // Check the Content-Type header to determine how to parse the response
    match response.headers().get(header::CONTENT_TYPE) {
        Some(ct) if ct == "application/json" => {
            // Parse JSON content
            let json: serde_json::Value = response.json()?;
            println!("JSON response: {:?}", json);
        }
        Some(ct) if ct.to_str()?.starts_with("text/") => {
            // Handle text content
            let text = response.text()?;
            println!("Text response: {}", text);
        }
        Some(ct) => {
            // Handle other content types or fallback to binary content
            println!("Other content type: {}", ct.to_str()?);
            let bytes = response.bytes()?;
            // Process the raw bytes as needed
        }
        None => {
            // No Content-Type header was provided
            println!("No Content-Type header found.");
        }
    }

    Ok(())
}

fn main() -> Result<(), Error> {
    let url = "http://example.com";
    fetch_and_handle_content(url)
}

In this example:

• We use the blocking client for simplicity, but reqwest also supports asynchronous requests with async/await.
• We check the Content-Type header to determine how to parse the body.
  • For JSON content, we use response.json() to deserialize the JSON into a serde_json::Value.
  • For text content (text/html, text/plain, etc.), we use response.text() to get the body as a String.
  • For other content types, we fall back to response.bytes() to get the raw bytes, which we can then handle as binary data.
• Note that the Content-Type header might include additional information like charset (e.g., text/html; charset=UTF-8). In such cases, you might need more sophisticated parsing of the header value.

Remember that this is a simplified example. In a production environment, you might want to handle character encodings, more specific MIME types, and other nuances associated with HTTP content negotiation and response parsing.