PHP Laravel 프레임워크 면접 질문 2026: Eloquent, 큐, 아키텍처 패턴 완벽 가이드

// 불필요한 데이터 로딩을 피하기 위해 제약 조건과 함께 이거 로드
$users = User::query()
    ->with(['posts' => function (Builder $query) {
        $query->where('published', true)
              ->select('id', 'user_id', 'title', 'published_at');
    }])
    ->withCount('posts')
    ->paginate(25);

// 잘못된 예: 루프 내에서 posts에 접근하면 N+1 발생
foreach ($users as $user) {
    $user->posts; // 각 반복마다 데이터베이스에 쿼리 실행
}

class Comment extends Model
{
    // morphTo는 commentable_type 열에서 부모 타입을 자동으로 해석
    public function commentable(): MorphTo
    {
        return $this->morphTo();
    }
}

// AppServiceProvider.php
// morph 맵은 데이터베이스에 클래스명 노출을 방지하고 쿼리 성능을 향상
Relation::enforceMorphMap([
    'post' => Post::class,
    'video' => Video::class,
    'product' => Product::class,
]);

// 글로벌 스코프: 명시적으로 제거하지 않는 한 모든 쿼리에 적용
protected static function booted(): void
{
    static::addGlobalScope('published', function (Builder $builder) {
        $builder->where('published', true);
    });
}

// 로컬 스코프: ->popular()로 명시적으로 호출
public function scopePopular(Builder $query, int $minViews = 1000): Builder
{
    return $query->where('views', '>=', $minViews);
}

// 사용 예: Post::popular(5000)->get()
// 글로벌 스코프 제거: Post::withoutGlobalScope('published')->get()

class ProcessOrder implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;           // 실패 전 최대 시도 횟수
    public int $backoff = 60;        // 재시도 간 초
    public int $timeout = 120;       // 최대 실행 시간
    public int $maxExceptions = 2;   // 2회 미처리 예외 후 실패

    public function __construct(
        public readonly Order $order
    ) {}

    public function handle(PaymentGateway $gateway): void
    {
        // SerializesModels는 잡 실행 시 Order를 데이터베이스에서 새로 가져옴
        $gateway->charge($this->order);
    }

    public function failed(Throwable $exception): void
    {
        // 모든 재시도 실패 후 호출 - 팀 알림, 환불 등
        Log::critical('Order processing failed', [
            'order_id' => $this->order->id,
            'exception' => $exception->getMessage(),
        ]);
    }
}

public function processBatch(array $orderIds): PendingBatch
{
    $jobs = collect($orderIds)
        ->map(fn (int $id) => new ProcessOrder(Order::find($id)));

    return Bus::batch($jobs)
        ->name('Process Orders ' . now()->toDateString())
        ->allowFailures()  // 일부 잡이 실패해도 배치 계속
        ->then(function (Batch $batch) {
            // 모든 잡이 성공적으로 완료
            Notification::send(Admin::all(), new BatchCompleted($batch));
        })
        ->catch(function (Batch $batch, Throwable $e) {
            // 배치 내 첫 번째 실패
            Log::warning('Batch job failed', ['batch_id' => $batch->id]);
        })
        ->finally(function (Batch $batch) {
            // 배치 종료(성공 또는 실패)
        })
        ->dispatch();
}

public function register(): void
{
    // 싱글톤: 요청 라이프사이클 전체에서 동일한 인스턴스
    $this->app->singleton(PaymentGateway::class, function (Application $app) {
        return new StripeGateway(
            apiKey: config('services.stripe.secret'),
            logger: $app->make(LoggerInterface::class)
        );
    });

    // 바인드: 해석할 때마다 새 인스턴스
    $this->app->bind(ReportGenerator::class, function (Application $app) {
        return new PdfReportGenerator($app->make(ViewFactory::class));
    });

    // 컨텍스트 바인딩: 컨슈머별로 다른 구현
    $this->app->when(PhotoController::class)
        ->needs(Filesystem::class)
        ->give(fn () => Storage::disk('photos'));

    $this->app->when(DocumentController::class)
        ->needs(Filesystem::class)
        ->give(fn () => Storage::disk('documents'));
}

class ReportingServiceProvider extends ServiceProvider implements DeferrableProvider
{
    public function register(): void
    {
        $this->app->singleton(ReportingService::class, function () {
            return new ReportingService(/* 무거운 초기화 */);
        });
    }

    // ReportingService가 요청될 때만 컨테이너가 이 프로바이더를 로드
    public function provides(): array
    {
        return [ReportingService::class];
    }
}

class LogRequestMetrics
{
    public function handle(Request $request, Closure $next): Response
    {
        $request->attributes->set('start_time', microtime(true));
        
        // 다음 미들웨어/컨트롤러로 진행
        return $next($request);
    }

    // 터미네이블: 응답 전송 후 실행
    public function terminate(Request $request, Response $response): void
    {
        $duration = microtime(true) - $request->attributes->get('start_time');
        
        Log::info('Request completed', [
            'path' => $request->path(),
            'status' => $response->getStatusCode(),
            'duration_ms' => round($duration * 1000, 2),
        ]);
    }
}

class OrderRepository
{
    public function __construct(
        private readonly Order $model
    ) {}

    public function findPendingForUser(User $user): Collection
    {
        return $this->model->query()
            ->where('user_id', $user->id)
            ->where('status', OrderStatus::Pending)
            ->with('items.product')
            ->orderByDesc('created_at')
            ->get();
    }

    public function calculateRevenueForPeriod(CarbonPeriod $period): Money
    {
        $total = $this->model->query()
            ->whereBetween('completed_at', [$period->start, $period->end])
            ->where('status', OrderStatus::Completed)
            ->sum('total_cents');

        return Money::ofMinor($total, 'USD');
    }
}

class OrderTest extends TestCase
{
    use RefreshDatabase;  // 클래스당 1회 마이그레이션, 테스트당 트랜잭션

    public function test_user_can_place_order(): void
    {
        // Arrange
        $user = User::factory()->create();
        $product = Product::factory()->create(['price_cents' => 2999]);

        // Act
        $response = $this->actingAs($user)
            ->postJson('/api/orders', [
                'items' => [
                    ['product_id' => $product->id, 'quantity' => 2],
                ],
            ]);

        // Assert
        $response->assertCreated()
            ->assertJsonPath('data.total_cents', 5998);

        $this->assertDatabaseHas('orders', [
            'user_id' => $user->id,
            'status' => 'pending',
        ]);
    }

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

        $user = User::factory()->create();
        $order = Order::factory()->for($user)->create();

        $this->actingAs($user)
            ->postJson("/api/orders/{$order->id}/process");

        Queue::assertPushed(ProcessOrder::class, function ($job) use ($order) {
            return $job->order->id === $order->id;
        });
    }
}

public function test_payment_failure_returns_error(): void
{
    $gateway = $this->mock(PaymentGateway::class);
    $gateway->shouldReceive('charge')
        ->once()
        ->andThrow(new PaymentFailedException('Card declined'));

    $user = User::factory()->create();
    $order = Order::factory()->for($user)->create();

    $response = $this->actingAs($user)
        ->postJson("/api/orders/{$order->id}/pay");

    $response->assertStatus(402)
        ->assertJsonPath('error', 'Card declined');
}