使用Guzzle和SilverStripe向外部服务上传文件的疑问

Great question! Let’s break this down for your SilverStripe + Guzzle setup.

First off, let’s cut to the chase: you don’t need to serialize files into strings (like base64) for this. Guzzle natively supports sending files directly via HTTP, which is more efficient (avoids bloating your request with unnecessary encoding) and aligns with standard file upload protocols that most external storage services expect.

Here’s how to implement this, tailored to your SilverStripe environment:

1. Understand the Two Common Upload Methods #

Most external services accept one of two upload formats—pick the one that matches your service’s API docs:

Option A: Multipart/Form-Data Upload (Most Common) #

This is the standard approach for uploading files via web forms, and nearly all storage services support it. With Guzzle, you can pass your uploaded files directly as part of a multipart request.

In SilverStripe, when a user submits your upload form, you can grab the UploadedFile instances from the request, then feed them into Guzzle’s multipart array.

Example Code

use GuzzleHttp\Client;
use SilverStripe\Control\Controller;
use SilverStripe\Control\HTTPRequest;

class ExternalFileUploadController extends Controller
{
    private static $allowed_actions = ['handleUpload'];

    public function handleUpload(HTTPRequest $request)
    {
        // Initialize Guzzle client
        $guzzle = new Client();
        $externalUploadUrl = 'https://your-external-service.com/bucket/upload';

        // Get all uploaded files from the SilverStripe request
        $uploadedFiles = $request->getUploadedFiles();

        // Build multipart form data array
        $multipartData = [];
        foreach ($uploadedFiles as $fieldName => $ssFile) {
            $multipartData[] = [
                'name'     => $fieldName, // Match the field name your external service expects
                'contents' => fopen($ssFile->getTempFilename(), 'r'), // Stream the file directly
                'filename' => $ssFile->getFileName() // Preserve original filename
            ];
        }

        // Add any required headers (like auth tokens)
        $headers = [
            'Authorization' => 'Bearer YOUR_SERVICE_API_KEY'
        ];

        try {
            // Send the request
            $response = $guzzle->post($externalUploadUrl, [
                'multipart' => $multipartData,
                'headers' => $headers
            ]);

            // Handle successful upload (return response to frontend, etc.)
            return $this->getResponse()->setBody($response->getBody())->setStatusCode(200);
        } catch (\Exception $e) {
            // Handle errors (log, return error message)
            return $this->getResponse()->setBody("Upload failed: " . $e->getMessage())->setStatusCode(500);
        }
    }
}

Option B: Binary Stream Upload (For Services That Accept Raw File Data) #

If your external service accepts raw binary file data (instead of multipart form data), you can send the file content directly as the request body.

Example Code Snippet

// For a single file
$ssFile = $request->getUploadedFiles()['your_file_field'];
$response = $guzzle->put($externalUploadUrl, [
    'body' => fopen($ssFile->getTempFilename(), 'r'),
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Content-Type' => $ssFile->getMimeType(), // Match the file's MIME type
        'Content-Disposition' => 'attachment; filename="' . $ssFile->getFileName() . '"'
    ]
]);

2. Why Serialization Is Unnecessary #

Serializing files to strings (e.g., base64 encoding) adds unnecessary overhead:

• Base64-encoded files are 33% larger than the original binary, which slows down uploads and uses more bandwidth.
• Guzzle handles streaming files directly, which is more memory-efficient (especially for large files, since it doesn’t load the entire file into memory at once).
• Most external services are optimized to handle standard multipart or binary uploads, so serialization would require extra work on both your end and the service’s end to decode.

Key Notes #

• Always check your external service’s API documentation to confirm the expected upload method, field names, and required headers.
• In SilverStripe, make sure your form is set to enctype="multipart/form-data" so file uploads are properly transmitted to your controller.

内容的提问来源于stack exchange，提问作者Frank.W