Entendendo a Estrutura de Pastas de um Projeto Laravel

O Laravel é um dos frameworks PHP mais utilizados, conhecido por sua simplicidade e elegância no desenvolvimento de aplicações web. Para quem está começando ou até para desenvolvedores experientes, entender a estrutura de pastas de um projeto Laravel é essencial para criar uma aplicação organizada, escalável e fácil de manter.

Nesta matéria, vamos explorar a estrutura padrão do Laravel, focando em pastas e arquivos como Controllers, Actions, Traits, Scopes, Services, Models e Observers. Também citaremos outras funcionalidades que tornam o Laravel tão poderoso e flexível.

1. A Estrutura de Diretórios do Laravel

Ao iniciar um novo projeto Laravel, você verá a seguinte estrutura de pastas:

app/
bootstrap/
config/
database/
public/
resources/
routes/
storage/
tests/
vendor/

Cada pasta tem um papel fundamental na organização da aplicação, mas nosso foco estará na pasta app/, onde grande parte da lógica de negócio reside.

2. Controllers

Os Controllers estão localizados em app/Http/Controllers e são responsáveis por lidar com as requisições HTTP e retornar respostas adequadas, geralmente uma view ou JSON. Eles atuam como intermediários entre as rotas e a lógica de negócio.

Exemplo de um Controller:

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('users.index', compact('users'));
    }

    public function store(Request $request)
    {
        // Lógica de validação e criação de um novo usuário
    }
}

3. Actions

As Actions são uma maneira de organizar métodos específicos e isolados para determinadas tarefas. Enquanto muitos utilizam métodos diretamente dentro dos controllers, em projetos maiores é comum delegar a lógica de ações para classes separadas dentro de app/Actions. Isso facilita a reutilização e testabilidade.

Exemplo de uma Action:

namespace App\Actions;

use App\Models\User;

class CreateUserAction
{
    public function execute(array $data)
    {
        return User::create($data);
    }
}

Essa estrutura promove o princípio de responsabilidade única, tornando o código mais modular.

4. Traits

As Traits são blocos de código reutilizáveis que você pode incluir em várias classes. No Laravel, é comum ver traits para isolar comportamentos que são compartilhados por diferentes classes, como métodos de logs ou validações.

As Traits são geralmente armazenadas dentro de app/Traits.

Exemplo de uma Trait:

namespace App\Traits;

trait Loggable
{
    public function log($message)
    {
        // Implementação de log
    }
}

Para utilizá-la em uma classe:

use App\Traits\Loggable;

class UserController extends Controller
{
    use Loggable;

    public function store()
    {
        $this->log('Usuário criado.');
    }
}

5. Scopes

Os Scopes são usados para definir consultas comuns que podem ser reutilizadas em diversos lugares da aplicação. Eles são muito utilizados em Models para filtrar resultados de consultas.

Os Scopes são definidos dentro dos Models:

namespace App\Models;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    public function scopeActive(Builder $query)
    {
        return $query->where('status', 'active');
    }
}

Agora, você pode utilizar esse scope em qualquer consulta:

$activeUsers = User::active()->get();

6. Services

Os Services encapsulam a lógica de negócio da aplicação, separando-a dos controllers e models. Services são ideais para gerenciar funcionalidades complexas, que envolvem múltiplas partes da aplicação.

Eles geralmente são armazenados dentro da pasta app/Services.

Exemplo de um Service:

namespace App\Services;

use App\Models\User;

class UserService
{
    public function createUser(array $data)
    {
        return User::create($data);
    }

    public function deleteUser(User $user)
    {
        return $user->delete();
    }
}

Esse service pode ser facilmente chamado em Controllers ou Actions:

$userService = new UserService();
$userService->createUser($request->all());

7. Models

Os Models representam as tabelas do banco de dados e são responsáveis por interagir diretamente com os dados da aplicação. Eles estão localizados na pasta app/Models e utilizam o Eloquent ORM para simplificar as consultas.

Exemplo de um Model:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = ['name', 'email', 'password'];
}

Além disso, você pode definir relações entre modelos, como belongsTo, hasMany, e outras.

8. Observers

Os Observers são utilizados para observar eventos no ciclo de vida de um model, como a criação, atualização ou exclusão de registros. Eles permitem que você execute ações automaticamente quando esses eventos ocorrem.

Os Observers são localizados em app/Observers.

Exemplo de um Observer:

namespace App\Observers;

use App\Models\User;

class UserObserver
{
    public function created(User $user)
    {
        // Enviar email de boas-vindas quando um usuário for criado
    }
}

O Observer deve ser registrado no AppServiceProvider:

use App\Models\User;
use App\Observers\UserObserver;

public function boot()
{
    User::observe(UserObserver::class);
}

9. Outras Pastas Importantes

• Middleware (app/Http/Middleware): Gerencia o tráfego HTTP antes que ele chegue aos controllers.
• Policies (app/Policies): Gerencia a autorização baseada em permissões.
• Jobs (app/Jobs): Manipula filas e tarefas assíncronas.
• Events e Listeners: Para trabalhar com eventos e ouvir ações específicas.

Conclusão

Entender a estrutura de pastas de um projeto Laravel é o primeiro passo para desenvolver aplicações bem organizadas e escaláveis. Componentes como Controllers, Actions, Traits, Scopes, Services, Models e Observers ajudam a separar as responsabilidades e facilitam a manutenção e extensão do projeto.

Essa organização não só melhora a legibilidade do código, mas também promove a reutilização de funcionalidades, um aspecto crucial em projetos de grande escala.