English | 中文

Jet, by Hyperf

Jet is a unification model RPC Client, built-in JSONRPC protocol, available to running in ALL PHP environments, including PHP-FPM and Swoole/Hyperf environments.

Also will built-in gRPC and Tars protocols in future.

Installation

composer require hyperf/jet

Quickstart

Register protocol

Register the protocol is not necessary, but you could manage the protocols more easily by using ProtocolManager.

You cloud register any protocol by Hyperf\Jet\ProtocolManager, per protocol basically including Transporter, Packer, DataFormatter and PathGenerator, you could register a JSONRPC protocol like below:

<?phpuseHyperf\Jet\DataFormatter\DataFormatter;
useHyperf\Jet\Packer\JsonEofPacker;
useHyperf\Jet\PathGenerator\PathGenerator;
useHyperf\Jet\ProtocolManager;
useHyperf\Jet\Transporter\StreamSocketTransporter;
ProtocolManager::register($protocol = 'jsonrpc', [
ProtocolManager::TRANSPORTER => newStreamSocketTransporter(),
ProtocolManager::PACKER => newJsonEofPacker(),
ProtocolManager::PATH_GENERATOR => newPathGenerator(),
ProtocolManager::DATA_FORMATTER => newDataFormatter(),
]);

If you use consul, you could register a JSONRPC protocol like below:

<?phpuseHyperf\Jet\DataFormatter\DataFormatter;
useHyperf\Jet\Packer\JsonEofPacker;
useHyperf\Jet\PathGenerator\PathGenerator;
useHyperf\Jet\ProtocolManager;
useHyperf\Jet\Transporter\ConsulTransporter;
// If you use consul service, you should register ProtocolManager::NODE_SELECTOR.
ProtocolManager::register($protocol = 'consul', [
ProtocolManager::TRANSPORTER => newStreamSocketTransporter(),
ProtocolManager::PACKER => newJsonEofPacker(),
ProtocolManager::PATH_GENERATOR => newPathGenerator(),
ProtocolManager::DATA_FORMATTER => newDataFormatter(),
ProtocolManager::NODE_SELECTOR => newNodeSelector($this->host, $this->port, $config), ]);

Register service

Register the service is not necessary, but you could manage the services more easily by using ServiceManager.

After you registered a protocol to Hyperf\Jet\ProtocolManager, you could bind the protocol with any services by Hyperf\Jet\ServiceManager, like below:

<?phpuseHyperf\Jet\ServiceManager;
// Bind CalculatorService with jsonrpc protocol, and set the static nodes info.
ServiceManager::register($service = 'CalculatorService', $protocol = 'jsonrpc', [
ServiceManager::NODES => [
[$host = '127.0.0.1', $port = 9503],
],
]);

Call RPC method

Call by ClientFactory

After you registered the protocol and service, you could get your service client via Hyperf/Jet/ClientFactory, like below:

<?phpuseHyperf\Jet\ClientFactory;
$clientFactory = newClientFactory();
$client = $clientFactory->create($service = 'CalculatorService', $protocol = 'jsonrpc');

When you have the client object, you could call any remote methods via the object, like below:

// Call the remote method `add` with arguments `1` and `2`.// The $result is the result of the remote method.$result = $client->add(1, 2);

If you call a not exist remote method, the client will throw an Hyperf\Jet\Exception\ServerException exception.

Call by custom client

You could also create a custom client class which extends Hyperf\Jet\AbstractClient, to call the remote methods via the client object.
For example, you want to define a RPC client for CalculatorService with jsonrpc protocol, you could create a CalculatorService class firstly, like below:

<?phpuseHyperf\Jet\AbstractClient;
useHyperf\Jet\Packer\JsonEofPacker;
useHyperf\Jet\Transporter\StreamSocketTransporter;
useHyperf\Rpc\Contract\DataFormatterInterface;
useHyperf\Rpc\Contract\PackerInterface;
useHyperf\Rpc\Contract\PathGeneratorInterface;
useHyperf\Rpc\Contract\TransporterInterface;
/** * @method int add(int $a, int $b); */class CalculatorService extends AbstractClient
{
// Define `CalculatorService` as the default value of $service.publicfunction__construct(
string$service = 'CalculatorService',
TransporterInterface$transporter = null,
PackerInterface$packer = null,
?DataFormatterInterface$dataFormatter = null,
?PathGeneratorInterface$pathGenerator = null
) {
// Specific the transporter here, you could also retrieve the transporter from ProtocolManager or passing by constructor.$transporter = newStreamSocketTransporter('127.0.0.1', 9503);
// Specific the packer here, you could also retrieve the packer from ProtocolManager or passing by constructor.$packer = newJsonEofPacker();
parent::__construct($service, $transporter, $packer, $dataFormatter, $pathGenerator);
}
}

If use Consul service, you can use it in the following way.

<?phpuseHyperf\Jet\AbstractClient;
useHyperf\Jet\Packer\JsonEofPacker;
useHyperf\Jet\Transporter\StreamSocketTransporter;
useHyperf\Rpc\Contract\DataFormatterInterface;
useHyperf\Rpc\Contract\PackerInterface;
useHyperf\Rpc\Contract\PathGeneratorInterface;
useHyperf\Rpc\Contract\TransporterInterface;
useHyperf\Jet\NodeSelector\NodeSelector;
/** * @method int add(int $a, int $b); */class CalculatorService extends AbstractClient
{
// Define `CalculatorService` as the default value of $service.publicfunction__construct(
string$service = 'CalculatorService',
TransporterInterface$transporter = null,
PackerInterface$packer = null,
?DataFormatterInterface$dataFormatter = null,
?PathGeneratorInterface$pathGenerator = null
) {
// Specific the transporter here, you could also retrieve the transporter from ProtocolManager or passing by constructor.$transporter = newStreamSocketTransporter();
$nodeSelector = newNodeSelector('127.0.0.1', 8500, $config);
[$transporter->host, $transporter->port] = $nodeSelector->selectRandomNode($service, 'jsonrpc');
// Specific the packer here, you could also retrieve the packer from ProtocolManager or passing by constructor.$packer = newJsonEofPacker();
parent::__construct($service, $transporter, $packer, $dataFormatter, $pathGenerator);
}
}

Now, you could use this class to call the remote method directly, like below:

// Call the remote method `add` with arguments `1` and `2`.// The $result is the result of the remote method.$client = newCalculatorService();
$result = $client->add(1, 2);