Welcome back! Today's focus will be on downloading files from an API using Go. Understanding how to retrieve files efficiently not only enhances your technical skills but also broadens your application's capabilities. In this lesson, we'll explore a practical scenario using our to-do list API, which, in addition to managing tasks, supports handling text files such as notes. These notes can be downloaded or uploaded through the /notes endpoint, allowing functionality for storing supplementary information. For example, users might keep notes about a meeting or important reminders. By understanding how to interact with this endpoint, you can effectively manage notes within your application. By the end of this lesson, you'll know how to request a file from an API, save it locally, and verify its contents.

Let's dive into downloading files with precision and confidence!

GET requests are fundamental for retrieving files from an API. When you send a GET request using Go's net/http package, your client communicates with the server at a specified URL, asking it to provide the file. The server responds with the file data, if available and permissible, along with an HTTP status code (like 200 OK).

Here's a basic example of downloading a file named welcome.txt from our API at http://localhost:8000/notes. This approach downloads the entire file at once, which is manageable for smaller files.

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "io"
6    "net/http"
7    "os"
8)
9
10func main() {
11    // Base URL for the API
12    baseURL := "http://localhost:8000"
13
14    // Specify the note name to download
15    noteName := "welcome.txt"
16
17    // Send a GET request to download the file
18    resp, err := http.Get(fmt.Sprintf("%s/notes/%s", baseURL, noteName))
19    if err != nil {
20        fmt.Printf("Error occurred: %v\n", err)
21        return
22    }
23    defer resp.Body.Close()
24
25    // Check for HTTP errors
26    if resp.StatusCode != http.StatusOK {
27        fmt.Printf("HTTP error occurred: %s\n", resp.Status)
28        return
29    }
30
31    // Save the file locally
32    body, err := io.ReadAll(resp.Body)
33    if err != nil {
34        fmt.Printf("Error reading response body: %v\n", err)
35        return
36    }
37
38    // Create (or overwrite) the file and write all data at once
39    err = os.WriteFile("downloaded_"+noteName, body, 0644)
40    if err != nil {
41        fmt.Printf("Error writing file: %v\n", err)
42    }
43}

This code sends a GET request and writes the full response content to a local file. This method works well for small files but can strain memory for larger files.

When dealing with large files, downloading them all at once can be inefficient and strain memory. To address this, you can use Go's io package to download files in chunks, thus optimizing memory usage and maintaining efficiency.

Below is a detailed code example demonstrating how to download the same file using streaming:

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "io"
6    "net/http"
7    "os"
8)
9
10func main() {
11    // Base URL for the API
12    baseURL := "http://localhost:8000"
13
14    // Specify the note name to download
15    noteName := "welcome.txt"
16
17    // Send a GET request to the API
18    resp, err := http.Get(fmt.Sprintf("%s/notes/%s", baseURL, noteName))
19    if err != nil {
20        fmt.Printf("Error occurred: %v\n", err)
21        return
22    }
23    defer resp.Body.Close()
24
25    // Check for HTTP errors
26    if resp.StatusCode != http.StatusOK {
27        fmt.Printf("HTTP error occurred: %s\n", resp.Status)
28        return
29    }
30
31    // Define the filename for storing the downloaded content
32    fileName := "downloaded_" + noteName
33
34    // Open the local file in binary write mode
35    file, err := os.Create(fileName)
36    if err != nil {
37        fmt.Printf("Error creating file: %v\n", err)
38        return
39    }
40    defer file.Close()
41
42    // Copy the response body to the file in chunks
43    _, err = io.Copy(file, resp.Body)
44    if err != nil {
45        fmt.Printf("Error writing to file: %v\n", err)
46    }
47}

In the code above, the os.Create function initializes a new file where the downloaded content will be stored, ensuring it's ready for writing. Instead of reading the entire response into memory, io.Copy streams data directly from resp.Body to the file, processing it in chunks. This approach optimizes memory usage, making it more efficient for handling large file downloads without overwhelming system resources.

By utilizing streaming, even large files are downloaded efficiently. This technique is especially useful when file sizes increase.

Once you've downloaded a file, it's imperative to verify its contents to ensure a successful transfer. In our example, after downloading, you can open the file and print its content to confirm data integrity:

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "os"
6)
7
8func main() {
9    // Specify the note name to verify
10    noteName := "welcome.txt"
11
12    // Open and read the downloaded file to verify its content
13    content, err := os.ReadFile("downloaded_" + noteName)
14    if err != nil {
15        fmt.Printf("File error occurred: %v\n", err)
16        return
17    }
18
19    fmt.Println(string(content))
20}

If everything is functioning correctly, you should see an output similar to:

Plain text
Copy to clipboard
1Welcome to Your Notes! 📝
2
3This is a sample note that comes with the application.

This step is essential for data verification. The familiar error-handling techniques come into play once more, using Go's error-handling practices to gracefully address any issues during the download and verification process.

In this lesson, you explored two methods for downloading files from an API: a straightforward approach for smaller files and a more efficient streaming method for larger files. You've practiced verifying file integrity by reading its contents post-download and reinforced your knowledge of error management. As you proceed to the practice exercises, you'll have the opportunity to apply these skills, reinforcing your ability to manage API interactions effectively. Keep experimenting with different files and settings, as this will further enhance your understanding and proficiency. Exciting topics await, such as file uploads and handling paginated responses. Your journey in mastering API interactions continues!