Guia para Iniciantes sobre Como Configurar um Projeto no Laravel

Tutoriais
PHP

Neste artigo, vamos passar pelos blocos de construção do Laravel e como podemos usar o Laravel para configurar um pequeno projeto.

Laravel é um poderoso e elegante framework para aplicações web PHP que ganhou imensa popularidade entre os desenvolvedores por sua simplicidade, versatilidade e recursos poderosos. Ao longo dos anos, o Laravel tornou-se o framework PHP de escolha para projetos grandes e pequenos.

Pré-requisitos: Começando com Laravel

Antes de mergulhar no desenvolvimento com Laravel, precisamos garantir que temos todas as ferramentas e softwares necessários instalados. Aqui está o que precisaremos:

  • PHP. O Laravel roda em PHP, então o primeiro passo é garantir que você tenha o PHP instalado em seu sistema. Se não tiver certeza se o PHP está instalado, abra um terminal ou prompt de comando e digite php -v. Se o PHP estiver instalado, você verá um número de versão. Caso contrário, você precisará instalá-lo.

    Para instalar o PHP em sua máquina, temos algumas opções:

    Instalação local. Você pode instalar o PHP diretamente no seu computador. Visite a página de downloads do PHP para obter a versão mais recente para o seu sistema operacional.

    Laravel Homestead. Para uma configuração mais simplificada, especialmente se você é novo no desenvolvimento em PHP, considere usar o Laravel Homestead. Homestead é uma caixa Vagrant pré-configurada que fornece um ambiente de desenvolvimento completo para Laravel. Você pode encontrar instruções de instalação aqui.

  • Composer. O Laravel usa o Composer para gerenciamento de dependências. Composer é o gerenciador de dependências padrão do PHP, e é amplamente utilizado e bem documentado.

  • Instalador do Laravel. O Laravel pode ser instalado globalmente em nosso sistema usando o Instalador do Laravel, uma ferramenta de linha de comando conveniente que simplifica e agiliza o processo de criação de novos projetos Laravel. Para instalá-lo globalmente em seu sistema, siga estes passos:

    1. Abra um terminal ou prompt de comando.
    2. Execute o seguinte comando do Composer:
    composer global require laravel/installer

    Após a conclusão da instalação, verifique se o diretório binário global do Composer está no seu sistema “PATH” para que você possa executar o comando laravel a partir de qualquer lugar.

    Se você prefere uma alternativa mais leve ao Homestead, pode considerar o Laravel Herd. Herd é um ambiente de desenvolvimento local baseado em Docker projetado especificamente para projetos Laravel. Você pode saber mais sobre o Herd e como configurá-lo aqui.

Configurar seu ambiente de desenvolvimento com PHP, Composer e o Laravel Installer (ou explorar opções como Homestead ou Herd) o deixará bem preparado para começar sua jornada com Laravel. Nas seções seguintes, vamos passar pelo processo de criação de um novo projeto Laravel, explorar sua estrutura de diretórios e configurar o ambiente de desenvolvimento.

Configurando um Novo Projeto Laravel

Agora que temos nosso ambiente de desenvolvimento pronto, é hora de criar um novo projeto Laravel. Para criar um novo projeto “vazio”, podemos usar o seguinte comando no terminal:

composer create-project --prefer-dist laravel/laravel project-name

project-name deve ser substituído pelo nome real do projeto. Este comando baixará a versão mais recente do Laravel e configurará um novo diretório de projeto com todos os arquivos e dependências necessárias.

Estrutura de Diretórios: Navegando em um Projeto Laravel

Ao criar um novo projeto Laravel, encontraremos uma estrutura de diretórios bem organizada. Entender essa estrutura é crucial para um desenvolvimento Laravel eficaz. Aqui estão alguns dos diretórios principais e suas finalidades:

  • app. Este diretório abriga a lógica central de nossa aplicação, incluindo controladores, modelos e provedores de serviços.
  • bootstrap. Os arquivos de inicialização e configuração do Laravel residem aqui.
  • config. Aqui encontramos arquivos de configuração para vários componentes de nossa aplicação, permitindo encontrar e personalizar configurações como conexões de banco de dados e serviços a partir de um único ponto no projeto.
  • Database. Neste diretório, definiremos nossas migrações e sementes de banco de dados a serem usadas pelo Eloquent ORM do Laravel. O Eloquent simplifica a gestão do banco de dados.
  • public. Ativos acessíveis publicamente, como CSS, JavaScript e imagens, pertencem aqui. Este diretório também contém o ponto de entrada para nossa aplicação, o arquivo index.php.
  • resources. Os ativos brutos e não compilados de nossa aplicação, como templates Blade, Sass e JavaScript, são armazenados aqui.
  • routes. A configuração de roteamento do Laravel é gerenciada neste diretório.
  • storage. Arquivos temporários e de cache, bem como logs, são armazenados aqui.
  • vendor. O Composer gerencia as dependências do nosso projeto neste diretório. Todas as bibliotecas baixadas estarão neste diretório.

Configuração: Configuração do Banco de Dados e Variáveis de Ambiente

Para configurar a conexão com o banco de dados, precisamos abrir o arquivo .env na pasta raiz do projeto. Aqui, podemos especificar o tipo de banco de dados, host, nome de usuário, senha e nome do banco de dados. Graças a Eloquent ORM, o Laravel suporta múltiplas conexões de banco de dados, tornando-o versátil para várias necessidades de projetos.

Entendendo o arquivo .env

O arquivo .env é onde definimos valores de configuração específicos do ambiente, como detalhes da conexão do banco de dados, chaves de API e outras configurações. Vamos dar uma olhada em um exemplo simples do que você pode encontrar em um .env file:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=my_database
DB_USERNAME=my_username
DB_PASSWORD=my_password

Neste exemplo:

  • DB_CONNECTION especifica o tipo de driver de banco de dados que estamos usando (como MySQL, PostgreSQL, SQLite).
  • DB_HOST especifica o host onde nosso servidor de banco de dados está localizado.
  • DB_PORT especifica a porta na qual o servidor de banco de dados está funcionando.
  • DB_DATABASE especifica o nome do banco de dados ao qual queremos nos conectar.
  • DB_USERNAME e DB_PASSWORD especificam o nome de usuário e a senha necessários para acessar o banco de dados.

Usando variáveis de ambiente

É crucial manter informações sensíveis, como credenciais de banco de dados, seguras. O Laravel incentiva o uso de variáveis de ambiente para alcançar isso. Em vez de codificar nossas credenciais no arquivo .env, podemos referenciá-las em nossos arquivos de configuração.

Por exemplo, em nossos arquivos de configuração do Laravel (localizados no diretório config/), podemos referenciar a configuração do banco de dados desta maneira:

'mysql' => [
    'driver' => env('DB_CONNECTION', 'mysql'),
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '3306'),
    'database' => env('DB_DATABASE', 'forge'),
    'username' => env('DB_USERNAME', 'forge'),
    'password' => env('DB_PASSWORD', ''),
    // ...
],

Aqui, a função env() recupera o valor da variável de ambiente especificada no arquivo .env. Se a variável não for encontrada, ela cai de volta para um valor padrão fornecido como segundo argumento.

Ao usar arquivos de configuração, podemos armazenar dados sensíveis em um local mais seguro e facilmente alternar configurações entre ambientes (como desenvolvimento e produção).

Com nosso projeto Laravel criado, diretórios organizados e banco de dados configurado, estamos prontos para começar a construir nossa aplicação web. Nas seções seguintes, focaremos em roteamento, controladores e trabalhar com modelos Blade para nossas visualizações de frontend.

Roteamento, Controladores e Visualizações: O Coração de Sua Aplicação Laravel

No Laravel, roteamento, controladores e visualizações trabalham em conjunto para lidar com solicitações HTTP e renderizar páginas web dinâmicas. Entender esses conceitos é essencial para criar aplicações web com Laravel.

Resumidamente, as solicitações HTTP são recebidas pelo roteador, que então sabe qual controlador deve lidar com a ação. O controlador é responsável por processar as informações e mostrar as informações processadas através de visualizações.

Roteamento

No Laravel, podemos definir rotas no arquivo routes/web.php. Uma definição básica de rota se parece com isto:

Route::get('/welcome', function () {
    return view('welcome');
});

Este exemplo configura uma rota que, quando acessada, retorna a visualização welcome. As rotas também podem ser usadas para chamar ações do controlador, como mencionamos acima, permitindo-nos organizar o código de forma mais eficiente.

Criando um controlador

Controladores atuam como a ponte entre nossas rotas e a lógica de nossa aplicação. Para criar um controlador, podemos usar o comando make:controller:

php artisan make:controller YourControllerName

Nosso novo controlador contém métodos que correspondem a diferentes ações em nossa aplicação, como exibir uma página ou processar dados de formulários.

Visualizações e modelos Blade

Visualizações no Laravel são responsáveis por apresentar os dados de nossa aplicação aos usuários. Por padrão, Laravel usa um mecanismo de modelagem chamado Blade, que simplifica a criação de visualizações dinâmicas e reutilizáveis. Aqui está um exemplo de renderização de uma visualização em um método do controlador:

public function index()
{
    $data = ['name' => 'John'];
    return view('welcome', $data);
}

Neste exemplo, a visualização welcome é renderizada com dados, neste caso, 'name' é passado para ela.

Blade é um mecanismo de modelagem muito poderoso que permite a criação de conteúdo dinâmico através de declarações condicionais, loops e assim por diante.

Migração e Sementeamento de Banco de Dados

O sistema de migração e sementeamento de banco de dados do Laravel nos permite definir nosso esquema de banco de dados e populá-lo com dados iniciais. Podemos considerar as migrações como alterações de banco de dados controladas por versão, e o seedimento como o processo de adicionar dados de amostra.

Migrações e seedimento são conceitos super poderosos que permitem a consistência do banco de dados em diferentes ambientes.

Para criar uma migração, podemos usar o comando make:migration:

php artisan make:migration create_table_name

Em seguida, podemos editar o arquivo de migração gerado para definir a estrutura da nossa tabela e, em seguida, usar o Artisan para executar a migração:

php artisan migrate

O seedimento é frequentemente usado para popular tabelas com dados iniciais para testes e desenvolvimento. Para criar seeders, podemos usar o comando make:seeder e executá-los com:

php artisan db:seed

Criando Modelos para Interação com o Banco de Dados

O ORM Eloquent do Laravel simplifica as interações com o banco de dados permitindo que trabalhemos com bancos de dados como se fossem objetos. Para criar um modelo, usamos o comando make:model:

php artisan make:model YourModelName

Defina a tabela e as relações no modelo para permitir a recuperação e manipulação de dados facilmente. Por exemplo, para recuperar todos os registros de uma tabela users:

$users = YourModelName::all();

Armados com todo esse conhecimento, incorporando roteamento, controladores, views, migração de banco de dados, seedimento e modelos, estamos bem encaminhados para construir aplicativos web dinâmicos com Laravel. Nas próximas seções, vamos aprofundar-nos na criação de um simples aplicativo CRUD e explorar mais recursos avançados do Laravel.

Criando um Simples Aplicativo CRUD no Laravel

Vamos levar nossa jornada com Laravel para o próximo nível construindo um aplicativo CRUD — neste caso, um simples aplicativo de registro de livros, onde podemos criar, ler, atualizar e deletar livros. Este exercício prático nos ajudará a entender como implementar operações CRUD em Laravel.

Por conta do tamanho deste artigo, nos concentraremos apenas na criação da página inicial do aplicativo, então cabe a você concluir este aplicativo!

Passo 1: Criar uma migração para a tabela de livros

Para gerar uma migração para a tabela books, vamos usar o seguinte comando:

php artisan make:migration create_books_table

Este comando gera um arquivo de migração para criar a tabela books no banco de dados. Em seguida, edite o arquivo de migração gerado que acabamos de criar (database/migrations/YYYY_MM_DD_create_books_table.php) para definir a estrutura da tabela:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateBooksTable extends Migration
{
    public function up()
    {
        Schema::create('books', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->string('author');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('books');
    }
}

Neste arquivo de migração, definimos a estrutura da tabela books, incluindo suas colunas (id, title, author, timestamps). Então, queremos executar a migração para criar a tabela:

php artisan migrate

Este comando executa o arquivo de migração e cria a tabela books no banco de dados.

Passo 2: Criar um seeder para a tabela de livros

Em seguida, queremos gerar um seeder para a tabela books para preenchê-la com alguns dados iniciais:

php artisan make:seeder BooksTableSeeder

Este comando gera um arquivo de seeder para preencher a tabela books com dados iniciais.

Edite o arquivo do seeder (database/seeders/BooksTableSeeder.php) para definir dados de livros de exemplo:

use Illuminate\Database\Seeder;

class BooksTableSeeder extends Seeder
{
    public function run()
    {
        DB::table('books')->insert([
            ['title' => 'Book 1', 'author' => 'Author A'],
            ['title' => 'Book 2', 'author' => 'Author B'],
            ['title' => 'Book 3', 'author' => 'Author C'],
        ]);
    }
}

Neste arquivo de semente, definimos dados de amostra de livros que serão inseridos na tabela books. Neste caso específico, estamos criando livros de 1 a 3 e autores de A a C.

Execute a semente para popular a tabela books:

php artisan db:seed --class=BooksTableSeeder

Este comando executa o arquivo de semente e popula a tabela books com os dados de amostra definidos.

Etapa 3: Criar um controlador

Gere um controlador para gerenciar livros:

php artisan make:controller BookController

Este comando gera um arquivo de controlador (BookController.php) que contém métodos para lidar com operações CRUD relacionadas a livros. Com o controlador criado, vamos nos concentrar na implementação de métodos CRUD no BookController. Está localizado em app/Http/Controllers/BookController.php:

use App\Book; // Importe o modelo Book

public function index()
{
    $books = Book::all();
    return view('books.index', compact('books'));
}

public function create()
{
    return view('books.create');
}

public function store(Request $request)
{
    $book = new Book;
    $book->title = $request->input('title');
    $book->author = $request->input('author');
    $book->save();

    return redirect()->route('books.index');
}

// Implemente métodos de edição, atualização, exibição e exclusão de forma semelhante

Neste arquivo de controlador, definimos métodos para lidar com operações CRUD relacionadas a livros. Por exemplo, o método index recupera todos os livros do banco de dados e os passa para a visualização index, enquanto o método store cria um novo registro de livro com base nos dados enviados por meio de um formulário. O método create() é responsável por exibir o formulário para criar um novo registro de livro. Quando um usuário navega até a rota associada a este método, o Laravel executará esta função e retornará uma visualização chamada books.create.

Etapa 4: Criar visualizações

Crie visualizações para listagem, criação e edição de livros no diretório resources/views.

Exemplo de Visualização (create.blade.php):

@extends('layout')

@section('content')
  <h1>Create a New Book</h1>
  <form method="POST" action="{{ route('books.store') }}">
    @csrf
    <div class="form-group">
      <label for="title">Title</label>
      <input type="text" name="title" class="form-control" id="title" placeholder="Enter book title">
    </div>
    <div class="form-group">
      <label for="author">Author</label>
      <input type="text" name="author" class="form-control" id="author" placeholder="Enter author name">
    </div>
    <button type="submit" class="btn btn-primary">Submit</button>
  </form>
  <a href="{{ route('books.index') }}">Back to the list</a>
@endsection

Neste exemplo, a visualização create contém um formulário para adicionar um novo livro. O formulário envia dados para o método store do BookController. A diretiva @csrf gera um token CSRF para proteger contra falsificação de solicitação entre sites.

Com este exemplo, você deve ser capaz de implementar os métodos do controlador e as visualizações para o restante das operações CRUD por conta própria, então vamos começar!

Conclusão

Neste artigo, examinamos os fundamentos de uma aplicação Laravel: como podemos usar a linha de comando para nos ajudar a construir uma aplicação, a estrutura de uma aplicação Laravel e como criar uma aplicação CRUD em Laravel.

I hope this article was useful and that you’re now capable of using Laravel to create your applications and expand the information here with more advanced topics. More information on Laravel can be found at the official Laravel website.

Source:
https://www.sitepoint.com/laravel-project-setup-beginners-guide/