<%= simple_format @article.body %>
<%# Partial สำหรับความคิดเห็น %>
<%= render @comments %>
```
ขั้นตอนปกติ: คำขอเข้าสู่ Router ซึ่งจะส่งต่อไปยัง Controller ที่เหมาะสม Controller จะโต้ตอบกับ Model เพื่อดึงหรือแก้ไขข้อมูล จากนั้นส่งข้อมูลให้ View เพื่อทำการเรนเดอร์ HTML
### คำถามที่ 2: Active Record คืออะไร และ ORM ของ Rails ทำงานอย่างไร?
Active Record คือ ORM (Object-Relational Mapping) ของ Rails ที่นำรูปแบบ Active Record มาใช้ คลาส Model แต่ละคลาสแทนตารางในฐานข้อมูล และอินสแตนซ์แต่ละตัวแทนแถวเดียว
```ruby
# 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 }
# Callback
before_save :normalize_email
# เมธอดของคลาสสำหรับ query
def self.admins
joins(:roles).where(roles: { name: 'admin' })
end
private
def normalize_email
self.email = email.downcase.strip
end
end
```
```ruby
# ตัวอย่าง query ของ Active Record
# Rails console หรือภายใน service
# การสร้าง
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')
# Query แบบเชื่อมต่อกัน (lazy evaluation)
recent_admins = User.admins
.where('created_at > ?', 1.month.ago)
.includes(:profile)
.limit(10)
# ป้องกัน N+1 ด้วย eager loading
articles = Article.includes(:author, :comments).published
# การอัปเดต
user.update!(name: 'Alice Martin')
# Transaction
User.transaction do
user.debit_balance!(100)
recipient.credit_balance!(100)
Payment.create!(from: user, to: recipient, amount: 100)
end
```
Active Record แปลงเมธอด Ruby ให้เป็น query SQL ที่ปรับให้เหมาะสม เมธอดอย่าง `where`, `joins`, `includes` เป็นแบบ lazy: query จะถูกประมวลผลเมื่อมีการวนซ้ำหรือเรียก `to_a` เท่านั้น
### คำถามที่ 3: อธิบายระบบ migration ของ Rails
Migration ช่วยให้สามารถจัดการเวอร์ชันของ schema ฐานข้อมูลด้วย Ruby ได้ Migration สามารถย้อนกลับได้ และช่วยให้โครงสร้างข้อมูลพัฒนาได้อย่างมีการควบคุม
```ruby
# db/migrate/20260203100000_create_products.rb
# Migration สำหรับสร้างตาราง
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
# Index เพื่อประสิทธิภาพ
add_index :products, :name
add_index :products, [:category_id, :active]
end
end
```
```ruby
# db/migrate/20260203110000_add_slug_to_products.rb
# Migration สำหรับแก้ไขตารางที่มีอยู่
class AddSlugToProducts < ActiveRecord::Migration[7.1]
def change
add_column :products, :slug, :string
add_index :products, :slug, unique: true
# เติม slug ที่มีอยู่
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
```
```bash
# คำสั่ง migration ที่จำเป็น
rails db:migrate # รัน migration ที่ค้างอยู่
rails db:rollback # ย้อนกลับ migration ล่าสุด
rails db:rollback STEP=3 # ย้อนกลับ migration 3 รายการล่าสุด
rails db:migrate:status # ดูสถานะ migration
rails db:seed # รัน db/seeds.rb
rails db:reset # Drop, create, migrate, seed
```
Migration ต้องสามารถย้อนกลับได้ เมธอด `change` ฉลาดและสามารถย้อนกลับการดำเนินการทั่วไปได้โดยอัตโนมัติ สำหรับกรณีที่ซับซ้อน ใช้ `up` และ `down` แยกกัน
## Active Record ขั้นสูง
### คำถามที่ 4: จะปรับ query N+1 ใน Rails ได้อย่างไร?
ปัญหา N+1 เกิดขึ้นเมื่อ query เริ่มต้นตามมาด้วย query เพิ่มเติมอีก N รายการเพื่อโหลดความสัมพันธ์ Rails มีเมธอด eager loading หลายแบบเพื่อแก้ปัญหานี้
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def index
# ❌ ปัญหา N+1: 1 query + N query ต่อหนึ่งคำสั่งซื้อ
# @orders = Order.all
# ใน view: order.user.name สร้าง query ต่อแต่ละคำสั่งซื้อ
# ✅ วิธีแก้ด้วย includes (eager loading)
@orders = Order.includes(:user, :items)
.where(status: 'completed')
.order(created_at: :desc)
# สร้างเพียง 3 query ทั้งหมด
end
def show
# includes: โหลดความสัมพันธ์แยกกัน (2-3 query)
@order = Order.includes(items: :product).find(params[:id])
# preload: บังคับให้โหลดแยกกัน
@order = Order.preload(:items, :user).find(params[:id])
# eager_load: บังคับใช้ LEFT OUTER JOIN (1 query)
@order = Order.eager_load(:items).find(params[:id])
end
end
```
```ruby
# app/models/order.rb
class Order < ApplicationRecord
belongs_to :user
has_many :items, class_name: 'OrderItem'
has_many :products, through: :items
# Scope พร้อม includes ค่าเริ่มต้น
scope :with_details, -> { includes(:user, items: :product) }
# Counter cache เพื่อหลีกเลี่ยง query COUNT
# ต้องการ: add_column :users, :orders_count, :integer, default: 0
belongs_to :user, counter_cache: true
end
```
```ruby
# ตรวจจับ N+1 ด้วย gem Bullet (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 จะแสดงการแจ้งเตือนเมื่อ:
# - ตรวจพบ query N+1
# - มี eager loading ที่ไม่จำเป็น
# - ควรใช้ counter cache
```
หลักการ: ใช้ `includes` เป็นค่าเริ่มต้น (Rails จะเลือกกลยุทธ์ที่เหมาะสมที่สุด) ใช้ `preload` เมื่อต้องการบังคับ query แยก และ `eager_load` เมื่อกรองตามความสัมพันธ์
### คำถามที่ 5: อธิบาย Scope และ Query Object ใน Rails
Scope ห่อหุ้มเงื่อนไข query ที่ใช้ซ้ำได้ สำหรับ query ที่ซับซ้อน Query Object ให้การจัดระเบียบและความสามารถในการทดสอบที่ดีกว่า
```ruby
# app/models/product.rb
class Product < ApplicationRecord
# Scope แบบง่าย
scope :active, -> { where(active: true) }
scope :in_stock, -> { where('stock_quantity > 0') }
scope :featured, -> { where(featured: true) }
# Scope ที่มีพารามิเตอร์
scope :cheaper_than, ->(price) { where('price < ?', price) }
scope :in_category, ->(category) { where(category: category) }
# Scope ที่เชื่อมต่อกันได้
scope :available, -> { active.in_stock }
# Scope ที่มี joins
scope :with_recent_orders, -> {
joins(:order_items)
.where('order_items.created_at > ?', 30.days.ago)
.distinct
}
# Scope ที่มี subquery
scope :bestsellers, -> {
where(id: OrderItem.group(:product_id)
.order('COUNT(*) DESC')
.limit(10)
.select(:product_id))
}
end
```
```ruby
# 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
# การใช้งานใน controller
@products = ProductsSearchQuery.new(Product.active).call(params)
```
Scope เหมาะสำหรับเงื่อนไขที่เรียบง่ายและใช้ซ้ำได้ Query Object เหมาะสำหรับการค้นหาที่ซับซ้อนซึ่งมีฟิลเตอร์ทางเลือกหลายแบบและตรรกะการประกอบ
## Routing และ Controller
### คำถามที่ 6: RESTful routing ใน Rails ทำงานอย่างไร?
Rails ส่งเสริมเส้นทางแบบ RESTful ซึ่งจับคู่ HTTP verb กับการกระทำ CRUD Router แปลง URL ให้เป็นการเรียก controller ที่เฉพาะเจาะจง
```ruby
# 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
# เส้นทาง API พร้อม namespace
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
```
```bash
# 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
```
Helper เส้นทางที่สร้างขึ้น (`article_path(@article)`, `new_article_path`) ช่วยให้สามารถอ้างอิง URL ได้อย่างไดนามิกและง่ายต่อการบำรุงรักษา
### คำถามที่ 7: อธิบาย callback และ filter ใน controller
Callback (before_action, after_action, around_action) ช่วยให้สามารถรันโค้ดก่อน หลัง หรือรอบ ๆ การกระทำของ controller
```ruby
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
# การป้องกัน CSRF เปิดใช้งานโดยเริ่มต้น
protect_from_forgery with: :exception
# Callback สากลสำหรับการยืนยันตัวตน
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
```
```ruby
# app/controllers/admin/products_controller.rb
class Admin::ProductsController < ApplicationController
# Callback พร้อมตัวเลือก
before_action :require_admin
before_action :set_product, only: [:show, :edit, :update, :destroy]
after_action :log_activity, only: [:create, :update, :destroy]
# Callback แบบมีเงื่อนไข
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
```
Callback จะถูกรันตามลำดับการประกาศ ใช้ `skip_before_action` ในคลาสย่อยเพื่อปิดการใช้งาน callback ที่สืบทอดมา หลีกเลี่ยง callback ที่มีตรรกะทางธุรกิจมากเกินไป ให้เลือกใช้ Service Object แทน
## Service และสถาปัตยกรรม
### คำถามที่ 8: จะนำ Service Object มาใช้ใน Rails ได้อย่างไร?
Service Object ห่อหุ้มตรรกะทางธุรกิจที่ซับซ้อนซึ่งไม่ควรอยู่ใน Model หรือ Controller ช่วยให้ทดสอบได้ดีขึ้นและสอดคล้องกับหลักการความรับผิดชอบเดียว
```ruby
# 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
```
```ruby
# 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
```
รูปแบบ Service Object ปฏิบัติตามแบบแผนง่าย ๆ คือ คลาสเดียว ความรับผิดชอบเดียว เมธอด `call` สาธารณะหนึ่งเมธอด การคืนค่าออบเจกต์ Result ช่วยให้จัดการความสำเร็จและความล้มเหลวได้อย่างเป็นระเบียบ
### คำถามที่ 9: อธิบาย Concern ใน Rails
Concern ช่วยให้สามารถดึงและแชร์โค้ดระหว่าง Model หรือ Controller ได้ ใช้ `ActiveSupport::Concern` เพื่อให้ syntax การ include สะอาด
```ruby
# app/models/concerns/sluggable.rb
# Concern ที่ใช้ซ้ำได้สำหรับสร้าง slug
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
```
```ruby
# 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
```
```ruby
# app/controllers/concerns/pagination.rb
# Concern สำหรับ controller
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
```
Concern มีประโยชน์สำหรับโค้ดที่แชร์กันจริง ๆ หลีกเลี่ยงการสร้าง Concern เพียงเพื่อ "ทำให้ Model สั้นลง" เพราะจะซ่อนความซับซ้อนโดยไม่ลดมัน
## การทดสอบด้วย RSpec
### คำถามที่ 10: จะจัดโครงสร้างการทดสอบ RSpec ใน Rails อย่างไร?
RSpec คือเฟรมเวิร์กการทดสอบมาตรฐานสำหรับ Rails โครงสร้างการทดสอบที่ดีรวมถึง Model spec, Controller spec, Service spec และการทดสอบการรวม
```ruby
# spec/models/user_spec.rb
require 'rails_helper'
RSpec.describe User, type: :model do
# Factory ด้วย 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 'ตรวจสอบรูปแบบของ email' 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
```
```ruby
# 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
```
```ruby
# 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
```
แนวปฏิบัติที่ดี: ใช้ `let` สำหรับข้อมูล `describe` สำหรับเมธอด/บริบท `context` สำหรับเงื่อนไข และ `it` สำหรับ assertion ที่เฉพาะเจาะจง การทดสอบหนึ่งควรทดสอบเพียงเรื่องเดียว
### คำถามที่ 11: จะใช้ factory กับ FactoryBot อย่างไร?
FactoryBot ช่วยสร้างข้อมูลทดสอบในรูปแบบ declarative และง่ายต่อการบำรุงรักษา Factory แทนที่ fixture แบบสถิต
```ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
# Sequence เพื่อรับประกันความเป็นเอกลักษณ์
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 ที่สืบทอด
factory :admin_user do
admin
with_profile
end
end
end
```
```ruby
# 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
```
```ruby
# การใช้งานในการทดสอบ
RSpec.describe OrderProcessor do
# build: อินสแตนซ์ที่ไม่บันทึก
let(:user) { build(:user) }
# create: บันทึกในฐานข้อมูล
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: เร็วกว่า สำหรับ unit test
let(:stubbed_user) { build_stubbed(:user) }
end
```
ใช้ `build` หรือ `build_stubbed` แทน `create` เมื่อไม่จำเป็นต้องบันทึก: สิ่งนี้ทำให้การทดสอบเร็วขึ้นอย่างมาก
## งานเบื้องหลัง
### คำถามที่ 12: จะใช้ Active Job และ Sidekiq ใน Rails อย่างไร?
Active Job ให้อินเทอร์เฟซที่เป็นหนึ่งเดียวสำหรับงานเบื้องหลัง โดยไม่ขึ้นอยู่กับ backend (Sidekiq, Resque ฯลฯ) Sidekiq เป็นตัวเลือกที่ได้รับความนิยมเนื่องจากประสิทธิภาพกับ Redis
```ruby
# 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 (หาก backend เป็น 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
```
```ruby
# app/jobs/batch_email_job.rb
class BatchEmailJob < ApplicationJob
queue_as :mailers
# จำกัดอัตราด้วย Sidekiq Enterprise หรือ gem throttle
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
```
```ruby
# จัดคิวงาน
# ทันที
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)
```
```ruby
# 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
```
Active Job แยกตัว backend ออก แต่การเข้าถึงคุณสมบัติเฉพาะ (batch, rate limiting) มักต้องการการเชื่อมโยงกับ backend ที่เลือก
## การพัฒนา API
### คำถามที่ 13: จะสร้าง RESTful API ด้วย Rails อย่างไร?
Rails ทำให้การสร้าง API JSON ง่ายขึ้นด้วย Controller แบบ API-only และ serializer API ที่ดีต้องมีเวอร์ชัน เอกสารและความปลอดภัย
```ruby
# 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
```
```ruby
# 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
```
```ruby
# app/serializers/product_serializer.rb
# ด้วย gem jsonapi-serializer
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
```
แนวปฏิบัติ API ที่ดี: จัดเวอร์ชันผ่าน namespace ใช้รหัส HTTP ที่เหมาะสม แบ่งหน้าชุดข้อมูล และให้ข้อความข้อผิดพลาดที่ชัดเจน
### คำถามที่ 14: จะนำการยืนยันตัวตนแบบ JWT มาใช้ใน Rails อย่างไร?
JWT (JSON Web Tokens) เป็นวิธีการยืนยันตัวตนแบบ stateless ที่ได้รับความนิยมสำหรับ API Token เข้ารหัสตัวตนและความถูกต้องของผู้ใช้
```ruby
# 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, 'Token หมดอายุ'
rescue JWT::DecodeError
raise AuthenticationError, 'Token ไม่ถูกต้อง'
end
end
end
```
```ruby
# 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
```
```ruby
# 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, 'ไม่มี Token' 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
```
สำหรับ production พิจารณา: refresh token, การ blacklist token เมื่อออกจากระบบ และเวลาหมดอายุที่สั้น Gem เช่น `devise-jwt` ทำให้การติดตั้งใช้งานง่ายขึ้น
## การ Cache และประสิทธิภาพ
### คำถามที่ 15: จะนำการ cache มาใช้ใน Rails อย่างไร?
Rails มีระดับการ cache หลายระดับ: fragment caching, Russian Doll caching, low-level caching การเลือกขึ้นอยู่กับกรณีการใช้งาน
```ruby
# 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
}
```
```erb
<%# app/views/products/index.html.erb %>
<%# Fragment caching ด้วยกุญแจ cache อัตโนมัติ %>
<% @products.each do |product| %>
<%# Cache อิงตาม updated_at ของสินค้า %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<%# Russian Doll caching - cache ซ้อนกัน %>
<% cache ['v1', @category] do %>