Ruby on Rails 면접 질문: 2026년 Top 25

# app/models/article.rb
# Model은 데이터와 비즈니스 로직을 관리합니다
class Article < ApplicationRecord
  # 데이터 검증
  validates :title, presence: true, length: { minimum: 5 }
  validates :body, presence: true

  # 다른 모델과의 연관관계
  belongs_to :author, class_name: 'User'
  has_many :comments, dependent: :destroy
  has_many :tags, through: :article_tags

  # 재사용 가능한 쿼리를 위한 스코프
  scope :published, -> { where(published: true) }
  scope :recent, -> { order(created_at: :desc).limit(10) }

  # 라이프사이클 콜백
  before_save :generate_slug

  private

  def generate_slug
    self.slug = title.parameterize if title_changed?
  end
end

# app/controllers/articles_controller.rb
# Controller는 요청을 받아 응답을 조정합니다
class ArticlesController < ApplicationController
  before_action :authenticate_user!, except: [:index, :show]
  before_action :set_article, only: [:show, :edit, :update, :destroy]

  def index
    @articles = Article.published.recent.includes(:author)
  end

  def show
    @comments = @article.comments.includes(:user)
  end

  def create
    @article = current_user.articles.build(article_params)

    if @article.save
      redirect_to @article, notice: '게시물이 성공적으로 생성되었습니다.'
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def set_article
    @article = Article.find(params[:id])
  end

  def article_params
    params.require(:article).permit(:title, :body, :published, tag_ids: [])
  end
end

<%# app/views/articles/show.html.erb %>
<%# View는 데이터를 HTML 형식으로 표시합니다 %>
<article class="article-detail">
  <header>
    <h1><%= @article.title %></h1>
    <p class="meta">
      작성자: <%= @article.author.name %> •
      <%= l @article.created_at, format: :long %>
    </p>
  </header>

  <div class="content">
    <%= simple_format @article.body %>
  </div>

  <%# 댓글을 위한 partial %>
  <%= render @comments %>
</article>

# app/models/user.rb
# Active Record는 컬럼을 속성으로 자동 매핑합니다
class User < ApplicationRecord
  # 'users' 테이블이 자동으로 연결됩니다
  # 컬럼: id, email, name, created_at, updated_at

  has_secure_password # 비밀번호용 BCrypt

  has_many :articles, foreign_key: :author_id
  has_one :profile, dependent: :destroy
  has_and_belongs_to_many :roles

  # 검증
  validates :email, presence: true,
                    uniqueness: { case_sensitive: false },
                    format: { with: URI::MailTo::EMAIL_REGEXP }

  # 콜백
  before_save :normalize_email

  # 쿼리를 위한 클래스 메서드
  def self.admins
    joins(:roles).where(roles: { name: 'admin' })
  end

  private

  def normalize_email
    self.email = email.downcase.strip
  end
end

# Active Record 쿼리 예시
# Rails 콘솔 또는 서비스 내부

# 생성
user = User.create!(email: 'dev@example.com', name: 'Alice', password: 'secret123')

# 조건이 있는 읽기
active_users = User.where(active: true).order(:name)
user = User.find_by(email: 'dev@example.com')

# 체이닝 쿼리 (lazy evaluation)
recent_admins = User.admins
                    .where('created_at > ?', 1.month.ago)
                    .includes(:profile)
                    .limit(10)

# eager loading 으로 N+1 방지
articles = Article.includes(:author, :comments).published

# 업데이트
user.update!(name: 'Alice Martin')

# 트랜잭션
User.transaction do
  user.debit_balance!(100)
  recipient.credit_balance!(100)
  Payment.create!(from: user, to: recipient, amount: 100)
end

# db/migrate/20260203100000_create_products.rb
# 테이블을 생성하기 위한 마이그레이션
class CreateProducts < ActiveRecord::Migration[7.1]
  def change
    create_table :products do |t|
      t.string :name, null: false
      t.text :description
      t.decimal :price, precision: 10, scale: 2, null: false
      t.integer :stock_quantity, default: 0
      t.references :category, null: false, foreign_key: true
      t.boolean :active, default: true

      t.timestamps # created_at 과 updated_at 을 자동 추가
    end

    # 성능을 위한 인덱스
    add_index :products, :name
    add_index :products, [:category_id, :active]
  end
end

# db/migrate/20260203110000_add_slug_to_products.rb
# 기존 테이블을 수정하는 마이그레이션
class AddSlugToProducts < ActiveRecord::Migration[7.1]
  def change
    add_column :products, :slug, :string
    add_index :products, :slug, unique: true

    # 기존 슬러그 채우기
    reversible do |dir|
      dir.up do
        Product.find_each do |product|
          product.update_column(:slug, product.name.parameterize)
        end
      end
    end

    # 채운 후 NOT NULL 로 변경
    change_column_null :products, :slug, false
  end
end

# 필수 마이그레이션 명령
rails db:migrate              # 대기 중인 마이그레이션 실행
rails db:rollback             # 직전 마이그레이션 취소
rails db:rollback STEP=3      # 직전 3개의 마이그레이션 취소
rails db:migrate:status       # 마이그레이션 상태 확인
rails db:seed                 # db/seeds.rb 실행
rails db:reset                # Drop, create, migrate, seed

# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
  def index
    # ❌ N+1 문제: 1개의 쿼리 + 주문당 N개의 쿼리
    # @orders = Order.all
    # 뷰에서 order.user.name 호출 시 주문마다 쿼리가 발생합니다

    # ✅ includes 를 활용한 해결 (eager loading)
    @orders = Order.includes(:user, :items)
                   .where(status: 'completed')
                   .order(created_at: :desc)
    # 총 3개의 쿼리만 발생
  end

  def show
    # includes: 연관관계를 별도로 로드 (2-3개의 쿼리)
    @order = Order.includes(items: :product).find(params[:id])

    # preload: 별도 로딩을 강제
    @order = Order.preload(:items, :user).find(params[:id])

    # eager_load: LEFT OUTER JOIN 강제 (1개의 쿼리)
    @order = Order.eager_load(:items).find(params[:id])
  end
end

# app/models/order.rb
class Order < ApplicationRecord
  belongs_to :user
  has_many :items, class_name: 'OrderItem'
  has_many :products, through: :items

  # 기본 includes 가 적용된 스코프
  scope :with_details, -> { includes(:user, items: :product) }

  # COUNT 쿼리를 피하기 위한 counter cache
  # 필요: add_column :users, :orders_count, :integer, default: 0
  belongs_to :user, counter_cache: true
end

# Bullet gem 으로 N+1 감지 (development)
# config/environments/development.rb
config.after_initialize do
  Bullet.enable = true
  Bullet.alert = true
  Bullet.bullet_logger = true
  Bullet.rails_logger = true
end

# Bullet 은 다음 상황에서 알림을 보여줍니다:
# - N+1 쿼리가 감지된 경우
# - 불필요한 eager loading 이 있는 경우
# - counter cache 를 사용해야 할 경우

# app/models/product.rb
class Product < ApplicationRecord
  # 단순 스코프
  scope :active, -> { where(active: true) }
  scope :in_stock, -> { where('stock_quantity > 0') }
  scope :featured, -> { where(featured: true) }

  # 매개변수가 있는 스코프
  scope :cheaper_than, ->(price) { where('price < ?', price) }
  scope :in_category, ->(category) { where(category: category) }

  # 체이닝 가능한 스코프
  scope :available, -> { active.in_stock }

  # joins 를 포함한 스코프
  scope :with_recent_orders, -> {
    joins(:order_items)
      .where('order_items.created_at > ?', 30.days.ago)
      .distinct
  }

  # 서브쿼리를 포함한 스코프
  scope :bestsellers, -> {
    where(id: OrderItem.group(:product_id)
                       .order('COUNT(*) DESC')
                       .limit(10)
                       .select(:product_id))
  }
end

# app/queries/products_search_query.rb
# 복잡한 검색을 위한 Query Object
class ProductsSearchQuery
  def initialize(relation = Product.all)
    @relation = relation
  end

  def call(params)
    @relation = filter_by_category(params[:category])
    @relation = filter_by_price_range(params[:min_price], params[:max_price])
    @relation = filter_by_search(params[:q])
    @relation = apply_sorting(params[:sort])
    @relation
  end

  private

  def filter_by_category(category)
    return @relation if category.blank?
    @relation.where(category_id: category)
  end

  def filter_by_price_range(min, max)
    @relation = @relation.where('price >= ?', min) if min.present?
    @relation = @relation.where('price <= ?', max) if max.present?
    @relation
  end

  def filter_by_search(query)
    return @relation if query.blank?
    @relation.where('name ILIKE ? OR description ILIKE ?',
                    "%#{query}%", "%#{query}%")
  end

  def apply_sorting(sort)
    case sort
    when 'price_asc' then @relation.order(price: :asc)
    when 'price_desc' then @relation.order(price: :desc)
    when 'newest' then @relation.order(created_at: :desc)
    else @relation.order(:name)
    end
  end
end

# 컨트롤러에서 사용
@products = ProductsSearchQuery.new(Product.active).call(params)

# config/routes.rb
Rails.application.routes.draw do
  # 표준 RESTful 라우트 (7개의 액션)
  resources :articles do
    # 중첩 라우트
    resources :comments, only: [:create, :destroy]

    # member 라우트 (인스턴스에 대해 동작)
    member do
      post :publish
      delete :archive
    end

    # collection 라우트 (컬렉션에 대해 동작)
    collection do
      get :drafts
      get :search
    end
  end

  # namespace 가 있는 API 라우트
  namespace :api do
    namespace :v1 do
      resources :products, only: [:index, :show, :create, :update] do
        resources :reviews, shallow: true
      end
    end
  end

  # 사용자 정의 라우트
  get 'dashboard', to: 'dashboard#index'

  # 라우트 제약
  constraints(SubdomainConstraint.new) do
    resources :admin_settings
  end

  # 루트 라우트
  root 'home#index'
end

# rails routes - 생성된 모든 라우트 표시
#
# Verb   URI Pattern                    Controller#Action
# GET    /articles                      articles#index
# POST   /articles                      articles#create
# GET    /articles/new                  articles#new
# GET    /articles/:id/edit             articles#edit
# GET    /articles/:id                  articles#show
# PATCH  /articles/:id                  articles#update
# DELETE /articles/:id                  articles#destroy
# POST   /articles/:id/publish          articles#publish
# GET    /articles/drafts               articles#drafts

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  # CSRF 보호는 기본 활성화
  protect_from_forgery with: :exception

  # 인증을 위한 전역 콜백
  before_action :authenticate_user!

  # 전역 에러 처리
  rescue_from ActiveRecord::RecordNotFound, with: :not_found
  rescue_from ActionController::ParameterMissing, with: :bad_request

  private

  def not_found
    render json: { error: '리소스를 찾을 수 없습니다' }, status: :not_found
  end

  def bad_request(exception)
    render json: { error: exception.message }, status: :bad_request
  end
end

# app/controllers/admin/products_controller.rb
class Admin::ProductsController < ApplicationController
  # 옵션이 있는 콜백
  before_action :require_admin
  before_action :set_product, only: [:show, :edit, :update, :destroy]
  after_action :log_activity, only: [:create, :update, :destroy]

  # 조건부 콜백
  before_action :check_stock, only: [:update], if: :stock_changed?

  def create
    @product = Product.new(product_params)

    if @product.save
      redirect_to [:admin, @product], notice: '상품이 생성되었습니다.'
    else
      render :new, status: :unprocessable_entity
    end
  end

  def update
    if @product.update(product_params)
      redirect_to [:admin, @product], notice: '상품이 업데이트되었습니다.'
    else
      render :edit, status: :unprocessable_entity
    end
  end

  private

  def require_admin
    redirect_to root_path unless current_user&.admin?
  end

  def set_product
    @product = Product.find(params[:id])
  end

  def stock_changed?
    params[:product][:stock_quantity].present?
  end

  def log_activity
    ActivityLog.create!(
      user: current_user,
      action: action_name,
      resource: @product
    )
  end

  def product_params
    params.require(:product).permit(:name, :price, :description, :stock_quantity)
  end
end

# app/services/order_processor.rb
# 표준 인터페이스를 가진 Service Object
class OrderProcessor
  def initialize(order, payment_method:)
    @order = order
    @payment_method = payment_method
  end

  def call
    return failure('주문이 이미 처리되었습니다') if @order.processed?

    ActiveRecord::Base.transaction do
      validate_stock!
      process_payment!
      update_inventory!
      send_confirmation!

      @order.update!(status: 'completed', processed_at: Time.current)
    end

    success(@order)
  rescue PaymentError => e
    failure("결제 실패: #{e.message}")
  rescue InsufficientStockError => e
    failure("재고 부족: #{e.message}")
  end

  private

  def validate_stock!
    @order.items.each do |item|
      unless item.product.stock_quantity >= item.quantity
        raise InsufficientStockError, item.product.name
      end
    end
  end

  def process_payment!
    result = PaymentGateway.charge(
      amount: @order.total,
      method: @payment_method,
      description: "주문 ##{@order.id}"
    )

    raise PaymentError, result.error unless result.success?
    @order.update!(payment_reference: result.transaction_id)
  end

  def update_inventory!
    @order.items.each do |item|
      item.product.decrement!(:stock_quantity, item.quantity)
    end
  end

  def send_confirmation!
    OrderMailer.confirmation(@order).deliver_later
  end

  def success(data)
    Result.new(success: true, data: data)
  end

  def failure(error)
    Result.new(success: false, error: error)
  end

  Result = Struct.new(:success, :data, :error, keyword_init: true) do
    def success? = success
    def failure? = !success
  end
end

# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
  def create
    @order = current_user.orders.build(order_params)

    if @order.save
      result = OrderProcessor.new(@order, payment_method: params[:payment_method]).call

      if result.success?
        redirect_to @order, notice: '주문이 확인되었습니다!'
      else
        @order.update!(status: 'payment_failed')
        flash.now[:alert] = result.error
        render :new, status: :unprocessable_entity
      end
    else
      render :new, status: :unprocessable_entity
    end
  end
end

# app/models/concerns/sluggable.rb
# 슬러그 생성을 위한 재사용 가능한 Concern
module Sluggable
  extend ActiveSupport::Concern

  included do
    # include 시 실행되는 코드
    before_validation :generate_slug, if: :should_generate_slug?
    validates :slug, presence: true, uniqueness: true
  end

  # 클래스 메서드
  class_methods do
    def find_by_slug!(slug)
      find_by!(slug: slug)
    end

    def sluggable_source(column = :title)
      @sluggable_source = column
    end

    def sluggable_source_column
      @sluggable_source || :title
    end
  end

  # 인스턴스 메서드
  def to_param
    slug
  end

  private

  def should_generate_slug?
    slug.blank? || send("#{self.class.sluggable_source_column}_changed?")
  end

  def generate_slug
    source = send(self.class.sluggable_source_column)
    return if source.blank?

    base_slug = source.parameterize
    self.slug = unique_slug(base_slug)
  end

  def unique_slug(base)
    slug = base
    counter = 1

    while self.class.where(slug: slug).where.not(id: id).exists?
      slug = "#{base}-#{counter}"
      counter += 1
    end

    slug
  end
end

# app/models/article.rb
class Article < ApplicationRecord
  include Sluggable

  sluggable_source :title # 선택, 기본값은 :title
end

# app/models/product.rb
class Product < ApplicationRecord
  include Sluggable

  sluggable_source :name
end

# app/controllers/concerns/pagination.rb
# 컨트롤러용 Concern
module Pagination
  extend ActiveSupport::Concern

  included do
    helper_method :page_param, :per_page_param
  end

  private

  def paginate(relation)
    relation.page(page_param).per(per_page_param)
  end

  def page_param
    params[:page]&.to_i || 1
  end

  def per_page_param
    [params[:per_page]&.to_i || 25, 100].min
  end
end

# spec/models/user_spec.rb
require 'rails_helper'

RSpec.describe User, type: :model do
  # FactoryBot 의 팩토리
  let(:user) { build(:user) }
  let(:admin) { build(:user, :admin) }

  describe 'validations' do
    it { is_expected.to validate_presence_of(:email) }
    it { is_expected.to validate_uniqueness_of(:email).case_insensitive }

    it '이메일 형식을 검증합니다' do
      user.email = 'invalid'
      expect(user).not_to be_valid
      expect(user.errors[:email]).to include('is invalid')
    end
  end

  describe 'associations' do
    it { is_expected.to have_many(:articles).dependent(:destroy) }
    it { is_expected.to have_one(:profile) }
    it { is_expected.to belong_to(:organization).optional }
  end

  describe '#full_name' do
    it '이름과 성을 결합해 반환합니다' do
      user = build(:user, first_name: 'John', last_name: 'Doe')
      expect(user.full_name).to eq('John Doe')
    end

    it '성이 없는 경우도 처리합니다' do
      user = build(:user, first_name: 'John', last_name: nil)
      expect(user.full_name).to eq('John')
    end
  end

  describe '.active' do
    it '활성 사용자만 반환합니다' do
      active = create(:user, active: true)
      inactive = create(:user, active: false)

      expect(User.active).to include(active)
      expect(User.active).not_to include(inactive)
    end
  end
end

# spec/services/order_processor_spec.rb
require 'rails_helper'

RSpec.describe OrderProcessor do
  let(:user) { create(:user) }
  let(:product) { create(:product, stock_quantity: 10, price: 100) }
  let(:order) { create(:order, user: user, items: [build(:order_item, product: product, quantity: 2)]) }

  subject { described_class.new(order, payment_method: 'card') }

  describe '#call' do
    context '주문이 유효한 경우' do
      before do
        allow(PaymentGateway).to receive(:charge).and_return(
          OpenStruct.new(success?: true, transaction_id: 'txn_123')
        )
      end

      it '주문이 정상적으로 처리됩니다' do
        result = subject.call

        expect(result).to be_success
        expect(order.reload.status).to eq('completed')
      end

      it '상품 재고를 감소시킵니다' do
        expect { subject.call }.to change { product.reload.stock_quantity }.by(-2)
      end

      it '확인 이메일을 발송합니다' do
        expect { subject.call }
          .to have_enqueued_mail(OrderMailer, :confirmation)
          .with(order)
      end
    end

    context '결제가 실패한 경우' do
      before do
        allow(PaymentGateway).to receive(:charge).and_return(
          OpenStruct.new(success?: false, error: 'Card declined')
        )
      end

      it '실패 결과를 반환합니다' do
        result = subject.call

        expect(result).to be_failure
        expect(result.error).to include('Card declined')
      end

      it '주문 상태는 변경되지 않습니다' do
        expect { subject.call }.not_to change { order.reload.status }
      end
    end
  end
end

# spec/requests/api/v1/products_spec.rb
require 'rails_helper'

RSpec.describe 'API V1 Products', type: :request do
  let(:user) { create(:user) }
  let(:headers) { { 'Authorization' => "Bearer #{user.api_token}" } }

  describe 'GET /api/v1/products' do
    let!(:products) { create_list(:product, 3, :active) }

    it '상품 목록을 반환합니다' do
      get '/api/v1/products', headers: headers

      expect(response).to have_http_status(:ok)
      expect(json_response['data'].size).to eq(3)
    end

    it '카테고리로 필터링합니다' do
      category = create(:category)
      categorized = create(:product, category: category)

      get '/api/v1/products', params: { category_id: category.id }, headers: headers

      expect(json_response['data'].map { |p| p['id'] }).to eq([categorized.id])
    end
  end

  describe 'POST /api/v1/products' do
    let(:valid_params) do
      { product: { name: '새 상품', price: 99.99, category_id: create(:category).id } }
    end

    it '새 상품을 생성합니다' do
      expect {
        post '/api/v1/products', params: valid_params, headers: headers
      }.to change(Product, :count).by(1)

      expect(response).to have_http_status(:created)
    end
  end
end

# spec/factories/users.rb
FactoryBot.define do
  factory :user do
    # 고유성을 보장하는 시퀀스
    sequence(:email) { |n| "user#{n}@example.com" }
    first_name { Faker::Name.first_name }
    last_name { Faker::Name.last_name }
    password { 'password123' }
    confirmed_at { Time.current }

    # 변형을 위한 trait
    trait :admin do
      role { 'admin' }
      after(:create) do |user|
        user.permissions.create!(name: 'admin_access')
      end
    end

    trait :unconfirmed do
      confirmed_at { nil }
    end

    trait :with_profile do
      after(:create) do |user|
        create(:profile, user: user)
      end
    end

    trait :with_articles do
      transient do
        articles_count { 3 }
      end

      after(:create) do |user, evaluator|
        create_list(:article, evaluator.articles_count, author: user)
      end
    end

    # 상속된 팩토리
    factory :admin_user do
      admin
      with_profile
    end
  end
end

# spec/factories/orders.rb
FactoryBot.define do
  factory :order do
    user
    status { 'pending' }

    trait :with_items do
      transient do
        items_count { 2 }
      end

      after(:create) do |order, evaluator|
        create_list(:order_item, evaluator.items_count, order: order)
        order.recalculate_total!
      end
    end

    trait :completed do
      status { 'completed' }
      processed_at { Time.current }
      with_items
    end

    trait :high_value do
      after(:create) do |order|
        create(:order_item, order: order, quantity: 10, unit_price: 500)
        order.recalculate_total!
      end
    end
  end
end

# 테스트에서의 사용
RSpec.describe OrderProcessor do
  # build: 영구화되지 않는 인스턴스
  let(:user) { build(:user) }

  # create: DB 에 저장
  let(:order) { create(:order, :with_items, user: user) }

  # create_list: 여러 인스턴스
  let(:products) { create_list(:product, 5) }

  # trait 조합
  let(:admin) { create(:user, :admin, :with_profile) }

  # 속성 덮어쓰기
  let(:expensive_order) { create(:order, :with_items, items_count: 10) }

  # build_stubbed: 더 빠르며 단위 테스트에 적합
  let(:stubbed_user) { build_stubbed(:user) }
end

# app/jobs/process_order_job.rb
class ProcessOrderJob < ApplicationJob
  queue_as :default

  # 재시도 설정
  retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
  retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
  discard_on ActiveJob::DeserializationError

  # Sidekiq 옵션 (백엔드가 Sidekiq 인 경우)
  sidekiq_options retry: 5, backtrace: true

  def perform(order_id)
    order = Order.find(order_id)

    OrderProcessor.new(order).call
  rescue ActiveRecord::RecordNotFound
    # 큐 등록과 실행 사이에 주문이 삭제된 경우
    Rails.logger.warn("Order #{order_id} not found, skipping job")
  end
end

# app/jobs/batch_email_job.rb
class BatchEmailJob < ApplicationJob
  queue_as :mailers

  # Sidekiq Enterprise 또는 throttle gem 으로 속도 제한
  sidekiq_options throttle: { threshold: 100, period: 1.minute }

  def perform(user_ids, template_id)
    template = EmailTemplate.find(template_id)

    User.where(id: user_ids).find_each do |user|
      UserMailer.custom_email(user, template).deliver_later
    end
  end
end

# 작업 큐잉
# 즉시 실행
ProcessOrderJob.perform_later(order.id)

# 지연 실행
ProcessOrderJob.set(wait: 5.minutes).perform_later(order.id)

# 특정 시각에 실행
ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order.id)

# 특정 큐에 실행
ProcessOrderJob.set(queue: :critical).perform_later(order.id)

# 동기 실행 (테스트나 디버깅용)
ProcessOrderJob.perform_now(order.id)

# config/sidekiq.yml
:concurrency: 10
:queues:
  - [critical, 3]    # 높은 우선순위, 가중치 3
  - [default, 2]     # 보통 우선순위, 가중치 2
  - [mailers, 1]     # 낮은 우선순위, 가중치 1
  - [low, 1]

:schedule:
  cleanup_job:
    cron: '0 3 * * *'  # 매일 새벽 3시
    class: CleanupJob

# app/controllers/api/v1/base_controller.rb
module Api
  module V1
    class BaseController < ActionController::API
      include ActionController::HttpAuthentication::Token::ControllerMethods

      before_action :authenticate_token!

      rescue_from ActiveRecord::RecordNotFound, with: :not_found
      rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
      rescue_from ActionController::ParameterMissing, with: :bad_request

      private

      def authenticate_token!
        authenticate_or_request_with_http_token do |token, options|
          @current_user = User.find_by(api_token: token)
        end
      end

      def current_user
        @current_user
      end

      def not_found(exception)
        render json: { error: '리소스를 찾을 수 없습니다', details: exception.message },
               status: :not_found
      end

      def unprocessable_entity(exception)
        render json: { error: '검증 실패', details: exception.record.errors },
               status: :unprocessable_entity
      end

      def bad_request(exception)
        render json: { error: '잘못된 요청', details: exception.message },
               status: :bad_request
      end
    end
  end
end

# app/controllers/api/v1/products_controller.rb
module Api
  module V1
    class ProductsController < BaseController
      before_action :set_product, only: [:show, :update, :destroy]

      def index
        @products = Product.active
                           .includes(:category)
                           .page(params[:page])
                           .per(params[:per_page] || 20)

        render json: {
          data: ProductSerializer.new(@products).serializable_hash,
          meta: pagination_meta(@products)
        }
      end

      def show
        render json: ProductSerializer.new(@product, include: [:category, :reviews])
      end

      def create
        @product = Product.new(product_params)
        @product.save!

        render json: ProductSerializer.new(@product), status: :created
      end

      def update
        @product.update!(product_params)
        render json: ProductSerializer.new(@product)
      end

      def destroy
        @product.destroy!
        head :no_content
      end

      private

      def set_product
        @product = Product.find(params[:id])
      end

      def product_params
        params.require(:product).permit(:name, :description, :price, :category_id)
      end

      def pagination_meta(collection)
        {
          current_page: collection.current_page,
          total_pages: collection.total_pages,
          total_count: collection.total_count
        }
      end
    end
  end
end

# app/serializers/product_serializer.rb
# jsonapi-serializer gem 을 사용
class ProductSerializer
  include JSONAPI::Serializer

  attributes :id, :name, :description, :price, :created_at

  attribute :formatted_price do |product|
    "$#{product.price.to_f.round(2)}"
  end

  belongs_to :category
  has_many :reviews

  link :self do |product|
    Rails.application.routes.url_helpers.api_v1_product_url(product)
  end
end

# app/services/jwt_service.rb
class JwtService
  SECRET_KEY = Rails.application.credentials.secret_key_base
  ALGORITHM = 'HS256'.freeze

  class << self
    def encode(payload, exp = 24.hours.from_now)
      payload[:exp] = exp.to_i
      payload[:iat] = Time.current.to_i
      JWT.encode(payload, SECRET_KEY, ALGORITHM)
    end

    def decode(token)
      decoded = JWT.decode(token, SECRET_KEY, true, algorithm: ALGORITHM)
      HashWithIndifferentAccess.new(decoded.first)
    rescue JWT::ExpiredSignature
      raise AuthenticationError, '토큰이 만료되었습니다'
    rescue JWT::DecodeError
      raise AuthenticationError, '유효하지 않은 토큰입니다'
    end
  end
end

# app/controllers/api/v1/auth_controller.rb
module Api
  module V1
    class AuthController < ActionController::API
      def login
        user = User.find_by(email: params[:email])

        if user&.authenticate(params[:password])
          token = JwtService.encode(user_id: user.id)
          render json: {
            token: token,
            user: UserSerializer.new(user),
            expires_at: 24.hours.from_now
          }
        else
          render json: { error: '잘못된 인증 정보' }, status: :unauthorized
        end
      end

      def refresh
        token = JwtService.encode(user_id: current_user.id)
        render json: { token: token, expires_at: 24.hours.from_now }
      end
    end
  end
end

# app/controllers/concerns/jwt_authenticatable.rb
module JwtAuthenticatable
  extend ActiveSupport::Concern

  included do
    before_action :authenticate_jwt!
  end

  private

  def authenticate_jwt!
    header = request.headers['Authorization']
    token = header&.split(' ')&.last

    raise AuthenticationError, '토큰이 없습니다' unless token

    decoded = JwtService.decode(token)
    @current_user = User.find(decoded[:user_id])
  rescue AuthenticationError => e
    render json: { error: e.message }, status: :unauthorized
  rescue ActiveRecord::RecordNotFound
    render json: { error: '사용자를 찾을 수 없습니다' }, status: :unauthorized
  end

  def current_user
    @current_user
  end
end

# config/environments/production.rb
config.action_controller.perform_caching = true
config.cache_store = :redis_cache_store, {
  url: ENV['REDIS_URL'],
  namespace: 'myapp:cache',
  expires_in: 1.day,
  race_condition_ttl: 10.seconds
}

<%# app/views/products/index.html.erb %>
<%# 자동 캐시 키를 사용하는 fragment caching %>
<% @products.each do |product| %>
  <%# 상품의 updated_at 기준으로 캐시 %>
  <% cache product do %>
    <%= render product %>
  <% end %>
<% end %>

<%# Russian Doll caching - 중첩 캐시 %>
<% cache ['v1', @category] do %>
  <h2><%= @category.name %></h2>

  <% @category.products.each do |product| %>
    <% cache ['v1', product] do %>
      <%= render product %>
    <% end %>
  <% end %>
<% end %>

<%# 조건부 캐시 %>
<% cache_if current_user.nil?, @product do %>
  <%= render @product %>
<% end %>

# app/models/product.rb
class Product < ApplicationRecord
  # 부모를 touch 하여 Russian Doll 캐시 무효화
  belongs_to :category, touch: true

  # 사용자 정의 캐시 키
  def cache_key_with_version
    "#{super}/#{reviews.maximum(:updated_at)&.to_i}"
  end
end

# 서비스 내 low-level caching
class DashboardStatsService
  def call
    Rails.cache.fetch('dashboard:stats', expires_in: 15.minutes) do
      {
        total_users: User.count,
        active_users: User.where('last_sign_in_at > ?', 30.days.ago).count,
        total_orders: Order.completed.count,
        revenue_mtd: Order.completed.where(created_at: Time.current.beginning_of_month..).sum(:total)
      }
    end
  end
end

# 경쟁 조건 보호가 있는 캐시
Rails.cache.fetch('popular_products', expires_in: 1.hour, race_condition_ttl: 10.seconds) do
  Product.bestsellers.limit(10).to_a
end

# 명시적 무효화
Rails.cache.delete('dashboard:stats')
Rails.cache.delete_matched('products:*')

# 데이터베이스 최적화
# config/database.yml
production:
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  prepared_statements: true
  advisory_locks: true

# app/models/order.rb
class Order < ApplicationRecord
  # 자주 사용되는 쿼리를 위한 복합 인덱스
  # add_index :orders, [:user_id, :status, :created_at]

  # 필요한 컬럼만 선택
  scope :summary, -> { select(:id, :status, :total, :created_at) }

  # 대량 데이터 배치 처리
  def self.process_pending
    pending.find_each(batch_size: 1000) do |order|
      ProcessOrderJob.perform_later(order.id)
    end
  end

  # 반복 계산 회피
  def self.revenue_by_month
    completed
      .group("DATE_TRUNC('month', created_at)")
      .sum(:total)
  end
end

# 메모리 최적화
# config/puma.rb
workers ENV.fetch("WEB_CONCURRENCY") { 2 }
threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
threads threads_count, threads_count

preload_app!

before_fork do
  ActiveRecord::Base.connection_pool.disconnect!
end

on_worker_boot do
  ActiveRecord::Base.establish_connection
end

# rack-mini-profiler 로 프로파일링
# Gemfile
group :development do
  gem 'rack-mini-profiler'
  gem 'memory_profiler'
  gem 'stackprof'
end

# config/initializers/mini_profiler.rb
if defined?(Rack::MiniProfiler)
  Rack::MiniProfiler.config.position = 'bottom-right'
  Rack::MiniProfiler.config.start_hidden = true
end

# 지연 로딩과 페이지네이션
class ProductsController < ApplicationController
  def index
    @products = Product.active
                       .includes(:category, :primary_image)
                       .page(params[:page])
                       .per(24)

    # 다음 페이지 prefetch
    if @products.next_page
      Rails.cache.fetch("products:page:#{@products.next_page}", expires_in: 5.minutes) do
        Product.active.page(@products.next_page).per(24).to_a
      end
    end
  end
end

# CSRF 보호
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  # 기본적으로 활성화되며 토큰이 유효하지 않으면 예외를 발생시킵니다
  protect_from_forgery with: :exception

  # API 의 경우 :null_session 사용
  # protect_from_forgery with: :null_session
end

# 뷰에서는 폼에 토큰이 자동으로 포함됩니다
# <%= form_with ... %> 는 authenticity_token 을 포함합니다

# AJAX 요청의 경우
# csrf_meta_tags 의 값으로 X-CSRF-Token 헤더를 추가합니다