Pytania na rozmowę kwalifikacyjną z PHP Laravel 2026: Eloquent, Kolejki i Wzorce Architektury

Kompleksowy przewodnik po pytaniach rekrutacyjnych Laravel 2026. Eloquent ORM, system kolejek, wzorce architektoniczne i najlepsze praktyki dla programistów PHP.

Pytania na rozmowę kwalifikacyjną z PHP Laravel 2026: Eloquent, Kolejki i Wzorce Architektury

Laravel pozostaje w 2026 roku wiodącym frameworkiem PHP dla aplikacji webowych klasy enterprise. Wraz z wydaniem Laravel 12 i ciągłym rozwojem ekosystemu, pytania rekrutacyjne stały się bardziej wymagające, obejmując zaawansowane koncepcje Eloquent ORM, systemy kolejek oraz wzorce architektoniczne. Ten artykuł przedstawia kluczowe zagadnienia techniczne, które pojawiają się podczas rozmów kwalifikacyjnych na stanowiska Laravel Developer.

Laravel 12 wprowadza natywne atrybuty PHP 8.4

Najnowsza wersja Laravel wykorzystuje atrybuty PHP 8.4 do definicji routingu i middleware. Znajomość nowej składni jest obecnie wymagana na większości rozmów kwalifikacyjnych, ponieważ projekty enterprise migrują do najnowszych wersji frameworka.

Eloquent ORM: Zaawansowane relacje i optymalizacja zapytań

Eloquent ORM to serce Laravel, a pytania dotyczące zaawansowanych relacji i optymalizacji N+1 pojawiają się praktycznie na każdej rozmowie. Rekruterzy oczekują głębokiego zrozumienia eager loading, lazy loading oraz technik optymalizacji zapytań.

Podstawowe pytanie dotyczy różnicy między with() a load(). Metoda with() realizuje eager loading na etapie budowania zapytania, podczas gdy load() wykonuje lazy eager loading na już pobranej kolekcji modeli.

php
// Eager loading - pojedyncze zapytanie z JOIN
$posts = Post::with(["author", "comments.user"])->get();

// Lazy eager loading - ładowanie po pobraniu
$posts = Post::all();
$posts->load("author");

// Constraining eager loads - filtrowanie relacji
$users = User::with(["posts" => function ($query) {
    $query->where("published", true)
          ->orderBy("created_at", "desc")
          ->limit(5);
}])->get();

Zaawansowane pytania obejmują polimorficzne relacje many-to-many oraz implementację własnych typów relacji. Polimorfizm w Eloquent pozwala na elastyczne modelowanie danych, gdzie jeden model może należeć do wielu różnych typów modeli.

php
// Polimorficzna relacja many-to-many
class Tag extends Model
{
    public function posts(): MorphToMany
    {
        return $this->morphedByMany(Post::class, "taggable");
    }

    public function videos(): MorphToMany
    {
        return $this->morphedByMany(Video::class, "taggable");
    }
}

class Post extends Model
{
    public function tags(): MorphToMany
    {
        return $this->morphToMany(Tag::class, "taggable");
    }
}

Query Builder vs Raw SQL: Kiedy użyć każdego podejścia

Rekruterzy często pytają o scenariusze, w których Query Builder nie wystarcza i konieczne jest użycie surowego SQL. Znajomość metod DB::raw(), whereRaw() oraz selectRaw() jest niezbędna dla programistów pracujących z kompleksowymi zapytaniami analitycznymi.

php
// Złożone zapytanie analityczne z funkcjami okna
$salesRanking = DB::table("sales")
    ->select([
        "product_id",
        "total_amount",
        DB::raw("RANK() OVER (PARTITION BY category_id ORDER BY total_amount DESC) as category_rank"),
        DB::raw("SUM(total_amount) OVER (PARTITION BY category_id) as category_total")
    ])
    ->whereYear("created_at", 2026)
    ->get();

// Subquery jako źródło danych
$topSellers = DB::table(DB::raw("(
    SELECT seller_id, SUM(amount) as total_sales
    FROM orders
    WHERE status = 'completed'
    GROUP BY seller_id
    HAVING SUM(amount) > 10000
) as top_sellers"))
->join("users", "users.id", "=", "top_sellers.seller_id")
->select("users.name", "top_sellers.total_sales")
->orderByDesc("total_sales")
->get();

System kolejek Laravel: Jobs, Workers i strategie retry

System kolejek to fundamentalny mechanizm dla skalowalnych aplikacji Laravel. Pytania rekrutacyjne koncentrują się na implementacji Job classes, konfiguracji workers oraz strategiach obsługi błędów.

php
namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\Middleware\WithoutOverlapping;

class ProcessPayment implements ShouldQueue, ShouldBeUnique
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;
    public int $backoff = 60;
    public int $timeout = 120;
    public int $uniqueFor = 3600;

    public function __construct(
        private readonly Order $order,
        private readonly string $paymentMethod
    ) {}

    public function middleware(): array
    {
        return [
            new WithoutOverlapping($this->order->id),
        ];
    }

    public function uniqueId(): string
    {
        return $this->order->id;
    }

    public function handle(PaymentGateway $gateway): void
    {
        $result = $gateway->charge(
            $this->order->total,
            $this->paymentMethod
        );

        if ($result->successful()) {
            $this->order->markAsPaid();
        }
    }

    public function failed(\Throwable $exception): void
    {
        Log::error("Payment failed", [
            "order_id" => $this->order->id,
            "error" => $exception->getMessage()
        ]);
        
        $this->order->markAsPaymentFailed();
    }
}

Zaawansowane zagadnienia obejmują Job Batching, który pozwala na grupowanie wielu zadań i monitorowanie ich postępu jako całości.

php
use Illuminate\Bus\Batch;
use Illuminate\Support\Facades\Bus;

$batch = Bus::batch([
    new ProcessPodcast($podcast1),
    new ProcessPodcast($podcast2),
    new ProcessPodcast($podcast3),
])->then(function (Batch $batch) {
    Log::info("All podcasts processed successfully");
})->catch(function (Batch $batch, \Throwable $e) {
    Log::error("Batch processing failed", ["error" => $e->getMessage()]);
})->finally(function (Batch $batch) {
    Cache::forget("processing_podcasts");
})->allowFailures()->dispatch();

// Monitorowanie postępu
$progress = $batch->progress();
$pending = $batch->pendingJobs;
$failed = $batch->failedJobs;

Wzorce architektoniczne: Repository, Service Layer i Action Classes

Pytania o architekturę aplikacji Laravel są standardem na rozmowach na stanowiska mid i senior. Repository Pattern izoluje logikę dostępu do danych, podczas gdy Service Layer enkapsuluje logikę biznesową.

php
// Repository Interface
namespace App\Repositories\Contracts;

interface UserRepositoryInterface
{
    public function findById(int $id): ?User;
    public function findByEmail(string $email): ?User;
    public function create(array $data): User;
    public function update(User $user, array $data): User;
    public function delete(User $user): bool;
    public function paginate(int $perPage = 15): LengthAwarePaginator;
}

// Repository Implementation
namespace App\Repositories;

class EloquentUserRepository implements UserRepositoryInterface
{
    public function __construct(
        private readonly User $model
    ) {}

    public function findById(int $id): ?User
    {
        return $this->model->find($id);
    }

    public function findByEmail(string $email): ?User
    {
        return $this->model->where("email", $email)->first();
    }

    public function create(array $data): User
    {
        return $this->model->create($data);
    }

    public function paginate(int $perPage = 15): LengthAwarePaginator
    {
        return $this->model->latest()->paginate($perPage);
    }
}

Action Classes to nowoczesny wzorzec promowany przez społeczność Laravel, gdzie każda klasa odpowiada za pojedynczą operację biznesową.

php
namespace App\Actions;

class CreateUserAction
{
    public function __construct(
        private readonly UserRepositoryInterface $users,
        private readonly HashManager $hash,
        private readonly Dispatcher $events
    ) {}

    public function execute(array $data): User
    {
        $user = $this->users->create([
            "name" => $data["name"],
            "email" => $data["email"],
            "password" => $this->hash->make($data["password"]),
        ]);

        $this->events->dispatch(new UserCreated($user));

        return $user;
    }
}

// Użycie w kontrolerze
class UserController extends Controller
{
    public function store(
        StoreUserRequest $request,
        CreateUserAction $action
    ): JsonResponse {
        $user = $action->execute($request->validated());
        
        return response()->json($user, 201);
    }
}

Middleware i Request Lifecycle

Zrozumienie cyklu życia żądania HTTP w Laravel jest kluczowe. Rekruterzy pytają o kolejność wykonywania middleware, różnicę między global i route middleware oraz implementację własnych middleware.

php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureUserIsSubscribed
{
    public function handle(Request $request, Closure $next): Response
    {
        if (!$request->user()?->subscribed()) {
            return redirect()->route("subscription.plans");
        }

        return $next($request);
    }
}

// Terminable middleware - wykonywane po wysłaniu odpowiedzi
class LogResponseTime
{
    private float $startTime;

    public function handle(Request $request, Closure $next): Response
    {
        $this->startTime = microtime(true);
        
        return $next($request);
    }

    public function terminate(Request $request, Response $response): void
    {
        $duration = microtime(true) - $this->startTime;
        
        Log::channel("performance")->info("Request completed", [
            "path" => $request->path(),
            "duration_ms" => round($duration * 1000, 2)
        ]);
    }
}

Testowanie w Laravel: Feature i Unit Tests

Testowanie jest integralną częścią rozmów kwalifikacyjnych. Kandydaci powinni znać różnicę między Feature Tests a Unit Tests oraz umieć mockować zależności.

php
namespace Tests\Feature;

use App\Models\User;
use App\Models\Post;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PostApiTest extends TestCase
{
    use RefreshDatabase;

    public function test_user_can_create_post(): void
    {
        $user = User::factory()->create();

        $response = $this->actingAs($user)
            ->postJson("/api/posts", [
                "title" => "Test Post",
                "content" => "Test content"
            ]);

        $response->assertStatus(201)
            ->assertJsonStructure([
                "data" => ["id", "title", "content", "created_at"]
            ]);

        $this->assertDatabaseHas("posts", [
            "title" => "Test Post",
            "user_id" => $user->id
        ]);
    }

    public function test_unauthenticated_user_cannot_create_post(): void
    {
        $response = $this->postJson("/api/posts", [
            "title" => "Test Post"
        ]);

        $response->assertStatus(401);
    }
}

Mockowanie zewnętrznych serwisów z użyciem Facades:

php
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Queue;

public function test_payment_webhook_dispatches_job(): void
{
    Queue::fake();

    $response = $this->postJson("/webhooks/stripe", [
        "type" => "payment_intent.succeeded",
        "data" => ["object" => ["id" => "pi_123"]]
    ]);

    $response->assertOk();
    Queue::assertPushed(ProcessPaymentWebhook::class);
}

public function test_external_api_integration(): void
{
    Http::fake([
        "api.example.com/*" => Http::response(["status" => "ok"], 200)
    ]);

    $service = app(ExternalApiService::class);
    $result = $service->fetchData();

    $this->assertEquals("ok", $result["status"]);
    Http::assertSent(fn ($request) => 
        $request->url() === "https://api.example.com/data"
    );
}

Gotowy na rozmowy o Laravel?

Ćwicz z naszymi interaktywnymi symulatorami, flashcards i testami technicznymi.

Odkryj Laravel

Podsumowanie

Rozmowy kwalifikacyjne na stanowiska Laravel Developer w 2026 roku wymagają solidnego zrozumienia Eloquent ORM, systemu kolejek oraz wzorców architektonicznych. Kandydaci powinni znać zaawansowane techniki optymalizacji zapytań, implementację Job Batching oraz wzorce Repository i Action Classes. Praktyczna znajomość testowania z wykorzystaniem PHPUnit oraz mockowania zależności stanowi dodatkowy atut podczas procesu rekrutacyjnego. Ciągły rozwój frameworka Laravel sprawia, że programiści muszą regularnie aktualizować swoją wiedzę o najnowsze funkcjonalności i najlepsze praktyki.

Wyzwanie dnia

Znajdziesz błąd w Laravel?

Prawdziwy fragment kodu, ukryty błąd, jedna próba dziennie. Bez konta, żeby spróbować.

Podejmij wyzwanie
Anthony Fillion-Maillet

Autor:

Anthony Fillion-Maillet

Założyciel SharpSkill

Programista fullstack od ponad 10 lat. Prowadzi SharpSkill i odpowiada za wszystko, co się tu ukazuje.

Zaktualizowano 16 września 2026

Udostępnij

Powiązane artykuły

Laravel Octane z Swoole i RoadRunner - optymalizacja wydajności

Laravel Octane w 2026: Swoole, RoadRunner i Optymalizacja Wydajności

Kompleksowy przewodnik po Laravel Octane w 2026 roku. Porównanie Swoole i RoadRunner, techniki optymalizacji wydajności, konfiguracja produkcyjna oraz pytania rekrutacyjne.

PHP Laravel Developer Interview Questions 2026

Pytania na rozmowę kwalifikacyjną PHP Laravel Developer 2026: Kompletny przewodnik przygotowawczy

Kompleksowy przewodnik po pytaniach technicznych na rozmowę kwalifikacyjną dla programistów PHP Laravel w 2026 roku. Obejmuje Eloquent ORM, Service Container, autoryzację, kolejki i testowanie.

Zaawansowane debugowanie Laravel i wzorce architektoniczne z PHP 8.4

Rozwiązania Laravel: Zaawansowane Wzorce, Debugowanie i Pytania Rekrutacyjne 2026

Kompleksowy przewodnik po zaawansowanych wzorcach architektonicznych w Laravel, technikach debugowania z Telescope oraz najczęstszych pytaniach rekrutacyjnych dla programistów Laravel.