Junio 2011

faltaba 1 año para...

Symfony 2.0 RC1

Bundle

¿Cuantos bundles deberían haber?

¡Uno para toda la App!

¡Buuuu!

¡Fueraaaaa!

¡Un Bundle por grupo!

Best Practices 2014

1 Bundle - src/AppBundle

  • Reducimos complejidad
  • Reducimos sistema de carpetas
  • Incrementamos rendimiento de trabajo
  • Reducimos separación semántica
  • Debemos ser más exigentes con el naming
  • Complicación si se quiere separar en un futuro

¿Cuantos bundles deberían haber... si hago...?

  • MVP
  • App + mantenimiento
  • Bundle FOS
  • Experimento

Nos hemos olvidado lo más importante de todo...

  • Como separamos el bundle
  • Cual es nuestra lógica de negocio
  • Cuales son las best practices

Salir de nuestra zona de confort


    namespace AppBundle;
    
    use Symfony\Component\HttpKernel\Bundle\Bundle;
    
    /**
     * This bundle will rule the world
     */
    class AppBundle extends Bundle
    {

    }

    namespace AppBundle;
    
    use Symfony\Component\HttpKernel\Bundle\Bundle;
    
    /**
     * This bundle will rule the world
     */
    class AppBundle extends Bundle
    {
    
    }
namespace AppBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

/**
 * This bundle will rule the world
 */
class AppBundle extends Bundle
{

}
  • Clase Bundle
  • Extensión
  • CompilerPass
  • Desacoplando
  • Clase Bundle
  • Extensión
  • CompilerPass
  • Desacoplando

    namespace Symfony\Component\HttpKernel\Bundle;

    /**
     * An implementation of BundleInterface that adds a few conventions
     * for DependencyInjection extensions and Console commands.
     *
     * @author Fabien Potencier <fabien@symfony.com>
     */
    abstract class Bundle implements BundleInterface
    {

    }

definición Extensión

    
    /**
     * Returns the bundle's container extension.
     *
     * @return ExtensionInterface|null The container extension
     *
     * @throws \LogicException
     */
    public function getContainerExtension()
    {
        if (null === $this->extension) {
            $extension = $this->createContainerExtension();
            if (null !== $extension) {
                if (!$extension instanceof ExtensionInterface) {
                    throw new \LogicException(sprintf('Extension %s must implement Symfony\Component\DependencyInjection\Extension\ExtensionInterface.', get_class($extension)));
                }
                // check naming convention
                $basename = preg_replace('/Bundle$/', '', $this->getName());
                $expectedAlias = Container::underscore($basename);
                if ($expectedAlias != $extension->getAlias()) {
                    throw new \LogicException(sprintf(
                        'Users will expect the alias of the default extension of a bundle to be the underscored version of the bundle name ("%s"). You can override "Bundle::getContainerExtension()" if you want to use "%s" or another alias.',
                        $expectedAlias, $extension->getAlias()
                    ));
                }
                $this->extension = $extension;
            } else {
                $this->extension = false;
            }
        }
        if ($this->extension) {
            return $this->extension;
        }
    }
  • Te busca automáticamente una Extensión
  • Dentro de /DependencyInjection
  • {App}Extension.php
  • Ante cualquier error... ¡ni te enteras!
  • ¡Ojo con el alias! Solo acepta si es {app}. Sino... claro, los usuarios no lo entenderán

    use Symfony\Component\HttpKernel\Bundle\Bundle;
    
    /**
     * My bundle
     */
    final class MyBundle extends Bundle
    {
        /**
         * Returns the bundle's container extension.
         *
         * @return ExtensionInterface|null The container extension
         *
         * @throws \LogicException
         */
        public function getContainerExtension()
        {
            return new MyExtension();
        }
    }

Title Text


    use Symfony\Component\HttpKernel\Bundle\Bundle;
    
    /**
     * My bundle
     */
    final class MyBundle extends Bundle
    {
        /**
         * Returns the bundle's container extension.
         *
         * @return ExtensionInterface|null The container extension
         *
         * @throws \LogicException
         */
        public function getContainerExtension()
        {
            return null;
        }
    }

DRY

BaseBundle

http://github.com/mmoreram/BaseBundle

  • Bundle base donde extender tus propios bundles
  • Añade una capa de simplificación para el gran porcentaje de los casos
  • Simples métodos con simples responsabilidades
  • Minimiza un poco cierta magia oculta
  • Por defecto, un bundle no tiene Extension
  • En caso contrario, se lo defines
  • Con esto ganas algo importante en tus proyectos, y es saber qué se carga, y cuándo
  • Te olvidas de este método-que-todo-lo-hace para siempre

    namespace AppBundle;
    
    use Mmoreram\BaseBundle\BaseBundle;
    
    /**
     * Class MyBundle.
     */
    final class MyBundle extends BaseBundle
    {
    
    }

Comandos


    /**
     * Finds and registers Commands.
     *
     * Override this method if your bundle commands do not follow the conventions:
     *
     * * Commands are in the 'Command' sub-directory
     * * Commands extend Symfony\Component\Console\Command\Command
     *
     * @param Application $application An Application instance
     */
    public function registerCommands(Application $application)
    {
        if (!is_dir($dir = $this->getPath().'/Command')) {
            return;
        }
        if (!class_exists('Symfony\Component\Finder\Finder')) {
            throw new \RuntimeException('You need the symfony/finder component to register bundle commands.');
        }
        $finder = new Finder();
        $finder->files()->name('*Command.php')->in($dir);
        $prefix = $this->getNamespace().'\\Command';
        foreach ($finder as $file) {
            $ns = $prefix;
            if ($relativePath = $file->getRelativePath()) {
                $ns .= '\\'.str_replace('/', '\\', $relativePath);
            }
            $class = $ns.'\\'.$file->getBasename('.php');
            if ($this->container) {
                $alias = 'console.command.'.strtolower(str_replace('\\', '_', $class));
                if ($this->container->has($alias)) {
                    continue;
                }
            }
            $r = new \ReflectionClass($class);
            if ($r->isSubclassOf('Symfony\\Component\\Console\\Command\\Command') && !$r->isAbstract() && !$r->getConstructor()->getNumberOfRequiredParameters()) {
                $application->add($r->newInstance());
            }
        }
    }
  • Te busca en el directorio /Command todos los comandos que tengas
  • En caso que exista un servicio con el nombre `console.command.{nombre-construido-al-tun-tun}` entonces no te lo carga
  • ¿Y si quieres tener los comandos en otra carpeta? No, compañeros, tampoco podéis.

    /**
     * Register Commands.
     *
     * Disabled as commands are registered as services.
     *
     * @param Application $application An Application instance
     */
    public function registerCommands(Application $application)
    {
        return;
    }
  • Por defecto, ningún bundle tiene comandos
  • Si un bundle necesita registrar comandos sin querer declararlos como servicios, lo hace específicamente
  • De este modo, un bundle sabe, exactamente, con precisión, cuáles son los comandos que está exponiendo
  • Veréis que esto tiene mucho sentido cuando separamos bundle de componente

    /**
     * Register Commands.
     *
     * Disabled as commands are registered as services.
     *
     * @param Application $application An Application instance
     */
    public function registerCommands(Application $application)
    {
        return [
            new OneCommand(),
            new AnotherCommand()
        ]
    }

¡OJO basurita!

¿Alguien sabe exactamente qué ocurre cuando... php bin/console?


    protected function registerCommands()
    {
        if ($this->commandsRegistered) {
            return;
        }

        $this->commandsRegistered = true;
        $this->kernel->boot();
        $container = $this->kernel->getContainer();

        foreach ($this->kernel->getBundles() as $bundle) {
            if ($bundle instanceof Bundle) {
                $bundle->registerCommands($this);
            }
        }

        if ($container->hasParameter('console.command.ids')) {
            foreach ($container->getParameter('console.command.ids') as $id) {
                $this->add($container->get($id));
            }
        }
    }
  • Cada vez que listas o ejecutas cualquier comando por consola... todos y cada uno de ellos se instancian...
  • ... ¡incluidos los que se han declarado como servicios!
  • Esto implica que si tenemos un comando declarado como un servicio, y un servicio inyectado que, a su vez, tiene el entity manager inyectado...
  • ... como no haya base de datos creada, simplemente, no funciona, no establece conexión y lanza Exception
  • Solución 1 - Puedes romper la barrera de creación en cadena de servicios utilizando en algún punto un proxy.
  • Solución 2 - Puedes utilizar algún sistema de CommandBus, dado que solo levantaría el bus en sí, nada más
  • Solución 3 - Utilizas el container entero, tan hermoso y tranquilo, y a dormir.
  • Solución 4 - Tienes huevos y planteas una solución en el repositorio de Symfony (Proxy casi seguro...)

definición CompilerPass


    /**
     * Builds bundle.
     *
     * @param ContainerBuilder $container Container
     */
    public function build(ContainerBuilder $container)
    {
        parent::build($container);

        $container->addCompilerPass(new CompilerPass1());
        $container->addCompilerPass(new CompilerPass2());
    }
  • No sobreescribamos el método build() entero solo para añadir nuestros compilerpass
  • BaseBundle tiene un método para ello

    /**
     * Return a CompilerPass instance array.
     *
     * @return CompilerPassInterface[]
     */
    public function getCompilerPasses()
    {
        return [
            new CompilerPass1(),
            new CompilerPass2(),
        ];
    }

Dependencias

Un bundle es un paquete autosuficiente

¿Alguien se lo cree?

¿Quién ha inyectado alguna vez el servicio @router?

  • Si instancio mi bundle, cuyos servicios necesitan inyectar @router... Necesito "si o si" instanciar FrameworkBundle
  • Al concepto "si o si" se le llama comunmente dependencia
  • Volvemos a Symfony 2.0 con su estupendo motor de dependencias... ¡el archivo deps!
  • Composer resuelve las dependencias de la mera existencia del paquete, por lo que framework-bundle DEBE estar en composer.yml
  • ¿Como solucionamos el hecho que cada bundle exponga sus dependencias a nivel de Kernel?

Adivinad qué pasó...

  • Un bundle, ahora mismo, NO es algo autosuficiente, por lo que algún mecanismo debe solucionar este problema
  • El repositorio Symfony Bundle Dependencies soluciona tanto la parte de dependencias de bundles, como la resolución por parte del Kernel
  • github.com/mmoreram/symfony-bundle-dependencies
  • Cualquier bundle que extienda BaseBundle puede definir sus dependencias (por defecto, vacío)

    /**
     * Create instance of current bundle, and return dependent bundle namespaces.
     *
     * @return array Bundle instances
     */
    public static function getBundleDependencies(KernelInterface $kernel)
    {
        return [];
    }

    /**
     * Create instance of current bundle, and return dependent bundle namespaces.
     *
     * @return array Bundle instances
     */
    public static function getBundleDependencies(KernelInterface $kernel)
    {
        return [
            'Another\Bundle',
            'Even\Another\Bundle',
        ];
    }
  • Clase Bundle
  • Extensión
  • CompilerPass
  • Desacoplando
    
    $configuration = new Configuration();
    $config = $this->processConfiguration($configuration, $config);
    
    /**
     * Setting all config elements as DI parameters to inject them
     */
    $container->setParameter(
        'my.bundle.service_provider',
        $config['service_provider']
    );

    $loader = new YamlFileLoader(
        $container,
        new FileLocator(__DIR__ . '/../Resources/config')
    );

    /**
     * Loading DI definitions
     */
    $loader->load('classes.yml');
    $loader->load('services.yml');
    $loader->load('commands.yml');
  • 1 método, mucha responsabilidad
  • Culpable de la pereza de hacer un bundle
  • No tiene buena relación complejidad/impacto
  • Muy habitualmente hacemos siempre lo mismo
    
    use Mmoreram\BaseBundle\DependencyInjection\BaseExtension;
    
    /**
     * This is the class that loads and manages your bundle configuration
     */
    class MyExtension extends BaseExtension
    {

    }
    
    /**
     * Returns the recommended alias to use in XML.
     *
     * This alias is also the mandatory prefix to use when using YAML.
     *
     * @return string The alias
     *
     * @api
     */
    public function getAlias()
    {
        return 'app';
    }
    
    /**
     * Return a new Configuration instance.
     *
     * If object returned by this method is an instance of
     * ConfigurationInterface, extension will use the Configuration to read all
     * bundle config definitions.
     *
     * Also will call getParametrizationValues method to load some config values
     * to internal parameters.
     *
     * @return ConfigurationInterface Configuration file
     */
    protected function getConfigurationInstance()
    {
        return new Configuration();
    }
    
    /**
     * Get the Config file location.
     *
     * @return string Config file location
     */
    protected function getConfigFilesLocation()
    {
        return __DIR__ . '/../Resources/config';
    }
    
    /**
     * Config files to load.
     *
     * Each array position can be a simple file name if must be loaded always,
     * or an array, with the filename in the first position, and a boolean in
     * the second one.
     *
     * As a parameter, this method receives all loaded configuration, to allow
     * setting this boolean value from a configuration value.
     *
     * return array(
     *      'file1',
     *      'file2',
     *      ['file3', $config['my_boolean'],
     *      ...
     * );
     *
     * @param array $config Config definitions
     *
     * @return array Config files
     */
    protected function getConfigFiles(array $config)
    {
        return [
            'services',
            'commands',
            'controllers',
        ];
    }
    
    /**
     * Load Parametrization definition.
     *
     * return array(
     *      'parameter1' => $config['parameter1'],
     *      'parameter2' => $config['parameter2'],
     *      ...
     * );
     *
     * @param array $config Bundles config values
     *
     * @return array Parametrization values
     */
    protected function getParametrizationValues(array $config)
    {
        return [
            'my.bundle.service_provider' => $config['service_provider'],
        ];
    }

¿Cuantos inyectáis parámetros en vuestros servicios?

¡OJO basurita!

  • En caso que compartáis el bundle, nadie os asegura que el valor del parámetro sea bueno
  • Si el bundle requiere que el proyecto final defina un parámetro, éste debe validarlo
  • Y esto, queridos amigos, se hace en el desconocido archivo Configuration
    
    /**
     * Load Parametrization definition.
     *
     * return array(
     *      'parameter1' => $config['parameter1'],
     *      'parameter2' => $config['parameter2'],
     *      ...
     * );
     *
     * @param array $config Bundles config values
     *
     * @return array Parametrization values
     */
    protected function getParametrizationValues(array $config)
    {
        return [
            'my.bundle.service_provider' => $config['service_provider'],
        ];
    }
  • Clase Bundle
  • Extensión
  • CompilerPass
  • Desacoplando
  • Un CompilerPass, entre otras cosas permite hacer búsqueda por tags
  • Hay un caso bastante habitual, cuando queremos añadir un set de servicios que implementan la misma interface a otra clase del tipo colector
  • Por ejemplo una clase que agrupa a todos los shipping providers y itera sobre ellos para determinar cual es el primero que puede actuar

    use Symfony\Component\DependencyInjection\ContainerBuilder;
    use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
    use Symfony\Component\DependencyInjection\Reference;
    
    class MailTransportPass implements CompilerPassInterface
    {
        public function process(ContainerBuilder $container)
        {
            // always first check if the primary service is defined
            if (!$container->has('app.mailer_transport_chain')) {
                return;
            }
    
            $definition = $container->findDefinition('app.mailer_transport_chain');
    
            // find all service IDs with the app.mail_transport tag
            $taggedServices = $container->findTaggedServiceIds('app.mail_transport');
    
            foreach ($taggedServices as $id => $tags) {
                // add the transport service to the ChainTransport service
                $definition->addMethodCall('addTransport', array(new Reference($id)));
            }
        }
    }
  • Siempre, exactamente siempre, lo mismo
  • Un método que hace muchas cosas
  • Podemos utilizar AbstractTagCompilerPass, pensado para que solo definas los tres valores imprescindibles para dicha acción

    use Mmoreram\BaseBundle\CompilerPass\TagCompilerPass;


    /**
     * Class FeederCompilerPass.
     */
    final class FeederCompilerPass extends TagCompilerPass
    {
    
    }

    /**
     * Get collector service name.
     *
     * @return string Collector service name
     */
    public function getCollectorServiceName()
    {
        return 'my.collector.service';
    }

    /**
     * Get collector method name.
     *
     * @return string Collector method name
     */
    public function getCollectorMethodName()
    {
        return 'addClass';
    }

    /**
     * Get tag name.
     *
     * @return string Tag name
     */
    public function getTagName()
    {
        return 'my.tag';
    }
  • Clase Bundle
  • Extensión
  • CompilerPass
  • Desacoplando
  • ¿Que pasa cuando nuestro bundle contiene una capa de servicios que queremos compartir?
  • ¿Tenemos claro exactamente qué es un bundle?

Bundle

App Symfony

¿Que pasa cuando alguien depende de nosotros?

Bundle

App Symfony

LIbrería externa PHP

  • Una simple librería PHP tendría como dependencia un Bundle y sus dependencias
  • No tiene sentido, solo quiere unas clases PHP
  • Conceptualmente un Bundle es la forma que tenemos de exponer nuestro código PHP al framework Symfony
  • Debemos convertir nuestro esquema de 2 actores a uno de 3

Librería PHP

Bundle

App Symfony

LIbrería externa PHP

Bundle externo

Librería PHP

Bundle

App Symfony

Transformación

  • En un bundle se pone todo lo necesario para que la librería PHP creada se pueda exponer al framework

  • La clase Bundle

  • Los mappings de Doctrine

  • Las clases para el Dependency Injection (Extension, CompilerPass, Configuration)

  • Los archivos yml de configuración

  • En un componente ponemos todo lo que depende de librerías PHP y no es exclusivo de Symfony Framework

  • Esto incluye clases, managers, entidades, factories, controladores, comandos...

  • La clase Bundle, aún dependiendo de una librería PHP (HttpKernel), solo es funcional en el Framework

  • Solo es útil cuando
    • Se trabaja con proyectos FOS. Se suele crear organizaciones en Github y se publican ambos
    • Se traslada la mentalidad FOS a un scope más reducido (una empresa)
    • Se espera que haya más integraciones de la librería PHP que la de Symfony (Laravel, Drupal)
  • Hay mucho que hacer aún en cuanto a Bundles se refiere
  • Cuando uno trabaja con un Framework es importante que conozca algunos de sus puntos críticos
  • Os animo a que dediquéis tiempo a comprender qué hay detrás de cierta magia y perdáis el miedo

Conclusiones

  • github.com/mmoreram
  • twitter.com/mmoreram
  • yuhu@mmoreram.com

¡Gracias!

Bundles

By Marc Morera Merino

Bundles

Buenas prácticas para crear Bundles de alta calidad

  • 610
Loading comments...