Beginning Laravel - A Beginner's Guide To Application Development With Laravel 5.3-1-95.en - PT

Traduzido do Inglês para o Português - www.onlinedoctranslator.
com
Começo
Laravel
Um guia para iniciantes na aplicação
desenvolvimento com Laravel 5.3
-
Sanjib Sinha
Começando o Laravel
Um guia para iniciantes na aplicação
desenvolvimento com Laravel 5.3
Sanjib Sinha
Começando o Laravel
Sanjib Sinha
Howrah, Bengala Ocidental, Índia
ISBN-13 (pbk): 978-1-4842-2537-0 ISBN-13 (eletrônico): 978-1-4842-2538-7

DOI 10.1007/978-1-4842-2538-7
Número de controle da Biblioteca do Congresso: 2016962198
Copyright © 2017 por Sanjib Sinha
Este trabalho está sujeito a direitos autorais. Todos os direitos são reservados à Editora, quer se trate da
totalidade ou de parte do material, especificamente os direitos de tradução, reimpressão, reutilização de
ilustrações, recitação, transmissão, reprodução em microfilmes ou de qualquer outra forma física, e transmissão
ou armazenamento de informações e recuperação, adaptação eletrônica, software de computador ou por
metodologia semelhante ou diferente agora conhecida ou desenvolvida posteriormente.
Nomes, logotipos e imagens de marcas registradas podem aparecer neste livro. Em vez de usar um
símbolo de marca registrada em cada ocorrência de um nome, logotipo ou imagem de marca registrada,
usamos os nomes, logotipos e imagens apenas de forma editorial e para o benefício do proprietário da
marca registrada, sem intenção de violar a marca registrada.
O uso nesta publicação de nomes comerciais, marcas registradas, marcas de serviço e termos
semelhantes, mesmo que não sejam identificados como tal, não deve ser tomado como uma expressão de
opinião sobre se estão ou não sujeitos a direitos de propriedade.
Embora os conselhos e as informações contidas neste livro sejam considerados verdadeiros e precisos
na data de publicação, nem os autores, nem os editores, nem a editora podem aceitar qualquer
responsabilidade legal por quaisquer erros ou omissões que possam ser cometidos. O editor não
oferece nenhuma garantia, expressa ou implícita, com relação ao material aqui contido.
Diretor administrativo: Welmoed Spahr

Editor principal: Nikhil Karkal
Revisor Técnico: Yogesh Sharma e Gaurav Yadav
Conselho Editorial: Steve Anglin, Pramila Balan, Laura Berendson, Aaron Black,
Louise Corrigan, Jonathan Gennick, Robert Hutchinson, Celestin Suresh John, Nikhil
Karkal, James Markham, Susan McDermott, Matthew Moodie, Natalie Pao, Gwenan
Spearing
Editor coordenador: Prachi Mehta
Editor de texto: Brendan Frost
Compositor: SPi Global
Indexador: SPi Global
Artista: SPi Global
Distribuído para o comércio de livros em todo o mundo pela Springer Science+Business Media New
York, 233 Spring Street, 6th Floor, New York, NY 10013. Telefone 1-800-SPRINGER, fax (201) 348-4505, e-
mailpedidos-ny@springer-sbm.com, ou visitewww.springeronline.com. Apress Media, LLC é uma LLC da
Califórnia e o único membro (proprietário) é Springer Science + Business Media Finance Inc (SSBM
Finance Inc). SSBM Finance Inc é umaDelawarecorporação.
Para informações sobre traduções, envie um e-maildireitos@apress.com, ou visitewww.apress.com.
Apress e amigos de livros ED podem ser adquiridos a granel para uso acadêmico, corporativo ou promocional.
Versões e licenças de e-books também estão disponíveis para a maioria dos títulos. Para obter mais informações,
consulte nossa página da web sobre vendas em massa especiais – licenciamento de e-books em www.apress.com/
bulk-sales.
Qualquer código-fonte ou outros materiais suplementares referenciados pelo autor neste texto estão
disponíveis aos leitores emwww.apress.com. Para obter informações detalhadas sobre como localizar
o código-fonte do seu livro, acessewww.apress.com/source-code/. Os leitores também podem acessar
o código-fonte no SpringerLink na seção Material Suplementar de cada capítulo.
Impresso em papel sem ácido

EM MEMÓRIA DO DR. BAIDYANATH HALDAR.
Senhor, eu realmente sinto sua falta.
Resumo do conteúdo
Sobre o autor ��
Sobre os revisores técnicos �� xi
Agradecimentos ��
- Capítulo 1: Compositor ��
- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant �� 7
- Capítulo 3: Estrutura do Arquivo ��
- Capítulo 4: Roteamento, um método estático�� 21
- Capítulo 5: Classe do Controlador��
- Capítulo 6: Visualização e Blade �� 41
- Capítulo 7: Meio Ambiente��
- Capítulo 8: Migração de banco de dados�� 49
- Capítulo 9: Eloquente ��
- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador��
- Capítulo 11: SQLite é uma brisa! �� 63
- Capítulo 12: Sentimentos complicados de formas�� 65
- Capítulo 13: Uma aplicação CRUD �� 67
- Capítulo 14: Autenticação e Autorização �� 81
- Capítulo 15: Mais sobre validação�� 91
- Capítulo 16: Relações Eloquentes �� 123
v
- Resumo do conteúdo
- Capítulo 17: Como a segurança e a autenticação funcionam juntas �� 153
- Capítulo 18: Como a solicitação e a resposta funcionam no Laravel 5 �� 161
- Capítulo 19: Contratos vs� Fachadas �� 167
- Capítulo 20: Middleware, Filtro de Camada e Segurança Extra �� 173
Índice��
vi
Conteúdo
Sobre o autor ��
Sobre os revisores técnicos �� xi
Agradecimentos ��
- Capítulo 1: Compositor ��
- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant �� 7
2.1 Instalando o Virtual Box e o Vagrant .......................................... ...... 7
2.2 Instalando o Homestead Vagrant Box ............................................. .... 9
2.3 Instalação e configuração do Homestead ............................ 10
- Capítulo 3: Estrutura do Arquivo ��
3.1 Princípio de Design SÓLIDO............................................. ................... 17
3.2 Interfaces e Injeção de Métodos ............................................. ..... 19
- Capítulo 4: Roteamento, um método estático�� 21
4.1 Melhores Práticas de Roteamento ............................................. ................. 25
4.2 Rotas Nomeadas................................................... ................................ 26
4.3 Organizar arquivos por meio de rota ............................................. ......... 27
4.4 Conceito Avançado de Roteamento e Funções Anônimas ........... 28
- Capítulo 5: Classe do Controlador��
5.1 Controlador RESTful ................................................ ........................... 32
5.2 Papel de um Controlador ............................................. ........................... 33
5.3 Controlador engenhoso ............................................. .................. 34
vii
- Conteúdo
5.4 Controlador, contêiner IoC e interface ........................................ 35
5.5 Resumo.................................................. .................................... 38
- Capítulo 6: Visualização e Blade �� 41
- Capítulo 7: Meio Ambiente�� 47
- Capítulo 8: Migração de banco de dados�� 49
8.1 Resumo................................................... ...................................... 52
- Capítulo 9: Eloquente ��
- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador��
10.1 Resumo................................................... .................................... 61

10.1.1 Nosso próximo desafio......................................... ........................................ 61
- Capítulo 11: SQLite é uma brisa! �� 63
- Capítulo 12: Sentimentos complicados de formas�� 65
- Capítulo 13: Uma aplicação CRUD �� 67
- Capítulo 14: Autenticação e Autorização �� 81
- Capítulo 15: Mais sobre validação�� 91
15.1 Regras Condicionais ............................................. ...................... 112
15.2 Validação Personalizada ............................................. ...................... 113
15.3 Como funciona a validação de formulário ............................................. ........ 119
- Capítulo 16: Relações Eloquentes �� 123
- Capítulo 17: Como a segurança e a autenticação funcionam juntas �� 153
- Capítulo 18: Como a solicitação e a resposta funcionam no Laravel 5 �� 161
- Capítulo 19: Contratos vs� Fachadas �� 167
- Capítulo 20: Middleware, Filtro de Camada e Segurança Extra �� 173
Índice��
viii
Sobre o autor
Sanjib Sinhaescreve histórias e códigos – nem sempre na mesma ordem.

Ele começou com C# e .NET framework e ganhou o Microsoft Community Contributor
Award em 2011. Mais tarde, o movimento de software de código aberto o atraiu e ele se tornou
um entusiasta de Linux, PHP e Python, especializando-se e trabalhando em White Hat Ethical
Hacking.
Como iniciante, ele sempre teve que lutar muito para encontrar uma maneira fácil de aprender
codificação. Ninguém lhe disse que programar é como escrever: visualizar uma imagem e trazê-la
para a Terra com a ajuda de palavras e símbolos.
Em todos os seus livros, ele tentou ajudar os iniciantes a partir de sua perspectiva – como
iniciante.
ix
Sobre o Técnico
Revisores
Yogesh SharmaSou desenvolvedor web, consultor de TI e empresário baseado em Pune, Índia. Eu

experimentei muitos paradigmas de TI, como serviços em nuvem, NoSQL, Middleware, mas a
programação está em meu coração. Graduado pela Escola de Tecnologia da Informação Vidyalankar,
atualmente trabalho em uma empresa da Fortune 500 como engenheiro de infraestrutura sênior.
Eu realmente gosto de ver o quadro geral com atenção às complexidades distintas. Tenho 8 anos
de experiência acumulada em vários domínios de TI e também atendi clientes em todo o mundo
desenvolvendo projetos que vão desde Gestão de Ativos até Manufatura e Logística. Gosto de mexer
com IoT, IA, Fala e Simulação. Se eu não for isso, você pode me encontrar preparando uma dose de
café expresso!"
Gaurav Yadavé desenvolvedor web Full Stack e blogueiro. Esportista de coração e apaixonado
por futebol. Possui experiência com diversos frameworks em php, python e javascript. Adora
explorar novas estruturas e evoluir com as tendências tecnológicas.
XI
Agradecimentos
KARTICK PAUL, GERENTE DE SISTEMA, AAJKAAL, KOLKATA: Sem sua ajuda persistente e
inspiradora, eu não poderia ter escrito este livro.
xiii
CAPÍTULO 1
Compositor
Composer é uma ferramenta de gerenciamento de dependências em PHP (Figura1-1). Para qualquer projeto
PHP você precisa usar sua biblioteca de códigos. O Composer gerencia facilmente essa tarefa em seu nome,
ajudando você a declarar esses códigos. Você também pode instalar ou atualizar qualquer código da sua
biblioteca através do Composer. Por favor visitehttps://getcomposer.orgpara mais detalhes.
Figura 1-1.Página inicial do compositor
Na página de abertura dohttps://getcomposer.org, clique no link 'primeiros

passos' (Figura1-2).
Material complementar eletrônicoA versão online deste capítulo

(faça:10.1007/978-1-4842-2538-7_1) contém material suplementar, que está disponível para
usuários autorizados.
© Sanjib Sinha 2017 1

S. Sinha,Começando o Laravel, DOI 10.1007/978-1-4842-2538-7_1
Capítulo 1-Compositor
Figura 1-2.Página de introdução no site do Composer
Na página mostrada na Figura1-2, você encontra dois links: 'localmente' e 'globalmente'. Representa
duas opções. Suponha que você não queira executar o Composer globalmente ou centralmente em seu
sistema. Nesse caso, você deve baixar e instalar o Composer sempre para cada projeto. Mas a opção global é
sempre preferível porque uma vez instalado o Composer na pasta bin do sistema, você pode chamá-lo a
qualquer momento para qualquer projeto.
Se você já está acostumado com qualquer distribuição Linux como o Ubuntu, você sabe que para
qualquer projeto PHP local costumávamos ir para '/var/www/html'pasta. Suponha que vamos construir
um projeto Laravel simples e queremos chamá-lo de 'MyFirstLaravelProject'. Abra seu terminal Ubuntu
(ctrl+alt+t) e vá primeiro para essa pasta.
Para chegar lá, você precisa digitar o seguinte comando em seu terminal:
cd /var/www/html/
Depois de alcançá-lo, você pode criar um diretório aqui com um comando simples:
sudo mkdir MyFirstLaravelProject
Ele solicitará sua senha de usuário 'root'. Digite a senha e uma pasta chamada
‘MyFirstLaravelProject’ será criada.
A seguir nesta pasta iremos baixar e instalar o 'composer'. Considerando que você é um
iniciante, por uma questão de brevidade, quero baixar e instalar o Composer localmente em nosso
projeto Laravel.
2
A seguir, emita esses dois comandos, um após o outro. Primeiro você digita isto:
sudo php -r "copy('https://getcomposer.org/installer',

'composer-setup.php');"
Isso levará algum tempo. Em seguida digite isto:
sudo php compositor-setup.php
Ele organizará seu arquivo de configuração do Composer para ir mais longe. Na verdade, seu Composer
está pronto para baixar pacotes para seu próximo projeto. Você pode testá-lo criando um arquivo 'composer.
json' dentro da pasta 'MyFirstLaravelProject'. Nesse arquivo 'composer.json' digite isto:
{
"exigir": {
"monólogo/monólogo": "1.0.*"
}
}
O que isto significa? Isso significa que você está instalando o pacote PHP 'monolog' para o seu
projeto Laravel. Terá algum uso imediato? A resposta é não'. Na verdade, estamos testando nosso
instalador do Composer e queremos ver como ele funciona.
Agora você pode emitir o comando que instalará o pacote 'monolog' para você. Digite
este comando em seu terminal:
instalação sudo php compositor.phar
Demorará um pouco para instalar o pacote 'monolog'. Depende da velocidade da sua

Internet.
Após a instalação, você encontrará uma pasta 'vendor' e alguns arquivos 'composer' dentro do
seu projeto. Sinta-se à vontade para descobrir o que está dentro da pasta ‘vendor’. Lá você encontrará
duas pastas: ‘composer’ e ‘monolog’. Novamente você pode ver o que eles têm dentro deles. Como
iniciante, é uma jornada interminável para descobrir coisas novas. Tente se familiarizar com tudo de
novo que você encontrou.
Chegou a hora de instalar o Laravel 5.2 através do Composer. Você pode instalar o Laravel como o
monolog. Isso significa que você pode escrever essa instrução em seu arquivo 'composer.json' e
apenas atualizar seu Composer. Mas, como iniciante, recomendo seguir o método mais simples.
Abra seu terminal e escreva o seguinte:
sudo compositor create-project --prefer-dist laravel/laravel blog
Ele instalará a versão mais recente do Laravel na pasta ‘blog’ do seu projeto Laravel
‘MyFirstLaravelProject’. Quando terminar, você receberá esta mensagem em seu terminal:
Chave do aplicativo
[base64:FrbQTSPezY8wQq+2+bZ/ieA8InA4KjA9N4A44AMbqas=] definido
com sucesso.
3
É uma chave aleatória gerada cada vez que você instala o Laravel. Isso significa que você
instalou o Laravel 5.3 com sucesso.
• Primeiro passo concluído: você instalou o Laravel na pasta '/var/www/html/

MyFirstLaravelProject/blog'. Agora você pode entrar nessa pasta e emitir um
comando Linux 'ls -la' para ver o que há dentro. Você também pode digitar o
comando 'php artesão serve' para executar seu primeiro aplicativo Laravel
para que você possa ir parahttp://localhost:8000 para ver a página de boas-
vindas. Esta instalação foi feita localmente.
Existe outro método mais fácil. Você pode instalar o Composer globalmente em seu
sistema Linux. Abra seu terminal e crie um diretório chamado ‘Code’ na área de trabalho. Abra
seu terminal e digite isto:
cd /Área de trabalho
Agora você está dentro da sua área de trabalho. Você vai criar o diretório ‘Code’ lá.
Digite o seguinte:
Código mkdir
Agora você deve entrar no diretório ‘Code’ escrevendo ‘cd Code’ em seu terminal. A seguir,
dentro da pasta ‘Code’ crie um diretório ‘test’, onde você criará sua primeira aplicação Laravel.
Não só isso, depois que o 'Laravel/Homestead' estiver instalado, você pode digitarhttp://teste. aplicativo
para executar seu primeiro aplicativo Laravel. Vou te mostrar isso passo a passo.
Agora é hora de instalar o Composer globalmente. Digite estes comandos um após o outro:
sudo php -r "copy('https://getcomposer.org/installer',

'composer-setup.php');"
sudo php compositor-setup.php
instalação sudo php compositor.phar
A instalação global do Composer levará alguns minutos. Depois de fazer isso, você pode criar qualquer
projeto Laravel em qualquer lugar.
Em seguida você pode criar seu primeiro projeto Laravel dentro da pasta ‘Code/test’ digitando
este comando:
sudo compositor create-project --prefer-dist laravel/laravel blog
Dentro da pasta ‘test’, o projeto Laravel é instalado como ‘blog’. Durante a instalação, você pode alterar
esse nome conforme sua preferência.
Isso levará alguns minutos, dependendo da velocidade da sua conexão com a Internet.
4
Uma vez feito isso, ele exibirá esta mensagem:
Chave do aplicativo
[base64:FrbQTSPezY8wQq+2+bZ/ieA8InA4KjA9N4A44AMbqas=] definido
com sucesso.
Você instalou a versão mais recente do Laravel 5.2.4 em seu '/Desktop/Cd/teste/blog'pasta. E

você fez isso globalmente. Sinta-se à vontade para criar qualquer pasta e subpastas em qualquer
lugar da sua máquina e instalar o Laravel através do Composer.
• Segunda etapa concluída: Laravel instalado na pasta '/Desktop/Code/

test/blog', e você fez isso globalmente.
No próximo capítulo, aprenderemos um pouco sobre a instalação do Laravel Homestead.
5
CAPÍTULO 2
Laravel Homestead, Virtual

Box e Vagrant
Laravel Homestead é uma caixa Vagrant oficial e pré-embalada. Um iniciante absoluto pode achar
esse conceito um pouco peculiar. Você pode imaginá-lo como uma plataforma de andaime ou caixa
mágica que contém tudo para construir aplicações Laravel em sua máquina local.
Eu encorajo você a pesquisar e aprender sobre o pacote Laravel Homestead. Se você possui o Laravel
Homestead instalado, não precisa se preocupar com as versões mais recentes do PHP e Linux. Ele também
vem com um servidor web e todos os tipos de software de servidor que você precisa para desenvolver alguns
aplicativos PHP incríveis além do Laravel!
Antes de executar o Laravel/Homestead você deve ter o Virtual Box 5.x:
https://www.virtualbox.org/wiki/Downloads.
Você também deve instalar o Vagrant:
http://www.vagrantup.com/downloads.html.
2.1 Instalando o Virtual Box e o Vagrant

A primeira pergunta que nos vem à mente é a seguinte: por que precisamos de uma “caixa virtual”
quando temos um sistema operacional padrão instalado? Existem vários motivos. A razão mais
importante é que no Virtual Box podemos brincar com qualquer sistema operacional sem medo de
estragar, até mesmo quebrar. Há todas as possibilidades de que, ao testar uma ferramenta de hacking,
possamos quebrar um sistema. Eu encorajo você a fazer isso. É uma máquina virtual. Então, vá em
frente. Teste tudo o que vier à mente. Outro grande motivo para usar o Virtual Box é a segurança.
Quando você visita um site, você pode considerá-lo seguro, mas na realidade não pode ser assim. Mas
nada importa no caso do Virtual Box. Não é a sua máquina original com dados confidenciais. Visitar
sites inseguros não é mais irritante (ou pior).
Só há uma coisa que você precisa lembrar. Fique dentro da lei. Ao testar suas ferramentas de
hacking ou executar códigos, você não pode comprometer nenhum outro sistema.
O site oficial do Oracle Virtual Box oferece muitas opções de download. Você pode escolher
qualquer um deles. De acordo com o seu sistema operacional, você vai até a seção “download” e vê o
que está disponível para você. Da Figura2-1, você terá uma ideia de como proceder.

Capítulo 2-Herdade LaraveL, caixa virtual e vagabundo
Figura 2-1.Seção de download do Virtual Box para hosts Linux
A linha selecionada na Figura2-1mostra o sistema operacional padrão que estou

executando atualmente. Esse é “Ubuntu 14.04 (Trusty)” e a arquitetura é “AMD64”.
O Virtual Box é muito fácil de instalar. Qualquer que seja o seu sistema operacional – Mac OS X,
Windows ou Linux – você pode instalá-lo. Primeiro você precisa saber sobre o seu sistema operacional.
Pode ser uma arquitetura de 32 ou 64 bits. Em qualquer distribuição Linux é extremamente fácil de
aprender. Basta abrir o terminal e digitar “nome -a”.
O terminal fornecerá algumas informações vitais que incluem todos os dados relativos ao
sistema padrão atual. Neste caso, o Linux é a versão 3.19.0 e o nome do superusuário é “hagudu”;por
fim, também indica que tipo de arquitetura de sistema está sendo utilizada.
Como no meu caso, é “x86_64” que significa 64 bits. Na página de download oficial do Virtual Box
para todas as distribuições Linux, primeiro você baixa os pacotes necessários e depois os instala de
acordo com a natureza do seu sistema operacional. Para Red Hat, Fedora ou qualquer distribuição
Linux pertencente a essa categoria, você notará que a última extensão é “.rpm”. Nesse caso você pode
ir para a pasta Virtual Box e emitir comandos como “rpm -eu”ou “yum instalar”caso você execute Red
Hat ou Fedora.
Mas existem métodos mais simples para instalar o Virtual Box.
Para iniciantes, é muito útil executar a distribuição Linux “UBUNTU” como seu sistema
operacional padrão. Você pode instalar o Virtual Box diretamente do centro de software,
sem abrir o terminal ou emitir qualquer comando.
O centro de software “UBUNTU” tem muitas categorias. Um deles mostra o software
“Instalado”.
8
Você pode não encontrá-lo lá por padrão. Nesse caso é extremamente fácil de instalar. Você pode
simplesmente digitar “Caixa Virtual” na caixa de texto de pesquisa e ela aparecerá. Vá em frente e
pressione o botão de instalação e ele será instalado em seu sistema. Instalar o Vagrant também é fácil.
Acesse o site oficial e baixe-o de acordo com seus sistemas operacionais. O processo de instalação
também é fácil. Para Ubuntu, basta extrair o conteúdo em qualquer lugar e instalá-lo conforme
procedimento citado no site. Pesquise na Internet e você encontrará muitos guias.
Através do Virtual Box você pode rodar diferentes sistemas operacionais em sua máquina
(Figura2-2).
Figura 2-2.Uma Virtual Box rodando Kali Linux e Windows XP
Depois de instalar o Virtual Box você pode emitir 'vagabundo -v'comando em seu terminal e
a mensagem aparecerá como 'vagabundo 1.8.5'.Está correndo.
Agora é hora de instalar o Laravel/Homestead.
2.2 Instalando a caixa Homestead Vagrant

Depois de instalar o Virtual Box e o Vagrant, você pode adicionar a caixa 'laravel/homestead' à
sua caixa Vagrant usando este comando em seu terminal:
caixa vagante adicionar laravel/homestead
Isso levará algum tempo, de 15 minutos a uma hora, dependendo da velocidade da

sua Internet.
9
2.3 Instalação e Configuração do Homestead

Em seguida, você pode instalar o Homestead clonando o repositório Homestead na pasta '/
home/Homestead' usando este comando:
clone git https://github.com/laravel/homestead.git

Homestead
Isso levará alguns segundos. Em seguida você precisa inicializar seu Homestead e criar o arquivo de
configuração.
bash init.sh
Em seguida, execute um 'ls -la'comando para descobrir o oculto './herdade'diretório. Tipo 'cd ./
homestead'comando para entrar nele e executar 'ls -la'comando novamente. Você encontrará um
arquivo chamado 'Homestead.yaml'.Você pode considerar este arquivo como o cérebro do seu
ambiente de desenvolvimento local 'laravel/homestead'.
Através deste arquivo, você pode instruir o servidor web local. Você pode mencionar o caminho
da raiz do seu projeto. Você pode decidir o nome do seu aplicativo local. Acho que é sempre
aconselhável adotar o mesmo nome que você usará em seu ambiente de produção. Suponha que seu
aplicativo final no nível de produção seja nomeado 'www.exemplo.com'; nesse caso, é bom usar o
mesmo nome localmente para que você possa digitarhttp://exemplo. comno seu navegador para
testar o aplicativo localmente.
Antes de editar o arquivo ‘Homestead.yaml’, você pode fazer mais duas coisas. Primeiro, verifique
sua versão do 'laravel/homestead' e se necessário execute este comando: 'sudo compositor global
requer laravel/homestead:v2.0.8'.Sempre tente manter o mais recente. Verifique na Internet. A seguir,
você também pode executar este comando: 'exportar PATH="~/.composer/vendor/bin:$PATH"'.Isso vai
te ajudar a correr'herdade'comando de qualquer lugar do seu sistema.
Agora você precisa editar o arquivo ‘Homestead.yaml’ para manter duas coisas importantes no
lugar. O primeiro é o provedor. Correr 'sudo gedit Homestead.yaml'comando para abrir o arquivo no
editor de texto. Por padrão, você veria 'provedor: caixa virtual'em seu arquivo. Então você não precisa
mudar isso. A seguir, você verifica esta parte.
A segunda parte é muito importante. Por padrão, o arquivo 'Homestead.yaml' vem com
esta pasta e estrutura de site:
pastas:
- mapa: ~/Código
para: /home/vagrant/Código
sites:
- mapa: homestead.app
para: /home/vagrant/Code/Laravel/public
10
Já instalamos o Laravel na pasta ‘Code/test/blog’ do desktop. Portanto, precisamos

primeiro adicionar isso nesta pasta e seção do site.
pastas:
- mapa: ~/Código
para: /home/vagrant/Código
- mapa: ~Desktop/Código/teste/blog
para: /home/vagrant/Desktop/Code/test/blog
sites:
- mapa: homestead.app
para: /home/vagrant/Code/Laravel/public
- mapa: test.app
para: /home/vagrant/Desktop/Code/test/blog/public
As linhas adicionadas estão marcadas em vermelho. Observe que mencionei o caminho completo.
Onde quer que você mantenha seu aplicativo Laravel, você precisa mencionar o caminho completo. Então,
estamos quase chegando ao fim.
Você provavelmente notou que chamamos nosso aplicativo de 'test.app'. Em seguida, você precisa
adicionar os “domínios” dos seus sites locais ao arquivo 'hosts' da sua máquina. O arquivo 'hosts' redirecionará
as solicitações dos sites Homestead para sua máquina Homestead. No Mac e no Linux, esse arquivo está
localizado em '/etc/hosts'. Abra este arquivo em seu editor de texto.
sudo gedit /etc/hosts/
Geralmente aparece com duas linhas no topo. Você deve adicionar seu 'test.app' após as duas
linhas.
127.0.0.1 host local 127.0.0.1 hagudu-H81M-S1 192.168.10.10

teste.app
Feito isso, agora você pode iniciar o Vagrant e administrar seu site. Vá para a pasta
Laravel 'cd /Desktop/Código/teste/blog'e emita este comando: 'vagabundo'.
O terminal geralmente se parece com a imagem da Figura2-3. Pode parecer diferente
dependendo do seu sistema operacional.
11
Figura 2-3.O terminal após emitir o comando 'vagrant up'
Normalmente leva alguns segundos para ativá-lo. Dê esse tempo e, em seguida, você poderá digitar com
segurançahttp://test.appno seu navegador para ver a página de boas-vindas do Laravel.
Estando na sua pasta Laravel, você pode executar o comando 'php artist serve' para executar a
mesma aplicação. Nesse caso, você deve digitarhttp://localhost:8000no seu navegador.
No entanto, existem muitas diferenças com o servidor Homestead. Ao executar o
Homestead, você obtém a versão mais recente do php, que é php 7.
Veja a imagem a seguir. Eu simplesmente mantive o método 'phpinfo()' em meu 'test. app'
página inicial do Laravel (Figura2-4).
12
Figura 2-4.test.app executando as informações do php 7
Espero que você consiga. Se por acaso você estiver preso, sinta-se à vontade para me escrever em
sanjib12sinha@gmail.com. Com certeza tentarei ajudar.
13
CAPÍTULO 3
Estrutura de arquivo
Vamos ver o que há dentro da pasta 'blog' do Laravel instalada. Possui pastas como 'app', 'bootstrap',
'config', 'database', 'public', 'resources', 'storage', 'tests', 'vendor' e mais alguns arquivos, incluindo um
'composer arquivo .json'.
Vamos primeiro ver como fica a estrutura do arquivo (Figura3-1).
Figura 3-1.Estrutura de arquivos do Laravel 5.3.18
Como você pode ver, cada pasta e seus arquivos incluídos têm suas próprias funções claramente definidas. Você
não deve tentar alterar ou ajustar nenhum código-fonte.
A pasta ‘app’ é extremamente importante. Ele contém, novamente, muitas pastas importantes.
Atualmente aguardaremos a pasta 'Http' que contém controladores, middleware, modelos e o arquivo
'routes.php'. Na verdade, colocamos nossa lógica de negócio nesta pasta através de rota e
controladores. Isso nos ajuda a manter o padrão de design orientado a objetos fracamente acoplado.

Capítulo 3-Estrutura de arquivo
A pasta 'bootstrap' é necessária para a inicialização do Laravel, e você precisa da pasta 'config'
para muitos arquivos de configuração. Como programador PHP, você sabe que a configuração da
sessão ou da autenticação é importante. O Laravel gerencia isso através desta pasta ‘config’.
O papel da pasta 'banco de dados' também é vital para migrações e sementes, que discutiremos mais
tarde em detalhes. Atualmente você pode pensar nas migrações de banco de dados como arquivos PHP que
escrevem códigos SQL e executam operações de banco de dados diretamente em sua aplicação. Você não
precisa acessar nenhuma interface MySQL como PHPMYADMIN. Você escreve códigos PHP e através da linha
de comando do Laravel pode executar operações de banco de dados. Você pode preencher tabelas de banco
de dados com dados, manipulando-os adequadamente. Acho que é uma das maiores características do
Laravel.
No 'público'pasta temos arquivos que estão disponíveis publicamente: '.htaccess', 'robots.txt',
'favicon.ico',eindex.php'.Esses arquivos desempenham papéis importantes para manter seu projeto nos
motores de busca. O 'recursos'pasta tem subpastas importantes como'Visualizações', onde seus
códigos PHP/HTML visíveis são armazenados. Em ‘storage’ são mantidos arquivos de cache e log, e a
pasta ‘testes’ é exclusiva para testes unitários. Finalmente, você conhece o 'fornecedor'pasta novamente
aqui, mas é apenas para pacotes de terceiros que o Laravel usa.
Eu encorajo você a entrar em cada pasta, abrir cada arquivo e ver como eles são escritos. Você
só se lembra de uma coisa: nunca altere nenhum código-fonte.
Nossa instalação do Laravel está completa. Nós o instalamos primeiro no '/var/www/html/
MyFirstLaravelProject/blog'pasta. Em seguida, instalamos em '/Desktop/Código/teste/blog'
pasta. O primeiro será usado para operações de banco de dados MySQL e o segundo será
usado para operações de banco de dados SQLite.
Tudo o que precisamos ver agora é que funciona perfeitamente. Vamos ao primeiro. Abra
seu terminal e escreva o seguinte:
cd /var/www/html/MyFirstLaravelProject/blog
Chegamos ao nosso projeto Laravel. Agora emita este comando:
php artesão servir
Ele iniciará o servidor do ambiente de desenvolvimento local para que, se você abrir
seu navegador e digitarhttp://localhost:8000, abrirá a página inicial do seu projeto Laravel.
Deve ficar assim (Figura3-2):
16
Figura 3-2.Página inicial do Laravel 5.3.18
Todos os navegadores geralmente fornecem saída HTML simples. Nesse sentido, deve haver alguns códigos
HTML escondidos em algum lugar do nosso projeto Laravel.
No capítulo4, veremos como podemos alterar essa saída HTML. Além disso, discutiremos
brevemente alguns pontos da pasta 'views' onde realmente precisamos armazenar esses códigos
HTML.
Mais adiante no livro, no capítulo 'vistas e lâminas', aprenderemos isso em detalhes.
3.1 Princípio de Design SÓLIDO

Sim, isso é algo bastante avançado que você precisa aprender melhor de antemão. No Laravel 4
o princípio de design SOLID foi mantido, e no Laravel 5 ele se torna mais familiar para que você
possa evitar codificação rígida e escrever códigos mais limpos. Vamos ver o que é esse princípio
de design SOLID.
Este livro não é o lugar para apresentar uma descrição detalhada do princípio SOLID.
Mas pelo menos podemos apresentar algo sobre isso em poucas palavras.
SOLID consiste nos cinco princípios de design articulados por Robert “Uncle Bob” Martin.
Aqui estão eles resumidamente, um por um. Na parte final irei discutir isso em detalhes, e
espero que até lá você já tenha se familiarizado com os princípios básicos da lógica de
aplicação do Laravel.
17
SÓLIDO significa
1)Princípio de Responsabilidade Única
2)Princípio Aberto Fechado
3)Princípio da Substituição de Liskov
4)Princípio de segregação de interface
5)Princípio de Inversão de Dependência
O Princípio da Responsabilidade Única significa que uma classe deve ter um, e quero dizer apenas um,
motivo para mudar. Limitar o conhecimento da classe é importante. O escopo da aula deve ter um foco restrito.
Uma classe faria seu trabalho e não seria afetada pela mudança que ocorre em suas dependências. Lembre-se,
se pudermos construir uma biblioteca de pequenas classes com responsabilidades bem definidas, nosso código
será mais desacoplado e fácil de testar e executar. O princípio aberto e fechado significa que uma classe está
sempre aberta para extensão, mas fechada para modificação. Como é isso? Nada, exceto que quaisquer
alterações no comportamento devem ser feitas sem modificação dos códigos-fonte. Se você consegue fazer seu
trabalho sem mexer no código-fonte, então você está seguindo o Princípio Aberto e Fechado! Lembre-se do que
o tio Bob diz: “Separe o comportamento extensível por trás de uma interface e inverta as dependências”.
Acontece que sempre que você modifica seu código, existe a possibilidade de quebrar completamente as
funcionalidades antigas, adicionando novos bugs.
Mas se você puder planejar seu aplicativo no início com base no princípio aberto e fechado,
poderá modificar sua base de código o mais rápido possível sem ser afetado. Qual é o Princípio da
Substituição de Liskov? Não fique assustado. Isto parece intimidante, mas como princípio é
extremamente útil e fácil de entender. Diz: As classes derivadas devem ser substituíveis por sua classe
baseada. Isso significa que os objetos devem ser substituídos por instâncias de seus subtipos sem
alterar a correção do programa. Se você não consegue seguir isso, siga em frente; Explicarei esses
princípios detalhadamente com exemplos e capturas de tela, para que a imagem fique muito mais
clara.
O Princípio de Segregação de Interface é um eco das Responsabilidades Singulares. Se for
quebrada, a Responsabilidade Singular será quebrada. Resumindo, diz que a interface é granular e
focada. Nenhuma implementação de interface deve ser forçada em métodos que ela não utiliza. Da
mesma forma, divida-as em pequenas interfaces conforme necessário para sua implementação.
Planeje com antecedência e aproveite o passeio tranquilo e desacoplado.
Finalmente, o Princípio da Inversão de Dependência afirma que os códigos de alto nível não
devem depender de códigos de baixo nível. Em vez disso, o código de alto nível depende da 'Abstração'
que atua como intermediário entre o alto e o baixo nível. O segundo aspecto é que a abstração não
depende de detalhes, mas os detalhes dependem de abstrações. Para iniciantes, esses princípios
podem não parecer suficientemente confortáveis, mas não se preocupe, pois discutiremos isso
detalhadamente com exemplos; a essa altura, você terá adquirido confiança suficiente para lidar com
essa linguagem conceitual. Você já considerou os termos “Interface” e “Abstração” mais de uma vez,
talvez muitas vezes, candidatos merecedores de discussão. Então, vamos passar algum tempo com
esses termos onipresentes que encontramos com tanta frequência em nossa aplicação Laravel.
18
3.2 Interfaces e Injeção de Método

A abstração em OOP envolve a extração de detalhes relevantes. Considere o papel de um vendedor de
carros. Existem muitos tipos de consumidor. Todo mundo quer comprar um carro, sem dúvida, mas
cada um tem critérios diferentes. Cada um deles está interessado em um ou dois recursos específicos.
Este atributo varia de acordo. Forma, cor, potência do motor, direção hidráulica, preço… a lista é
interminável. O vendedor conhece todos os detalhes do carro, mas será que repete a lista um por um
até que alguém encontre a sua escolha? Não. Ele apresenta apenas as informações relevantes ao
potencial cliente. Como resultado o vendedor pratica a “Abstração” e apresenta apenas detalhes
relevantes ao cliente.
Agora considere a abstração da perspectiva de um programador que deseja que um usuário
adicione itens à lista. Abstração não significa que a informação esteja indisponível, mas garante que a
informação relevante seja fornecida ao usuário.
PHP 5 introduz classes e métodos abstratos. Classes definidas como abstratas não podem ser
instanciadas e qualquer classe que contenha pelo menos um método abstrato também deve ser
abstrata. Lembre-se de que métodos abstratos não podem definir a implementação. Por outro lado, as
interfaces de objetos permitem criar código que especifica quais métodos uma classe deve
implementar, sem ter que definir como esses métodos serão tratados.
As interfaces são definidas com a palavra-chave interface, da mesma forma que uma classe
padrão, mas sem que nenhum dos métodos tenha seu conteúdo definido.
Todos os métodos declarados em uma interface devem ser públicos; esta é a natureza de uma
interface. Tenho experiência em .NET e descobri que o uso de interfaces é quase onipresente. E no
Laravel a injeção de interfaces nas classes é vista com frequência, então é melhor você se familiarizar
com o background conceitual.
No Laravel a Interface é considerada um Contrato.
Contrato entre quem? E porque? Porque uma interface não contém nenhum código, mas apenas
define um conjunto de métodos que um objeto implementa. Dito isto, espero que agora você entenda
que eles estão inter-relacionados. Falamos sobre manter uma biblioteca de pequenas classes com
escopos claramente definidos, e isso é possível com a ajuda de Interfaces. À medida que o livro avança,
você encontrará muitos exemplos de Interfaces, então não se preocupe, você encontrará essas duas
palavras com bastante frequência nos exemplos. Até então, tenha paciência e continue lendo.
Para uma imagem clara, gostaria de dar um pequeno exemplo para que possamos entender
rapidamente esta propriedade do comportamento do contrato encapsulado da Interface.
Imaginemos que tenho uma pasta 'Conexão' dentro de uma pasta chamada 'Bengaliana' na
qual tenho uma classe de conexão que nos conectaria ao banco de dados 'sanjib' e recuperaria
alguns dados das respectivas tabelas 'usuários' e 'tarefas'.
Não quero que o 'ConnectionClass' conheça nosso destino de dados. Tudo o que ele fará é obter a
conexão e recuperar o único atributo de uma tabela. O atributo e o nome da tabela que gostaria de fornecer
dinamicamente para que, a partir de um método, eu possa recuperar vários tipos de dados. Podem ser nomes
de usuários ou títulos de tarefas simples, etc. Isso também estará de acordo com a natureza de homomorfismo
de nossos objetos.
19
No Laravel 5, como diz o documento, todos os componentes principais implementam interfaces

que estão localizadas no repositório 'illuminate/contracts'. Este repositório não possui dependências
externas. Ter um conjunto centralizado de interfaces torna você livre para usar classes desacopladas
opcionais alternativas e fazer algumas injeções de dependência mais livremente sem Laravel
Facades. Isso torna suas escolhas mais abertas e fáceis de usar. Bem, há muitas novas equipes que
você encontrará à medida que avança e os novos recursos tornarão sua jornada absolutamente
agradável. Para citar alguns, existem Route Cache, Middleware, Controller Method Injection e muitos
mais.
No Laravel 5, a autenticação de usuários se torna mais fácil, e os controladores de registro de
usuário, autenticação e redefinição de senha agora estão incluídos imediatamente para que
possam ser facilmente usados. Ok, chega de introdução. Agora é hora de pegar os artesãos da web
e fazer alguns códigos para que possamos fazer algumas aplicações incríveis no futuro.
20
CAPÍTULO 4
Roteamento, um método estático
Roteamento é o conceito de criação de um novo URI comohttp://localhost:8000/olá. Isso o levará

a uma página da web de destino. Laravel torna isso extremamente simples. É um método
estático que aceita duas coisas: um URI e uma função anônima ou Closure.
No 'app/Http/routes.php'foi definido principalmente. Inicie seu editor de texto favorito e
abra o arquivo. O que você vê?
Você vê algum código como este:
Rota::get('/', function() {
retornar visualização('bem-vindo');
});
Aqui, 'Route' é uma classe que possui um método estático 'get' que retorna um método 'view' que
apresenta uma página web. Quando um usuário visita a página inicial, ele é levado à página de “boas-vindas”.
Este 'bem-vindo' é na verdade um arquivo PHP: 'bem vindo.blade.php'.Ele foi armazenado por padrão na pasta
'views' enquanto estávamos instalando o Laravel. Quando discutirmos o conceito de mecanismo de modelo
'view' e 'blade', você entenderá perfeitamente o que está acontecendo na camada de apresentação.
Usando o protocolo HTTP você pode enviar outra solicitação em vez da rota padrão.
retorne 'bem-vindo';
});
Ele simplesmente retornará a palavra “bem-vindo” na sua página inicial. Experimente ou qualquer outra
coisa. Veja o código; há uma função anônima também. Como programador PHP, presumo que você
conheça funções ou fechamentos anônimos. É uma função muito útil que usamos frequentemente na
construção de aplicativos. Laravel também usa esse conceito.
Agora ainda não definimos nossa rota, então se acertarmos o navegador na URLhttp://
localhost:8000/oláobteremos uma página de erro. Então, vamos criá-lo primeiro. Vá para as 'rotas. php'
e adicione este código:
//solicitando uma nova página

Route::get('/hello', function () {
echo '<h1>Olá</h1>';
});

Capítulo 4-roteamento, um método StatiC
Vamos ver como fica e se podemos adicionar algum novo código HTML para alterar o
olhar.
Principalmente se parece com isso (veja a Figura4-1):
Figura 4-1.Roteando parahttp://localhost:8000/oláURL
Agora gostaríamos de adicionar mais estilo CSS a ele. Eu mudo o código anterior para este:
//solicitando uma nova página

Route::get('/hello', function () {
eco "<html>"
"<head><title>Laravel</title>
<estilo>
html, corpo {
altura: 100%;
}
corpo {
margem: 0;
preenchimento: 0;
largura: 100%;
exibição: mesa;
22
peso da fonte: 100;

tamanho da fonte: 20px;
família de fontes: 'Lato';
}
. contêiner {
alinhamento de texto: centro;
display: célula-tabela;
alinhamento vertical: meio;
}
. contente {
alinhamento de texto: centro;
display: bloco embutido;
}
. título {
}
</estilo>
</head>
<corpo>
<div class='contêiner'>
<div class='content'>
<div class='title'>Olá, caro leitor</div> <div
class='container'>
<div class='content'>Como você está? Espero que você
ame este livro!
</div>
</div>
</div>
</div>
</corpo>"
"</html>";
});
Este código é bastante grande. É porque adicionei um pequeno estilo CSS a ele. Você não precisa
escrever este código. Apenas tente entender o poder deste pequeno arquivo'rotas.php'.Você pode adicionar
virtualmente qualquer funcionalidade ao seu aplicativo por meio deste arquivo. Mas nunca faça isso. O
arquivo 'routes.php' não foi feito para isso. O Laravel criou locais separados para colocar seus estilos CSS e
páginas HTML. Veremos isso mais tarde em detalhes. Pouco antes disso, queríamos apenas brincar com ele.
Agora parece completamente diferente no seu navegador. Basta dar uma olhada (ver Figura4-2):
23
Figura 4-2.Roteando parahttp://localhost:8000/oláURL
Com um novo estilo CSS parece muito especial. Mais tarde daremos a mesma saída usando o
mecanismo de template 'blade' do Laravel.
Agora, o roteamento tem muitas outras funções importantes. Vamos considerá-los um por
um. Em primeiro lugar, podemos adicionar parâmetros de rota e passar dados através da
URL. É algo como se você tivesse umhttp://localhost:8000/olápágina e quer dizer 'olá' ao seu
amigo. Laravel gerencia isso muito bem. Através da função anônima podemos passar este
parâmetro comohttp://localhost:8000/hello/readere a saída será 'Olá leitor'. Vamos ver como
podemos fazer isso.
Adicione este código ao seu 'routes.php':
Route::get( 'olá/{nome}', function ($nome){

eco "Olá". $nome;
});
Agora você pode passar qualquer dado pela URLhttp://localhost:8000/hello/reader como

parâmetro de rota. Passei em 'leitor', você pode passar quaisquer outros dados que quiser.
Espero que você tenha uma ideia básica de como usar a classe Route. Você também soube que
a classe Route possui alguns métodos estáticos como 'GET' e outros métodos. Através desses
métodos, a classe Route ajuda o usuário a chegar ao destino da URL.
Outros métodos de roteamento são assim:
Rota::get();
Rota::post();
Rota::patch();
Rota::put();
24
Rota::delete();
Rota::qualquer();
Eu acho o 'qualquer()'método muito interessante. Você pode registrar qualquer rota que responda a
qualquer verbo HTTP com este método.
Rota::any('qualquer', function(){
return "Tudo é possível se você se esforçar!";
});
Vá para 'http://localhost:8000/qualquer' e veja esta saída simples.
4.1 Melhores Práticas de Roteamento

Suponha que você queira proteger seu aplicativo contra falsificação de solicitação entre sites (mais
conhecida como CSRF). O que você pode fazer? Existe algum comando único que possamos emitir para
proteger nosso site dos 'Crackers' ou 'Bad Guys'? Sim, existem. Vamos ver como podemos fazer isso.
Escreva este código em seu Routes.php:
Rota::when('*', 'csrf', ['post', 'put', 'patch']);
Voilá! Isso é tudo que você precisa para proteger seu site e na próxima vez que você iniciar seu
aplicativo Laravel, ele cuidará de todos os tipos de CSRF.
Especialmente em uma aplicação grande, onde muitos usuários colocam muitas postagens e seu
servidor está ocupado, isso é uma grande dor de cabeça. Mas espere um minuto. Existem muitas coisas
incomuns na classe ‘Route’; deixe-me chamá-lo de mágico, esperando que o exploremos.
Primeiramente, discutiremos sobre roteamento 'implícito' e 'explícito'. Se você tem uma experiência com
o 'CodeIgniter', provavelmente já viu instâncias de roteamento 'implícito'. Quando escrevemos assim:
Route::controller('admin', 'AdminController');
Ele nos redireciona implicitamente para a pasta 'View/admin' através de 'AdminController'. Ok, você
é novo no conceito de Controllers, mas não se preocupe: no próximo capítulo abordaremos toda a equipe
de controllers, então continue lendo. Sugiro que você releia este capítulo mais tarde para entender melhor
a magia.
A questão é a seguinte: podemos “encaminhar” isto explicitamente? Sim, nós podemos. Deixa-nos tentar:
Route::get('teste/teste', 'HomeController@showTest'); Rota::get('home/

index', 'HomeController@showIndex'); Route::get('home/about',
'HomeController@About'); Route::get('home/contato',
'HomeController@showContact'); Rota::get('php/phptraininginkolkata',
'PhpController@showIndex'); Route::get('php/variableanddatatype',
'PhpController@phpFirstPage'); Route::get('codeigniter/codeignitertrainingin
kolkata', 'CodeIgniterController@showIndex');
25
Route::get('codeigniter/howtostartcodeigniter',
'CodeIgniterController@CIFirstPage');
Rota::get('wordpress/howtostartwordpress', 'WpController@showIndex');
Deixe-me pegar a última linha:
Rota::get('wordpress/howtostartwordpress', 'WpController@showIndex');
Diz: na pasta ‘View/wordpress’, temos uma página como ‘how-to-start-wordpress.

blade.php' e nosso controlador 'WpController' tem uma função pública chamada 'showIndex',
que tem algo dentro dela para que nosso ponto final seja 'howtostartwordpress.blade.php'.
Agora a questão é a seguinte: podemos agrupar essa longa lista de roteamento de controladores?
Sim, temos uma ferramenta útil chamadaRota::grupo().Suponha que estejamos preocupados apenas
com os controladores “domésticos”. Podemos agrupá-lo; sem problemas. Toda a lâmina 'inicial' pode estar
em um grupo como este:
Rota::group(['prefix']=>'home', function() {
Rota::get('/', 'HomeController@showIndex');
Route::get('/about', 'HomeController@About');
Rota::get('/contato',
'HomeController@showContato'); });
Veja bem, dentro do grupo não precisamos mais escrever 'casa'. É explicitamente informado
ao nosso roteador. Na linha de comando você sempre pode verificar como está o seu trabalho
através deste comando:
rotas artesanais em php
No final das contas, ele mostra todos os controladores que usei em meu arquivo 'routes.php' e escrevi
antes. Para obter todos os controladores 'domésticos', podemos fazer outra coisa. Considerando essa ‘casa’
como meu ‘recurso’ posso escrever assim:
Route::resource('home', 'HomeController');
Há mais por vir. Outra prática recomendada é 'nomear uma rota'.
4.2 Rotas Nomeadas

Suponha que você tenha uma página de login e vá usar a sessão para realizar a tarefa. Agora, para
começar, podemos escrever assim para chegar à nossa página de login:
//exemplo de rotas nomeadas

Route::get('/', function(){
return link_to_route('sessão/criar', 'Login');
});
26
Podemos escrever a mesma rota usando nossos controladores assim:
Route::get('sessão/criar','SessionController@create');
Mas todos estes são procedimentos normais que vimos antes. Então, você deve ter
perguntado, onde fica a rota nomeada?
Ok, aqui está:
Route::get('session/create', ['as'=>'create',
'use'=>'SessionController@create']); //equivalente a
Rota::get('/', function(){
return rota('criar');
});
E ainda há muitos funcionários esperando por você. É sua preferência o que você
usaria, pois a escolha é sua.
Rota::get('registrar', [
'antes'=>['convidado'],
'como'=>['registrar'],
'use'=>['SessionController@register']
]);
Você também pode escrever assim:
Rota::get('registrar', [
'como'=>['registrar'],
'use'=>['SessionController@register'] ])-
>before('convidado');
4.3 Organizar arquivos por meio de rota

Sim, você pode organizar seus arquivos através do seu Route. E às vezes isso pode ser muito útil. Suponha
que você tenha uma estrutura de pastas como esta:
app/rotas/admin.php
app/rotas/login.php
app/rotas/register.php
Agora podemos declarar esta estrutura no seu 'routes.php' em um único comando como este:
(Arquivo::allFiles(_DIR_, '/routes') como $partial)

{
require_once $partial->getPathname; }
27
4.4 Conceito Avançado de Roteamento e

Funções Anônimas
Ser capaz de definir sua própria função sozinho é uma ótima coisa que você pode fazer como
programador e deve fazê-lo durante o desenvolvimento de um aplicativo. No Laravel vimos o
conceito de encerramentos. O que é aquilo? Programadores experientes sabem disso muito
bem, mas para os iniciantes requer mais explicações. Isso nada mais é do que uma função
anônima. Também é chamado de 'lambdas'. Uma função anônima nada mais é do que uma
função sem nome.
$olá = function($nome)
{ echo “Olá ” . $nome; }
$olá('Mundo'); //saída: Olá mundo
Isto não é pura loucura; é claro que tem propósito. Muitas funções em PHP aceitam
funções como argumentos, por isso ela ajuda nessas situações.
Considere uma situação como esta:
function seuNome($valor){ //
faça alguma coisa
}
array_map('seuNome', $nomes);
Mas em vez disso, basta usar uma função anônima em linha e defini-la assim:
array_map(function($value){ //
faça algo com $value },
$names)
Finalmente, uma função anônima pode ser usada como fechamento em PHP, um conceito
bastante avançado, mas menos comum em PHP; é frequentemente usado em JavaScript. E no Laravel
você já encontrou isso na usabilidade em nível de rota de uma função anônima.
Route::get('/', function()
{ return 'Olá mundo!'
});
28
CAPÍTULO 5
Classe de controlador
No framework MVC, o controlador tem uma função definida. Ele controla principalmente o fluxo entre o
modelo e a visualização. No arquivo 'routes.php' vimos como enviamos a solicitação usando o protocolo
HTTP. Agora queremos organizar o mesmo comportamento usando a classe controlador.
Vamos lembrar o primeiro método de rota. Quando você instala o Laravel ele normalmente vem
com este método de rota padrão.
retornar visualização('bem-vindo');
});
Neste método de rota, obtemos uma visualização. Como diz o método de rota: retorne uma
visualização. A questão é: onde estão os modelos e controladores? Não devemos criar apenas visualizações
usando um Closure, não é?
Suponha que tenhamos 100 páginas em nosso aplicativo. Não podemos criar uma rota para cada página.
Não podemos colocar todos os nossos códigos HTML e CSS nesse arquivo ‘routes.php’. Esse design é
simplesmente feio e impensável. Também não devemos colocar a lógica da nossa aplicação no arquivo
'routes.php'. Para resolver este problema o conceito de classe controladora entra em cena.
Controlador significa controlar o aplicativo. É bastante literal: controla ou gerencia as
camadas de aplicação. Quais são as camadas?
Um aplicativo bem projetado sempre possui algumas camadas internas ocultas. Os usuários não devem ter
nenhuma pista disso. Tudo o que eles deverão ver é a camada de apresentação. A lógica do aplicativo deve sempre
permanecer oculta.
Como iniciante, você deve se acostumar com essa divisão de camadas. Um bom senso de
programação orientada a objetos sempre o guiará para separar a lógica da aplicação da lógica de
apresentação.
Um controlador é um transportador. Ele transporta a lógica do aplicativo para a camada de
apresentação. Um bom princípio de design sempre incentiva você a escrever a lógica do seu aplicativo em um
arquivo oculto separado. Um controlador executará apenas esses métodos e retornará uma visualização.
Nunca saberá o que carrega.
Para começar, vamos criar rapidamente um controlador. É uma boa prática planejar primeiro.
Suponha que você queira criar um controlador simples que retorne apenas uma visualização. Que
tal dar um nome'MeuControlador'?Mantemos este controlador em 'app/Http/Controladores'pasta.

capítulo 5-Classe de controlador
Aqui está o código do nosso arquivo MyController.php:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request; use
App\Http\Requests;
class MeuControlador estende Controlador {
// retornando uma página simples usando view

public function returnASimplePage() {
return view('novapágina');
}
}
Escrevi este código manualmente em meu editor de texto. Na verdade você pode criar qualquer
controlador automaticamente através da linha de comando usando 'artesão'comando. Vamos aprender sobre '
artesão'comando em detalhes mais tarde. Depois disso, também aprenderemos sobre modelos e visualizações
e os conectaremos para obter uma compreensão total do modelo, da visualização e do fluxo do controlador. Na
verdade, mais tarde você encontrará mais usos do 'artesão'comando na criação de migrações de banco de
dados, controladores, modelos e muito mais. Basta ir até a pasta do Laravel e emitir este comando:artesão php.
Então,observe a saída.
Agora é hora de usar este controlador em nosso 'rotas.php'arquivo. Até agora, usamos apenas o roteamento para ir para
a página de visualização. Uma página de visualização é na verdade uma camada de apresentação. Vamos pensar de uma forma
orientada a objetos.
Pela primeira vez usaremos algo diferente: um controlador. Nas 'rotas. php',
adicionamos este código:
Route::get('newpage', 'MyController@returningASimplePage');
Vamos entender esta linha palavra por palavra. A primeira parte está bem. A classe Route
usa um método estático fornecendo uma URL: 'nova página'.Na segunda parte escrevemos o
nome do controlador 'MyController' e usamos um sinal especial '@' para chamar a função
'retornandoASimplePage'.
Se você voltar e der uma olhada no código MyController, descobrirá que esta função
'returningASimplePage' simplesmente retorna uma 'nova página'. Já armazenamos isso 'nova
página.blade.php'arquivo em nosso'Visualizações'pasta antes. Não quero fornecer um código HTML
tão longo. É quase igual ao código HTML que usamos em nosso arquivo 'routes.php' antes.
Agora podemos digitarhttp://localhost:8000/newpagepara ver o que isso mostra!

(Figura5-1.)
30
Figura 5-1.Uma visualização de página simples por meio de um controlador simples
É uma pequena saída interessante e nós a produzimos a partir de um controlador.

Avançamos um pouco!
Como você acabou de ver em 'MeuController.php'arquivo, é uma classe. Deve ter uma função pública; caso
contrário, o Laravel não poderá encaminhá-lo.
Ao escrever uma classe de controlador, você precisa se lembrar de algumas coisas.
Primeiro, renderizamos uma view usando uma classe controladora sempre usando funções públicas.
índice de função pública() {

retornar visualização('casa');
}
Em segundo lugar, no 'rotas.php'arquivo, não usamos mais a função anônima ou Closure.

Em vez disso, roteamos o controlador.
Route::get('home', 'MyController@index');
Nesta primeira parte da aula de controlador, não vamos nos aprofundar muito. Vamos primeiro ver como
model e view funcionam em uníssono com uma classe de controlador. Depois disso, na segunda parte da classe do
controlador, veremos mais funcionalidades e tentaremos construir uma aplicação dinâmica orientada a banco de
dados.
31
5.1 Controlador RESTful

Antes de começarmos este capítulo, vamos perceber uma coisa. REST (Representational State Transfer)
é um protocolo arquitetônico por meio do qual imaginamos nossos URLs como substantivos e damos a
eles verbos comuns como GET, POST, PUT ou DELETE. Cada URL é uma representação de um recurso
imaginário. Espero poder discutir este tópico interessante na sequência deste livro básico do Laravel
Learner. Como usei esse termo antes, presumo que você já esteja familiarizado com o termo 'RESTful'. O
que isso significa? Num sentido simples, oferece algumas soluções. Quando roteamos para Closures
podemos definir o verbo HTTP na forma do método.
Route::get('index','Customer\Profiling\ProfileController@showIndex');
Mas agora estamos preocupados com o Controller, então precisamos encontrar uma solução para isso
também. Conseqüentemente, 'RESTful' vem em nosso socorro. Agora podemos dizer explicitamente ao nosso
mecanismo de transporte: que tipo de verbos devemos usar e como. Como podemos fazer isso? 'app/Contrllers/
profile.php' pode ser escrito assim:
namespace Cliente\Profiling;
classe ProfileController estende BaseController
função pública getProfile()
return Visualização::make('perfil');
}
função pública postCreate() {
//algum formulário aqui para coletar dados

}
}
Esses métodos poderiam ter sido mais. O número realmente não importa. Podemos adicionar o verbo
'delete' também. Agora em nosso 'routes.php' podemos usar todos esses verbos HTTP em um único comando
como este:
Route::controller('perfil','Customer\Profiling\ProfileController');
Através deste comando podemos rotear todos os verbos HTTP utilizados na classe ‘ProfileController’.
Nossa intenção é bem simples. Tentamos disponibilizar um formulário onde os usuários preencherão seus
nomes e outros dados. Depois disso, pegamos esses dados e os publicamos em nosso banco de dados. No
Laravel 3.2, costumávamos escrever de forma diferente, mas os prefixos 'get' ou 'put' também estão lá.
32
5.2 Papel de um Controlador

A primeira pergunta é a seguinte: o que é um controlador? Como você viu nos exemplos dados até
agora, nada mais é do que uma espécie de mecanismo de transporte. Leva seus usuários ou
visualizadores para a camada de apresentação. Lembramos a lei de que uma classe deve ter uma tarefa
singular. A classe Controller leva você para a camada de apresentação e seu trabalho deve ser
finalizado lá. Ele não deve conhecer sua aplicação ou lógica de domínio. Por que não? Porque é um
mecanismo de transporte e nada mais. É como um cabo de dados para um monitor de TV. Há muitas
outras coisas em seu aplicativo acontecendo em segundo plano, e você deve cuidar disso para que
alguém de fora não possa chegar lá. Imagine uma situação como esta:
class UserController estende BaseController

{função pública getIndex()
{
$usuários = Usuário::todos();
return View::make('users.index',compact('users')); }}
Este 'User::all()' refere-se à proposta do Eloquent ORM. Não se preocupe, chegaremos a esse capítulo em
breve na parte de banco de dados e discutiremos detalhadamente sobre o 'Eloquent ORM'. Atualmente você só
precisa saber que ele mantém contato com a camada de dados. Agora, devemos nos conectar ao banco de
dados diretamente dos nossos Controllers? Um mecanismo de transporte que deveria se comunicar com nossa
camada de apresentação também deveria se comunicar com a camada de dados? Uma camada de dados é um
ponto vulnerável e nos colocará em uma situação difícil se alguém colocar alguns códigos sujos nela. Lembre-
se, o controlador é uma transportadora, então ele irá carregá-lo de volta para a camada de dados e teremos
que enfrentar a bagunça!
Portanto, é melhor não saber sobre a lógica do domínio ou a camada de dados e tornar seu
trabalho singular, desacoplando-o de uma forma adequada à nossa aplicação. Como podemos fazer
isso? Aqui, a Interface vem em nosso socorro: algo realmente ótimo. No capítulo Interfaces falamos
sobre voltar a isso, e aqui estamos mais uma vez. As interfaces podem nos salvar encapsulando a
lógica real. Nós estamos seguros. Como não queremos atingir o banco de dados diretamente da nossa
classe Controller, mantemos um escudo entre eles, ou seja, Interfaces. Ele atuará como um meio entre
o Eloquent ORM e o Controller. Nosso Controlador nunca saberá de onde vêm os dados.
Ele fará o seu trabalho e esquecerá disso. Tem muitas vantagens como classes abstratas.
Mas há uma diferença sutil entre eles. Uma Interface define o contrato sintático que todas
as classes derivadas devem seguir. Especificamente, a interface define a parte “o quê” do
contrato sintático e as classes derivadas descreverão a parte “como” do contrato.
interface Detalhes do pedido {

função pública UpdateCustomerStatus(array
$usuário, $quantidade);
}
classe UserClass implementa OrderDetails {
função pública UpdateCustomerStatus(array
$usuário, $quantidade) {
//faça algo através do Eloquent
}
}
33
Você pode usar diversas interfaces entre eles; não se preocupe em usá-los em todo o seu
aplicativo. Quanto mais você usar, melhor. Algumas pessoas podem se opor à digitação extra,
mas pessoalmente acho que o uso de Interfaces tornaria seu aplicativo mais robusto e ágil. Você
pode testá-los sem atingir a lógica do domínio na camada da web.
5.3 Controlador engenhoso

O controlador engenhoso é uma das melhores novas equipes de controladores que o Laravel 4 vem
com. O método de recurso da classe controlador às vezes pode fazer a mágica para nós, e vamos ver
como isso acontece! Vamos dar uma olhada no meu comando artesão e descobrir se há alguma coisa
sobre a equipe do Controlador. Digite o seguinte:
php artesão –lista
E vemos umcontrolador: fazermétodo para criar um controlador engenhoso. É muito bom ter
descoberto que em uma linha de comando do PHP Crafter muito melhorada, podemos criar um controlador
engenhoso.
Vamos criar um controlador engenhoso usando o comando php crafts e ver o que
acontece. Podemos emitir o comando assim:
controlador artesão php:make UserController
Agora, se deixarmos assim, ele criará um controlador cheio de recursos na pasta de

controladores do meu projeto. O céu é o limite para o que você pode fazer com seu controlador
engenhoso UserController. Você pode mostrar qualquer usuário com seu ID, pode editar, atualizar e
criar, e até destruir ou deletar os registros. Atualmente estamos interessados nos dois primeiros
métodos, ou seja, index e show($id). Vamos declarar um novo método Route::resource() em nosso
arquivo Routes.php. É algo assim:
Rota::resource('sanjib', 'UserController',
['apenas'=>['índice', 'mostrar']]);
Como você pode ver, podemos chamar nosso recurso de 'sanjib' e esse recurso é
gerenciado pelo 'UserController' e ele manipula apenas os métodos 'index' e 'show'.
Agora se você digitarhttp://localhost:8000/sanjibvocê vê uma boa saída de qualquer coisa
retornada do método de índice 'UserController'. E além disso, se você digitar http://
localhost:8000/sanjib/1, ele fornecerá uma boa saída com a passagem $id, que é 1 aqui.
Portanto, este é um grande avanço em relação ao Laravel 3, onde este '$id' passou como um método.
De qualquer forma, se você escrever comoRoute::resource('sanjib', 'UserController'), eleproduzirá todos os
sete métodos que acabei de mostrar. E finalmente você pode criar, armazenar,
34
edite, atualize e exclua seus usuários desses métodos. Agora podemos anexar filtro a cada
método de uma só vez ou sozinho. Vamos fazer uma alteração em nosso código UserController,
adicionando uma linha de chamada do filtro do construtor como esta:
//UserController.php
função pública __construir() {
$this>beforeFilter('sanjib');
}
E com isso vamos anexar filtro a todos os meus métodos no arquivo 'routes.php' como
esse:
Rota::filter('sanjib', function(){
return 'Este filtro está anexado a todos os
métodos de recurso sanjib';
});
Agora podemos restringir este filtro ao único 'índice' ou qualquer método que você desejar. Isso
também é moleza agora. Se você quiser anexá-lo ao ‘índice’, basta escrever o seguinte:
função pública __construir() {

$this>beforeFilter('sanjib', ['apenas' } => ['índice']]);
Dessa forma, apenas o método 'index' é filtrado, nada mais. Espero que o papel de um controlador esteja
bem claro agora e que possamos fazer alguns ajustes na página 'Visualizar' construída dinamicamente e ver
como podemos controlar e passar nossos dados através do controlador e construir um site simples.
5.4 Controlador, contêiner IoC e interface

Até agora falamos muito sobre o que um Controlador deve saber. Mas, você pode perguntar, onde
está sua implementação? Exatamente! Isso é o que vou mostrar agora e esta é a pura beleza das
abordagens de código feliz do Laravel 4.2. E todos nós queremos ser felizes com o código, não é?
Deveríamos ser capazes de escrever algum código decente: se não formos tão talentosos quanto
Taylor Otwell, pelo menos poderíamos tentar algumas coisas sofisticadas que satisfizessem nossa
estética inata.
Então, vamos tentar algumas boas práticas. Como queríamos limitar o conhecimento de um
controlador, implementamos uma interface e tornamos nosso controlador ignorante de quaisquer
outras atividades, exceto o mecanismo de transporte. Se dentro do nosso UserController escrevermos
algo assim:
$usuário = Usuário::todos();
retornar Visualização::make('user.index')
> with('usuário', $usuário);
35
nosso controlador atinge diretamente o banco de dados. Isso não queremos. Então, o que podemos fazer em vez
disso?
Vamos criar uma interface 'AllUser' em nossa pasta de modelo. O código é simples.
<?php
/*
* esta interface recebe todos os usuários através de uma classe
chamada GetAllUsers
*/
interface Todos os usuários {
função pública getUsers();
}
Esta interface funcionará como um contrato entre nossas classes ‘GetAllUsers’ e nosso
controlador ‘Usercontroller’. Vamos criar uma classe 'GetAllUsers' assim:
<?php
/*
* esta classe implementa a interface AllUsers e
vinculada ao contêiner IoC
*/
classe GetAllUsers implementa AllUsers {
função pública getUsuários(){
$usuários = Usuário::todos();
retornar $usuários;
}
}
Através desta classe recuperamos todos os nossos usuários da tabela do banco de dados users. Ainda não
cobrimos visualização, modelo, Eloquent ORM e banco de dados, então não se preocupe. Tudo que você precisa saber
agora que temos uma tabela de usuários dentro do nosso banco de dados e estamos recuperando todos os
funcionários da tabela de usuários.
Agora, finalmente, como é o nosso controlador 'UserController'?
<?php
class UserController estende \BaseController
{ protegido $usuários;
função pública __construct(TodosUsuários
$usuários) {
$this>usuários = $usuários;
}
$usuário = $this>usuários>getUsers();
return View::make('user.index')->with('user', $user);
}
índice de função pública()
{
//
36
}
função pública criar() {
//
}
loja de função pública() {
//
}
função pública mostrar($id) {
//
}
função pública editar($id) {
//
}
atualização de função pública($id) {
//
}
função pública destruir($id) {
//
}
}
Esta parte é particularmente importante:
$usuários protegidos;
função pública __construct(TodosUsuários $usuários) {
$this>usuários = $usuários;
}
$usuário = $this->usuários->getUsers();
return View::make('user.index')->with('user', $user);
Implementamos a interface e através da nossa classe 'GetAllUsers' finalmente obtivemos toda a

tabela de usuários. Agora, na visualização 'index', apenas percorremos o objeto 'user' e extraímos o
'nome de usuário' assim:
foreach ($usuário como $valor){

echo $valor>nomedeusuário. "<br>";
}
37
Agora a lógica é clara e muito lúcida de seguir. Agora estamos livres para alterar o destino dos dados a
qualquer momento, apenas mudando dentro da classe ou criando outra classe. Aqui usamos 'MySql', mas
podemos alterá-lo a qualquer momento para qualquer banco de dados que desejar. O mais importante é que
nosso controlador nunca saberia o que está acontecendo lá dentro. Mas o hack final está dentro do nosso
arquivo de 'rota', porque temos que vincular a classe e a interface e o grande contêiner IoC desempenha o
papel fundamental aqui. Isso é muito simples com as fachadas do seu 'App'. O código é o seguinte:
App::bind('AllUsers', 'GetAllUsers');
Como você pode ver, nossas fachadas de 'App' unem a classe e a interface para que uma bela
camada seja incluída entre nossa fonte de dados e o mecanismo de transporte. Além disso, nosso
controlador não sabe o que está acontecendo dentro dessa camada. Nosso aplicativo fica mais
desacoplado e você pode testá-lo facilmente com 'phpUnit' sem acessar diretamente o banco de dados.
5.5 Resumo
Normalmente organizamos nosso mecanismo de transporte ou camada web por meio da classe controladora.
Portanto, esta é uma boa prática para torná-lo ignorante sobre nossa lógica de domínio e usar interfaces como
meio entre a web e a camada de dados. Através de classes controladoras organizamos nossa lógica de nível de
rota e além disso podemos utilizar recursos modernos como injeções de dependências.
Use interface e deixe os controladores manterem sua singularidade de trabalho que deve se preocupar apenas
com a camada web. Como usamos o Composer para carregar automaticamente nossas classes PHP, ele pode residir em
qualquer lugar do sistema de arquivos, desde que o controlador saiba disso. E o roteamento para o controlador é
totalmente dissociado do sistema de arquivos.
Controladores engenhosos geralmente criam controladores RESTful em torno dos recursos. Por fim,
podemos concluir com a parte do filtro, que é extremamente importante no gerenciamento da
administração de uma aplicação. Você pode controlá-lo através do nível de rota ou usá-lo explicitamente
dentro do seu controlador.
Route::get('profile', array('before' => 'auth', 'uses' =>

'UserController@showProfile'));
Ou você pode mencioná-lo especificamente dentro do controlador:
Classe UserController estende BaseController

{função pública __construct()
{
$this>beforeFilter('auth', array('except' =>
'getLogin'));
$this>beforeFilter('csrf', array('on' => 'post'));
$this>afterFilter('log', array('only' =>

array('fooAction', 'barAction')));
}
}
38
E finalmente o filtro pode ser usado através de um construtor como este:
class UserController estende BaseController

{função pública __construct()
{
$this>beforeFilter(função() {
// algum código
});
}
}
Após dominar o controlador básico, é bom consultar a documentação oficial do

Laravel para aprimorar suas habilidades.
39
CAPÍTULO 6
Visualização e Lâmina
No framework MVC, a parte ‘view’ tem um papel importante. Em primeiro lugar, deve ter uma boa
aparência e ser atraente. Ele lida com HTML, CSS, JavaScript e muitos outros códigos que tornam
uma página ótima.
Atualmente é necessário um pouco de conhecimento. Você não precisa ser um especialista para
aprender este capítulo. A pasta 'Views' permanece dentro da pasta 'resources'. Você precisa manter seus
códigos HTML aqui. Para torná-lo incrível, você pode querer ter um ótimo estilo CSS! Esse arquivo CSS e outros
arquivos JavaScript necessários devem ir para a pasta 'pública'. Laravel os conecta facilmente.
Aprenderemos esse processo passo a passo.

Primeiro criaremos algumas páginas estáticas. Em segundo lugar, passaremos dados dinâmicos para que mais
tarde possamos construir um aplicativo dinâmico sobre eles.
Suponha que queiramos ter uma página 'Sobre' em seu aplicativo. Vamos criá-lo e conectá-lo
ao nosso 'MeuControlador'e finalmente encaminhá-lo para o navegador.
É bastante natural que não nos limitemos a ter apenas uma página estática. Mais tarde, poderemos
precisar de uma página 'Fale Conosco' ou de qualquer outra página. Mantendo essa perspectiva em mente,
vamos criar uma pasta 'páginas' dentro da pasta 'visualizações'. Na pasta 'pages', primeiro criamos um
'master.blade.php'arquivo. Esta é uma página de layout mestre. Não é obrigatório chamá-lo sempre de
“mestre”. Podemos chamá-lo de 'layout.blade.php'ou 'padrão.blade.php'ou podemos escolher qualquer outro
nome significativo. Esta página mestra é um modelo de nosso layout básico que outras páginas seguirão.
Lembre-se de que você sempre pode criar pastas separadas para manter layouts mestres
separados para outras páginas. Nem é preciso dizer que você deve sempre ter apenas um layout mestre
para todo o seu aplicativo.
Vamos manter nosso layout mestre bastante simples. Antes de escrever os códigos, podemos
querer aprender uma coisa: o que significa o termo ‘lâmina’?
Bem, 'blade' é o mecanismo de template do Laravel e deve ser escrito em php. Possui
funções próprias para facilitar sua vida. E por esse motivo você precisa adicionar uma
extensão 'blade.php'.
Vamos escrever um código simples 'master.blade.php' e ele terá algumas funções especiais
de modelagem 'blade'.
//resources/views/pages/master.blade.php <!
DOCTYPE html>
<html>
<cabeça>

Capítulo 6-Visualização e Lâmina
@yield('cabeça')
<link rel='stylesheet' href='/css/style.css'> <título>
@yield('título')
</título>
</head>
<corpo>
<div class="contêiner">
<div class="título">
@yield('título')
</div>
<div class="conteúdo">
@rendimento('conteúdo')
</div>
<div class="footer">@yield('footer')</div> </div>
</body>
</html>
Como você pode ver, usamos apenas uma função...colheita'-dentro da página mestra.
Chamamos essa função com um '@' sinal. Esta função tem um significado literal. Realmente
rende, produz ou gera algo.
Segmentamos nossos códigos HTML em algumas partes para que possam ser facilmente
lembrados. Na parte ‘head’ temos duas funções ‘yield’: ‘head’ e ‘title’. Na função '@yield('head')'
temos nosso link de estilo CSS e a outra função 'yield' tem 'title' dentro dela. A parte restante
segue as classes de divisão de estilo CSS. No 'título' mantemos um título grande. Na parte do
conteúdo definimos o ponto do corpo, o estilo da fonte, etc.
Vamos ver nosso código de estilo CSS que mantivemos na pasta 'public/css'.
//public/css/style.css
html, corpo {
altura: 100%;
}
corpo {
margem: 10;
preenchimento: 10;
largura: 90%;
exibição: compacto;
peso da fonte: 100;
}
. contêiner {
alinhamento de texto: esquerda;
display: célula-tabela;
alinhamento vertical: meio;
}
42
. contente {
alinhamento de texto: esquerda;
display: bloco embutido;

}
. rodapé {
alinhamento de texto: certo;
exibição: compacto;
cor vermelha;
}
. cabeçalho {
alinhamento de texto:centro;
altura do texto: tamanho máximo;
cor: vermelho indiano;
}
. h1 {
família de fontes:fantasia;
cor: tomate;
}
. h2 {
família de fontes:cursiva;
cor:coral;
}
Até agora, definimos nosso arquivo ‘master.blade.php’ e nosso arquivo ‘style.css’. Você provavelmente
notou que no arquivo 'master.blade.php' na seção 'head' fornecemos o link do estilo CSS. Agora existe uma
opção onde você pode colocar esse link de arquivo CSS em seu arquivo 'about. página blade.php'.
Vamos primeiro anotar o arquivo 'about.blade.php'.
//resources/views/pages/about.blade.php
@extends('pages.master')
@seção('cabeça')
@parar
@Título da seção')
É uma página de teste
@stop
@seção('título')
{{ $nome }} {{ $profissão }}
@stop
@seção('conteúdo')
<div classe='h1'>
43
Cada escrita é um problema!

</div>
<p>
Houve um problema há alguns minutos. Houve um problema há alguns
minutos.
Houve um problema há alguns minutos. Houve um problema há alguns
minutos.
Houve um problema há alguns minutos.
</p>
<divclass='h2'>
Acabei de resolver isso.
</div>
<p>
Divirtam-se, pessoal.
</p>
@parar
@seção('rodapé')
Casa de Sanjib Sinha
@stop
No topo usamos a função ‘extends’, que literalmente estende a modularidade da página master.
Depois disso, usamos continuamente apenas duas funções: 'section' e 'stop'. Na verdade, essas
funções se conectam aos estilos CSS que você definiu anteriormente.
Cada seção tem sua própria divisão: ‘cabeçalho’, ‘título’, ‘cabeçalho’, ‘conteúdo’ e ‘rodapé’. Cada 'seção'
contém seu próprio conteúdo e então usamos a função 'stop' para interromper essa 'seção'.
Dentro da seção 'head' de 'master.blade.php', usamos o link de estilo CSS. Você também
pode usar o mesmo link dentro de 'about.blade.php'. Nesse caso, você não precisa usar o link
de estilo CSS dentro do arquivo ‘master.blade.php’. A parte superior da nossa página
'about.blade.php' é assim:
@seção('cabeça')
<link rel='stylesheet' href='/css/style.css'> @stop
Mas usar o estilo CSS dentro de 'master.blade.php' é sempre preferível.

Agora, espero que você consiga estabelecer uma relação entre as funções de
'master. blade.php' e 'about.blade.php.' A página mestra desempenha o papel de pai e
a página sobre é sua filha. A lógica flui do pai para o filho.
No 'about.blade.php' encontramos dois termos estrangeiros na seção 'título':
@section('heading')
{{ $nome }} {{ $profissão }}
@stop
44
Você é inteligente o suficiente para adivinhar que são os nomes das variáveis que usamos em
nosso controlador. Caso contrário, como eles apareceriam em nossos arquivos ‘about.blade.php’? Não
os vimos em nossa página mestra.
Você acertou: eles vêm do controlador, 'MeuController.php'arquivo. Anteriormente,
falamos sobre a passagem de dados dinamicamente através do controlador para o view
blade. Por ser uma página 'sobre' podemos passar alguns dados interessantes sobre nós.
Decidimos passar dois dados importantes pelo controlador: 'nome' e
'profissão'. Vamos ver primeiro o código MyController.
//app/Http/Controllers/MyController.php
função pública sobre() {
$nome = 'John Doe,';
$profissão = 'Um Escritor';
return view('pages.about', compact('nome', 'profissão'));
}
Você vê que definimos duas variáveis primeiro e depois retornamos essas variáveis usando o
método 'view' para 'pages.about'. Aqui o termo 'páginas' refere-se ao nome da pasta 'recursos/
visualizações/páginas'.A segunda parte—'about'—refere-se ao arquivo 'about.blade.php'. Poderíamos
ter escrito como 'páginas/sobre'em MeuController. Mas eu pessoalmente prefiro o'.'notação, pois
reflete a abordagem orientada a objetos.
Essa passagem de dados pode ser feita usando vários truques. Mostramos o método
'compacto' do PHP. Mas também poderia ter sido feito desta forma.
$nome = 'John Doe';
return view('pages.about')->with('nome', $nome);
}
Ou poderíamos ter passado como um valor de array, e você pode passar um array longo dessa forma.
return view('pages.about')->com([
'nome'=>'John Doe',
'profissão'=>'Um
Escritor' ]);
}
Finalmente, podemos verificar como fica em nosso navegador favorito. Tipohttp://

localhost: 8000/cerca dee abre a página (Figura6-1).
45
Figura 6-1.Passamos dados dinamicamente para visualização
Até agora, aprendemos alguns truques que nos permitirão criar páginas estáticas com
alguns dados gerados dinamicamente através do controlador.
Tendo progredido um pouco, ganhámos alguma confiança e provavelmente podemos aventurar-
nos agora para assumir algumas tarefas mais difíceis.
46
CAPÍTULO 7
Ambiente
Laravel vem com muitos recursos impressionantes. Um deles são definitivamente as migrações de
banco de dados. No próximo capítulo discutiremos a migração em detalhes.
Antes disso, precisamos entender adequadamente nosso ambiente. O que é ambiente no
Laravel? Se você olhar a raiz do documento, encontrará um arquivo '.env'. Basicamente, nos informa
sobre as conexões do banco de dados. Onde obteríamos esse arquivo de configuração de banco de
dados padrão? Na pasta ‘config’, temos um arquivo ‘database.php’. Abra e veja o conteúdo.
Vemos uma linha que nos informa sobre a conexão padrão com o banco de dados.
//config/database.php
'padrão' => env('DB_CONNECTION', 'mysql'),
É MySQL. Não vamos alterá-lo por enquanto, embora seja temporário, pois na parte posterior do livro
veremos como podemos trabalhar com banco de dados SQLite. No momento, mantenha-o como está – nosso
banco de dados padrão é MySQL. Agora abrindo nosso arquivo '.env' adicionamos nosso banco de dados,
nome de usuário e senha.
//.env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=testdb
DB_USERNAME=raiz
DB_PASSWORD=senha
Há um problema, é claro. Suponha que gostaríamos de colocar nosso projeto em qualquer repositório
em nuvem como ‘github’. Nesse caso, nossos segredos podem ser revelados.
Laravel pensou nisso.
No '.gitignore'arquivo, ele já adicionou esta linha:
//.gitignore
/fornecedor
/node_modules
/público/armazenamento
Homestead.yaml
Homestead.json
. ambiente

Capítulo 7-ambiente
Quando você coloca o projeto inteiro, ele ignora automaticamente as pastas e arquivos
listados. Homestead.yaml e Homestead.json estão entre eles.
Configuramos nosso ambiente e agora podemos avançar com segurança para nosso próximo grande capítulo:
migrações de banco de dados. Depois disso discutiremos o Eloquent e finalmente veremos como funciona o fluxo de
trabalho de Model, View e Controller. Veremos também como podemos “criar, recuperar, atualizar e excluir” nosso
banco de dados SQLite.
48
CAPÍTULO 8
Migração de banco de dados
A migração de banco de dados é um dos melhores recursos que o Laravel oferece. Como iniciante,
você pode achar um pouco difícil adquirir o conceito. Mas depois de aprender sobre migração de
banco de dados, a experiência de trabalhar com qualquer tipo de banco de dados torna-se
extremamente fácil e agradável.
No passado, você precisava criar um banco de dados, tabela e colunas por codificação
SQL ou usando uma ferramenta como PHPMyAdmin. A tarefa às vezes parece assustadora.
Com o Laravel não é mais difícil.
Além disso, temos uma vantagem extra. Como desenvolvedor, trabalhando em equipe, você pode
sincronizar bem seu trabalho de banco de dados com seus colegas. Nesse sentido, tornou-se como um controle
de versão. Você pode implementar facilmente sua tabela de banco de dados e atualizar com novos recursos por
meio de códigos php dentro de seu aplicativo.
Tudo que você precisa fazer é escrever algumas linhas de código PHP e o Laravel cuidará dos próximos
passos. É simples assim.
Vamos começar com uma tabela simples de ‘tarefas’.
Já mencionamos os nomes dos bancos de dados e outros funcionários em nosso arquivo '.env'. Agora é hora de
criar uma tabela de ‘tarefas’ e adicionar algumas colunas a ela.
Antes de iniciar uma nova migração vamos ao nosso 'banco de dados/migrações/'pasta; descobrimos
que dois arquivos PHP já foram armazenados lá. Esses arquivos de migração são 'usuários' e 'redefinições
de senha'. O Laravel vem com eles para que possamos dar uma olhada e tentar entender como realmente
funciona.
Abra a tabela 'usuários'. Tem um nome longo: '
2014_10_12_000000_create_users_tabela.php'.
//banco de dados/migrações/2014_10_12_000000_create_users_table.php <?

php
use Illuminate\Database\Schema\Blueprint; use
Illuminate\Database\Migrations\Migration;
class CreateUsersTable estende migração {
função pública ativa()

{
Schema::create('usuários', function (Blueprint $tabela) {
$tabela->incrementos('id');
$tabela->string('nome');

Capítulo 8-Migração de banco de dados
$tabela->string('email')->unique();
$tabela->string('senha');
$tabela->lembrarToken();
$tabela->timestamps();
});
}
função pública para baixo()
{
Schema::drop('usuários');
}
}
Como você pode ver, existem apenas duas funções: ‘up’ e ‘down’. As instruções escritas no interior
são bastante simples de entender. Ele nos fala sobre a criação de colunas na tabela 'usuários'.
Menciona as características das colunas: se será 'string', ou 'texto', ou terá algum recurso extra de
exclusividade. O método 'up' significa que você gera ou atualiza as tabelas. O método 'down' tem um
significado significativo. Isso significa que você pode reverter suas migrações a qualquer momento e
gerá-las novamente.
Suponha que na tabela de 'tarefas' você de repente pense em alterar o nome de uma
determinada coluna. Você pode reverter sua migração antiga. Você pode atualizá-lo em seu arquivo
PHP de migração e então executar o comando novamente.
Vamos começar a criar nossa nova tabela de ‘tarefas’. Abra seu terminal e emita este
comando:
//fazendo migração
php artesão make:migração create_tasks_table --create="tasks"
Depois de emitir este comando, ele executará automaticamente a migração e

aparecerá em seu terminal.
Depois de criar a tabela 'tarefas', ela também mostrará as outras migrações que foram
enviadas com o Laravel.
//executa o comando de
migração php crafts migram
Após uma migração bem-sucedida, todas as migrações serão mostradas em um só lugar.
//mostrando as migrações Tabela de migração criada com

sucesso. Migrado: 2014_10_12_000000_create_users_table
Migrado: 2014_10_12_100000_create_password_resets_table
Migrado: 2016_08_30_024812_create_tasks_table
Agora, na verdade, temos três mesas em mãos. A nova tabela 'tarefas' também foi
criada com sucesso. Você pode verificar em seu terminal ou abrir sua ferramenta MySQL e
vê-lo. Além disso, precisamos ver como o arquivo PHP de migração foi criado em nosso '
banco de dados/migrações'pasta.
50
Deve haver um arquivo chamado '2016_08_30_024812_create_tasks_table.php'

nessa pasta. Vamos abri-lo e ver o que ele nos reserva.
//banco de dados/migrações/2016_08_30_024812_create_tasks_table.php <?

php
class CreateTasksTable estende migração {

{
Schema::create('tarefas', function (Blueprint $tabela) {
});
}
{
Schema::drop('tarefas');
}
}
Você vê a diferença entre a tabela padrão de 'usuários' e a tabela de 'tarefas' recém-criada.

Nossa tabela de 'tarefas' apresenta dois métodos - como sempre, 'up' e 'down' - mas possui
apenas duas colunas: 'id' e 'timestamps'.
Lembre-se, sempre que você executa uma migração, um arquivo PHP é gerado dentro de 'banco
de dados/migrações'pasta e fica assim. Agora, é nossa responsabilidade adicionar colunas e emitir
novamente o comando de migração. Fizemos a mesma coisa aqui. Mudamos esta parte. Adicionamos
colunas de título e corpo para completar nossa tabela de ‘tarefas’.
//banco de dados/migrações/2016_08_30_024812_create_tasks_table.php
função pública up()
{
Schema::create('tarefas', function (Blueprint $tabela) {
$tabela->string('título');
$tabela->texto('corpo');
});
}
Executamos o comando 'migrate' novamente para atualizar a tabela do banco de

dados. Depois disso, ele se atualiza automaticamente.
//executa o comando de
migração php crafts migram
51
Nesta etapa, suponha que tenhamos esquecido uma coluna na tabela de 'tarefas' recém-criada. Podemos
adicioná-lo depois que todas as migrações terminarem? Sim nos podemos fazer isso.
A grandeza do Laravel é que ele já pensou em todas as possibilidades que poderiam
acontecer. Desta vez o comando é um pouco diferente.
//adicionando uma nova coluna na tabela

php artesão make:migration add_reminder_to_tasks_table --table="tasks"
Migração criada: 2016_08_30_035529_add_reminder_to_tasks_table
Esquecemos de adicionar uma coluna 'lembrete' em nossa tabela de 'tarefas'. Acabamos de adicioná-lo usando o
comando de migração. Agora podemos dar uma olhada em nossa tabela de banco de dados de 'tarefas' recém-criada
em nossa ferramenta phpMyAdmin (Figura8-1).
Figura 8-1.A tabela de 'tarefas' na ferramenta phpMyAdmin
Nossa tabela de 'tarefas' agora tem todas as colunas: 'id', 'título', 'corpo', 'timestamps' e finalmente
'lembrete', que adicionamos mais tarde.
8.1 Resumo
A migração de banco de dados no Laravel é uma técnica que nos ajuda a criar, atualizar ou deletar a
tabela e suas colunas. Em um cenário de desenvolvimento, quando você trabalha em um projeto
participando de diferentes destinos, você pode facilmente modificar ou manipular seu banco de dados
através de alguns comandos php simples.
52
CAPÍTULO 9
Eloquente
A classe Eloquent Model é usada para os métodos de 'implementação de registro ativo' do Laravel. Literalmente
significa que podemos facilmente 'CRIAR, RECUPERAR, ATUALIZAR ou DELETAR' qualquer registro de banco de
dados usando esta classe Eloquent Model.
No comando PHP Crafter do Laravel geramos arquivos através de 'make'. Já vimos isso antes no
caso de 'controladores', 'migrações'. Agora podemos fazer a mesma coisa em nossa classe Model.
Lembre-se de uma coisa: se você possui uma tabela chamada ‘tarefas’, então você deve ter um modelo
chamado ‘Tarefa’. Se tivermos uma tabela chamada ‘songs’, devemos ter um modelo chamado ‘Song’. No
modelo, o nome começa com letra maiúscula e a última letra da tabela é ignorada.
Vamos criar nossa primeira classe de modelo 'Task'.
Como de costume, abrimos nosso terminal e emitimos este comando:
//criando tarefa modelo

php artesão make:model Tarefa
Modelo criado com sucesso.
Depois de emitir este comando, na pasta ‘app’ um arquivo PHP é gerado

automaticamente.
//app/Task.php
<?php
aplicativo de espaço para nome;
use Illuminate\Database\Eloquent\Model;
classe Tarefa estende Modelo
{
}
//código finalizado
É um arquivo PHP simples com uma classe vazia e você não consegue perceber seu poder à primeira
vista.
Mas a realidade é diferente. A classe 'Task' estende a classe 'Model', que é uma classe bastante
complexa com todo tipo de funcionalidade de banco de dados. Possui muitos métodos complexos que
implementam ativamente muitas coisas. Para citar alguns, existem métodos 'salvar', 'encontrar',
'atualizar' e muitos mais. Você pode salvar seu registro. Você pode atualizar seu registro. Você pode
emitir uma atribuição em massa. Há mais funcionalidades que veremos no curso futuro.

Capítulo 9-eloquente
Vamos primeiro preencher as 'tarefas' da nossa tabela de banco de dados com algumas tarefas.
Para isso podemos adicionar ou atualizar registros através de um painel administrativo que possui
formulários para receber entradas ou podemos usar qualquer outro truque.
No momento não aprendemos nada sobre o uso dos formulários. Aprenderemos mais tarde. Portanto, podemos
usar o 'Tinker' em nosso terminal para adicionar alguns registros rápidos para testar nosso modelo de 'Tarefa'.
O que é 'Tinker'?
É um comando artesanal que vem com o Laravel e nos permite trabalhar diretamente na base de
código do Laravel através do terminal.
Se emitirmos este comando: php artesão tinker, ele apenas abre uma interface agradável no terminal
para funcionar incessantemente.
//adicionando 'tarefas' à tabela do banco de dados por

tinker php artesão tinker
Psy Shell v0.7.2 (PHP 5.5.9-1ubuntu4.14 - cli) por Justin Hileman
> > > $tarefa = novo aplicativo\tarefa; =>
Aplicativo\Tarefa {#632}
>>> $tarefa
=> Aplicativo\Tarefa {#632}
> > > $task->title = 'Minha primeira tarefa'; =>
"Minha primeira tarefa"
> > > $task->body = 'Vou acordar cedo amanhã.'; => "Vou acordar cedo
amanhã."
> > > $task->reminder = 'Não esqueça'; =>
"Não esqueça"
> > > $tarefa->toArray();
=> [
"title" => "Minha primeira tarefa",
"body" => "Vou acordar cedo amanhã.", "reminder" => "Não
esqueça",
]
> > > $tarefa->salvar(); =>
verdadeiro
>>>
//adição concluída
Na verdade, criamos um objeto 'tarefa' usando a classe 'Task'. Agora esse objeto pode acessar
automaticamente as colunas quase como propriedades. Assista a esta parte da operação anterior de
conserto.
> > > $task->title = 'Minha primeira tarefa'; =>

"Minha primeira tarefa"
Na verdade, ele mantém esses valores na memória. Quando você finalmente chama o método save(), ele
salva todos os registros da tabela.
Vamos preencher com outro conjunto de registros.
//cria um novo conjunto de

registros php artesão tinker
54
Psy Shell v0.7.2 (PHP 5.5.9-1ubuntu4.14 - cli) por Justin Hileman

> > > $tarefa = novo aplicativo\tarefa;
=> Aplicativo\Tarefa {#632}
> > > $task->create(['title' => 'Minha Segunda Tarefa', 'body'
=> 'Gostaria de acordar cedo', 'lembrete' => 'Preciso
comprar remédios']);
=> Aplicativo\Tarefa {#643
título: "Minha segunda tarefa",
corpo: "Gostaria de acordar cedo", lembrete: "Preciso
comprar remédios",
atualizado_at: "30/08/2016 04:45:10",
criado_at: "30/08/2016 04:45:10", id: 2,
}
>>>
//criado com sucesso
Podemos atualizar o primeiro registro agora? Sim, claro que podemos.

Existem dois métodos pelos quais você pode atualizar seus registros anteriores. O primeiro
método é o método antigo de escrevê-lo novamente e chamar o método save() como antes.
//agora você deseja atualizar o primeiro registro

> > > $tarefa = App\Task::find(1); =>
Aplicativo\Tarefa {#631
identificação: "1",
título: "Minha primeira tarefa",

body: "Eu gostaria de ir ao mercado às
nove.",created_at: "2016-08-30 04:20:53",
atualizado_em: "30/08/2016 04:37:52",
lembrete: "Você precisa ir. Você precisa comprar remédios.",
}
> > > $task->body = 'Vou acordar de manhã.'; => "Vou
acordar de manhã."
> > > $tarefa->salvar();
=> verdadeiro
> > > $task->reminder = 'Preciso fazer.'; =>

"Devo fazer."
> > > $tarefa->salvar(); =>
verdadeiro
>>>
//registro atualizado com sucesso
Existe outro método onde você pode chamar o método update() diretamente para atualizar seu
registro.
//outro método de atualização

> > > $task->update(['reminder' => 'Devo fazer e não esquecer!']);
55
=> verdadeiro
>>>
//registro atualizado com sucesso
Finalmente, queremos testar uma atribuição em massa usando a classe de modelo eloquente.
> > > $tarefa = novo aplicativo\tarefa; =>

Aplicativo\Tarefa {#633}
> > > $task->create(['title' => 'Minha Terceira Tarefa', 'body'
=> 'Tenho que ligar o motor do carro', 'lembrete' => 'A bateria vai
engasgar']);
=> Aplicativo\Tarefa {#646
título: "Minha Terceira Tarefa",
body: "Tenho que ligar o motor do
carro", lembrete: "A bateria vai
engasgar", atualizado_at: "31/08/2016
05:36:16", criado_at: "31/08/2016
05:36:16", id : 3,
}
>>>
Não deu nenhum erro. Mas teria ocorrido o erro se já não tivéssemos mudado a
eloqüente classe do modelo 'Task'.
Anteriormente adicionamos esta linha àquela classe vazia.
//app/Task.php
<?php
classe Tarefa estende Modelo
{
protegido $ preenchível = [
'título',
'corpo',
'lembrete'
];
}
Adicionamos uma propriedade $preenchivele instruímos a classe do modelo Laravel Task a lembrar que
três colunas - 'título', 'corpo' e 'lembrete' - devem ser preenchíveis por meio de atribuição em massa. Essas
colunas podem ser atribuídas em massa a qualquer momento.
Finalmente, podemos concluir que após a migração do banco de dados, a classe do modelo eloquente realmente
nos permite realizar operações de banco de dados com mais flexibilidade. Mas não é o fim; pelo contrário, é um ótimo
começo. A classe de modelo Eloquent tem muitos outros presentes surpreendentes para os desenvolvedores. Agora
vamos aprendê-los através de um fluxo de trabalho completo Model-View-Controller.
Para fazer isso, criaremos um novo controlador e algumas páginas de visualização que renderizarão a
saída do banco de dados. Já criamos um modelo – 'Tarefa' – então não precisamos criá-lo novamente. E
usando o comando artesanal 'tinker', adicionamos dois ou três registros em nossa tabela de banco de dados
MySQL.
56
Usaremos a classe do controlador para usar a abstração da classe do modelo eloquente, por sua vez, para
produzir uma bela visualização de nossa tabela de banco de dados no navegador.
Será parecido com a imagem da Figura9-1:
Figura 9-1.Uma visão das 'tarefas' da tabela do banco de dados
Esta visualização é um produto de um fluxo de trabalho Model-View-

Controller. No próximo capítulo veremos como funciona.
57
CAPÍTULO 10
Fluxo de trabalho de modelo, visualização
e controlador
Até agora aprendemos algumas coisas importantes, incluindo roteamento, controlador, visualização,
migrações de banco de dados e modelo eloquente. Na verdade aprendemos muito e fizemos muitas coisas
que não podem ser feitas em tão pouco tempo com linhas de código tão pequenas.
Usamos o banco de dados MySQL para construir uma tabela de tarefas simples onde agora podemos criar,
recuperar, atualizar e finalmente excluir nossas tarefas usandofunileiroem nosso terminal.
Na verdade, fizemos muitas coisas facilmente com menos código. Você construiu um aplicativo
CRUD (criar, recuperar, atualizar, excluir) completo sem escrever uma única linha de código SQL.
Se você não usasse o Laravel, teria que escrever centenas de linhas de códigos php e sql. O
Laravel fez isso de forma orientada a objetos. Se você quiser fazer isso sozinho, precisará criar pelo
menos 25 arquivos php para ter aquela ideia das divisões de camadas. Além disso, você teria que
usar uma ferramenta MySQL como o phpMyAdmin. Agora pode parecer complicado.
Qual é a característica mais marcante que descobrimos até agora?

O que mais me impressiona é a universalidade desta aplicação. Muitas coisas foram alojadas
sob o mesmo teto. Você não precisa sair do seu aplicativo para fazer nada. Você pode fazer
migrações de banco de dados criando, atualizando ou excluindo tabelas de banco de dados com a
ajuda de apenas algumas linhas de código php. Você pode criar, atualizar ou excluir dados do banco
de dados com algumas linhas de código php sem se preocupar com nenhuma ferramenta MySQL.
Tudo é tão simples.
Ficar dentro do seu aplicativo e fazer coisas difíceis sem sair de casa não é
brincadeira. Laravel fez isso por nós.
Agora temos uma tabela de banco de dados completa que armazenou poucas tarefas. A seguir, veremos como é fácil
recuperar esses dados e apresentá-los em uma página web. Tudo o que precisamos é de um controlador, uma página de
visualização e um modelo.
Na verdade, já temos um modelo chamado ‘Task’, então não precisamos mais criá-lo. Vamos construir primeiro a
classe do controlador que irá buscar os dados do banco de dados em uma página de visualização.
Vamos registrar o controlador primeiro em nosso 'routes.php'.
Route::get('tarefa', 'TaskController@index');

Capítulo 10-Fluxo de trabalho de modelo, visualização e controlador
Agora podemos criar um controlador usando o comando artesão. Deixe-nos fazer isso.
php artesão make:TaskController
Ele cria uma classe de controlador - um arquivo php - 'TaskController.php', na pasta 'app/Http/
Controllers'. É uma classe simples sem nenhum método definido. Vamos criar um método chamado
'index' que irá buscar todos os registros da nossa tabela 'tarefas' no banco de dados.
Para fazer isso, precisamos de nossa eloqüente classe de modelo 'Task', que já definimos no
capítulo anterior. Precisamos usar essa classe no topo do arquivo ‘TaskController.php’ e apenas
chamar o método ‘all()’ a partir dela.
$tarefas = Tarefa::todos();
retornar $tarefas;
Parece muito limpo e simples. A saída vem em 'json' assim:
[{"id":1,"title":"Minha primeira tarefa","body":"Vou acordar de

manhã.","created_at":"2016-08-30 04:20:53", "updated_at":"2016-08-30
04:53:22","reminder":"Devo fazer e não esquecer!"}
.....
//o resto é omitido por questão de brevidade
O Laravel sabe que a saída de um banco de dados pode ser usada para qualquer API. Portanto, o
formato 'json' é a resposta para isso.
Em apenas duas linhas de código recuperamos todos os nossos dados de uma tabela de banco de dados. Mas queremos
obter esses dados em nossa página de visualização. Precisamos criar uma página de visualização. Aprendemos como fazer isso.
Também aprendemos como passar dados de um controlador para uma página de visualização.
Finalmente, nossa classe TaskController se destaca com códigos limpos e simples que buscam todos os
dados do banco de dados usando a eloqüente classe de modelo 'Task'.
<?php
namespace App\Http\Controllers; use
Aplicativo\Tarefa;
use Illuminate\Http\Request;
use App\Http\Requests;
class TaskController estende Controlador {

$tarefas = Tarefa::todos();
return view('páginas.task', compact('tarefas'));
}
}
60
Capítulo 10-Fluxo de trabalho de modelo, visualização e controlador
Agora você deve criar um arquivo 'task.blade.php' dentro da pasta 'resources/views/pages'. Não
vou repetir a parte HTML. Você precisa entender uma coisa importante. No seu TaskController você
captura todos os dados do banco de dados em uma variável chamada '$tarefas'. A saída 'json' anterior
mostra que na verdade é um array. O que você precisa é de um loop 'foreach' para recuperá-los dentro
da sua página 'task.blade.php'.
@foreach ($tarefas como $tarefa)

<h3>
{{ $tarefa->título }}
</h3>
<divclass='h2'>
{{ $tarefa->corpo }}
</div>
Lembrete :
<div classe='h1'>
{{ $ tarefa-> lembrete }}
</div>
@endforeach
Para cada '$tasks' como '$task' podemos obter os dados diretamente. O fluxo de trabalho está concluído.
10.1 Resumo
Tudo começou com a construção de um arquivo de ambiente onde mencionamos o banco de dados padrão como
MySQL e nomeamos o banco de dados como 'testdb'. Em seguida fizemos as migrações do banco de dados e usando
'tinker' adicionamos e atualizamos algumas tarefas. Além disso, seguimos em frente e criamos uma classe de modelo
eloquente 'Task', já que o nome da tabela do nosso banco de dados era 'tasks'. Em seguida registramos a rota e criamos
uma classe TaskController e através dela passamos os dados utilizando o modelo 'Task' para nossa página de
visualização 'task.blade.php'.
10.1.1 Nosso próximo desafio

Para um pequeno aplicativo de banco de dados baseado em texto, o SQLite é adequado. É rápido e baseado em arquivos. Vamos
construir um aplicativo baseado em banco de dados que irá criar, recuperar, atualizar e excluir 'avaliações'. Desta vez não
usaremos 'tinker' para operações de banco de dados. Em vez disso, aprenderemos sobre formulários e criaremos páginas
separadas para esses trabalhos.
A página de 'revisão' de um determinado usuário, John Doe por exemplo, terá uma página inicial
que listará os títulos. Se alguém clicar nesse título, ela poderá ler a resenha em uma página separada.
Ao mesmo tempo, John pode gerenciar todo o banco de dados através de um painel onde será
necessária autenticação. Através desse dashboard ele irá gerenciar o ‘CRUD’. Desta vez usamos nossa
caixa Laravel/homestead e nomeamos este aplicativo como 'review.app', para que se você digitarhttp://
review.appvocê pode ver os comentários de John. E você também pode inserir, atualizar e excluir
dados; será um aplicativo CRUD total.
Vamos bater os pés na praia! É
divertido…
61
CAPÍTULO 11
SQLite é uma brisa!
Gostaríamos de fazer esta aplicação inteiramente baseada no banco de dados SQLite. Normalmente, para uma grande
aplicação as pessoas optam pelo MySQL ou PgSQL, pois podem receber mais visitantes. O SQLite pode não ser grande o
suficiente e ser basicamente baseado em arquivos e de natureza leve, mas pode facilmente lidar com aplicativos de
pequeno a médio porte com cem mil visitantes. Portanto, podemos ficar à vontade para usá-lo em nosso aplicativo
CRUD. Especialmente para o Laravel, o SQLite é muito fácil de usar. Em um minuto você entenderá por que pareço tão
confiante.
Para usar SQLite no Laravel você precisa alterar a configuração padrão do banco de dados. Duas linhas
precisam ser alteradas.
//Code/test/blog/config/databse.php 'default' =>

env('DB_CONNECTION', 'sqlite'),
Na segunda linha, você precisa mencionar o caminho do arquivo do banco de dados SQLite.
//Code/test/blog/config/databse.php
'conexões' => [
'sqlite' => [
'driver' => 'sqlite',
//'database' => storage_path('database.sqlite'),
'banco de dados' => env('DB_DATABASE', database_path('/../database/
database.sqlite')),
'prefixo' => '',
],
Vamos manter nosso arquivo SQLite no diretório 'Código/teste/blog/banco de dados/'pasta. Muitas

pessoas vão para oarmazenarpasta. Qualquer um deles funcionará.
Em segundo lugar, precisamos alterar o arquivo ‘.env’. No arquivo original que acompanha o
Laravel, o banco de dados padrão é mencionado assim:
//Código/teste/blog/.env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306

Capítulo 11-SQLite é uma brisa!
DB_DATABASE=testdb
DB_USERNAME=raiz
DB_PASSWORD=senha
Você deve alterá-lo para isto:
//Código/teste/blog/.env
DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
Portanto, a partir de agora, qualquer operação de banco de dados que você fizer em sua
aplicação será automaticamente registrada no arquivo de banco de dados SQLite que você criar no '
Código/teste/blog/banco de dados'pasta. Normalmente, as pessoas não criam um novo arquivo
SQLite em 'Código/teste/blog/banco de dados'pasta. Eles escolhem o 'Código/teste/blog/storage/
databse.sqlite'arquivo que vem com o Laravel por padrão. Nesse caso, no caminho do seu banco de
dados 'Código/teste/blog/config/databse.php'você precisa mudar o caminho.
Queremos fazer uma pequena pausa no caminho normal e criar um 'database.sqlite' em 'Código/teste/
blog/banco de dados'pasta. Para fazer isso você deve primeiro ir até a pasta desejada.
Código do cd/teste/blog/banco de dados
Em seguida, temos que usar o comando ‘touch’ para criar o arquivo.
toque em banco de dados.sqlite
Agora você está pronto para criar um aplicativo CRUD incrível usando SQLite. E para isso, a primeira
coisa que você precisa fazer é preencher os formulários com os insumos. Por meio dessas entradas, você
pode inserir ou atualizar dados em seu banco de dados SQLite baseado em arquivo.
64
CAPÍTULO 12
Sentimentos complicados de formas
Para preencher os formulários, você precisa primeiro senti-los. Desde o Laravel 5.2.45 esse sentimento é
um pouco diferente. Tornou-se um pouco complicado.
Você precisa instalar o construtor de formulário HTML para poder usar o modelo de formulário Laravel;
isso é muito importante por razões de segurança. Mas há um porém. Desde o Laravel 5.2.45 o velho truque
não funciona. Você não pode mais usar 'compositor requer iluminação/html'comando para adicionar modelos
de construtor de formulário ao seu projeto. Em vez disso, você deve emitir este comando:
sudo compositor requer laravelcollective/html
O compositor levará alguns minutos para atualizar seu sistema. Em seguida, ele procurará
'provedores'e 'apelido'.Então você deve abrir 'Código/teste/blog/config/app.php'arquivo e esta linha
dentro de 'fornecedoresvariedade.
//Code/test/blog/config/app.php
'providers' => [
/*
* Provedores de serviços do Framework Laravel...
*/
...
'Coletivo\Html\HtmlServiceProvider', ],
Em seguida, você deve adicionar duas linhas entre o 'apelido'variedade.
//Code/test/blog/config/app.php
'aliases' => [
...
'Formulário' => 'Coletivo\Html\FormFacade',
'Html' => 'Coletivo\Html\HtmlFacade',
],
Agora você está totalmente preparado para usar o modelo de formulário do Laravel. No próximo capítulo
veremos o uso extensivo dos formulários.

CAPÍTULO 13
Um aplicativo CRUD
Não quero elaborar esta aplicação porque acredito que você seja inteligente o suficiente para
acompanhar o que acontecerá em alguns minutos, quando der uma olhada nos códigos subsequentes.
A aplicação que vamos fazer é muito simples. John Doe é um usuário que deseja criar uma página de
revisão para seu site. Ele deve ter uma página de índice. A partir dessa página de índice pode-se ir para a
seção de detalhes das avaliações que ele vem mantendo. Para fazer isso, ele primeiro tem um arquivo de
migração de banco de dados.
Primeiro criamos esse arquivo (consulte o capítulo sobre migração de banco de dados). Nosso arquivo
tem o nome mais ou menos assim:2016_09_03_015541_create_reviews_table.php.
O código é assim:
<?php
class CreateReviewsTable estende migração {
/**
* Execute as migrações.
*
* @return nulo
*/
{
Schema::create('reviews', function (Blueprint $tabela) {
$tabela->string('categoria');
$tabela->string('título');
$tabela->texto('conteúdo');
$tabela->string('classificação');
});
}
/**
* Reverter as migrações.

Capítulo 13-uma aplicação CrUD
*
* @return nulo
*/
{
Esquema::drop('comentários');
}
}
Você já escolheu o arquivo de banco de dados SQLite para manter seus dados. Então a próxima parte
é bem simples. Anote o modelo, as visualizações e os controladores.
O modelo que usamos neste caso, o antigo modelo 'Task' não funcionará mais. Precisamos criar
um novo modelo de 'Revisão'. Crie-o de acordo com o truque que você aprendeu. Emita o comando
artesão. Ele será criado automaticamente.
O 'Revisão.php'arquivo é criado em seu 'Código/teste/blog/aplicativo'pasta.
//Código/teste/blog/app/ Review.php <?

php
revisão de classe estende modelo {
protegido $ preenchível = [
'categoria',
'título',
'contente',
'avaliação'
];
}
Em seguida, você cria uma classe de controlador. Você aprendeu antes como criar a
classe do controlador: 'TaskController.php'arquivo.
//Código/teste/blog/app/Http/Controllers/ReviewController.php <?
php
namespace App\Http\Controllers;
use Aplicativo\Revisão;
class TaskController estende Controlador {
$revisões protegidas;
$solicitações protegidas;
68
função pública __construct(Revisão $reviews, Solicitar $requests) {
$this->comentários = $comentários;
$this->solicitações = $solicitações;
}

$tarefas = $isto->comentários->todos();
return view('páginas.index', compact('tarefas'));
}
//retorna $tarefas por id; $tarefas =
Revisão::findOrFail($id); return
view('páginas.show', compact('tarefas'));
}
return view('páginas.create');
}
armazenamento de função pública(Solicitação $solicitação){
//$input = Solicitação::all(); //
retorna $entrada;
//retorna $request->title; $revisão = nova
revisão(); $revisão->categoria = $request-
>categoria; $review->title = $request->title;
$review->content = $request->content;
$review->rating = $request->rating;
$revisão->salvar();
retornar "Sucesso";
}
função pública revisãodeedição() {
$tarefas = $this->reviews->get(); //
retorna todas as $tarefas;
return view('pages.editreview', compact('tarefas'));
}
edição de função pública ($id)
{
$tarefas = $this->reviews->find($id); return
View('páginas.edit', compact('tarefas'));
}
atualização de função pública ($id)

{
$revisão = $this->reviews->find($id);
$request = $this->requests;
$revisão->categoria = $request->categoria;
69
$review->title = $request->title; $review-

>content = $request->content; $review-
>rating = $request->rating; $revisão-
>salvar();
retornar "Sucesso";
}
Na classe do controlador você entende que existem alguns métodos novos além do '
índice'.O método de índice mostra a página inicial da página de revisão de John Doe (Figura
13-1).
Figura 13-1.A página de revisão de John Doe
O método do controlador é assim:

}
O código da página 'index.blade.php' na pasta views é uma mera repetição dos códigos
anteriores que usamos no desenvolvimento inicial de nosso aplicativo. Estende um layout mestre e
segue algumas regras simples.
70
//resources/views/pages/index.blade.php
@seção('cabeça')
@parar
É uma página de tarefas recém-criada
@stop
@seção('título')
Página de revisão de John Doe <p></p><p></p><p></
p> <p></p><p></p><p></p> @stop
<p></p><p></p><p></p> <p></p><p></p><p></p>
<h3>
Categoria: {{ $task->category }} </
h3>
<h3>
Título: <a href="/task/{{ $task->id }}">{{ $task->title }}</a> ⋅⋅⋅⋅⋅
Título: <a href="{{ action('TaskController@show', [$task->id]) }}">{{ $task-

>title }}</a>
⋅⋅⋅⋅⋅
Título: <a href="{{ url('/task', $task->id) }}">{{ $task->title }}</a>
</h3>
@endforeach
@parar
@seção('rodapé')
<p></p>
<p></p><p></p><p></p><p></p><p></p><p></p>
<p></p>< p></p><p></p><p></p>
⋅⋅⋅⋅⋅
<a href="{{ url('/create') }}">Criar novas avaliações</a> ⋅⋅⋅⋅⋅
<p></p>
<p></p><p></p><p></p><p></p><p></p><p></p>
<p></p>< p></p><p></p><p></p>
Casa de John Doe
@stop
A rota necessária para esta página será bastante simples. Assumimos que a revisão é nossa nova tarefa, por
isso a mantemos como uma tarefa simples.
//app/Http/routes.php
Route::get('tarefa', 'TaskController@index');
71
Assim que a página de índice da resenha de John Doe aparecer, o visitante ficará feliz em
clicar nos títulos e ler as resenhas. Para isso usamos a função especial 'url'. Observe esta parte
da página 'index.blade.php'.
<h3>
Título: <a href="/task/{{ $task->id }}">{{ $task->title }}</a> ⋅⋅⋅⋅⋅
Título: <a href="{{ action('TaskController@show', [$task->id]) }}">{{ $task-

>title }}</a>
⋅⋅⋅⋅⋅
Título: <a href="{{ url('/task', $task->id) }}">{{ $task->title }}</a>
Usamos três métodos apenas para mostrar os vários métodos flexíveis. No mundo real você
deve usar apenas um. Se você perguntar minha preferência, votarei em qualquer um deles!
Os links clicáveis levarão os visitantes à página 'show.blade.php' na pasta
views (Figura13-2).
Figura 13-2.O detalhe da página de revisão
É bastante simples em nossa parte ‘TaskController’. Observe este segmento de código.
//TaskConreoller.php
}
72
$tarefas = Revisão::findOrFail($id); return

view('páginas.show', compact('tarefas'));
}
O código do 'show.blade.php' é um pouco complicado. Mas não precisa de explicação

nesta fase.
//show.blade.php
@section('head')
@parar
@stop
@seção('título')
Página de revisão de John Doe
@stop
<h3>
Categoria: {{ $tasks->categoria }} </
h3>
<h3>
Título: {{$tarefas->título}}
</h3>
<divclass='h2'>
Revisão: {{ $tasks->content }} </
div>
<div classe='h1'>
Avaliação: {{ $tasks->rating }} </
div>
<p></p>
<a href="{{ url('/task') }}">Voltar à página
inicial</a> ⋅⋅⋅⋅⋅
@parar
@seção('rodapé')
<p></p>
<a href="{{ url('/create') }}">Criar novas avaliações</a>
Casa de John Doe
@stop
Agora podemos rotear esta página através do arquivo 'routes.php' assim:
//rotas.php
Route::get('tarefa/{id}', 'TaskController@show');
Agora a parte importante do aplicativo surge lentamente. Primeiro vem a parte da criação. John
Doe deseja criar ou adicionar comentários às suas páginas. Ele adicionará categorias, título, conteúdo
e classificação, um após o outro (Figura13-3).
73
Figura 13-3.Criar página de revisão
O processo não é muito difícil. Em um aplicativo php simples, provavelmente seriam necessárias algumas
centenas de linhas de código para criar tal aplicativo. Mas o Laravel torna a vida muito mais simples.
Na classe ‘TaskController’ o segmento chama sua atenção. Escrevemos esta parte com dois
métodos consecutivamente.
//TaskController.php
return view('páginas.create');
}
armazenamento de função pública(Solicitação $solicitação){
//$input = Solicitação::all(); //
retorna $entrada;
//retorna $request->title; $revisão = nova
revisão(); $revisão->categoria = $request-
>categoria; $review->title = $request->title;
$review->content = $request->content;
$review->rating = $request->rating;
$revisão->salvar();
retornar "Sucesso";
}
Em seguida, devemos ter uma página de visualização do modelo de blade onde podemos usar os formulários. O
código de 'create.blade.php' é semelhante ao seguinte.
74
//criar.blade.php
@section('head')
@parar
Criação de avaliações
@parar
@seção('título')
John Doe vai criar novas avaliações @stop
<div class="formgroup">
{!! Form::open(['url' => 'criar/tarefa']) !!} <div
class="formgroup">
{!! Form::label('categoria', 'Categoria') !!}
{!! Form::text('categoria', null, ['class' => 'formcontrol', 'required'])!!}
</div>
{!! Form::label('título', 'Título') !!}
{!! Form::text('title', null, ['class' => 'formcontrol', 'required'])!!}
</div>
<p>
</p>
{!! Form::label('content', 'Content') !!} {!! Form::textarea('content',
null, ['class' => 'formcontrol', 'required']) !!}
</div><p></p>
{!! Form::label('classificação', 'classificação') !!}
{!! Form::text('rating', null, ['class' => 'formcontrol', 'required'])!!}
</div>
<p>
<p></p>
<p></p>
{!! Form::submit("Criar avaliações") !!} {!!
Formulário::close() !!}
</div>
@parar
@seção('rodapé')
<a href="{{ url('/editreview') }}">John Doe não está com vontade de adicionar
novas avaliações, então ele voltará para casa para editar as avaliações antigas!</a>
75
Casa de John Doe

@stop
E para registrar a rota necessária, temos que escrever esse trecho de código em nosso arquivo 'routes. php'
arquivo.
//rotas.php
Route::get('criar', 'TaskController@criar');
Route::post('criar/tarefa', 'TaskController@store');
Finalmente, a parte mais complicada da nossa aplicação CRUD está por vir. Parece complicado, mas
o Laravel torna tudo muito mais fácil com o conceito de vinculação de modelo. Como o modelo 'Revisão'
desempenha essencialmente o papel principal nos bastidores, a seção 'editar' é basicamente tratada por
um método especial.
A primeira coisa é a nossa parte do controlador.
//TaskController.php
edição de função pública ($id)
{
$tarefas = $this->reviews->find($id); return
View('páginas.edit', compact('tarefas'));
}
atualização de função pública ($id)
{
$revisão = $this->reviews->find($id);
$request = $this->requests;
$revisão->categoria = $request->categoria;
$review->title = $request->title; $review-
>content = $request->content; $review-
>rating = $request->rating; $revisão-
>salvar();
retornar "Sucesso";
}
Como você pode ver, precisávamos de dois métodos. O primeiro é o método ‘edit’, que nos leva à
página ‘edit.blade.php’. A segunda parte é obviamente o método 'update', que faz o trabalho por trás.
Mas no final das contas, é a encadernação do modelo que faz o verdadeiro truque nos bastidores.
Primeiro vem a página 'editreview'. Se John Doe quiser editar seus comentários, ele
digitará este URL em seu navegador:http://test.app/editreview.
Veremos o código em nossa página 'editreview.blade.php'.
//editreview.blade.php
@section('head')
@parar
76

@stop
@seção('título')
John Doe vai editar a página de avaliação
@stop
<h3>
Categoria: {{ $task->category }} </
h3>
<h3>
Título: <a href="{{ url('/edit', $task->id) }}">{{ $task->title }}</a>
</h3>
@endforeach
@parar
@seção('rodapé')
Casa de John Doe

@stop
Não há nada de muito especial nesta página. Ele clica em um link e chega à página de 'edição'. O
código de 'edit.blade.php' é complicado em uma linha. Atente para isso! (Veja a figura13-4.)
Figura 13-4.Editar página da crítica de John Doe
77
A página de edição onde ocorrerá a edição real será um pouco diferente.
//edit.blade.php
@section('head')
@parar
@stop
@seção('título')
John Doe vai editar a página de avaliação
@stop
{!! Form::model($tasks, ["url" => "update/$tasks->id", "method" => "PATCH"]) !!}
<ul>
<li>
{{ Form::label('category', 'Category:') }}
{{ Form::text('category') }}
</li>
<li>
{{ Form::label('title', 'Title:') }}
{{ Form::text('title') }}
</li>
<li>
{{ Form::label('content', 'Content:') }}
{{ Form::textarea('content') }}
</li>
<li>
{{ Form::label('rating', 'Rating:') }}
{{ Form::text('rating') }}
</li>
<li>
{{ Form::submit('Update', array('class' => 'btn btn-info')) }} </li>
</ul>
{!! Formulário::close() !!}
</div>
@parar
@seção('rodapé')
78
Casa de John Doe

@stop
Esta parte é complicada:
{!! Form::model($tasks, ["url" => "update/$tasks->id", "method" => "PATCH"]) !!}
A rota subsequente será registrada no 'rotas.php'arquivo.
//rotas.php
Route::get('editreview', 'TaskController@editreview');
Route::get('edit/{id}', 'TaskController@edit');
Route::patch('update/{id}', 'TaskController@update');
A página de edição da crítica do John Doe fica assim quando ele clica no título relevante
para editá-los (Figura13-5).
Figura 13-5.A página de edição da crítica de John Doe
Nosso aplicativo é completo em poucas linhas de código. Você não precisava escrever
cem mil linhas de código para realizar essa tarefa complexa.
A página de índice mostra os títulos das resenhas. Quando alguém clica nos títulos, ela pode
acessar a página de revisão. O método 'show' em 'TaskController.php' a levou aos detalhes das análises.
Quando John Doe deseja adicionar comentários, é muito fácil. Ele adiciona apenas preenchendo seus
formulários. A seguir vem a parte mais fácil: a seção de edição. Ele clica no título e chega à página de
edição.
79
CAPÍTULO 14
Autenticação e
Autorização
O Laravel 5.3 torna a autenticação extremamente simples e, se você estiver familiarizado com
o .NET Framework, ele irá lembrá-lo do processo de login e logout do ASP.NET.
Na verdade, você não precisa fazer nada. Tudo está pronto à sua porta; tudo que você
precisa é apenas conectar e ligar, e o processo de autenticação funcionará perfeitamente.
Pessoas com experiência no Laravel 3.2 ou 4.2 às vezes acham isso inacreditável. Na verdade,
você não deve escrever longas linhas de código. É tão fácil e prático. Funciona imediatamente
porque tudo foi configurado previamente e você pode passar pelo código 'config/app.php'. Ao
instalar o Laravel 5, você verá que dois controladores já foram configurados na pasta 'app/Http/
Controllers/Auth/'. Esses dois controladores são 'AuthController' e 'PasswordController'. Vamos
ver como funciona o 'AuthController'. Ele é usado para fins de registro e login de novos usuários.
E através do 'PasswordController' um usuário pode redefinir sua senha. Cada um desses
controladores usa Traits para ter os métodos necessários. Portanto, inicialmente você não deve
alterar esses controladores, a menos que esteja em uma situação muito especial em que gostaria
de personalizar seu processo de registro e login. Vamos ver primeiro o que está dentro deste
controlador 'AuthController', para que possamos entender como ele funciona imediatamente.
<?php
namespace App\Http\Controllers\Auth;
use Illuminate\Support\Facades\Auth;
use Aplicativo\Usuário;
usar Validador;
use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\ThrottlesLogins;
usar

Capítulo 14-autenticação e autorização
Illuminate\Foundation\Auth\AuthenticatesAndRegistersUsers;
classe AuthController estende o controlador
/*
| Controlador de registro e login-------------------------------
- - - - - - - - - - - - - - - - - - | Este controlador cuida do registro de novos

usuários, bem como
| autenticação de usuários existentes. Por padrão, este controlador usa
| uma característica simples para adicionar esses comportamentos. Por que você não explora isso?
*/
use AuthenticatesAndRegistersUsers, ThrottlesLogins;
protegido $redirectPath = '/painel';
protegido $loginPath = 'auth/login';
/**
* Crie uma nova instância do controlador de autenticação.
* @return nulo
*/
função pública __construct()
$this>middleware('convidado', ['exceto' =>
'getLogout']);
82
/**
* Obtenha um validador para uma solicitação de registro recebida.
* @param matriz $dados
* @retornar
\Illuminate\Contratos\Validação\Validador
*/
validador de função protegida (array $data)
return Validador::make($dados, [
'nome' => 'obrigatório|máx:255',
'e-mail' => 'obrigatório|e-mail|max:255| único:usuários',
'senha' => 'obrigatório|confirmado| min:6',
]);
/**
* Crie uma nova instância de usuário após um registro válido.
* @param matriz $dados
* @return Usuário
*/
função protegida criar(matriz $dados)
return Usuário::criar([
83
'nome' => $dados['nome'],
'e-mail' => $dados['e-mail'],
'senha' =>
bcrypt($dados['senha']),
]);
Quando você cria uma instância de autenticação, ela chama automaticamente a propriedade
'middleware' e, em sua rota, você pode configurá-la para que, se quiser proteger qualquer página de visitantes
ou convidados não assinados, basta mencioná-la em sua rota.
função pública __construct()
{
$this>middleware('convidado', ['exceto' =>
'getLogout']);
}
O método validator() ao mesmo tempo funciona para que quando alguém se cadastre seja orientado
adequadamente para manter a regra.
validador de função protegida(array $data) {
return Validador::make($dados, [
'nome' => 'obrigatório|máx:255',
'e-mail' => 'obrigatório|e-mail|max:255|
único:usuários',
'senha' => 'obrigatório|confirmado|min:6',
]);
Resumindo, o 'AuthController' é enviado com todas as armas para disparar em caso de crise. Agora
vamos começar a construir um bom processo de autenticação através do qual podemos registrar e fazer login.
E ao mesmo tempo veremos como podemos usar a propriedade 'middleware' para
84
proteger os painéis de nossos usuários. Para começar você precisa criar uma tabela de 'usuários'. Você recebe um
arquivo de migração de usuário padrão em seu arquivo 'banco de dados/migração'. Vamos configurá-lo primeiro
assim:
Schema::create('usuários', função
(Modelo $tabela) {
$tabela>string('nome');
$tabela->string('email')->unique();
$tabela->string('senha', 60);
$tabela>lembrarToken();
});
Você vê que eu configurei as colunas. Agora emita o seguinte comando:
php artesão migrar
Eu configurei um banco de dados 'MyApp' no arquivo '.env' anteriormente para que os 'usuários' tenham sido
adicionados a esse banco de dados agora. Agora adicionamos quatro páginas de visualização à nossa pasta
'visualizações'. Essas páginas são 'login.blade.php,' 'register.blade.php,' 'dashboard.blade.php,' e 'home.blade.php.'
//códigos de 'login.blade.php' iniciando
@extends('auth.master')
Página de login
@parar
85
<h1>
Entrar
</h1>
@foreach ($erros->all() como $erro)
<li>
{{ $ erro }}
</li>
@endforeach
{!! Form::open(["url" => "auth/login",
"método" => "POST"]) !!}
{!! Form::label('Nome: ') !!} {!!
Formulário::texto('nome')!!}
</div>
<p></p>
{!! Form::label('E-mail: ') !!} {!!
Formulário::e-mail('e-mail')!!}
</div>
<p></p>
{!! Form::label('Senha: ') !!} {!!
86
Formulário::senha('senha')!!}
</div>
<p></p>
<p></p><p></p>
{!! Form::submit('Entrar') !!}
</div>
@parar
@seção('rodapé')
Página de registro de usuários
@parar
Agora vamos criar uma página de registro.
//código de início de 'dashbaord.blade.php'
@extends('auth.master')
Página de registro
@parar
<h1>
Registro
</h1>
@foreach ($erros->all() como $erro)
<li>
87
{{ $ erro }}
</li>
@endforeach
{!! Form::open(["url" => "auth/registro",
{!! Form::label('Nome: ') !!} {!!
Formulário::texto('nome')!!}
</div>
<p></p>
{!! Form::label('E-mail: ') !!} {!!
Formulário::e-mail('e-mail')!!}
</div>
<p></p>
{!! Form::label('Senha: ') !!} {!!
Formulário::senha('senha')!!}
</div>
<p></p>
{!! Form::label('Confirmação de senha: ') !!}
{!! Formulário::senha('senha_confirmação')!!}
</div>
88
<p></p><p></p>
{!! Form::submit('Registrar') !!}
</div>
@parar
@seção('rodapé')
Página de registro
@parar
Por questões de brevidade, pularemos os códigos do painel e da página inicial. Tudo é

igual, exceto por uma opção de logout. É assim:
{!! Form::open(["url" => "auth/logout",
<p></p><p></p>
{!! Form::submit('Sair') !!}
Agora, finalmente, adicionamos estes métodos 'routes.php'
//códigos de 'routes.php' começando
//Rotas de autenticação
Rota::get('auth/login',
'Auth\AuthController@getLogin');
Rota::post('auth/login',
'Auth\AuthController@postLogin');
Rota::get('auth/logout',
89
'Auth\AuthController@getLogout');
Rota::post('auth/logout',
'Auth\AuthController@getLogout');
// Rotas de registro
Rota::get('auth/register',
'Auth\AuthController@getRegister');
Rota::post('auth/register',
'Auth\AuthController@postRegister');
//como proteger a página de seus usuários
Route::group(['middleware' => 'auth'], função ()
Rota::get('home', function() {
retornar visualização('auth.home');
});
Rota::get('painel', function() {
retornar visualização('auth.dashboard');
});
//funciona
//Rota::get('teste', 'MeuController@teste');
});
Agora sua página de registro faz automaticamente a validação do lado do servidor. Você vê o método
$errors>all() da página 'register.blade.php'. Isso funciona. Se um usuário preencher todos os campos
corretamente e pressionar o botão de cadastro, ele será direcionado automaticamente para a página inicial.
E se ele fizer login, será redirecionado para o painel. Lá ele pode sair. Portanto, podemos concluir que a
autenticação no Laravel 5 é como uma moleza. Tudo o que você precisa fazer é definir a tabela de usuários,
criar algumas páginas de visualização e adicionar as rotas necessárias.
90
CAPÍTULO 15
Mais sobre validação
Ok, não há nada de novo na palavra validação. Mesmo que você seja iniciante já sabe o que
significa o termo validação. Muito simples. O envio de formulários em branco pode causar
grandes problemas para o servidor e, como desenvolvedor, você também sofreria com isso.
Outro grande problema é o próprio usuário. A regra é não confiar no usuário. E isso é verdade.
Você deseja o e-mail do usuário e algum texto está sendo fornecido. Como enfrentaremos esta
ameaça? A resposta é validação. E o Laravel tornou isso muito fácil. Não só fácil, mas com tantas
opções, torna-se realmente algo onde as possibilidades são infinitas. Vamos considerar uma
forma como antes:
{{Formulário::open(array('url' => '/')) }}
{{ Form::label('nome de usuário', 'Nome de usuário') }}
{{ Formulário::texto('nome de usuário') }}
{{ Formulário::label('email', 'Endereço de e-mail') }}
{{ Formulário::email('email', ' me@sanjib.me ') }}
{{ Campo de senha. }}
{{ Form::label('senha', 'Senha') }}
{{Formulário::senha('senha') }}
{{ Campo de confirmação de senha. }}
{{ Form::label('senhaConfirmação', 'Senha
confirmação') }}
{{ Form::password('passwordConfirmation') }}
{{Formulário::open(array('url' => '/')) }}


Beginning Laravel - A Beginner's Guide To Application Development With Laravel 5.3-1-95.en - PT

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Beginning Laravel - A Beginner's Guide To Application Development With Laravel 5.3-1-95.en - PT

Enviado por

Direitos autorais:

Formatos disponíveis

Traduzido do Inglês para o Português - www.onlinedoctranslator.

ISBN-13 (pbk): 978-1-4842-2537-0 ISBN-13 (eletrônico): 978-1-4842-2538-7

Copyright © 2017 por Sanjib Sinha

Diretor administrativo: Welmoed Spahr

Para informações sobre traduções, envie um e-maildireitos@apress.com, ou visitewww.apress.com.

Impresso em papel sem ácido

Sobre o autor ������������������������������������������� ���������������������������

Sobre os revisores técnicos ��������������������������������������������� ����������xi

Agradecimentos ���������������������������������������������� ����������������������

- Capítulo 1: Compositor ��������������������������������������������� ������������������

- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant ��������������� 7

- Capítulo 3: Estrutura do Arquivo �������������������������������������������� ��������������

- Capítulo 4: Roteamento, um método estático����������������������������������������� ��� 21

- Capítulo 5: Classe do Controlador��������������������������������������������� �������������

- Capítulo 6: Visualização e Blade ������������������������������������������� �������������� 41

- Capítulo 7: Meio Ambiente��������������������������������������������� ����������������

- Capítulo 8: Migração de banco de dados�������������������������������������������� �������� 49

- Capítulo 9: Eloquente ��������������������������������������������� �������������������

- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador�����������������������������������������

- Capítulo 11: SQLite é uma brisa! ���������������������������������������������� �� 63

- Capítulo 12: Sentimentos complicados de formas������������������������������������������ 65

- Capítulo 13: Uma aplicação CRUD ������������������������������������������ ������� 67

- Capítulo 14: Autenticação e Autorização ����������������������������� 81

- Capítulo 15: Mais sobre validação������������������������������������������� ��� 91

- Capítulo 16: Relações Eloquentes ������������������������������������������� ����� 123

- Capítulo 17: Como a segurança e a autenticação funcionam juntas ��� 153

- Capítulo 18: Como a solicitação e a resposta funcionam no Laravel 5 ������������� 161

- Capítulo 19: Contratos vs� Fachadas ������������������������������������������ �� 167

- Capítulo 20: Middleware, Filtro de Camada e Segurança Extra ���������� 173

Sobre o autor ������������������������������������������� ���������������������������

Sobre os revisores técnicos ��������������������������������������������� ����������xi

Agradecimentos ���������������������������������������������� ����������������������

- Capítulo 1: Compositor ��������������������������������������������� ������������������

- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant ��������������� 7

2.1 Instalando o Virtual Box e o Vagrant .......................................... ...... 7

2.2 Instalando o Homestead Vagrant Box ............................................. .... 9

2.3 Instalação e configuração do Homestead ............................ 10

- Capítulo 3: Estrutura do Arquivo �������������������������������������������� ��������������

3.1 Princípio de Design SÓLIDO............................................. ................... 17

3.2 Interfaces e Injeção de Métodos ............................................. ..... 19

- Capítulo 4: Roteamento, um método estático����������������������������������������� ��� 21

4.1 Melhores Práticas de Roteamento ............................................. ................. 25

4.2 Rotas Nomeadas................................................... ................................ 26

4.3 Organizar arquivos por meio de rota ............................................. ......... 27

4.4 Conceito Avançado de Roteamento e Funções Anônimas ........... 28

- Capítulo 5: Classe do Controlador��������������������������������������������� �������������

5.1 Controlador RESTful ................................................ ........................... 32

5.2 Papel de um Controlador ............................................. ........................... 33

5.3 Controlador engenhoso ............................................. .................. 34

5.4 Controlador, contêiner IoC e interface ........................................ 35

5.5 Resumo.................................................. .................................... 38

- Capítulo 6: Visualização e Blade ������������������������������������������� �������������� 41

- Capítulo 7: Meio Ambiente��������������������������������������������� ����������������� 47

- Capítulo 8: Migração de banco de dados�������������������������������������������� �������� 49

8.1 Resumo................................................... ...................................... 52

- Capítulo 9: Eloquente ��������������������������������������������� ����������������������

- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador���������������������������������������������

10.1 Resumo................................................... .................................... 61

- Capítulo 11: SQLite é uma brisa! ���������������������������������������������� �� 63

- Capítulo 12: Sentimentos complicados de formas������������������������������������������ 65

- Capítulo 13: Uma aplicação CRUD ������������������������������������������ ������� 67

- Capítulo 14: Autenticação e Autorização ����������������������������� 81

- Capítulo 15: Mais sobre validação������������������������������������������� ��� 91

Sobre o autor ��

Sobre os revisores técnicos �� xi

Agradecimentos ��

- Capítulo 1: Compositor ��

- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant �� 7

- Capítulo 3: Estrutura do Arquivo ��

- Capítulo 4: Roteamento, um método estático�� 21

- Capítulo 5: Classe do Controlador��

- Capítulo 6: Visualização e Blade �� 41

- Capítulo 7: Meio Ambiente��

- Capítulo 8: Migração de banco de dados�� 49

- Capítulo 9: Eloquente ��

- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador��

- Capítulo 11: SQLite é uma brisa! �� 63

- Capítulo 12: Sentimentos complicados de formas�� 65

- Capítulo 13: Uma aplicação CRUD �� 67

- Capítulo 14: Autenticação e Autorização �� 81

- Capítulo 15: Mais sobre validação�� 91

- Capítulo 16: Relações Eloquentes �� 123

- Capítulo 17: Como a segurança e a autenticação funcionam juntas �� 153

- Capítulo 18: Como a solicitação e a resposta funcionam no Laravel 5 �� 161

- Capítulo 19: Contratos vs� Fachadas �� 167

- Capítulo 20: Middleware, Filtro de Camada e Segurança Extra �� 173

Sobre o autor ��

Sobre os revisores técnicos �� xi

Agradecimentos ��

- Capítulo 1: Compositor ��

- Capítulo 2: Laravel Homestead, Virtual Box e Vagrant �� 7

- Capítulo 3: Estrutura do Arquivo ��

- Capítulo 4: Roteamento, um método estático�� 21

- Capítulo 5: Classe do Controlador��

- Capítulo 6: Visualização e Blade �� 41

- Capítulo 7: Meio Ambiente�� 47

- Capítulo 8: Migração de banco de dados�� 49

- Capítulo 9: Eloquente ��

- Capítulo 10: Modelo, Visualização, Fluxo de Trabalho do Controlador��

- Capítulo 11: SQLite é uma brisa! �� 63

- Capítulo 12: Sentimentos complicados de formas�� 65

- Capítulo 13: Uma aplicação CRUD �� 67

- Capítulo 14: Autenticação e Autorização �� 81

- Capítulo 15: Mais sobre validação�� 91

- Capítulo 16: Relações Eloquentes �� 123

- Capítulo 17: Como a segurança e a autenticação funcionam juntas �� 153

- Capítulo 18: Como a solicitação e a resposta funcionam no Laravel 5 �� 161

- Capítulo 19: Contratos vs� Fachadas �� 167

- Capítulo 20: Middleware, Filtro de Camada e Segurança Extra �� 173