Symfony - Componentes

Conforme discutido anteriormente, os componentes do Symfony são uma biblioteca PHP autônoma que fornece um recurso específico, que pode ser usado em qualquer aplicativo PHP. Novos componentes úteis estão sendo introduzidos em cada versão do Symfony. Atualmente, existem mais de 30 componentes de alta qualidade no framework Symfony. Vamos aprender sobre o uso de componentes Symfony neste capítulo.

Instalando um componente Symfony

Os componentes do Symfony podem ser instalados facilmente usando o comando composer. O seguinte comando genérico pode ser usado para instalar qualquer componente Symfony.

cd /path/to/project/dir 
composer require symfony/<component_name>

Vamos criar um aplicativo php simples e tentar instalar Filesystem componente.

Step 1 - Crie uma pasta para o aplicativo, filesystem-example

cd /path/to/dev/folder 
mdkir filesystem-example 
cd filesystem-example

Step 2 - Instale o componente Filesystem usando o seguinte comando.

composer require symfony/filesystem

Step 3 - Crie um arquivo main.php e digite o seguinte código.

<?php 
   require_once __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Filesystem\Filesystem; 
   use Symfony\Component\Filesystem\Exception\IOExceptionInterface; 
   
   $fs = new Filesystem(); 
   try { 
      $fs->mkdir('./sample-dir'); 
      $fs->touch('./sample-dir/text.txt'); 
   } catch (IOExceptionInterface $e) { 
      echo $e; 
   } 
?>

A primeira linha é muito importante, pois carrega todas as classes necessárias de todos os componentes instalados usando o comando Composer. As próximas linhas usam a classe Filesystem.

Step 4 - Execute o aplicativo usando o seguinte comando e ele criará uma nova pasta sample-dir e um arquivo test.txt sob ele.

php main.php

Detalhes dos componentes Symfony

Symfony fornece componentes que variam de recursos simples, como sistema de arquivos, a recursos avançados, como eventos, tecnologia de contêiner e injeção de dependência. Informe-nos sobre todos os componentes, um por um, nas seções a seguir.

Sistema de arquivo

O componente do sistema de arquivos fornece um comando básico do sistema relacionado a arquivos e diretórios, como criação de arquivos, criação de pastas, existência de arquivos, etc. O componente do sistema de arquivos pode ser instalado usando o seguinte comando.

composer require symfony/filesystem

Localizador

O componente Finder fornece classes fluentes para localizar arquivos e diretórios em um caminho especificado. Ele fornece uma maneira fácil de iterar os arquivos em um caminho. O componente Finder pode ser instalado usando o seguinte comando.

composer require symfony/finder

Console

O componente Console oferece várias opções para criar comandos facilmente, que podem ser executados em um terminal. Symfony usa oCommand componente extensivamente para fornecer várias funcionalidades, como a criação de um novo aplicativo, a criação de um pacote, etc. Até mesmo o PHP construído no servidor web pode ser invocado usando o comando Symfony, php bin/console server:runcomo visto na seção de instalação. oConsole componente pode ser instalado usando o seguinte comando.

composer require symfony/console

Vamos criar um aplicativo simples e criar um comando, HelloCommand usando o Console componente e invocá-lo.

Step 1 - Crie um projeto usando o seguinte comando.

cd /path/to/project 
composer require symfony/console

Step 2 - Crie um arquivo main.php e inclua o código a seguir.

<?php 
   require __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Console\Application; 
   
   $app = new Application(); 
   $app->run(); 
?>

Application classe configura a funcionalidade necessária de um aplicativo de console básico.

Step 3 - Execute o aplicativo, php main.php, que produzirá o seguinte resultado.

Console Tool  
Usage: 
   command [options] [arguments]  
Options: 
   -h, --help            Display this help message 
   -q, --quiet           Do not output any message 
   -V, --version         Display this application version 
         --ansi            Force ANSI output 
         --no-ansi         Disable ANSI output 
   -n, --no-interaction  Do not ask any interactive question 
   -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 
      2 for more verbose output and 3 for debug  
Available commands: 
   help  Displays help for a command 
   list  Lists commands

Step 4 - Crie uma classe chamada HelloCommand estendendo Command classe no main.php em si.

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

class HelloCommand extends Command { 
}

O aplicativo usa as seguintes quatro classes disponíveis em Command componente.

• Command - Usado para criar um novo comando

• InputInterface - Usado para definir as entradas do usuário

• InputArgument - Usado para obter entradas do usuário

• OutputInterface - Usado para imprimir a saída para o console

step 5 - Crie uma função configure() e defina o nome, a descrição e o texto de ajuda.

protected function configure() { 
   $this 
      ->setName('app:hello') 
      ->setDescription('Sample command, hello') 
      ->setHelp('This command is a sample command') 
}

step 6 - Crie um argumento de entrada, user para o comando e definido como obrigatório.

protected function configure() { 
   $this 
      ->setName('app:hello') 
      ->setDescription('Sample command, hello') 
      ->setHelp('This command is a sample command') 
      ->addArgument('name', InputArgument::REQUIRED, 'name of the user'); 
}

step 7 - Crie uma função execute() com dois argumentos InputArgument e OutputArgument.

protected function execute(InputInterface $input, OutputInterface $output) { 
}

step 8 - Use InputArgument para obter os detalhes do usuário inseridos pelo usuário e imprimi-los no console usando OutputArgument.

protected function execute(InputInterface $input, OutputInterface $output) { 
   $name = $input->getArgument('name'); 
   $output->writeln('Hello, ' . $name); 
}

step 9 - Cadastre o HelloCommand no aplicativo usando o add método de Application classe.

$app->add(new HelloCommand());

O aplicativo completo é o seguinte.

<?php 
   require __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Console\Application; 
   use Symfony\Component\Console\Command\Command; 
   use Symfony\Component\Console\Input\InputInterface; 
   use Symfony\Component\Console\Output\OutputInterface; 
   use Symfony\Component\Console\Input\InputArgument;  
   
   class HelloCommand extends Command { 
      protected function configure() { 
         $this 
            ->setName('app:hello') 
            ->setDescription('Sample command, hello') 
            ->setHelp('This command is a sample command') 
            ->addArgument('name', InputArgument::REQUIRED, 'name of the user'); 
      }  
      protected function execute(InputInterface $input, OutputInterface $output) { 
         $name = $input->getArgument('name'); 
         $output->writeln('Hello, ' . $name);
      }  
      $app = new Application(); 
      $app->add(new HelloCommand()); 
      $app->run(); 
   }         
?>

Step 10 - Agora, execute o aplicativo usando o seguinte comando e o resultado será Olá, Jon como o esperado.

php main.php app:hello Jon

Symfony vem com um binário pré-construído chamado console no diretório bin de qualquer aplicativo da web Symfony, que pode ser usado para invocar os comandos em um aplicativo.

Processo

O componente de processo fornece opções para executar qualquer comando do sistema em um subprocesso, de maneira segura e eficiente. O componente do processo pode ser instalado usando o seguinte comando.

composer require symfony/process

ClassLoader

O componente ClassLoader fornece implementação para ambos PSR-0 e PSR-4padrão do carregador de classes. Ele pode ser usado para carregar automaticamente as classes. Será depreciado em um futuro próximo. O carregador de classes baseado no Composer é preferível a este componente. O componente ClassLoader pode ser instalado usando o seguinte comando.

composer require symfony/class-loader

PropertyAccess

O componente PropertyAccess oferece várias opções para ler e gravar um objeto e detalhes de array usando a notação de string. Por exemplo, um arrayProduct com chave price pode ser acessado dinamicamente usando [price] corda.

$product = array( 
   'name' => 'Cake' 
   'price' => 10 
);  
var priceObj = $propertyAccesserObj->getValue($product, '[price]');

O componente PropertyAccess pode ser instalado usando o seguinte comando.

composer require symfony/property-access

PropertyInfo

O componente PropertyInfo é semelhante ao componente PropertyAccess, mas funciona apenas com objetos PHP e oferece muito mais funcionalidade.

class Product { 
   private $name = 'Cake'; 
   private $price = 10;  
   
   public function getName() { 
      return $this->name; 
   }  
   public function getPrice() { 
      return $this->price; 
   } 
}  
$class = Product::class; 
$properties = $propertyInfoObj->getProperties($class);  
/* 
   Example Result 
   -------------- 
   array(2) { 
      [0] => string(4) "name" 
      [1] => string(5) "price" 
   } 
*/

O componente PropertyInfo pode ser instalado usando o seguinte comando.

composer require symfony/property-info

EventDispatcher

O componente EventDispatcher fornece uma programação baseada em eventos em PHP. Ele permite que os objetos se comuniquem entre si despachando eventos e ouvindo-os. Aprenderemos como criar eventos e ouvi-los no capítulo Eventos e Listener de eventos.

O componente EventDispatcher pode ser instalado usando o seguinte comando.

composer require symfony/event-dispatcher

Injeção de dependência

O componente DependencyInjection fornece um mecanismo fácil e eficiente para criar um objeto com sua dependência. Quando um projeto cresce, ele apresenta muitas classes com dependência profunda, que precisam ser tratadas corretamente. Caso contrário, o projeto falha. DependencyInjection fornece um contêiner simples e robusto para lidar com a dependência. Aprenderemos sobre os containers e o conceito de injeção de dependência no capítulo Service Container.

O componente DependencyInjection pode ser instalado usando o seguinte comando.

composer require symfony/dependency-injection

Serializador

O componente Serializer fornece uma opção para converter um objeto PHP em um formato específico, como XML, JSON, Binary, etc., e então permite convertê-lo de volta em um objeto original sem qualquer perda de dados.

O componente serializador pode ser instalado usando o seguinte comando.

composer require symfony/serializer

Config

O componente Config fornece opções para carregar, analisar, ler e validar configurações do tipo XML, YAML, PHP e ini. Ele fornece várias opções para carregar detalhes de configuração do banco de dados também. Este é um dos componentes importantes úteis na configuração de aplicativos da web de maneira clara e concisa. O componente de configuração pode ser instalado usando o seguinte comando.

composer require symfony/config

ExpressionLanguage

O componente ExpessionLanguage fornece um mecanismo de expressão completo. As expressões são de uma linha com o objetivo de retornar um valor. O mecanismo de expressão permite compilar, analisar e obter facilmente o valor de uma expressão. Ele permite que uma ou mais expressões sejam usadas em um ambiente de configuração (arquivo) por um programador não PHP, digamos um administrador de sistema. O componente ExpressionLanguage pode ser instalado usando o seguinte comando.

composer require symfony/expression-language

OptionsResolver

O componente OptionsResolver fornece uma maneira de validar o sistema de opções usado em nosso sistema. Por exemplo, a configuração do banco de dados é colocada em uma matriz, dboption com host, nome de usuário, senha, etc., como chaves. Você precisa validar as entradas antes de usá-lo para se conectar a um banco de dados. OptionsResolver simplifica essa tarefa fornecendo uma classe simples OptionsResolver e um resolvedor de método, que resolve a configuração do banco de dados e, se houver algum problema de validação, ele o relatará.

$options = array( 
   'host'     => '<db_host>', 
   'username' => '<db_user>', 
   'password' => '<db_password>', 
);  
$resolver = new OptionsResolver(); 
$resolver->setDefaults(array( 
   'host'     => '<default_db_host>', 
   'username' => '<default_db_user>', 
   'password' => '<default_db_password>', 
)); 
$resolved_options = $resolver->resolve($options);

O componente OptionsResolver pode ser instalado usando o seguinte comando.

composer require symfony/options-resolver

Dotenv

O componente Dotenv oferece várias opções para analisar arquivos .env e a variável definida neles para serem acessíveis via getenv(), $_ENV, ou $_SERVER. O componente Dotenv pode ser instalado usando o seguinte comando.

composer require symfony/dotenv

Cache

O componente de cache fornece uma extensão PSR-6implementação. Ele pode ser usado para adicionar funcionalidade de cache ao nosso aplicativo da web. Uma vez que seguePSR-6, é fácil de começar e pode ser facilmente usado no lugar de outro componente de cache baseado em PSR-6. O componente de cache pode ser instalado usando o seguinte comando.

composer require symfony/cache

Intl

O componente Intl é a biblioteca de substituição para a extensão C Intl. O componente internacional pode ser instalado usando o seguinte comando.

composer require symfony/intl

Tradução

O componente de tradução oferece várias opções para internacionalizar nosso aplicativo. Normalmente, os detalhes da tradução de diferentes idiomas serão armazenados em um arquivo, um arquivo por idioma, e será carregado dinamicamente durante o tempo de execução do aplicativo. Existem diferentes formatos para escrever um arquivo de tradução. O componente de tradução oferece várias opções para carregar qualquer tipo de formato, como arquivo PHP simples, CSV, ini, Json, Yaml, arquivo de recursos ICU, etc. O componente de tradução pode ser instalado usando o seguinte comando.

composer require symfony/translation

Fluxo de Trabalho

O componente de fluxo de trabalho fornece ferramentas avançadas para processar uma máquina de estado finito. Ao fornecer essa funcionalidade de uma forma simples e orientada a objetos, o componente Workflow permite a programação avançada em PHP com relativa facilidade. Aprenderemos sobre isso em detalhes no capítulo Conceito avançado.

O componente de fluxo de trabalho pode ser instalado usando o seguinte comando.

composer require symfony/workflow

Yaml

O componente Yaml fornece uma opção que analisa o formato de arquivo YAML e o converte em matrizes PHP. Ele também é capaz de escrever arquivos YAML a partir de um array php simples. O componente Yaml pode ser instalado usando o seguinte comando.

composer require symfony/yaml

Ldap

O componente Ldap fornece classes PHP para se conectar a um servidor LDAP ou Active Directory e autenticar o usuário nele. Ele oferece uma opção de conexão a um controlador de domínio do Windows. O componente Ldap pode ser instalado usando o seguinte comando.

composer require symfony/ldap

Depurar

O componente de depuração oferece várias opções para habilitar a depuração no ambiente PHP. Normalmente, a depuração do código PHP é difícil, mas o componente de depuração fornece classes simples para facilitar o processo de depuração e torná-lo limpo e estruturado. O componente de depuração pode ser instalado usando o seguinte comando.

composer require symfony/debug

Cronômetro

O componente Stopwatch fornece a classe Stopwatch para criar o perfil de nosso código PHP. Um uso simples é o seguinte.

use Symfony\Component\Stopwatch\Stopwatch; 
$stopwatch = new Stopwatch(); 
$stopwatch->start('somename');  

// our code to profile 
$profiled_data = $stopwatch->stop('somename');  
echo $profiled_data->getPeriods()

O componente do cronômetro pode ser instalado usando o seguinte comando.

composer require symfony/stopwatch

VarDumper

O componente VarDumper fornece melhor dump()função. Basta incluir o componente VarDumper e usar a função de despejo para obter a funcionalidade aprimorada. O componente VarDumper pode ser instalado usando o seguinte comando.

composer require symfony/var-dumper

BrowserKit

O componente BrowserKit fornece uma interface de cliente de navegador abstrata. Ele pode ser usado para testar o aplicativo da web programaticamente. Por exemplo, ele pode solicitar um formulário, inserir os dados de amostra e enviá-los para localizar qualquer problema no formulário de forma programática. O componente BrowserKit pode ser instalado usando o seguinte comando.

composer require symfony/browser-kit

Ponte PHPUnit

O componente PHPUnit Bridge oferece muitas opções para melhorar o ambiente de teste do PHPUnit. O componente PHPUnit Bridge pode ser instalado usando o seguinte comando.

composer require symfony/phpunit-bridge

De ativos

O componente de ativos fornece uma manipulação de ativos genérica em um aplicativo da web. Ele gera URL para os ativos como CSS, HTML, JavaScript e também realiza manutenção de versão. Verificaremos o componente do ativo em detalhes no capítulo View Engine. O componente ativo pode ser instalado usando o seguinte comando.

composer require symfony/asset

CssSelector

O componente CssSelector fornece uma opção para converter seletores baseados em CSS em expressão XPath. Um desenvolvedor da web conhece a expressão Seletores baseada em CSS mais do que a expressão XPath, mas a expressão mais eficiente para encontrar um elemento em um documento HTML e XML éXPath Expression.

CssSelector permite que o desenvolvedor escreva a expressão em Seletores CSS , no entanto, o componente a converte em expressão XPath antes de executá-la. Assim, o desenvolvedor tem como vantagem a simplicidade dos seletores CSS e a eficiência da expressão XPath.

O componente CssSelector pode ser instalado usando o seguinte comando.

composer require symfony/css-selector

DomCrawler

O componente DomCrawler fornece várias opções para localizar o elemento em um documento HTML e XML usando o conceito DOM. Ele também fornece a opção de usar a expressão XPath para localizar um elemento. O componente DomCrawler pode ser usado junto com o componente CssSelector para usar seletores CSS em vez da expressão XPath. O componente DomCrawler pode ser instalado usando o seguinte comando.

composer require symfony/dom-crawler

Formato

O componente Form permite a fácil criação de formulários em um aplicativo da web. Aprenderemos a programação de formulários em detalhes no capítulo Formulários. O componente de formulário pode ser instalado usando o seguinte comando.

composer require symfony/form

HttpFoundation

O componente HttpFoundation fornece uma camada orientada a objetos para a especificação HTTP. Por padrão, o PHP fornece detalhes de solicitação e resposta HTTP como objeto baseado em array, como$_GET, $_POST, $_FILES, $_SESSION, etc. A funcionalidade baseada em HTTP, como a configuração de um cookie, pode ser feita usando uma função simples e antiga setCookie(). HttpFoundation fornece todas as funcionalidades relacionadas ao HTTP em um pequeno conjunto de classes, como Request, Response, RedirectResponse, etc., aprenderemos sobre essas classes nos capítulos posteriores.

O componente HttpFoundation pode ser instalado usando o seguinte comando.

composer require symfony/http-foundation

HttpKernel

O componente HttpKernel é o componente principal na configuração da Web do Symfony. Ele fornece todas as funcionalidades necessárias para uma aplicação web - desde o recebimento doRequest objeto de enviar de volta o Responseobjeto. A arquitetura completa do aplicativo da web Symfony é fornecida pelo HttpKernel conforme discutido na arquitetura de um framework da web Symfony.

O componente HttpKernel pode ser instalado usando o seguinte comando.

composer require symfony/http-kernel

Encaminhamento

O componente de roteamento mapeia a solicitação HTTP para um conjunto predefinido de variáveis ​​de configuração. O roteamento decide qual parte de nosso aplicativo deve lidar com uma solicitação. Aprenderemos mais sobre o roteamento no capítulo Roteamento.

O componente de roteamento pode ser instalado usando o seguinte comando.

composer require symfony/filesystem

Templating

O componente de modelagem fornece a infraestrutura necessária para construir um sistema de template eficiente. Symfony usa o componente Templating para sua implementação do View engine. Aprenderemos mais sobre o componente Templating no capítulo View engine.

O componente de modelagem pode ser instalado usando o seguinte comando.

composer require symfony/templating

Validador

O componente Validator fornece uma implementação de JSR-303 Bean Validation Specification. Ele pode ser usado para validar um formulário em um ambiente web. Aprenderemos mais sobre o Validador no capítulo Validação.

O componente validador pode ser instalado usando o seguinte comando.

composer require symfony/validator

Segurança

O componente de segurança fornece um sistema de segurança completo para nosso aplicativo da web, seja autenticação HTTP básica, autenticação HTTP digest, autenticação baseada em formulário interativo, login de certificação X.509, etc. Ele também fornece mecanismo de autorização baseado na função do usuário através do sistema ACL embutido . Aprenderemos mais detalhes no capítulo Conceito avançado.

O componente de segurança pode ser instalado usando o seguinte comando.

composer require symfony/security