Sekitar setahun yang lalu, perusahaan kami menuju pemisahan monolit besar di Magento 1 menjadi layanan mikro. Sebagai dasar, mereka hanya memilih Symfony 4, yang dirilis dalam rilis tersebut. Selama ini saya mengembangkan beberapa proyek pada kerangka ini, tetapi saya khususnya merasa tertarik untuk mengembangkan bundel, menggunakan kembali komponen untuk Symfony. Di bawah kucing, panduan langkah demi langkah tentang pengembangan bundel HealthCheck untuk memperoleh status / kesehatan layanan mikro di bawah Syfmony 4.1, di mana saya mencoba menyentuh momen yang paling menarik dan kompleks (untuk saya sekali).

Di perusahaan kami, bundel ini digunakan, misalnya, untuk memperoleh status pengindeksan ulang produk di ElasticSearch - berapa banyak produk yang terkandung dalam Elastic dengan data saat ini, dan berapa banyak yang memerlukan pengindeksan.

Buat kerangka bundel

Dalam Symfony 3, ada bundel yang nyaman untuk menghasilkan kerangka bundel, tetapi dalam Symfony 4 tidak lagi didukung dan oleh karena itu Anda harus membuat kerangka sendiri. Saya memulai pengembangan setiap proyek baru dengan meluncurkan tim

composer create-project symfony/skeleton health-check 

Harap dicatat bahwa Symfony 4 mendukung PHP 7.1+, jadi jika Anda menjalankan perintah ini pada versi di bawah ini, Anda akan mendapatkan kerangka proyek untuk Symfony 3.

Perintah ini menciptakan proyek Symfony 4.1 baru dengan struktur berikut:

Pada prinsipnya, ini tidak perlu, karena file-file yang dibuat pada akhirnya tidak kita butuhkan, tetapi lebih nyaman bagi saya untuk membersihkan segala sesuatu yang tidak diperlukan daripada membuat yang diperlukan dengan tangan saya.

composer.json

Langkah selanjutnya adalah mengedit composer.json sesuai kebutuhan kita. Pertama-tama, Anda perlu mengubah jenis jenis proyek ke symfony-bundle ini akan membantu Symfony Flex menentukan ketika menambahkan bundel ke proyek bahwa itu benar-benar bundel Symfony, sambungkan secara otomatis dan instal resep (tetapi lebih lanjut tentang itu nanti). Selanjutnya, pastikan untuk menambahkan bidang name dan description . name juga penting karena menentukan di folder mana di dalam vendor bundel akan ditempatkan.

 "name": "niklesh/health-check", "description": "Health check bundle", 

Langkah penting berikutnya adalah mengedit bagian pengisian autoload , yang bertanggung jawab untuk memuat kelas bundel. autoload untuk lingkungan kerja, autoload-dev untuk lingkungan kerja.

 "autoload": { "psr-4": { "niklesh\\HealthCheckBundle\\": "src" } }, "autoload-dev": { "psr-4": { "niklesh\\HealthCheckBundle\\Tests\\": "tests" } }, 

Bagian scripts dapat dihapus. Ini berisi skrip untuk merakit aset dan membersihkan cache setelah menjalankan composer install dan composer update perintah composer update , namun, bundel kami tidak mengandung aset atau cache, oleh karena itu perintah ini tidak berguna.

Langkah terakhir adalah mengedit bagian persyaratan dan persyaratan require-dev . Hasilnya, kami mendapatkan yang berikut:

 "require": { "php": "^7.1.3", "ext-ctype": "*", "ext-iconv": "*", "symfony/flex": "^1.0", "symfony/framework-bundle": "^4.1", "sensio/framework-extra-bundle": "^5.2", "symfony/lts": "^4@dev", "symfony/yaml": "^4.1" } 

Saya perhatikan bahwa dependensi dari require akan diinstal ketika bundel terhubung ke draft kerja.

Kami memulai composer update - dependensi diinstal.

Pembersihan yang tidak perlu

Jadi, dari file yang diterima Anda dapat dengan aman menghapus folder berikut:

• bin - berisi file console diperlukan untuk menjalankan perintah Symfony
• config - berisi file konfigurasi untuk perutean, bundel yang terhubung,
  layanan, dll.
• publik - berisi index.php - titik masuk ke aplikasi
• var - log dan cache disimpan di sini

Kami juga menghapus file src/Kernel.php , .env.dist , .env.dist
Kami tidak membutuhkan semua ini karena kami sedang mengembangkan bundel, bukan aplikasi.

Membuat struktur bundel

Jadi, kami menambahkan dependensi yang diperlukan dan membersihkan semua yang tidak diperlukan dari bundel kami. Saatnya untuk membuat file dan folder yang diperlukan untuk berhasil menghubungkan bundel ke proyek.

Pertama-tama, di folder src , buat file HealthCheckBundle.php dengan konten berikut:

 <?php namespace niklesh\HealthCheckBundle; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { } 

Kelas semacam itu harus ada di setiap bundel yang Anda buat. Dia akan config/bundles.php dalam file config/bundles.php proyek utama. Selain itu, ia dapat mempengaruhi "membangun" bundel.

Komponen bundel berikutnya yang diperlukan adalah bagian DependencyInjection . Buat folder dengan nama yang sama dengan 2 file:

• src/DependencyInjection/Configuration.php

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\Definition\Builder\TreeBuilder; use Symfony\Component\Config\Definition\ConfigurationInterface; class Configuration implements ConfigurationInterface { public function getConfigTreeBuilder() { $treeBuilder = new TreeBuilder(); $treeBuilder->root('health_check'); return $treeBuilder; } } 

File ini bertanggung jawab untuk mem-parsing dan memvalidasi konfigurasi bundel dari file Yaml atau xml. Kami akan memodifikasinya nanti.

• src/DependencyInjection/HealthCheckExtension.php

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\FileLocator; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\DependencyInjection\Extension; use Symfony\Component\DependencyInjection\Loader; class HealthCheckExtension extends Extension { /** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yaml'); } } 

File ini bertanggung jawab untuk memuat file konfigurasi bundel, membuat dan mendaftarkan layanan "definisi", memuat parameter ke wadah, dll.

Dan langkah terakhir pada tahap ini adalah menambahkan file src/Resources/services.yaml , yang akan berisi deskripsi layanan bundel kami. Biarkan kosong untuk saat ini.

Antarmuka Kesehatan

Tugas utama bundel kami adalah mengembalikan data tentang proyek yang digunakannya. Tetapi pengumpulan informasi adalah karya layanan itu sendiri, bundel kami hanya dapat menunjukkan format informasi yang harus ditransmisikan oleh layanan, dan metode yang akan menerima informasi ini. Dalam implementasi saya, semua layanan (dan mungkin ada beberapa) yang mengumpulkan informasi harus mengimplementasikan antarmuka HealthInterface dengan 2 metode: getName dan getHealthInfo . Yang terakhir harus mengembalikan objek yang mengimplementasikan antarmuka HealthDataInterface .

Pertama, buat antarmuka data src/Entity/HealthDataInterface.php :

 <?php namespace niklesh\HealthCheckBundle\Entity; interface HealthDataInterface { public const STATUS_OK = 1; public const STATUS_WARNING = 2; public const STATUS_DANGER = 3; public const STATUS_CRITICAL = 4; public function getStatus(): int; public function getAdditionalInfo(): array; } 

Data harus mengandung status integer dan informasi tambahan (yang, omong-omong, mungkin kosong).

Karena kemungkinan besar implementasi antarmuka ini akan menjadi khas kebanyakan keturunan, saya memutuskan untuk menambahkannya ke src/Entity/CommonHealthData.php :

 <?php namespace niklesh\HealthCheckBundle\Entity; class CommonHealthData implements HealthDataInterface { private $status; private $additionalInfo = []; public function __construct(int $status) { $this->status = $status; } public function setStatus(int $status) { $this->status = $status; } public function setAdditionalInfo(array $additionalInfo) { $this->additionalInfo = $additionalInfo; } public function getStatus(): int { return $this->status; } public function getAdditionalInfo(): array { return $this->additionalInfo; } } 

Terakhir, tambahkan antarmuka untuk layanan pengumpulan data src/Service/HealthInterface.php :

 <?php namespace niklesh\HealthCheckBundle\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; interface HealthInterface { public function getName(): string; public function getHealthInfo(): HealthDataInterface; } 

Pengendali

Pengontrol akan memberikan data tentang proyek hanya dalam satu rute. Tetapi rute ini akan sama untuk semua proyek yang menggunakan bundel ini: /health

Namun, tugas pengontrol kami tidak hanya untuk memberikan data, tetapi juga untuk mengeluarkannya dari layanan yang mengimplementasikan HealthInterface , oleh karena itu, pengontrol harus menyimpan tautan ke masing-masing layanan ini. Metode addHealthService akan bertanggung jawab untuk menambahkan layanan ke controller

Tambahkan controller src/Controller/HealthController.php :

 <?php namespace niklesh\HealthCheckBundle\Controller; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Annotation\Route; class HealthController extends AbstractController { /** @var HealthInterface[] */ private $healthServices = []; public function addHealthService(HealthInterface $healthService) { $this->healthServices[] = $healthService; } /** * @Route("/health") * @return JsonResponse */ public function getHealth(): JsonResponse { return $this->json(array_map(function (HealthInterface $healthService) { $info = $healthService->getHealthInfo(); return [ 'name' => $healthService->getName(), 'info' => [ 'status' => $info->getStatus(), 'additional_info' => $info->getAdditionalInfo() ] ]; }, $this->healthServices)); } } 

Kompilasi

Symfony dapat melakukan tindakan tertentu dengan layanan yang mengimplementasikan antarmuka spesifik. Anda dapat memanggil metode tertentu, menambahkan tag, tetapi Anda tidak dapat mengambil dan menyuntikkan semua layanan tersebut ke layanan lain (yang merupakan pengendali). Masalah ini diselesaikan dalam 4 tahap:

Kami menambahkan ke setiap HealthInterface kami yang menerapkan tag HealthInterface .

Tambahkan konstanta TAG ke antarmuka:

 interface HealthInterface { public const TAG = 'health.service'; } 

Selanjutnya, Anda perlu menambahkan tag ini ke setiap layanan. Dalam hal konfigurasi proyek, ini bisa
implementasikan di file config/services.yaml di bagian _instanceof . Dalam kasus kami, ini
entri akan terlihat seperti ini:

 serivces: _instanceof: niklesh\HealthCheckBundle\Service\HealthInterface: tags: - !php/const niklesh\HealthCheckBundle\Service\HealthInterface::TAG 

Dan, pada prinsipnya, jika Anda mempercayakan konfigurasi bundel kepada pengguna, itu akan berfungsi, tetapi menurut saya ini bukan pendekatan yang tepat, bundel itu sendiri harus terhubung dengan benar dan dikonfigurasi dengan intervensi pengguna minimal ketika ditambahkan ke proyek. Seseorang mungkin ingat bahwa kita memiliki services.yaml kita sendiri. Ya, ada di dalam bungkusan itu, tetapi tidak, itu tidak akan membantu kita. Pengaturan ini hanya berfungsi jika ada dalam file proyek, bukan bundel.
Saya tidak tahu apakah ini bug atau fitur, tetapi sekarang kami memiliki apa yang kami miliki. Karena itu, kita harus menyusup ke proses kompilasi bundel.

Pergi ke file src/HealthCheckBundle.php dan mendefinisikan kembali metode build :

 <?php namespace niklesh\HealthCheckBundle; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { public function build(ContainerBuilder $container) { parent::build($container); $container->registerForAutoconfiguration(HealthInterface::class)->addTag(HealthInterface::TAG); } } 

Sekarang setiap kelas yang mengimplementasikan HealthInterface akan ditandai.

Mendaftarkan pengontrol sebagai layanan

Pada langkah berikutnya, kita perlu menghubungi controller sebagai layanan, pada tahap kompilasi bundel. Dalam hal bekerja dengan proyek, di sana semua kelas terdaftar sebagai layanan secara default, tetapi dalam kasus bekerja dengan bundel kita harus secara eksplisit menentukan kelas yang akan menjadi layanan, meletakkan argumen untuk mereka, dan menunjukkan apakah mereka akan menjadi publik.

Buka file src/Resources/config/services.yaml dan tambahkan konten berikut

 services: niklesh\HealthCheckBundle\Controller\HealthController: autoconfigure: true 

Kami secara eksplisit mendaftarkan controller sebagai layanan, sekarang dapat diakses pada tahap kompilasi.

Menambahkan layanan ke controller.

Pada tahap penyusunan wadah dan bundel, kami hanya dapat beroperasi dengan definisi layanan. Pada tahap ini, kita perlu mengambil definisi HealthController dan menunjukkan bahwa setelah dibuatnya, perlu menambahkan semua layanan yang ditandai dengan tag kita. Untuk operasi semacam itu dalam bundel, kelas yang mengimplementasikan antarmuka bertanggung jawab
Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface

Buat kelas src/DependencyInjection/Compiler/HealthServicePath.php :

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection\Compiler; use niklesh\HealthCheckBundle\Controller\HealthController; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Reference; class HealthServicesPath implements CompilerPassInterface { public function process(ContainerBuilder $container) { if (!$container->has(HealthController::class)) { return; } $controller = $container->findDefinition(HealthController::class); foreach (array_keys($container->findTaggedServiceIds(HealthInterface::TAG)) as $serviceId) { $controller->addMethodCall('addHealthService', [new Reference($serviceId)]); } } } 

Seperti yang Anda lihat, pertama-tama kita ambil pengontrol menggunakan metode findDefinition , lalu - semua layanan dengan tag dan kemudian, dalam satu lingkaran, tambahkan panggilan ke metode addHealthService untuk setiap layanan yang ditemukan, tempat kami meneruskan tautan ke layanan ini.

Menggunakan CompilerPath

Langkah terakhir adalah menambahkan HealthServicePath kami ke proses kompilasi bundel. Mari kita kembali ke kelas HealthCheckBundle dan mengubah metode build sedikit lebih. Sebagai hasilnya, kita mendapatkan:

 <?php namespace niklesh\HealthCheckBundle; use niklesh\HealthCheckBundle\DependencyInjection\Compiler\HealthServicesPath; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { public function build(ContainerBuilder $container) { parent::build($container); $container->addCompilerPass(new HealthServicesPath()); $container->registerForAutoconfiguration(HealthInterface::class)->addTag(HealthInterface::TAG); } } 

Pada dasarnya, pada tahap ini bundel kami siap digunakan. Itu dapat menemukan layanan pengumpulan informasi, bekerja dengan mereka dan memberikan jawaban ketika menghubungi /health (Anda hanya perlu menambahkan pengaturan routing ketika menghubungkan), tetapi saya memutuskan untuk memasukkannya kemampuan tidak hanya untuk mengirim informasi berdasarkan permintaan, tetapi juga menyediakan kemampuan untuk mengirim informasi ini ke atau, misalnya, menggunakan permintaan POST atau melalui manajer antrian.

HealthSenderInterface

Antarmuka ini dimaksudkan untuk menggambarkan kelas yang bertanggung jawab untuk mengirim data di suatu tempat. Buat di src/Service/HealthSenderInterface

 <?php namespace niklesh\HealthCheckBundle\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; interface HealthSenderInterface { /** * @param HealthDataInterface[] $data */ public function send(array $data): void; public function getDescription(): string; public function getName(): string; } 

Seperti yang Anda lihat, metode send akan memroses array data yang diterima dari semua kelas yang mengimplementasikan HealthInterface dan kemudian mengirimkannya ke tempat yang diperlukan.
Metode getDescription dan getName diperlukan hanya untuk menampilkan informasi saat menjalankan perintah konsol.

Perintah kirim

Mulai mengirim data ke sumber daya pihak ketiga akan menjadi perintah konsol SendDataCommand . Tugasnya adalah mengumpulkan data untuk distribusi, dan kemudian memanggil metode send pada setiap layanan distribusi. Jelas, perintah ini sebagian akan mengulangi logika controller, tetapi tidak semuanya.

 <?php namespace niklesh\HealthCheckBundle\Command; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthInterface; use niklesh\HealthCheckBundle\Service\HealthSenderInterface; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; use Symfony\Component\Console\Style\SymfonyStyle; use Throwable; class SendDataCommand extends Command { public const COMMAND_NAME = 'health:send-info'; private $senders; /** @var HealthInterface[] */ private $healthServices; /** @var SymfonyStyle */ private $io; public function __construct(HealthSenderInterface... $senders) { parent::__construct(self::COMMAND_NAME); $this->senders = $senders; } public function addHealthService(HealthInterface $healthService) { $this->healthServices[] = $healthService; } protected function configure() { parent::configure(); $this->setDescription('Send health data by senders'); } protected function initialize(InputInterface $input, OutputInterface $output) { parent::initialize($input, $output); $this->io = new SymfonyStyle($input, $output); } protected function execute(InputInterface $input, OutputInterface $output) { $this->io->title('Sending health info'); try { $data = array_map(function (HealthInterface $service): HealthDataInterface { return $service->getHealthInfo(); }, $this->healthServices); foreach ($this->senders as $sender) { $this->outputInfo($sender); $sender->send($data); } $this->io->success('Data is sent by all senders'); } catch (Throwable $exception) { $this->io->error('Exception occurred: ' . $exception->getMessage()); $this->io->text($exception->getTraceAsString()); } } private function outputInfo(HealthSenderInterface $sender) { if ($name = $sender->getName()) { $this->io->writeln($name); } if ($description = $sender->getDescription()) { $this->io->writeln($description); } } } 

HealthServicesPath , menulis penambahan layanan pengumpulan data ke tim.

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection\Compiler; use niklesh\HealthCheckBundle\Command\SendDataCommand; use niklesh\HealthCheckBundle\Controller\HealthController; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Reference; class HealthServicesPath implements CompilerPassInterface { public function process(ContainerBuilder $container) { if (!$container->has(HealthController::class)) { return; } $controller = $container->findDefinition(HealthController::class); $commandDefinition = $container->findDefinition(SendDataCommand::class); foreach (array_keys($container->findTaggedServiceIds(HealthInterface::TAG)) as $serviceId) { $controller->addMethodCall('addHealthService', [new Reference($serviceId)]); $commandDefinition->addMethodCall('addHealthService', [new Reference($serviceId)]); } } } 

Seperti yang Anda lihat, perintah di konstruktor menerima array pengirim. Dalam hal ini, Anda tidak akan dapat menggunakan fitur pengikatan dependensi otomatis, kami harus membuat dan mendaftarkan tim sendiri. Satu-satunya pertanyaan adalah layanan pengirim mana yang ditambahkan ke perintah ini. Kami akan menunjukkan id mereka dalam konfigurasi bundel seperti ini:

 health_check: senders: - '@sender.service1' - '@sender.service2' 

Bundel kami masih tidak tahu bagaimana menangani konfigurasi seperti itu, kami akan mengajarkannya. Pergi ke Configuration.php dan tambahkan pohon konfigurasi:

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\Definition\Builder\TreeBuilder; use Symfony\Component\Config\Definition\ConfigurationInterface; class Configuration implements ConfigurationInterface { public function getConfigTreeBuilder() { $treeBuilder = new TreeBuilder(); $rootNode = $treeBuilder->root('health_check'); $rootNode ->children() ->arrayNode('senders') ->scalarPrototype()->end() ->end() ->end() ; return $treeBuilder; } } 

Kode ini menentukan bahwa simpul root akan menjadi simpul health_check , yang akan berisi senders array senders , yang pada gilirannya akan berisi sejumlah baris. Itu saja, sekarang bundel kami tahu cara menangani konfigurasi, yang kami uraikan di atas. Sudah waktunya untuk mendaftarkan tim. Untuk melakukannya, buka HealthCheckExtension dan tambahkan kode berikut:

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use niklesh\HealthCheckBundle\Command\SendDataCommand; use Symfony\Component\Config\FileLocator; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Definition; use Symfony\Component\HttpKernel\DependencyInjection\Extension; use Symfony\Component\DependencyInjection\Loader; use Symfony\Component\DependencyInjection\Reference; class HealthCheckExtension extends Extension { /** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yaml'); //    $commandDefinition = new Definition(SendDataCommand::class); //        foreach ($config['senders'] as $serviceId) { $commandDefinition->addArgument(new Reference($serviceId)); } //       $commandDefinition->addTag('console.command', ['command' => SendDataCommand::COMMAND_NAME]); //     $container->setDefinition(SendDataCommand::class, $commandDefinition); } } 

Itu saja, tim kami ditentukan. Sekarang, setelah menambahkan bundel ke proyek, saat dipanggil
bin/console kita akan melihat daftar perintah, termasuk kita: health:send-info , Anda dapat memanggilnya dengan cara yang sama: bin/console health:send-info

Bundel kami siap. Sudah waktunya untuk mengujinya di proyek. Buat proyek kosong:

 composer create-project symfony/skeleton health-test-project 

Tambahkan bundel kami yang baru dipanggang ke dalamnya, untuk ini kami menambahkan bagian repositories di composer.json :

 "repositories": [ { "type": "vcs", "url": "https://github.com/HEKET313/health-check" } ] 

Dan jalankan perintah:

 composer require niklesh/health-check 

Dan juga, untuk permulaan tercepat, tambahkan server simfoni ke proyek kami:

 composer req --dev server 

Bundel terhubung, Symfony Flex secara otomatis menghubungkannya ke config/bundles.php , tetapi untuk secara otomatis membuat file konfigurasi, Anda perlu membuat resep. Tentang resep dilukis dengan indah di artikel lain di sini: https://habr.com/post/345382/ - jadi lukis cara membuat resep, dll. Saya tidak akan berada di sini, dan belum ada resep untuk bundel ini.

Namun demikian, file konfigurasi diperlukan, jadi buatlah dengan pegangan:

• config/routes/niklesh_health.yaml

 health_check: resource: "@HealthCheckBundle/Controller/HealthController.php" prefix: / type: annotation 

• config/packages/hiklesh_health.yaml

 health_check: senders: - 'App\Service\Sender' 

Sekarang Anda perlu menerapkan kelas pengiriman informasi untuk tim dan kelas pengumpulan informasi

• src/Service/DataCollector.php

Semuanya sangat sederhana di sini.

 <?php namespace App\Service; use niklesh\HealthCheckBundle\Entity\CommonHealthData; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthInterface; class DataCollector implements HealthInterface { public function getName(): string { return 'Data collector'; } public function getHealthInfo(): HealthDataInterface { $data = new CommonHealthData(HealthDataInterface::STATUS_OK); $data->setAdditionalInfo(['some_data' => 'some_value']); return $data; } } 

• src/Service/Sender.php

Dan di sini bahkan lebih mudah

 <?php namespace App\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthSenderInterface; class Sender implements HealthSenderInterface { /** * @param HealthDataInterface[] $data */ public function send(array $data): void { print "Data sent\n"; } public function getDescription(): string { return 'Sender description'; } public function getName(): string { return 'Sender name'; } } 

Selesai! Bersihkan cache dan mulai server

 bin/console cache:clear bin/console server:start 

Sekarang Anda dapat mencoba tim kami:

 bin/console health:send-info 

Kami mendapatkan kesimpulan yang sangat indah:

Akhirnya, kami mengetuk rute kami http://127.0.0.1:8000/health dan mendapatkan kesimpulan yang kurang indah, tetapi juga:

 [{"name":"Data collector","info":{"status":1,"additional_info":{"some_data":"some_value"}}}] 

Itu saja! Saya harap tutorial sederhana ini membantu seseorang untuk memahami dasar-dasar penulisan bundel untuk Symfony 4.

Kode Sumber PS tersedia di sini .