<%= simple_format @article.body %>
<%# Partial cho phần bình luận %>
<%= render @comments %>
```
Luồng điển hình: yêu cầu đến Router, Router chuyển nó tới Controller phù hợp. Controller tương tác với Model để lấy hoặc sửa đổi dữ liệu, sau đó chuyển dữ liệu cho View để render HTML.
### Câu hỏi 2: Active Record là gì và ORM của Rails hoạt động như thế nào?
Active Record là ORM (Object-Relational Mapping) của Rails, triển khai pattern Active Record. Mỗi class Model đại diện cho một bảng cơ sở dữ liệu, mỗi instance đại diện cho một dòng.
```ruby
# app/models/user.rb
# Active Record tự động ánh xạ cột sang thuộc tính
class User < ApplicationRecord
# Bảng 'users' được liên kết tự động
# Cột: id, email, name, created_at, updated_at
has_secure_password # BCrypt cho mật khẩu
has_many :articles, foreign_key: :author_id
has_one :profile, dependent: :destroy
has_and_belongs_to_many :roles
# Xác thực
validates :email, presence: true,
uniqueness: { case_sensitive: false },
format: { with: URI::MailTo::EMAIL_REGEXP }
# Callback
before_save :normalize_email
# Phương thức class cho truy vấn
def self.admins
joins(:roles).where(roles: { name: 'admin' })
end
private
def normalize_email
self.email = email.downcase.strip
end
end
```
```ruby
# Ví dụ truy vấn Active Record
# Console Rails hoặc trong service
# Tạo
user = User.create!(email: 'dev@example.com', name: 'Alice', password: 'secret123')
# Đọc với điều kiện
active_users = User.where(active: true).order(:name)
user = User.find_by(email: 'dev@example.com')
# Truy vấn nối chuỗi (lazy evaluation)
recent_admins = User.admins
.where('created_at > ?', 1.month.ago)
.includes(:profile)
.limit(10)
# Phòng tránh N+1 với eager loading
articles = Article.includes(:author, :comments).published
# Cập nhật
user.update!(name: 'Alice Martin')
# Giao dịch
User.transaction do
user.debit_balance!(100)
recipient.credit_balance!(100)
Payment.create!(from: user, to: recipient, amount: 100)
end
```
Active Record chuyển các phương thức Ruby thành các truy vấn SQL được tối ưu. Các phương thức như `where`, `joins`, `includes` là lazy: truy vấn chỉ thực thi khi lặp hoặc khi gọi `to_a`.
### Câu hỏi 3: Hãy giải thích hệ thống migration của Rails
Migration cho phép phiên bản hóa schema cơ sở dữ liệu bằng Ruby. Chúng có thể đảo ngược và cho phép tiến hóa có kiểm soát của cấu trúc dữ liệu.
```ruby
# db/migrate/20260203100000_create_products.rb
# Migration để tạo bảng
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 và updated_at tự động
end
# Index cho hiệu năng
add_index :products, :name
add_index :products, [:category_id, :active]
end
end
```
```ruby
# db/migrate/20260203110000_add_slug_to_products.rb
# Migration để sửa đổi bảng đã tồn tại
class AddSlugToProducts < ActiveRecord::Migration[7.1]
def change
add_column :products, :slug, :string
add_index :products, :slug, unique: true
# Điền slug cho dữ liệu hiện có
reversible do |dir|
dir.up do
Product.find_each do |product|
product.update_column(:slug, product.name.parameterize)
end
end
end
# Đặt NOT NULL sau khi điền
change_column_null :products, :slug, false
end
end
```
```bash
# Các lệnh migration cần thiết
rails db:migrate # Chạy các migration đang chờ
rails db:rollback # Hoàn tác migration cuối
rails db:rollback STEP=3 # Hoàn tác 3 migration cuối
rails db:migrate:status # Xem trạng thái migration
rails db:seed # Chạy db/seeds.rb
rails db:reset # Drop, create, migrate, seed
```
Migration phải có thể đảo ngược. Phương thức `change` thông minh và có thể đảo ngược các thao tác phổ biến tự động. Cho các trường hợp phức tạp, sử dụng `up` và `down` riêng biệt.
## Active Record nâng cao
### Câu hỏi 4: Làm thế nào để tối ưu truy vấn N+1 trong Rails?
Vấn đề N+1 xảy ra khi sau truy vấn ban đầu là N truy vấn bổ sung để tải các liên kết. Rails cung cấp nhiều phương pháp eager loading để giải quyết vấn đề này.
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def index
# ❌ VẤN ĐỀ N+1: 1 truy vấn + N truy vấn cho mỗi đơn hàng
# @orders = Order.all
# Trong view: order.user.name tạo một truy vấn cho mỗi đơn hàng
# ✅ GIẢI PHÁP với includes (eager loading)
@orders = Order.includes(:user, :items)
.where(status: 'completed')
.order(created_at: :desc)
# Chỉ tạo 3 truy vấn tổng cộng
end
def show
# includes: tải các liên kết riêng (2-3 truy vấn)
@order = Order.includes(items: :product).find(params[:id])
# preload: ép tải riêng
@order = Order.preload(:items, :user).find(params[:id])
# eager_load: ép LEFT OUTER JOIN (1 truy vấn)
@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 với includes mặc định
scope :with_details, -> { includes(:user, items: :product) }
# Counter cache để tránh truy vấn COUNT
# Yêu cầu: add_column :users, :orders_count, :integer, default: 0
belongs_to :user, counter_cache: true
end
```
```ruby
# Phát hiện N+1 với 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 sẽ hiển thị cảnh báo khi:
# - Phát hiện truy vấn N+1
# - Có eager loading không cần thiết
# - Nên sử dụng counter cache
```
Quy tắc: dùng `includes` mặc định (Rails chọn chiến lược tối ưu), dùng `preload` khi muốn ép truy vấn riêng, dùng `eager_load` khi lọc theo các liên kết.
### Câu hỏi 5: Hãy giải thích Scope và Query Object trong Rails
Scope đóng gói các điều kiện truy vấn có thể tái sử dụng. Cho các truy vấn phức tạp, Query Object cung cấp tổ chức và khả năng kiểm thử tốt hơn.
```ruby
# app/models/product.rb
class Product < ApplicationRecord
# Scope đơn giản
scope :active, -> { where(active: true) }
scope :in_stock, -> { where('stock_quantity > 0') }
scope :featured, -> { where(featured: true) }
# Scope có tham số
scope :cheaper_than, ->(price) { where('price < ?', price) }
scope :in_category, ->(category) { where(category: category) }
# Scope nối chuỗi
scope :available, -> { active.in_stock }
# Scope với joins
scope :with_recent_orders, -> {
joins(:order_items)
.where('order_items.created_at > ?', 30.days.ago)
.distinct
}
# Scope với truy vấn con
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 cho tìm kiếm phức tạp
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
# Sử dụng trong controller
@products = ProductsSearchQuery.new(Product.active).call(params)
```
Scope hoàn hảo cho các điều kiện đơn giản, tái sử dụng. Query Object phù hợp cho các tìm kiếm phức tạp với nhiều bộ lọc tùy chọn và logic kết hợp.
## Routing và Controller
### Câu hỏi 6: Routing RESTful trong Rails hoạt động như thế nào?
Rails khuyến khích các tuyến RESTful ánh xạ động từ HTTP với hành động CRUD. Router dịch các URL thành các lệnh gọi controller cụ thể.
```ruby
# config/routes.rb
Rails.application.routes.draw do
# Tuyến RESTful chuẩn (7 hành động)
resources :articles do
# Tuyến lồng nhau
resources :comments, only: [:create, :destroy]
# Tuyến member (tác động lên một instance)
member do
post :publish
delete :archive
end
# Tuyến collection (tác động lên tập hợp)
collection do
get :drafts
get :search
end
end
# Tuyến API với namespace
namespace :api do
namespace :v1 do
resources :products, only: [:index, :show, :create, :update] do
resources :reviews, shallow: true
end
end
end
# Tuyến tùy chỉnh
get 'dashboard', to: 'dashboard#index'
# Ràng buộc tuyến
constraints(SubdomainConstraint.new) do
resources :admin_settings
end
# Tuyến gốc
root 'home#index'
end
```
```bash
# rails routes - Hiển thị tất cả các tuyến được tạo
#
# 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
```
Các route helper được tạo (`article_path(@article)`, `new_article_path`) cho phép tham chiếu URL một cách động và dễ bảo trì.
### Câu hỏi 7: Hãy giải thích callback và filter trong controller
Callback (before_action, after_action, around_action) cho phép thực thi mã trước, sau hoặc xung quanh các hành động của controller.
```ruby
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
# Bảo vệ CSRF được kích hoạt mặc định
protect_from_forgery with: :exception
# Callback toàn cục cho xác thực
before_action :authenticate_user!
# Xử lý lỗi toàn cục
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def not_found
render json: { error: 'Không tìm thấy tài nguyên' }, 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 với tùy chọn
before_action :require_admin
before_action :set_product, only: [:show, :edit, :update, :destroy]
after_action :log_activity, only: [:create, :update, :destroy]
# Callback có điều kiện
before_action :check_stock, only: [:update], if: :stock_changed?
def create
@product = Product.new(product_params)
if @product.save
redirect_to [:admin, @product], notice: 'Đã tạo sản phẩm.'
else
render :new, status: :unprocessable_entity
end
end
def update
if @product.update(product_params)
redirect_to [:admin, @product], notice: 'Đã cập nhật sản phẩm.'
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 được thực thi theo thứ tự khai báo. Sử dụng `skip_before_action` trong các lớp con để vô hiệu hóa callback kế thừa. Tránh callback chứa quá nhiều logic nghiệp vụ - hãy ưu tiên Service Object.
## Service và kiến trúc
### Câu hỏi 8: Làm thế nào để triển khai Service Object trong Rails?
Service Object đóng gói logic nghiệp vụ phức tạp không thuộc về Model hay Controller. Chúng cải thiện khả năng kiểm thử và tuân theo nguyên tắc một trách nhiệm duy nhất.
```ruby
# app/services/order_processor.rb
# Service Object với giao diện chuẩn hóa
class OrderProcessor
def initialize(order, payment_method:)
@order = order
@payment_method = payment_method
end
def call
return failure('Đơn hàng đã được xử lý') 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("Thanh toán thất bại: #{e.message}")
rescue InsufficientStockError => e
failure("Không đủ hàng tồn: #{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: "Đơn hàng ##{@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: 'Đơn hàng đã được xác nhận!'
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
```
Pattern Service Object tuân theo một quy ước đơn giản: một class, một trách nhiệm, một phương thức công khai `call`. Trả về một đối tượng Result cho phép xử lý thành công và thất bại một cách rõ ràng.
### Câu hỏi 9: Hãy giải thích Concern trong Rails
Concern cho phép trích xuất và chia sẻ mã giữa các Model hoặc Controller. Chúng sử dụng `ActiveSupport::Concern` để có cú pháp include sạch sẽ.
```ruby
# app/models/concerns/sluggable.rb
# Concern tái sử dụng để tạo slug
module Sluggable
extend ActiveSupport::Concern
included do
# Mã được thực thi khi include
before_validation :generate_slug, if: :should_generate_slug?
validates :slug, presence: true, uniqueness: true
end
# Phương thức class
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
# Phương thức instance
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 # Tùy chọn, mặc định là :title
end
# app/models/product.rb
class Product < ApplicationRecord
include Sluggable
sluggable_source :name
end
```
```ruby
# app/controllers/concerns/pagination.rb
# Concern cho 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 hữu ích cho mã thực sự được chia sẻ. Tránh tạo Concern chỉ để "rút gọn" một Model: việc đó che giấu sự phức tạp mà không giảm bớt nó.
## Kiểm thử với RSpec
### Câu hỏi 10: Làm thế nào để cấu trúc các bài kiểm thử RSpec trong Rails?
RSpec là framework kiểm thử chuẩn cho Rails. Một cấu trúc kiểm thử tốt bao gồm Model spec, Controller spec, Service spec và các bài kiểm thử tích hợp.
```ruby
# spec/models/user_spec.rb
require 'rails_helper'
RSpec.describe User, type: :model do
# Factory với 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 'xác thực định dạng 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 'trả về tên và họ kết hợp' do
user = build(:user, first_name: 'John', last_name: 'Doe')
expect(user.full_name).to eq('John Doe')
end
it 'xử lý khi thiếu họ' do
user = build(:user, first_name: 'John', last_name: nil)
expect(user.full_name).to eq('John')
end
end
describe '.active' do
it 'chỉ trả về người dùng đang hoạt động' 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 'khi đơn hàng hợp lệ' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: true, transaction_id: 'txn_123')
)
end
it 'xử lý đơn hàng thành công' do
result = subject.call
expect(result).to be_success
expect(order.reload.status).to eq('completed')
end
it 'giảm tồn kho sản phẩm' do
expect { subject.call }.to change { product.reload.stock_quantity }.by(-2)
end
it 'gửi email xác nhận' do
expect { subject.call }
.to have_enqueued_mail(OrderMailer, :confirmation)
.with(order)
end
end
context 'khi thanh toán thất bại' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: false, error: 'Card declined')
)
end
it 'trả về kết quả thất bại' do
result = subject.call
expect(result).to be_failure
expect(result.error).to include('Card declined')
end
it 'không cập nhật trạng thái đơn hàng' 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 'trả về danh sách sản phẩm' do
get '/api/v1/products', headers: headers
expect(response).to have_http_status(:ok)
expect(json_response['data'].size).to eq(3)
end
it 'lọc theo danh mục' 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: 'Sản phẩm mới', price: 99.99, category_id: create(:category).id } }
end
it 'tạo một sản phẩm mới' 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
```
Phương pháp tốt: sử dụng `let` cho dữ liệu, `describe` cho phương thức/ngữ cảnh, `context` cho điều kiện và `it` cho khẳng định cụ thể. Một bài test nên kiểm tra một thứ.
### Câu hỏi 11: Làm thế nào để sử dụng factory với FactoryBot?
FactoryBot cho phép tạo dữ liệu kiểm thử theo cách khai báo và dễ bảo trì. Factory thay thế các fixture tĩnh.
```ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
# Sequence để đảm bảo tính duy nhất
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 cho biến thể
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 kế thừa
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
# Sử dụng trong các bài kiểm thử
RSpec.describe OrderProcessor do
# build: instance không lưu vào DB
let(:user) { build(:user) }
# create: lưu vào DB
let(:order) { create(:order, :with_items, user: user) }
# create_list: nhiều instance
let(:products) { create_list(:product, 5) }
# Kết hợp các trait
let(:admin) { create(:user, :admin, :with_profile) }
# Ghi đè thuộc tính
let(:expensive_order) { create(:order, :with_items, items_count: 10) }
# build_stubbed: nhanh hơn, cho unit test
let(:stubbed_user) { build_stubbed(:user) }
end
```
Ưu tiên `build` hoặc `build_stubbed` thay vì `create` khi không cần lưu trữ: điều này tăng tốc đáng kể các bài test.
## Background Job
### Câu hỏi 12: Làm thế nào để sử dụng Active Job và Sidekiq trong Rails?
Active Job cung cấp một giao diện thống nhất cho các job nền, không phụ thuộc backend (Sidekiq, Resque, v.v.). Sidekiq là lựa chọn phổ biến vì hiệu năng với Redis.
```ruby
# app/jobs/process_order_job.rb
class ProcessOrderJob < ApplicationJob
queue_as :default
# Cấu hình thử lại
retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
discard_on ActiveJob::DeserializationError
# Tùy chọn Sidekiq (nếu backend là Sidekiq)
sidekiq_options retry: 5, backtrace: true
def perform(order_id)
order = Order.find(order_id)
OrderProcessor.new(order).call
rescue ActiveRecord::RecordNotFound
# Đơn hàng đã bị xóa giữa lúc xếp hàng và thực thi
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
# Giới hạn tốc độ với Sidekiq Enterprise hoặc 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
# Xếp hàng job
# Ngay lập tức
ProcessOrderJob.perform_later(order.id)
# Trì hoãn
ProcessOrderJob.set(wait: 5.minutes).perform_later(order.id)
# Vào thời điểm cụ thể
ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order.id)
# Hàng đợi cụ thể
ProcessOrderJob.set(queue: :critical).perform_later(order.id)
# Đồng bộ (cho test hoặc debug)
ProcessOrderJob.perform_now(order.id)
```
```ruby
# config/sidekiq.yml
:concurrency: 10
:queues:
- [critical, 3] # Ưu tiên cao, trọng số 3
- [default, 2] # Ưu tiên trung bình, trọng số 2
- [mailers, 1] # Ưu tiên thấp, trọng số 1
- [low, 1]
:schedule:
cleanup_job:
cron: '0 3 * * *' # Mỗi ngày lúc 3 giờ sáng
class: CleanupJob
```
Active Job trừu tượng hóa backend, nhưng truy cập các tính năng cụ thể (batch, rate limiting) thường yêu cầu liên kết chặt với backend được chọn.
## Phát triển API
### Câu hỏi 13: Làm thế nào để xây dựng RESTful API với Rails?
Rails giúp việc xây dựng API JSON dễ dàng với các Controller API-only và serializer. Một API tốt được phiên bản hóa, tài liệu hóa và an toàn.
```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: 'Không tìm thấy tài nguyên', details: exception.message },
status: :not_found
end
def unprocessable_entity(exception)
render json: { error: 'Xác thực thất bại', details: exception.record.errors },
status: :unprocessable_entity
end
def bad_request(exception)
render json: { error: 'Yêu cầu không hợp lệ', 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
# Với 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
```
Phương pháp tốt cho API: phiên bản hóa thông qua namespace, sử dụng mã HTTP phù hợp, phân trang tập hợp và cung cấp thông báo lỗi rõ ràng.
### Câu hỏi 14: Làm thế nào để triển khai xác thực JWT trong Rails?
JWT (JSON Web Tokens) là phương pháp xác thực stateless phổ biến cho API. Token mã hóa danh tính và tính hợp lệ của người dùng.
```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 đã hết hạn'
rescue JWT::DecodeError
raise AuthenticationError, 'Token không hợp lệ'
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: 'Thông tin đăng nhập không hợp lệ' }, 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, 'Thiếu 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: 'Không tìm thấy người dùng' }, status: :unauthorized
end
def current_user
@current_user
end
end
```
Cho production, hãy cân nhắc: refresh token, blacklist token khi đăng xuất và thời gian hết hạn ngắn. Các gem như `devise-jwt` đơn giản hóa việc triển khai.
## Cache và hiệu năng
### Câu hỏi 15: Làm thế nào để triển khai cache trong Rails?
Rails cung cấp nhiều cấp độ cache: fragment caching, Russian Doll caching, low-level caching. Lựa chọn phụ thuộc vào trường hợp sử dụng.
```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 với khóa cache tự động %>
<% @products.each do |product| %>
<%# Cache dựa trên updated_at của sản phẩm %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<%# Russian Doll caching - cache lồng nhau %>
<% cache ['v1', @category] do %>