如何使用zf3和symfony控制台实现控制台命令

Question

The zend console is deprecated. I will use symfony/console (as suggested): composer require symfony/console

With the ZF 2 & 3 I have some years of experience. With Symfony I have done different things, even several console commands.

My skeleton for a symfony console command:

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class InstallCommand extends Command
{
    /**
     * @var string The name of the command (the part after "bin/console")
     */
    protected static $defaultName = 'app:modulename-install';

    protected function configure()
    {
        $this->addArgument('test', InputArgument::REQUIRED, 'Only a test.');
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $text = 'your argument: ' . $input->getArgument('test');
        $output->writeln($text);
    }
}

1. problem : symfony console has none *Action() 's in classes *Command . How can i configure a route?

2 problem : there is no /vendor/bin/console file.

How can I implement symfony 4.x console command in Zend Framework 3?

...the internet is silent on this topic

Answer 1

According to Symfony documentation each console command is a separate class inherited from Symfony\\Component\\Console\\Command\\Command and you need to implement your command runtime code inside execute() method. Because of this there is no routing is involved. Actually you can think about your console command class itself as an action because Symfony's console Application includes routing .

Question about bin/console file is a bit tricky. Normally when you're working with Symfony 4 itsef you're usually using Symfony Flex . Flex itself connects Composer packages with so called "recipes" that resides into separate service . Flex uses these recipes to allow automatic configuration of packages that are installed for Symfony application through Composer. Because of this fact bin/console command is not a part of Composer package, but instead part of Flex recipe for symfony/console package. You can fine it out by yourself inside official recipes repository.

I have almost zero knowledge about ZF3, but in a case if you're using console as a standalone component you may decide either to deal with Symfony's DI container and store all services (including commands) inside it or to manually register every command in console application by using Application::add() method.

Answer 2

It's been a realllllyyy long time since I created/updated this, so not too sure how this all fit together anymore.

But! I can give you an example.

---

This is this no longer maintained module on Github which I found quite handy in the days of ZF2, and I've sort of upgraded it in a few projects of mine where I wanted it, but never into a fully blown ZF3 module. But it works :)

Purpose: run fixtures (yea I know, php bin/console doc:fix:load -n in SF4 :p)

If I remember right, you could use this with: ./vendor/bin/doctrine-module data-fixture:import from the project root and have your Fixture classes registered like so:

...,
'doctrine' => [
    ...,
    'fixture' => [
        FQCN::class,
        FQCN2::class,
    ],
],

So, here it goes (if you copy this, mind the namespaces for folder structure, based on ZF3 with all in src/ folder):

A Module.php class:

<?php

namespace DoctrineFixture;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\Console\ConsoleRunner;
use DoctrineFixture\Command\ImportCommand;
use DoctrineFixture\Service\FixtureFactory;
use Interop\Container\ContainerInterface;
use Zend\EventManager\EventInterface;
use Zend\ModuleManager\Feature\ServiceProviderInterface;
use Zend\ModuleManager\ModuleManager;

class Module implements ServiceProviderInterface
{    
    public function init(ModuleManager $e)
    {
        $events = $e->getEventManager()->getSharedManager();

        // Attach to helper set event and load the entity manager helper.
        $events->attach(
            'doctrine',
            'loadCli.post',
            function (EventInterface $e) {
                /* @var $cli \Symfony\Component\Console\Application */
                $cli = $e->getTarget();

                /* @var $sm ContainerInterface */
                $sm    = $e->getParam('ServiceManager');
                $em    = $sm->get(EntityManager::class);
                $paths = $sm->get('doctrine.configuration.fixtures');

                $importCommand = new ImportCommand();
                $importCommand->setObjectManager($em);
                $importCommand->setPaths($paths);
                ConsoleRunner::addCommands($cli);
                $cli->addCommands(
                    [
                        $importCommand,
                    ]
                );
            }
        );
    }

    public function getServiceConfig()
    {
        return [
            'factories' => [
                'doctrine.configuration.fixtures' => new FixtureFactory(),
            ],
        ];
    }

    public function getConfig()
    {
        $config = [];

        foreach (glob(__DIR__ . '/config/*.php') as $filename) {
            $config = array_merge_recursive($config, include $filename);
        }

        return $config;
    }

    public function getAutoloaderConfig()
    {
        return [
            'Zend\Loader\StandardAutoloader' => [
                'namespaces' => [
                    __NAMESPACE__ => __DIR__ . DIRECTORY_SEPARATOR . 'src',
                ],
            ],
        ];
    }
}

Class ImportCommand

<?php

namespace DoctrineFixture\Command;

use Doctrine\Common\DataFixtures\Executor\ORMExecutor;
use Doctrine\Common\DataFixtures\Loader;
use Doctrine\Common\DataFixtures\Purger\ORMPurger;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Command for generate migration classes by comparing your current database schema
 * to your mapping information.
 */
class ImportCommand extends Command
{
    const PURGE_MODE_TRUNCATE = 0; // 1 = DELETE FROM, 2 = TRUNCATE

    /** @var array */
    protected $paths;

    /** @var ObjectManager|EntityManager */
    protected $objectManager;

    /**
     * @return int|null|void
     */
    public function execute(InputInterface $input, OutputInterface $output)
    {
        $loader = new Loader();
        $purger = new ORMPurger();

        if ($input->getOption('purge-with-truncate')) {
            $purger->setPurgeMode(self::PURGE_MODE_TRUNCATE);
        }

        $executor = new ORMExecutor($this->getObjectManager(), $purger);

        foreach ($this->getPaths() as $key => $value) {
            $loader->loadFromDirectory($value);
        }

        $executor->execute($loader->getFixtures(), $input->getOption('append'));
    }

    public function getPaths(): array
    {
        return $this->paths;
    }

    public function setPaths(array $paths): ImportCommand
    {
        $this->paths = $paths;

        return $this;
    }

    /**
     * @return ObjectManager|EntityManager
     */
    public function getObjectManager()
    {
        return $this->objectManager;
    }

    /**
     * @param ObjectManager|EntityManager $objectManager
     */
    public function setObjectManager($objectManager): ImportCommand
    {
        $this->objectManager = $objectManager;

        return $this;
    }

    /**
     * Register command
     */
    protected function configure(): void
    {
        parent::configure();

        $this->setName('data-fixture:import')
             ->setDescription('Import Data Fixtures')
             ->setHelp(
                 <<<EOT
The import command Imports data-fixtures
EOT
             )
             ->addOption('append', null, InputOption::VALUE_NONE, 'Append data to existing data.')
             ->addOption('purge-with-truncate', null, InputOption::VALUE_NONE, 'Truncate tables before inserting data');
    }

}

And a class FixtureFactory to tie it all together:

<?php

namespace DoctrineFixture\Service;

use Interop\Container\ContainerInterface;
use Zend\ServiceManager\Factory\FactoryInterface;

class FixtureFactory implements FactoryInterface
{
    /**
     * @return array|object
     * @throws \Psr\Container\ContainerExceptionInterface
     * @throws \Psr\Container\NotFoundExceptionInterface
     */
    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
    {
        $options = $container->get('config');
        if (! isset($options['doctrine']['fixture'])) {

            return [];
        }

        return $options['doctrine']['fixture'];
    }
}