Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Objek perintah dalam AWS SDK for PHP Versi 3

AWS SDK for PHP Menggunakan pola perintah untuk merangkum parameter dan handler yang akan digunakan untuk mentransfer HTTP permintaan di lain waktu.

Penggunaan perintah secara implisit

Jika Anda memeriksa kelas klien apa pun, Anda dapat melihat bahwa metode yang sesuai dengan API operasi sebenarnya tidak ada. Mereka diimplementasikan menggunakan metode __call() sihir. Metode semu ini sebenarnya adalah pintasan yang merangkum penggunaan objek perintah. SDK

Anda biasanya tidak perlu berinteraksi dengan objek perintah secara langsung. Ketika Anda memanggil metode sepertiAws\S3\S3Client::putObject(), SDK sebenarnya membuat Aws\CommandInterface objek berdasarkan parameter yang disediakan, mengeksekusi perintah, dan mengembalikan Aws\ResultInterface objek yang diisi (atau melempar pengecualian pada kesalahan). Alur serupa terjadi saat memanggil salah satu Async metode klien (misalnya,Aws\S3\S3Client::putObjectAsync()): klien membuat perintah berdasarkan parameter yang disediakan, membuat serial HTTP permintaan, memulai permintaan, dan mengembalikan janji.

Contoh-contoh berikut secara fungsional setara.

$s3Client = new Aws\S3\S3Client([
    'version' => '2006-03-01',
    'region'  => 'us-standard'
]);

$params = [
    'Bucket' => 'foo',
    'Key'    => 'baz',
    'Body'   => 'bar'
];

// Using operation methods creates a command implicitly
$result = $s3Client->putObject($params);

// Using commands explicitly
$command = $s3Client->getCommand('PutObject', $params);
$result = $s3Client->execute($command);

Parameter perintah

Semua perintah mendukung beberapa parameter khusus yang bukan bagian dari layanan API tetapi mengontrol SDK perilaku.

@http

Dengan menggunakan parameter ini, dimungkinkan untuk menyempurnakan cara HTTP handler yang mendasari mengeksekusi permintaan. Opsi yang dapat Anda sertakan dalam @http parameter sama dengan yang dapat Anda atur saat Anda membuat instance klien dengan opsi klien “http”.

// Configures the command to be delayed by 500 milliseconds
$command['@http'] = [
    'delay' => 500,
];

@retries

Seperti opsi klien “coba ulang”, @retries mengontrol berapa kali perintah dapat dicoba ulang sebelum dianggap gagal. Setel ke 0 untuk menonaktifkan percobaan ulang.

// Disable retries
$command['@retries'] = 0;

Membuat objek perintah

Anda dapat membuat perintah menggunakan getCommand() metode klien. Itu tidak segera mengeksekusi atau mentransfer HTTP permintaan, tetapi hanya dieksekusi ketika diteruskan ke execute() metode klien. Ini memberi Anda kesempatan untuk memodifikasi objek perintah sebelum menjalankan perintah.

$command = $s3Client->getCommand('ListObjects');
$command['MaxKeys'] = 50;
$command['Prefix'] = 'foo/baz/';
$result = $s3Client->execute($command);

// You can also modify parameters
$command = $s3Client->getCommand('ListObjects', [
    'MaxKeys' => 50,
    'Prefix'  => 'foo/baz/',
]);
$command['MaxKeys'] = 100;
$result = $s3Client->execute($command);

Perintah HandlerList

Ketika perintah dibuat dari klien, itu diberikan klon dari Aws\HandlerList objek klien. Perintah diberikan klon dari daftar handler klien untuk memungkinkan perintah menggunakan middleware kustom dan handler yang tidak mempengaruhi perintah lain yang dijalankan klien.

Ini berarti Anda dapat menggunakan HTTP klien yang berbeda per perintah (misalnya,Aws\MockHandler) dan menambahkan perilaku khusus per perintah melalui middleware. Contoh berikut menggunakan a MockHandler untuk membuat hasil tiruan alih-alih mengirim HTTP permintaan yang sebenarnya.

use Aws\Result;
use Aws\MockHandler;

// Create a mock handler
$mock = new MockHandler();
// Enqueue a mock result to the handler
$mock->append(new Result(['foo' => 'bar']));
// Create a "ListObjects" command
$command = $s3Client->getCommand('ListObjects');
// Associate the mock handler with the command
$command->getHandlerList()->setHandler($mock);
// Executing the command will use the mock handler, which returns the
// mocked result object
$result = $client->execute($command);

echo $result['foo']; // Outputs 'bar'

Selain mengubah handler yang digunakan perintah, Anda juga dapat menyuntikkan middleware khusus ke perintah. Contoh berikut menggunakan tap middleware, yang berfungsi sebagai pengamat dalam daftar handler.

use Aws\CommandInterface;
use Aws\Middleware;
use Psr\Http\Message\RequestInterface;

$command = $s3Client->getCommand('ListObjects');
$list = $command->getHandlerList();

// Create a middleware that just dumps the command and request that is
// about to be sent
$middleware = Middleware::tap(
    function (CommandInterface $command, RequestInterface $request) {
        var_dump($command->toArray());
        var_dump($request);
    }
);

// Append the middleware to the "sign" step of the handler list. The sign
// step is the last step before transferring an HTTP request.
$list->append('sign', $middleware);

// Now transfer the command and see the var_dump data
$s3Client->execute($command);

CommandPool

Aws\CommandPoolIni memungkinkan Anda untuk menjalankan perintah secara bersamaan menggunakan iterator yang menghasilkan Aws\CommandInterface objek. CommandPoolIni memastikan bahwa sejumlah perintah yang konstan dijalankan secara bersamaan saat mengulang perintah di kolam (saat perintah selesai, lebih banyak dijalankan untuk memastikan ukuran kolam konstan).

Berikut adalah contoh yang sangat sederhana dari hanya mengirim beberapa perintah menggunakanCommandPool.

use Aws\S3\S3Client;
use Aws\CommandPool;

// Create the client
$client = new S3Client([
    'region'  => 'us-standard',
    'version' => '2006-03-01'
]);

$bucket = 'example';
$commands = [
    $client->getCommand('HeadObject', ['Bucket' => $bucket, 'Key' => 'a']),
    $client->getCommand('HeadObject', ['Bucket' => $bucket, 'Key' => 'b']),
    $client->getCommand('HeadObject', ['Bucket' => $bucket, 'Key' => 'c'])
];

$pool = new CommandPool($client, $commands);

// Initiate the pool transfers
$promise = $pool->promise();

// Force the pool to complete synchronously
$promise->wait();

Contoh itu cukup kurang bertenaga untuk. CommandPool Mari kita coba contoh yang lebih kompleks. Katakanlah Anda ingin mengunggah file pada disk ke bucket Amazon S3. Untuk mendapatkan daftar file dari disk, kita bisa menggunakan PHP'sDirectoryIterator. Iterator ini menghasilkan objekSplFileInfo. CommandPoolMenerima iterator yang menghasilkan Aws\CommandInterface objek, jadi kami memetakan SplFileInfo objek untuk mengembalikan objek. Aws\CommandInterface

<?php
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\S3\S3Client;
use Aws\CommandPool;
use Aws\CommandInterface;
use Aws\ResultInterface;
use GuzzleHttp\Promise\PromiseInterface;

// Create the client
$client = new S3Client([
    'region'  => 'us-standard',
    'version' => '2006-03-01'
]);

$fromDir = '/path/to/dir';
$toBucket = 'amzn-s3-demo-bucket';

// Create an iterator that yields files from a directory
$files = new DirectoryIterator($fromDir);

// Create a generator that converts the SplFileInfo objects into
// Aws\CommandInterface objects. This generator accepts the iterator that
// yields files and the name of the bucket to upload the files to.
$commandGenerator = function (\Iterator $files, $bucket) use ($client) {
    foreach ($files as $file) {
        // Skip "." and ".." files
        if ($file->isDot()) {
            continue;
        }
        $filename = $file->getPath() . '/' . $file->getFilename();
        // Yield a command that is executed by the pool
        yield $client->getCommand('PutObject', [
            'Bucket' => $bucket,
            'Key'    => $file->getBaseName(),
            'Body'   => fopen($filename, 'r')
        ]);
    }
};

// Now create the generator using the files iterator
$commands = $commandGenerator($files, $toBucket);

// Create a pool and provide an optional array of configuration
$pool = new CommandPool($client, $commands, [
    // Only send 5 files at a time (this is set to 25 by default)
    'concurrency' => 5,
    // Invoke this function before executing each command
    'before' => function (CommandInterface $cmd, $iterKey) {
        echo "About to send {$iterKey}: "
            . print_r($cmd->toArray(), true) . "\n";
    },
    // Invoke this function for each successful transfer
    'fulfilled' => function (
        ResultInterface $result,
        $iterKey,
        PromiseInterface $aggregatePromise
    ) {
        echo "Completed {$iterKey}: {$result}\n";
    },
    // Invoke this function for each failed transfer
    'rejected' => function (
        AwsException $reason,
        $iterKey,
        PromiseInterface $aggregatePromise
    ) {
        echo "Failed {$iterKey}: {$reason}\n";
    },
]);

// Initiate the pool transfers
$promise = $pool->promise();

// Force the pool to complete synchronously
$promise->wait();

// Or you can chain the calls off of the pool
$promise->then(function() { echo "Done\n"; });

CommandPoolkonfigurasi

Aws\CommandPoolKonstruktor menerima berbagai opsi konfigurasi.

Pengumpulan sampah manual antar perintah

Jika Anda mencapai batas memori dengan kumpulan perintah besar, ini mungkin karena referensi siklik yang dihasilkan oleh yang SDK belum dikumpulkan oleh pengumpul PHP sampah ketika batas memori Anda tercapai. Memanggil algoritma pengumpulan secara manual di antara perintah memungkinkan siklus dikumpulkan sebelum mencapai batas itu. Contoh berikut membuat sebuah CommandPool yang memanggil algoritma koleksi menggunakan callback sebelum mengirim setiap perintah. Perhatikan bahwa memanggil pengumpul sampah memang datang dengan biaya kinerja, dan penggunaan optimal akan tergantung pada kasus penggunaan dan lingkungan Anda.

$pool = new CommandPool($client, $commands, [
    'concurrency' => 25,
    'before' => function (CommandInterface $cmd, $iterKey) {
        gc_collect_cycles();
    }
]);