Symfony

Como criar recipes do Symfony Flex e enviar para o repositório

O Symfony Flex facilita a instalação de dependências na aplicação. Ele faz isso usando uma “receita” ou em inglês recipe que indica quais ações ele deve realizar no projeto. Essa receita fica armazenada dentro dos repositórios do Symfony Flex que pode ser o repositório oficial, da própria comunidade chamado repositório contrib ou repositórios privados.

Antes de iniciar a criação do recipe aconselho realizar a leitura do post Como criar repositórios privados do Symfony Flex, pois alguns conceitos são explicados nele.

Nesse post vamos aprender como criar recipes dos nossos próprios bundles, validar e enviar para o repositório, seja ele o repositório disponível para comunidade (contrib) ou um repositório privado, já que o processo basicamente é o mesmo.

Curso de
CONHEÇA O CURSO

Ações possíveis

O Symfony Flex possui um conjunto de ações que podemos inserir na receita para que ele possa executar no projeto onde a dependência foi instalada:

  • bundles configurator – configura entradas no arquivo de bundles da aplicação
  • container configurator – configura entradas no container da aplicação
  • copy-from-package configurator – copia pastas e arquivos do repositório para a aplicação
  • copy-from-recipe configurator – copia pastas e arquivos do recipe para a aplicação
  • env configurator – Adiciona entradas no arquivo de configuração de ambiente .env
  • composer-scripts configurator – registra scripts no arquivo composer.json
  • gitignore configurator – Adiciona entradas no arquivo de configuração .gitignore
  • post-install-output configurator – Permite definir informações que serão exibidas no console ao final do processo de configuração do Flex

Essas ações são definidas dentro de um arquivo JSON que será lido pelo Flex.

Estrutura de pastas de um recipe

A primeira coisa que precisamos nos preocupar quando vamos criar um recipe é a estrutura de pastas. A leitura do recipe pelo Flex depende que ele possua um padrão de pastas envolvendo o nome do fornecedor, bundle e versão mínima. Essas informações são retiradas do packagist.org, veja o exemplo abaixo:

Se formos criar um recipe para o bundle acima precisamos definir a seguinte estrutura de pastas:

elton-fonseca/empty-symfony-bundle/1.0

No caso acima, estamos informando que esse recipe deve ser usado da versão 1.0.0 em diante do nosso bundle.

Criando o primeiro recipe

Vamos agora criar nosso primeiro recipe. Crie a seguinte estrutura de pastas dentro de um local qualquer do seu computador:

Agora precisamos criar um arquivo chamado manifest.json onde devemos colocar todas as ações que o Flex deve fazer.

Vamos testar algumas das ações possíveis quando estamos trabalhando com Flex. No arquivo criado anteriormente insira o seguinte conteúdo:

{
    "env": {
        "TREINAWEB": "cursos"
    },
    "copy-from-package": {
        "Treinaweb.php": "%SRC_DIR%/Treinaweb.php"
    },
    "copy-from-recipe": {
        "config/": "%CONFIG_DIR%/"
    },
    "aliases": ["treinaweb", "treinaweb-recipe"]
}

É importante deixar uma quebra de linha no final do arquivo, caso contrário o validador do Flex da erro na hora de enviar

Primeiro declaramos que o flex deve adicionar uma nova entrada no arquivo .env do projeto com chave TREINAWEB e valor cursos.

"env": {
    "TREINAWEB": "cursos"
},

Em seguida falamos para o flex copiar um arquivo que está dentro do bundle para a pasta SRC do projeto que está instalando a dependência:

"copy-from-package": {
    "Treinaweb.php": "%SRC_DIR%/Treinaweb.php"
},

Na última ação pedimos para ele copiar uma pasta chamada config do recipe para a pasta do projeto:

"copy-from-recipe": {
    "config/": "%CONFIG_DIR%/"
},

Crie dentro da mesma pasta onde está o arquivo manifest.json uma pasta chamada config com um arquivo de exemplo chamado treinaweb.yaml. Dentro do arquivo coloque apenas um comentário:

#arquivo de teste

É importante deixar uma quebra de linha no final do arquivo, caso contrário o validador do Flex da erro na hora de enviar

Conforme vimos anteriormente além das ações mostradas neste exemplo é possível realizar outras. Você pode consultar todas as ações possíveis no repositório oficial da equipe do Symfony.

Clonando o repositório na máquina local

Independente se enviará seu recipe para um repositório privado ou público, a primeira coisa que precisa fazer é clonar o repositório. Vamos usar como exemplo o repositório privado criado no post sobre esse assunto citado no início do artigo:

Para clonar o repositório vamos usar a linha de comandos. Se estiver usando Windows aconselho o Power Shell, se estiver usando Linux ou MacOS pode usar o terminal padrão sem problemas. Execute o comando para clonar:

git clone https://github.com/elton-fonseca/flex-private-repository.git

Entre na pasta flex-private-repository com o comando:

cd flex-private-repository

Agora precisamos criar uma nova branch no repositório que clonamos. Através dessa branch podemos criar um pedido para que nosso recipe seja validado e integrado ao repositório. Execute o comando:

git checkout -b new-recipe
Curso de
CONHEÇA O CURSO

Enviando o recipe para o repositório

Agora dentro da pasta onde clonou o repositório faça a cópia da pasta do recipe que criamos, representada pelo nome do fornecedor do pacote.

Precisamos enviar essas alterações para o servidor do Github. Execute os comandos:

git add .

git commit -m "adicionar um novo recipe"

git push origin new-recipe

Precisamos dizer ao Github que desejamos que as alterações realizadas no branch novo sejam adicionadas ao branch principal. Ao acessar o repositório no Github automaticamente ele te dirá que enviou um branch se deseja unir a outro:

No nosso caso precisamos unir o novo branch ao master, clique no botão conforme abaixo para realizar esse pedido:

Uma vez que envia o pedido automaticamente, o robô do Symfony Flex faz a validação do conteúdo do seu recipe. Se tudo for aprovado basta clicar Merge Pull Request:

Ao voltar na página inicial do repositório verá que a pasta do recipe já está no branch master:

Testando o recipe

Acesse uma aplicação gerenciada pelo Symfony Flex com código de projeto inserido no repositório, caso seja um repositório privado, e execute o comando para instalação do nosso bundle:

composer install elton-fonseca/empty-symfony-bundle

Ao instalar o pacote no seu projeto automaticamente serão executadas as ações do recipe:

Ao verificar as diferenças no projeto depois da execução verá que as ações foram executadas corretamente:

  • Copiou o arquivo do recipe para a pasta de configuração
  • Copiou o arquivo do bundle para a pasta SRC
  • Adicionou um novo valor no arquivo de env

Isso indica que nosso recipe foi criado corretamente.

Como criar repositórios privados do Symfony Flex

O Symfony Flex possui 2 repositórios públicos onde ele busca os recipes. O primeiro é o repositório oficial onde ficam as recipes da própria equipe do Symfony. O segundo é o repositório contrib onde o pessoal da comunidade envia as recipes que são usadas para bundles públicos que não são oficiais.

Quando precisamos criar recipes para automatizar tarefas em bundles que serão usados apenas em projetos privados, os dois repositórios anteriores não são aplicáveis. Nesses casos podemos criar os nossos próprios repositórios privados para armazenar nossas recipes.

Curso de
CONHEÇA O CURSO

Como criar o repositório privado

O repositório privado do Symfony Flex, na verdade, é um repositório comum Git hospedado no GitHub e integrado ao robô de verificação da equipe do Symfony. O repositório no GitHub pode ser público ou privado, em ambos os casos o recipe será reconhecido, porém já que estamos criando um repositório privado do Flex faz mais sentido o repositório do GitHub também ser privado.

No início de 2019 o GitHub passou a permitir a criação de repositórios privados ilimitados nas contas pessoais gratuitamente, mais informações https://github.blog/2019-01-07-new-year-new-github/

Vamos criar um novo repositório privado no GitHub. Uma vez logado acesse o endereço https://github.com/new e preencha as informações conforme abaixo:

Integrando o repositório do GitHub com o Flex

Agora precisamos indicar ao Symfony Flex que ele deve validar e ler os recipes que colocamos dentro do repositório que acabamos de criar. Isso é feito através de uma integração com o GitHub, acesse o endereço https://github.com/apps/symfony-flex-server/installations/new e selecione a conta que está o repositório que criamos no passo anterior:

Ele vai confirmar sua senha do GitHub e perguntar se você deseja adicionar todos os repositórios da sua conta como repositório do Flex ou apenas 1. Aconselho indicar somente os repositórios que realmente serão usados como repositórios do Symfony Flex:

Depois de clicar em instalar ele apresentará uma tela de congratulations, vamos falar dos passos explicados nessa tela mais adiante.

Formação:
CONHEÇA A FORMAÇÃO

Como liberar os projetos que podem acessar o repositório

Como nós temos um repositório privado é importante que apenas os projetos autorizados consigam utilizar nossos recipes. Para isso nós geramos um identificador único de cada projeto e configuramos dentro do nosso repositório.

Na aplicação Symfony que utiliza o Flex para gerenciamento, execute o comando abaixo:

composer symfony:generate-id

Esse comando não retorna nenhuma mensagem no console. Ele realiza a criação de um identificador do seu projeto dentro do arquivo composer.json na sessão extra.symfony.id:

"extra": {
    "symfony": {
        "allow-contrib": false,
        "require": "4.3.*",
        "id": "01DFEFJHVTGS3PAR3J1K2HB60T"
    }
}

Agora precisamos configurar esse id no repositório junto com todos outros projetos que terão acesso aos recipes. Esse conteúdo é definido dentro do arquivo config.json na raiz do projeto com o seguinte padrão:

{
  "projects": {
    "id1": "descriçao do projeto 1",
    "id2": "descriçao do projeto 2",
    "id3": "descriçao do projeto 3"
  }
}

Crie o arquivo na raiz do repositório:

Como enviar os recipes

Precisamos enviar os recipes que vamos usar em nossos projetos para o repositório. O processo para criação e envio do recipe é o mesmo usado para o repositório de contrib do Symfony.

Vamos ver como criar um recipe e como enviar para o repositório no próximo post.

O que é o Symfony Flex e como ele funciona

O Symfony é um dos frameworks mais utilizados na linguagem PHP. Ele possui grande importância no ecossistema, pois além da utilização direta do framework, diversas outras ferrramentas e até frameworks utilizam seus componentes como base de desenvolvimento. Mesmo com tanta relevância o Symfony não era tão falado na comunidade brasileira, porém com as novidades apresentadas nos últimos tempos ele voltou a ganhar bastante destaque. Inclusive, prova disso é o evento oficial da Symfony que aconteceu em São Paulo.

Formação:
CONHEÇA A FORMAÇÃO

Um dos recursos mais interessantes aprensentados pela equipe do Symfony é o Flex. Ele automatiza o processo de configuração das dependências no momento da instalação. Isso possibilita ao desenvolvedor começar o projeto com o mínimo possível de dependencias, algo parecido com um micro framework, e adicionar novas dependencias de forma muito fluida até chegar a uma estrutura parecida com um framework full stack.

O que é Symfony Flex

O Symfony Flex é um plugin para composer. Ele automatiza os principais processos na hora da criação do projeto e instalação das dependências. Pode ser usado a partir da versão 3.4 do Symfony e passou a ser usado por padrão a partir da versão 4. O Flex altera o comportamento padrão de alguns dos comandos do Composer para permitir a automatização das tarefas de gerenciamento do projeto.

Quando realizamos a instalação de um novo pacote do composer, o Symfony Flex verifica dentro de um repositório próprio se existe alguma automatização correspondente a essa dependência, se existir ele executa as ações definidas.

O que são Recipes

Recipe (receita) é o nome dado ao conjunto de arquivos responsável pela automatização do processo de instalação de uma dependência específica. As instruções são definidas dentro de um arquivo chamado manifest.json que fica dentro do repositório do Flex, veja um exemplo abaixo:

{
    "bundles": {
        "Symfony\Bundle\DebugBundle\DebugBundle": ["dev", "test"]
    },
    "copy-from-recipe": {
        "config/": "%CONFIG_DIR%/"
    }
}

O recipe acima está pedindo para adicionar um novo bundle no arquivo de configuração e copiar a pasta config de dentro do repositório do Symfony Flex para o projeto. Esse arquivo faz parte do recipe de debug https://github.com/symfony/recipes/blob/master/symfony/debug-bundle/4.1/manifest.json

Ao executar essas tarefas, o Flex evita que o desenvolvedor necessite executar manualmente, diminuindo a chance de erro e a complexidade de instalação de novos pacotes.

Curso de
CONHEÇA O CURSO

Repositório de recipes

O Symfony Flex possui 2 repositórios de recipes. O primeiro é o repositório oficial onde somente projetos da equipe do Symfony são colocados:

O segundo é o repositório contrib onde qualquer pessoa pode submeter um recipe para automatizar as configurações do seu bundle.

Ainda é possível criar repositórios privados onde podemos colocar as recipes do Flex que serão usadas somente dentro dos nossos projetos.

Como o Flex cria a estrutura da aplicação Symfony na instalação

Curso de
CONHEÇA O CURSO

Como instalar novas dependências no projeto

Uma vez que temos uma aplicação que utiliza o Flex podemos facilmente instalar novas dependências e se beneficiar das automatizações. O Symfony possui uma página onde podemos consultar todos os recipes tanto oficiais quanto do repositório de contrib https://flex.symfony.com, vamos procurar por twig:

Note que temos vários recipes relacionados ao twig. Vamos instalar o pacote symfony/twig-bundle.

composer require symfony/twig-bundle

Se tudo der certo o resultado final será parecido com esse:

Note que após instalar o pacote do composer no projeto ele executou o recipe. Ao fazer isso o Flex configurou todos os detalhes necessários para o Twig funcionar no seu projeto. Podemos ver isso na prática se olharmos no Git as alterações realizadas:

Apelidos para os pacotes do Flex

Alguns pacotes possuem Aliases (apelidos). Se notar o pacote que instalamos verá que ele possui alguns nomes definidos:

O principal objetivo do alias é facilitar na hora de instalação, podemos fazer simplesmente:

composer require twig

Ou

composer require template

Se estiver dentro de uma aplicação que não utiliza o Flex, o composer não vai encontrar esses pacotes, pois o padrão para identificação de pacotes do composer é nome-vendor/nome-pacote. Usar apelidos só é possível graças ao Symfony Flex e em pacotes que possuem Recipes.

Curso de
CONHEÇA O CURSO

Prefetch e download simultâneo

Quando usamos o Flex ele adiciona 2 funções muito interessantes ao composer:

  • Prefetch – Ele baixa todos os pacotes necessários antes de iniciar a instalação
  • Download Simultâneo – O composer por padrão baixa uma dependência por vez, com uso do Flex ele passar a realizar o download ao mesmo tempo de vários pacotes, tornando mais rápido o processo.

O interessante é que se instalarmos o Flex globalmente no sistema operacional esses 2 recursos passam a ser usados em qualquer projeto, mesmo que não utilize o Symfony. Para instalar o Flex global basta executar:

composer global require symfony/flex 

Conclusão

O Flex torna o gerenciamento das dependências de uma aplicação muito mais simples, rápido e seguro. Uma vez que remove a necessidade de configuração manual por parte do desenvolvedor. Além disso ele ainda conta com uma série de recursos avançados que facilitam o trabalho diário de manutenção de aplicações Symfony.

Principais comandos do Symfony CLI

Quando criamos uma aplicação Symfony automaticamente podemos executar uma série de comandos a partir do arquivo bin/console. Esses comandos são muito úteis no desenvolvimento do nosso projeto, porém ele está limitado ao contexto da aplicação. Baseado nessa dificuldade e outras limitações foi criado um programa de linha de comando que pode ser instalado globalmente na máquina. Ele facilita desde a criação do projeto até tarefas diárias no desenvolvimento.

O utilitário também conta com uma série de recursos para deploy e configuração de aplicações que utilizam o Symfony Cloud, um serviço de nuvem que apresenta uma série de facilidade para a hospedagem de aplicações que utilizam o framework.

Instalando o comando Symfony

A instalação é extremamente simples, independente do sistema operacional que está usando na sua máquina.

Windows: Basta baixar o instalador e executar com todas as opções padrão. Ele fará o download do utilitário e colocará o caminho na variável PATH, permitindo que execute o comando symfony a partir do prompt.

Linux: Ao executar no terminal wget https://get.symfony.com/cli/installer -O - | bash ele fará o download e a instalação. Em seguida precisamos tornar o comando global, para isso podemos mover o arquivo para a pasta de executáveis com o seguinte comando mv $HOME/.symfony/bin/symfony /usr/local/bin/symfony

MacOS: Executar no terminal curl -sS https://get.symfony.com/cli/installer | bash e em seguida mover o arquivo para a pasta de executáveis com o comando mv $HOME/.symfony/bin/symfony /usr/local/bin/symfony

Verificando a instalação

Depois de instalado podemos executar o comando symfony em qualquer terminal que ele exibirá os comandos disponíveis:

Caso queira explorar todos os comandos de forma detalhada execute Symfony --help. Conforme falamos anteriormente, o comando symfony possui uma série de ferramentas específicas para trabalhar com Symfony Cloud, porém no escopo desse artigo vamos explorar apenas os comandos voltados para aplicação local.

Criando o projeto

A primeira coisa que podemos fazer é criar a estrutura do nosso projeto através do comando symfony, ele possui uma sintaxe bem mais simples que a do composer. Para criar a aplicação com estrutura mínima usamos:

symfony new my_project

Se quisermos a aplicação com a estrutura completa web executamos:

symfony new --full my_project

Caso não saiba a diferença entre os 2 tipos de aplicação e a sintaxe de criação de projetos a partir do composer veja: Como criar projeto no Symfony e seu primeiro CRUD.

Curso de
CONHEÇA O CURSO

Servidor de desenvolvimento

A recomendação do Symfony é utilizar o servidor disponível no utilitário de linha de comandos symfony para desenvolvimento. Esse servidor possui suporte a HTTP2, HTTPS, domínio local e outros.

Dentro da pasta da aplicação execute:

symfony server:start

Caso tenha várias versões do PHP na máquina ele pode apresentar um erro ao iniciar o servidor, dependendo das versões instaladas. Nesse caso você pode executar o comando symfony local:php:list ele mostrará qual versão está usando, se precisar mudar basta criar um arquivo chamado .php-version com a versão do PHP desejada.

Caso queira usar certificado local para HTTPS, precisa executar uma única vez o comando:

symfony server:ca:install

Comandos da aplicação

Podemos ainda rodar os comandos da aplicação diretamente pelo utilitário symfony, ao invés de executar o comando php bin/console conseguimos chamar symfony console.

Veja o exemplo abaixo:

symfony console make:form clientType

Esse comando realiza a criação de uma classe específica para trabalhar com componente de formulários. Poderia ser qualquer outro comando disponível no framework.

Verificação de segurança das dependências

Sempre que instalamos dependências em nosso projeto estamos sujeitos a adicionar código com algum tipo de vulnerabilidade. Existem algumas bases de dados que indicam quais dependências e versões dela possuem problemas de segurança. O symfony possui um comando para realizar essa verificação:

symfony security:check

Ele faz a leitura do composer.lock que guarda a versão de todos os itens instalados no seu projeto e te avisa caso algum deles possui falha conhecida.

Executando demais utilitários

O comando symfony ainda nos permite executar outros recursos através dele: composer, php, pecl, pear, php-fpm, php-cgi, php-config e phpdbg.

No caso do composer a principal vantagem é executar o gerenciador de dependências sem limite de memória. Por exemplo:

symfony composer require symfony/maker-bundle --dev

E para os comandos do php a principal vantagem é a execução já na versão do php usada no projeto, versão que pode ser indicada no arquivo .php-version na raiz do projeto.

Curso de
CONHEÇA O CURSO

Conclusão

O comando symfony é uma ferramenta indispensável no ambiente de desenvolvimento. Ela contém um poderoso servidor de desenvolvimento, utilitários que ajudam no dia a dia, além de comandos específicos para trabalhar com Symfony Cloud.

Iniciando com Symfony: Como criar o projeto e seu primeiro CRUD

Caso nunca tenha tido contato com Symfony, antes de iniciar esse artigo aconselho a leitura: O que é o Symfony Framework, nele falamos sobre o padrão estrutural MVC, componentes, ciclo de atualização e suporte, além de outras características.

Uma das principais novidades que o Symfony trouxe a partir da versão 4 é o Flex, que vamos falar em nosso próximo artigo. Ele é um plugin para composer que faz a criação de toda a estrutura do nosso projeto, além facilitar a instalação de novos pacotes. A partir do seu uso é possível de forma muito simples começar com um pequeno projeto e ir “plugando” novos recursos quando necessário. O Flex permitiu ao Symfony unir as características de microframework e framework full stack em um único lugar.

Baseado nessa característica é possível escolher quando vamos criar o projeto entre duas opções. A primeira é a estrutura mínima, com poucas dependências, muito utilizada para APIs e pequenos projetos. A segunda estrutura chamada de website, é uma estrutura mais completa que contém a maioria das dependências necessárias para aplicações web clássicas.

Curso de
CONHEÇA O CURSO

Criando o projeto com estrutura mínima

Quando vamos trabalhar com API, micro serviço ou uma aplicação muito pequena geralmente não precisamos de todos os recursos de uma aplicação web. Nesses casos ao invés de usar um microframework como Slim ou Lumen, podemos usar o Symfony com sua estrutura de base simplificada.

Para realizarmos a criação do projeto precisamos apenas do PHP e do composer instalados na máquina. Ao executarmos o comando abaixo ele fará a criação do projeto:

composer create-project symfony/skeleton nome-do-projeto

Ao abrir o projeto verá que ele possui uma estrutura bem enxuta. E poucas dependências declaradas no composer.json:

"require": {
    "php": "^7.1.3",
    "ext-ctype": "*",
    "ext-iconv": "*",
    "symfony/console": "4.3.*",
    "symfony/dotenv": "4.3.*",
    "symfony/flex": "^1.1",
    "symfony/framework-bundle": "4.3.*",
    "symfony/yaml": "4.3.*"
},

Podemos começar desenvolver nossa aplicação e instalar os pacotes conforme necessário.

Criando o projeto com estrutura website

Quando vamos criar uma aplicação web normalmente precisamos de uma série de recursos específicos, como por exemplo, template engine, forms, gerenciador de assets e outros. Nesse caso podemos usar o projeto que possui todos esses elementos já instalados e pré-configurado por padrão.

Basta executar o comando abaixo:

composer create-project symfony/website-skeleton nome-projeto2

Depois de criado faça uma comparação entre a estrutura dele e o primeiro. Além da própria estrutura, a quantidade de pacotes instalados também é bem maior:

"require": {
    "php": "^7.1.3",
    "ext-ctype": "*",
    "ext-iconv": "*",
    "sensio/framework-extra-bundle": "^5.1",
    "symfony/asset": "4.3.*",
    "symfony/console": "4.3.*",
    "symfony/dotenv": "4.3.*",
    "symfony/expression-language": "4.3.*",
    "symfony/flex": "^1.1",
    "symfony/form": "4.3.*",
    "symfony/framework-bundle": "4.3.*",
    "symfony/http-client": "4.3.*",
    "symfony/intl": "4.3.*",
    "symfony/monolog-bundle": "^3.1",
    "symfony/orm-pack": "*",
    "symfony/process": "4.3.*",
    "symfony/security-bundle": "4.3.*",
    "symfony/serializer-pack": "*",
    "symfony/swiftmailer-bundle": "^3.1",
    "symfony/translation": "4.3.*",
    "symfony/twig-bundle": "4.3.*",
    "symfony/validator": "4.3.*",
    "symfony/web-link": "4.3.*",
    "symfony/yaml": "4.3.*"
},
"require-dev": {
    "symfony/debug-pack": "*",
    "symfony/maker-bundle": "^1.0",
    "symfony/profiler-pack": "*",
    "symfony/test-pack": "*",
    "symfony/web-server-bundle": "4.3.*"
},

Rodando o projeto

Depois de terminar a criação do projeto podemos testar, basta iniciar o servidor embutido do PHP dentro da pasta public:

php -S 127.0.0.1:8080

Já é possível ver a página de boas-vindas do Symphony no endereço http://127.0.0.1:8080

O mais aconselhável é usar o servidor de desenvolvimento através do comando symfony, porém como estamos apenas trabalhando em uma aplicação de exemplo vamos manter assim.

Criando um CRUD de forma prática

O Symfony conta com uma aplicação console que nos ajuda executar as tarefas de desenvolvimento de forma fácil e segura. A partir dela podemos gerar uma série de arquivos na nossa aplicação e até mesmo cadastros completos. No vídeo abaixo, veja como é possível criar um CRUD com as 4 operações básicas do banco de dados usando apenas comandos. Essa ferramenta é muito útil para quem está começando a aprender o Symfony, mas também para automatizar a tarefa em sistemas que possuem muitos cadastros.

O que é Symfony?

Software livre sobre a licença MIT, o Symfony é um Framework web escrito em PHP, lançado em 2005.

Sua comunidade conta com mais de 600.000 desenvolvedores de mais de 120 países, tornando a implementação de novas funcionalidades ao Framework um processo rápido.

É um Framework amplamente conhecido por ter sido um dos primeiros a trabalhar com componentes, possibilitando o reuso do seu código em diversos projetos open sources. Os principais pontos em sua filosofia são:

  • A utilização de melhores práticas de desenvolvimento;
  • A criação de aplicações profissionais, e;
  • A interoperabilidade de aplicações.

Padrão MVC

Utiliza o padrão de projeto MVC, que é basicamente:

  • Model: Parte lógica da aplicação que gerencia o comportamento dos dados. A camada de model apenas tem o necessário para que tudo aconteça, mas não sabe quando irá executar.

  • View: Gerencia a saída gráfica e textual da aplicação ao usuário final, não possuindo a responsabilidade de saber quando vai exibir os dados, apenas como irá exibi-los.

  • Controller: Essa é a camada que sabe quem chamar e quando chamar para executar determinada ação, comandando a visão e o modelo para se alterarem de forma apropriada.

Basicamente, o MVC funciona da seguinte forma:

Ao receber uma requisição, o Controller solicita ao Model as informações necessárias (que provavelmente virão do banco de dados), que as obtém e retorna ao Controller. De posse dessas informações, o Controller as envia para a View que irá renderizá-las.

Vantagens do Symfony

  • Orientado a objetos;
  • Possui ferramentas de depuração;
  • Suporte para ambientes de implantação;
  • Recursos avançados de segurança;
  • Documentação completa e bem explicada;
  • ORM: Fácil integração com Doctrine;
  • Integração com PHPUnit;
  • Versões mantidas por um longo período.
Curso de
CONHEÇA O CURSO

Componentes

Os componentes são um conjunto de bibliotecas PHP desacopladas e reutilizáveis, permitindo que sejam utilizadas em qualquer projeto PHP independentemente do Symfony Framework.

Dentre os vários componentes do Symfony, podemos citar:

  • DependencyInjection – Permite padronizar e centralizar a maneira como os objetos são construídos em sua aplicação;
  • Debug – Fornece ferramentas para facilitar a depuração de código PHP;
  • Form – Fornece ferramentas para facilitar a criação, processamento e reutilização de formulários HTML;
  • Mailer – Ajuda a implementar o envio de e-mails e fornece integração com os principais serviços.

Muitos outros componentes podem ser utilizados para te auxiliar na realização de suas aplicações. A lista de todos os componentes do Symfony você pode acessar neste link.

Os componentes do Symfony são usados nos principais projetos PHP. Alguns projetos importantes que fazem o uso são:

  • Laravel Framework
  • Yii Framework
  • Drupal
  • Joomla
  • Magento

É possível ver a lista completa de projetos que usam componentes do Symfony aqui.

Framework ou Micro-Framework?

A partir da versão 4 o Symfony possui uma ferramenta chamada Flex. Ela realiza a instalação e configuração de pacotes de uma maneira extremamente simples e automática. Isso permite ao desenvolvedor iniciar um projeto com o mínimo de dependências e “plugar” novas funcionalidades quando necessário. Baseado nesse recurso quando vamos instalar o Symfony podemos escolher entre uma aplicação mínima com características de micro-framework ou uma aplicação completa, com características de framework.

Quando usamos a estrutura completa do Symfony temos as principais características de um framework:

  • Completo;
  • Integrado;
  • Padronizado;
  • Fácil de deployar.

Quando usamos a estrutura mínima, podemos citar as seguintes características:

  • Leve;
  • Altamente customizável;
  • “Rápido”;
  • Ideal para cenários com micro-serviços.

Ou seja, desta forma, o Symfony traz o melhor dos dois mundos onde atenderá desde aplicações menores a aplicações mais robustas.

Caso ainda não tenha ficado claro a diferença entre Framework e Micro-Framework, temos aqui no blog dois artigos bem legais sobre o assunto. Basta clicar sobre os links. 🙂

Atualizações e Suporte

O Symfony possui cronogramas muito bem definido de manutenção de correções e suporte para cada uma das versões lançadas. Isso garante uma segurança maior, principalmente para projetos corporativos.

As versões comuns contam com 6 meses de suporte a correções e 1 ano de suporte de segurança, enquanto as versões LTS (long term support) 3 anos de suporte para correção e 4 anos de suporte para segurança, sendo a segunda a versão mais indicada para uso em produção.

A cada 6 meses uma nova versão minor é lançada, conforme o cronograma acima. Atualmente estamos na versão 4.3, a versão LTS atual é a 3.4 e a próxima versão LTS é a 4.4 que será lançada em novembro.

Concluindo

O Symfony é um ótimo framework para a criação de aplicações, independente do seu tamanho. Neste artigo vimos algumas de suas principais características.