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');
}