Rails开发必读 MVC模式在框架中的高效应用与性能优化实践指南
引言：理解Rails MVC架构的核心价值
Rails框架基于Ruby语言构建，其核心设计理念是”约定优于配置”（Convention over Configuration），而MVC（Model-View-Controller）模式是这一理念的基石。在现代Web开发中，正确理解和应用MVC模式不仅能提升开发效率，更能显著优化应用性能。
MVC模式将应用分为三个核心组件：
Model（模型）
：负责数据处理和业务逻辑
View（视图）
：负责用户界面展示
Controller（控制器）
：负责协调Model和View，处理用户请求
在Rails中，这三个组件通过清晰的文件结构和命名约定紧密协作，形成了一个高效、可维护的开发框架。
一、Model层的高效应用与性能优化
1.1 ActiveRecord最佳实践
ActiveRecord是Rails的ORM（对象关系映射）层，它将数据库表映射为Ruby对象，提供了强大的数据库操作能力。
1.1.1 避免N+1查询问题
N+1查询是Rails应用中最常见的性能陷阱。当遍历一个关联集合并对每个元素执行查询时，就会产生这个问题。
问题示例：
# 假设我们有Post和Comment模型，Post has_many :comments
# 错误的写法 – 会产生N+1查询
@posts = Post.all
@posts.each do |post|
puts “Post: #{post.title}”
post.comments.each do |comment| # 每次循环都会查询数据库
puts “Comment: #{comment.content}”
end
end
优化方案：
# 使用eager loading预加载关联数据
@posts = Post.includes(:comments).all
@posts.each do |post|
puts “Post: #{post.title}”
post.comments.each do |comment| # 不会再查询数据库
puts “Comment: #{comment.content}”
end
end
更复杂的关联优化：
# 多层级关联的预加载
@posts = Post.includes(comments: :user).all
# 或者使用preload和eager_load的精确控制
@posts = Post.preload(:comments).where(published: true)
@posts = Post.eager_load(:comments).where(comments: { approved: true })
1.1.2 批量操作与内存优化
处理大量数据时，避免一次性加载所有记录到内存中。
问题写法：
# 加载所有记录到内存，可能导致内存溢出
User.all.each do |user|
user.update(last_login_at: Time.current)
end
优化方案1 – find_each：
# 分批处理，默认每批1000条记录
User.find_each do |user|
user.update(last_login_at: Time.current)
end
# 可以自定义批次大小
User.find_each(batch_size: 500) do |user|
user.update(last_login_at: Time.current)
end
优化方案2 – update_all：
# 数据库层面批量更新，效率最高
User.where(active: true).update_all(last_login_at: Time.current)
优化方案3 – insert_all（Rails 6+）：
# 批量插入，避免回调和验证
users_data = [
{ name: ‘Alice’, email: ‘alice@example.com’ },
{ name: ‘Bob’, email: ‘bob@example.com’ }
]
User.insert_all(users_data)
1.1.3 索引优化策略
合理的数据库索引是提升查询性能的关键。
# 迁移文件中的索引创建
class AddIndexesToUsers < ActiveRecord::Migration[7.0]
def change
# 单列索引
add_index :users, :email, unique: true
# 复合索引
add_index :users, [:account_id, :created_at], order: { created_at: :desc }
# 部分索引（PostgreSQL）
add_index :users, :email, where: 'active = true'
# 全文索引（PostgreSQL）
add_index :users, :name, using: :gin, opclass: :gin_trgm_ops
end
end
索引使用原则：
为经常用于查询条件的列添加索引
为外键列添加索引
复合索引的列顺序很重要：最常用的查询条件放在前面
避免过度索引，因为索引会降低写入性能
1.2 数据库查询优化
1.2.1 选择性字段查询
避免查询不需要的字段，特别是包含大文本或二进制数据的字段。
# 不好的做法 - 查询所有字段
users = User.all
# 好的做法 - 只查询需要的字段
users = User.select(:id, :name, :email).all
# 在视图中使用时，可以使用pluck直接获取数组
user_emails = User.where(active: true).pluck(:email)
# 获取单个字段的值
first_user_name = User.first&.name # 只查询name字段
1.2.2 使用数据库函数
利用数据库的内置函数进行计算，减少数据传输。
# 统计查询
active_users_count = User.where(active: true).count
recent_users = User.where('created_at > ?’, 1.week.ago).count
# 使用数据库函数进行计算
User.select(‘*, DATEDIFF(NOW(), last_login_at) as days_since_login’)
# 在查询中使用CASE语句
users = User.select(<<~SQL)
users.*,
CASE
WHEN last_login_at > ? THEN ‘active’
ELSE ‘inactive’
END as status
SQL
1.2.3 复杂查询的SQL优化
对于复杂查询，直接编写SQL可能更高效。
# 使用Arel构建复杂查询
users = User.arel_table
posts = Post.arel_table
query = users
.project(users[:id], users[:name], posts[:title].count.as(‘post_count’))
.join(posts).on(users[:id].eq(posts[:user_id]))
.group(users[:id], users[:name])
.order(posts[:title].count.desc)
User.find_by_sql(query.to_sql)
1.3 缓存策略
1.3.1 片段缓存
在视图中缓存经常变化但计算成本高的部分。
<%# app/views/posts/index.html.erb %>
<% @posts.each do |post| %>
<% cache post do %>
<%= post.title %>
<%= truncate(post.content, length: 200) %>
By <%= post.user.name %>
<%= time_ago_in_words(post.created_at) %>
<% end %>
<% end %>
1.3.2 模型缓存
# 缓存模型查询结果
class Post < ApplicationRecord
# 缓存关联
has_many :comments, -> { order(created_at: :desc) }
# 缓存计数
def cached_comments_count
Rails.cache.fetch(“#{cache_key}/comments_count”) do
comments.count
end
end
end
# 在控制器中使用
class PostsController < ApplicationController
def show
@post = Rails.cache.fetch("post_#{params[:id]}_#{params[:updated_at]}", expires_in: 1.hour) do
Post.includes(comments: :user).find(params[:id])
end
end
end
1.3.3 Russian Doll Caching（俄罗斯套娃缓存）
<%# 嵌套缓存示例 %>
<% cache @post do %>
<%= @post.title %>
<%# 内部缓存依赖外部缓存 %>
<% cache @post.comments do %>
<% end %>
<% end %>
二、View层的高效应用与性能优化
2.1 模板优化策略
2.1.1 局部模板复用
<%# app/views/shared/_card.html.erb %>
<%= title %>
<%= yield %>
<%# 使用示例 %>
<%= render 'shared/card', title: '用户信息', class: 'user-card' do %>
用户名: <%= @user.name %>
邮箱: <%= @user.email %>
<% end %>
2.1.2 集合渲染优化
<%# 不推荐 - 每次迭代都调用局部模板 %>
<% @posts.each do |post| %>
<%= render partial: 'post', locals: { post: post } %>
<% end %>
<%# 推荐 - 使用collection一次渲染所有 %>
<%= render partial: 'post', collection: @posts %>
<%# 更好的做法 - 使用简写 %>
<%= render @posts %>
2.1.3 条件渲染与内容块
# 在Helper中定义灵活的内容块
module ApplicationHelper
def card(title: nil, &block)
content_tag(:div, class: ‘card’) do
concat(content_tag(:div, title, class: ‘card-header’)) if title
concat(content_tag(:div, class: ‘card-body’, &block))
end
end
end
# 在视图中使用
<%= card(title: 'Dashboard') do %>
欢迎回来，<%= current_user.name %>!
您有 <%= @unread_count %> 条未读消息
<% end %>
2.2 减少视图渲染时间
2.2.1 避免在视图中执行复杂查询
# 错误的Controller写法
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
# 错误的View写法 - 在视图中执行查询
<% @posts.each do |post| %>
<%= post.user.name %>
# 每次都会查询users表
<% end %>
# 正确的Controller写法 – 预加载
class PostsController < ApplicationController
def index
@posts = Post.includes(:user).all
end
end
# 正确的View写法
<% @posts.each do |post| %>
<%= post.user.name %>
# 使用预加载的数据
<% end %>
2.2.2 使用Presenter/Decorator模式
# app/presenters/post_presenter.rb
class PostPresenter
def initialize(post, view_context)
@post = post
@view_context = view_context
end
def title
@post.title.upcase
end
def published_date
@view_context.l(@post.created_at, format: :long)
end
def author_info
“#{@post.user.name} (#{@post.user.email})”
end
def status_badge
@view_context.content_tag(:span, @post.status, class: “badge badge-#{@post.status}”)
end
end
# 在Controller中使用
class PostsController < ApplicationController
def show
@post = PostPresenter.new(Post.find(params[:id]), view_context)
end
end
# 在View中使用
<%= @post.title %>
<%= @post.published_date %>
<%= @post.author_info %>
<%= @post.status_badge %>
2.3 前端资源优化
2.3.1 Turbolinks优化
// app/javascript/application.js
// 确保Turbolinks事件正确处理
document.addEventListener(‘turbolinks:load’, function() {
// 初始化插件
initializePlugins();
// 绑定事件
bindEvents();
});
// 避免在页面卸载时执行耗时操作
document.addEventListener(‘turbolinks:before-cache’, function() {
// 清理工作
cleanUp();
});
2.3.2 部分页面更新
# Controller支持Turbo Streams
class PostsController < ApplicationController
def update
@post = Post.find(params[:id])
if @post.update(post_params)
respond_to do |format|
format.html { redirect_to @post }
format.turbo_stream
end
end
end
end
# app/views/posts/update.turbo_stream.erb
<%= turbo_stream.replace @post %>
<%= turbo_stream.prepend "flash_messages", partial: "shared/flash" %>
三、Controller层的高效应用与性能优化
3.1 控制器职责分离
3.1.1 单一职责原则
# 不好的做法 – 控制器承担过多职责
class UsersController < ApplicationController
def create
@user = User.new(user_params)
if @user.save
# 发送邮件
UserMailer.welcome(@user).deliver_later
# 发送短信
SmsService.send_welcome(@user.phone)
# 记录日志
Rails.logger.info("User created: #{@user.id}")
# 更新缓存
Rails.cache.delete('user_stats')
redirect_to @user
else
render :new
end
end
end
# 好的做法 - 使用Service对象
class UsersController < ApplicationController
def create
@user = User.new(user_params)
if @user.save
UserCreationService.new(@user).call
redirect_to @user
else
render :new
end
end
end
# app/services/user_creation_service.rb
class UserCreationService
def initialize(user)
@user = user
end
def call
send_welcome_email
send_welcome_sms
log_creation
update_cache
end
private
def send_welcome_email
UserMailer.welcome(@user).deliver_later
end
def send_welcome_sms
SmsService.send_welcome(@user.phone)
end
def log_creation
Rails.logger.info("User created: #{@user.id}")
end
def update_cache
Rails.cache.delete('user_stats')
end
end
3.1.2 使用Concerns提取共享逻辑
# app/controllers/concerns/paginatable.rb
module Paginatable
extend ActiveSupport::Concern
included do
before_action :set_page_and_per_page
end
private
def set_page_and_per_page
@page = params[:page]&.to_i || 1
@per_page = params[:per_page]&.to_i || 20
end
def paginate(relation)
relation.offset((@page - 1) * @per_page).limit(@per_page)
end
end
# 在Controller中使用
class PostsController < ApplicationController
include Paginatable
def index
@posts = paginate(Post.includes(:user).order(created_at: :desc))
end
end
3.2 请求处理优化
3.2.1 条件查询优化
# 不好的写法 - 复杂的条件分支
class PostsController < ApplicationController
def index
if params[:category].present?
if params[:tag].present?
@posts = Post.where(category: params[:category], tag: params[:tag])
else
@posts = Post.where(category: params[:category])
end
else
if params[:tag].present?
@posts = Post.where(tag: params[:tag])
else
@posts = Post.all
end
end
end
end
# 好的写法 - 使用作用域和链式调用
class Post < ApplicationRecord
scope :by_category, ->(category) { where(category: category) if category.present? }
scope :by_tag, ->(tag) { where(tag: tag) if tag.present? }
end
class PostsController < ApplicationController
def index
@posts = Post.includes(:user)
.by_category(params[:category])
.by_tag(params[:tag])
.order(created_at: :desc)
.page(params[:page])
end
end
3.2.2 异步处理
# 使用ActiveJob处理耗时任务
class PostsController < ApplicationController
def create
@post = Post.new(post_params)
if @post.save
# 异步处理索引更新
IndexUpdateJob.perform_later(@post)
# 异步处理通知
NotifyFollowersJob.perform_later(@post)
redirect_to @post
else
render :new
end
end
end
# app/jobs/index_update_job.rb
class IndexUpdateJob < ApplicationJob
queue_as :default
def perform(post)
# 更新搜索索引
SearchService.index_post(post)
end
end
# app/jobs/notify_followers_job.rb
class NotifyFollowersJob < ApplicationJob
queue_as :notifications
def perform(post)
post.followers.each do |follower|
NotificationMailer.new_post(follower, post).deliver_later
end
end
end
3.3 响应格式优化
3.3.1 多格式响应
class PostsController < ApplicationController
def show
@post = Post.find(params[:id])
respond_to do |format|
format.html
format.json { render json: @post }
format.xml { render xml: @post }
format.pdf { render pdf: @post.title, template: 'posts/show.pdf.erb' }
end
end
end
3.3.2 部分响应（Partial Response）
# 只返回需要的字段
def show
@post = Post.find(params[:id])
render json: @post.as_json(only: [:id, :title, :created_at])
end
# 或者使用Jbuilder进行复杂JSON构建
# app/views/posts/show.json.jbuilder
json.id @post.id
json.title @post.title
json.content @post.content
json.author do
json.name @post.user.name
json.email @post.user.email
end
json.comments @post.comments do |comment|
json.id comment.id
json.content comment.content
json.author comment.user.name
end
四、Rails性能优化综合实践
4.1 数据库层面优化
4.1.1 数据库配置优化
# config/database.yml
production:
adapter: postgresql
encoding: unicode
database: myapp_production
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
timeout: 5000
# 连接池配置
max_connections: 100
# 准备语句缓存
prepared_statements: true
4.1.2 使用数据库视图
# 迁移文件
class CreateActiveUsersView < ActiveRecord::Migration[7.0]
def up
execute <<-SQL
CREATE VIEW active_users AS
SELECT id, name, email, last_login_at
FROM users
WHERE active = true
AND last_login_at > NOW() – INTERVAL ’30 days’
SQL
end
def down
execute “DROP VIEW active_users”
end
end
# 模型映射
class ActiveUser < ApplicationRecord
self.table_name = 'active_users'
self.readonly = true
end
4.1.3 使用物化视图（PostgreSQL）
# 迁移文件
class CreatePostStatsMaterializedView < ActiveRecord::Migration[7.0]
def up
execute <<-SQL
CREATE MATERIALIZED VIEW post_stats AS
SELECT
posts.id,
posts.title,
COUNT(comments.id) as comments_count,
AVG(ratings.value) as avg_rating
FROM posts
LEFT JOIN comments ON comments.post_id = posts.id
LEFT JOIN ratings ON ratings.post_id = posts.id
GROUP BY posts.id, posts.title
SQL
add_index :post_stats, :id, unique: true
end
def down
execute "DROP MATERIALIZED VIEW post_stats"
end
end
# 刷新物化视图
class RefreshPostStatsJob < ApplicationJob
def perform
ActiveRecord::Base.connection.execute(
"REFRESH MATERIALIZED VIEW CONCURRENTLY post_stats"
)
end
end
4.2 应用层优化
4.2.1 使用俄罗斯套娃缓存（Russian Doll Caching）
# app/models/post.rb
class Post < ApplicationRecord
belongs_to :user
has_many :comments
# 定义缓存键
def cache_key_with_version
"post/#{id}-#{updated_at.to_i}"
end
end
# app/views/posts/show.html.erb
<% cache @post do %>
<%= @post.title %>
<%= @post.content %>
<%# 内部缓存 %>
<% cache @post.comments do %>
<% end %>
<% end %>
4.2.2 使用缓存存储优化
# config/environments/production.rb
config.cache_store = :redis_cache_store, {
url: ENV.fetch(‘REDIS_URL’) { ‘redis://localhost:6379/1’ },
namespace: ‘cache’,
expires_in: 90.minutes,
race_condition_ttl: 5.seconds,
reconnect_attempts: 1,
error_handler: -> (method:, returning:, exception:) {
Rails.logger.error(“Cache error: #{exception.message}”)
}
}
# 多级缓存策略
config.cache_store = :multi_cache_store, [
[:memory_store, size: 64.megabytes],
[:redis_cache_store, url: ENV.fetch(‘REDIS_URL’)]
]
4.2.3 后台任务优化
# 使用Sidekiq进行后台处理
# Gemfile
gem ‘sidekiq’
gem ‘sidekiq-cron’
# config/sidekiq.yml
:concurrency: 10
:queues:
– default
– mailers
– notifications
– indexing
# app/jobs/process_post_job.rb
class ProcessPostJob < ApplicationJob
queue_as :default
sidekiq_options retry: 3, dead: false
def perform(post_id)
post = Post.find(post_id)
# 使用事务确保数据一致性
Post.transaction do
post.update!(processed: true)
update_search_index(post)
notify_subscribers(post)
end
rescue ActiveRecord::RecordNotFound
# 记录错误但不重试
Rails.logger.warn("Post #{post_id} not found")
end
private
def update_search_index(post)
# 更新Elasticsearch索引
SearchService.index_post(post)
end
def notify_subscribers(post)
# 批量发送通知
post.subscribers.find_each(batch_size: 500) do |subscriber|
NotificationMailer.new_post(subscriber, post).deliver_later
end
end
end
4.3 监控与调试
4.3.1 性能监控
# config/initializers/instrumentation.rb
ActiveSupport::Notifications.subscribe "sql.active_record" do |*args|
event = ActiveSupport::Notifications::Event.new(*args)
if event.duration > 100 # 毫秒
Rails.logger.warn “Slow SQL: #{event.payload[:sql]} (#{event.duration}ms)”
end
end
# 自定义监控
class PerformanceMonitor
def self.measure(label)
start = Time.current
result = yield
duration = (Time.current – start) * 1000
if duration > 50
Rails.logger.info “[PERF] #{label}: #{duration.round(2)}ms”
end
result
end
end
# 使用示例
PerformanceMonitor.measure(“Post search”) do
Post.search(params[:q])
end
4.3.2 日志优化
# config/initializers/filter_parameter_logging.rb
Rails.application.config.filter_parameters += [
:password, :credit_card, :ssn, :api_key
]
# 自定义日志格式
class CustomLogFormatter < ActiveSupport::Logger::SimpleFormatter
def call(severity, time, progname, msg)
"[#{time.strftime("%Y-%m-%d %H:%M:%S")}] #{severity}: #{msg}\n"
end
end
# config/environments/production.rb
config.log_formatter = CustomLogFormatter.new
五、Rails 7新特性与性能优化
5.1 Turbo和Stimulus的性能优势
// app/javascript/controllers/hello_controller.js
import { Controller } from "@hotwired/stimulus"
export default class extends Controller {
static targets = ["name", "output"]
greet() {
this.outputTarget.textContent =
`Hello, ${this.nameTarget.value}!`
}
// 异步加载数据
async load() {
const response = await fetch('/api/data')
const data = await response.json()
this.render(data)
}
}
5.2 Zeitwerk自动加载器优化
# config/application.rb
module MyApp
class Application < Rails::Application
# Zeitwerk自动加载配置
config.autoloader = :zeitwerk
# 自定义加载路径
config.autoload_paths << "#{root}/app/services"
config.autoload_paths << "#{root}/app/decorators"
# 忽略特定文件
config.autoload_ignore_paths << "#{root}/app/lib/legacy_code.rb"
end
end
六、性能优化检查清单
6.1 开发阶段检查清单
[ ] 是否使用了
includes
或
preload
避免N+1查询？
[ ] 是否使用了
select
只查询需要的字段？
[ ] 是否使用了
find_each
处理大量数据？
[ ] 是否为频繁查询的字段添加了索引？
[ ] 是否使用了缓存策略？
[ ] 是否将耗时任务放入后台队列？
[ ] 是否使用了Service对象分离业务逻辑？
6.2 生产环境监控清单
[ ] 数据库查询时间监控（< 100ms）
[ ] 应用响应时间监控（< 200ms）
[ ] 内存使用监控（< 500MB）
[ ] CPU使用率监控（< 70%）
[ ] 缓存命中率监控（> 80%）
[ ] 后台任务队列长度监控
6.3 性能测试工具
# 使用benchmark-ips进行基准测试
require ‘benchmark/ips’
Benchmark.ips do |x|
x.report(“N+1查询”) { Post.all.each { |p| p.user.name } }
x.report(“预加载”) { Post.includes(:user).all.each { |p| p.user.name } }
x.compare!
end
# 使用rack-mini-profiler
# Gemfile
gem ‘rack-mini-profiler’
# config/initializers/rack_profiler.rb
if Rails.env.development?
require ‘rack-mini-profiler’
Rack::MiniProfiler.config.position = ‘right’
Rack::MiniProfiler.config.start_hidden = true
end
七、总结
Rails MVC模式的高效应用需要开发者深入理解框架的每个组件，并在实际开发中不断实践和优化。关键要点包括：
Model层
：善用ActiveRecord的查询优化、索引策略和缓存机制
View层
：减少复杂计算、使用缓存、优化前端资源
Controller层
：保持职责单一、使用Service对象、异步处理
综合优化
：数据库优化、应用层缓存、监控调试
通过遵循这些最佳实践，你的Rails应用将获得显著的性能提升和更好的可维护性。记住，性能优化是一个持续的过程，需要在开发、测试和生产环境中不断监控和调整。
提示
：在实际项目中，建议先使用性能监控工具找出瓶颈，然后有针对性地应用上述优化策略，避免过早优化。
# Rails开发必读：MVC模式在框架中的高效应用与性能优化实践指南
引言：理解Rails MVC架构的核心价值
Rails框架基于Ruby语言构建，其核心设计理念是”约定优于配置”（Convention over Configuration），而MVC（Model-View-Controller）模式是这一理念的基石。在现代Web开发中，正确理解和应用MVC模式不仅能提升开发效率，更能显著优化应用性能。
MVC模式将应用分为三个核心组件：
Model（模型）
：负责数据处理和业务逻辑
View（视图）
：负责用户界面展示
Controller（控制器）
：负责协调Model和View，处理用户请求
在Rails中，这三个组件通过清晰的文件结构和命名约定紧密协作，形成了一个高效、可维护的开发框架。
一、Model层的高效应用与性能优化
1.1 ActiveRecord最佳实践
ActiveRecord是Rails的ORM（对象关系映射）层，它将数据库表映射为Ruby对象，提供了强大的数据库操作能力。
1.1.1 避免N+1查询问题
N+1查询是Rails应用中最常见的性能陷阱。当遍历一个关联集合并对每个元素执行查询时，就会产生这个问题。
问题示例：
# 假设我们有Post和Comment模型，Post has_many :comments
# 错误的写法 – 会产生N+1查询
@posts = Post.all
@posts.each do |post|
puts “Post: #{post.title}”
post.comments.each do |comment| # 每次循环都会查询数据库
puts “Comment: #{comment.content}”
end
end
优化方案：
# 使用eager loading预加载关联数据
@posts = Post.includes(:comments).all
@posts.each do |post|
puts “Post: #{post.title}”
post.comments.each do |comment| # 不会再查询数据库
puts “Comment: #{comment.content}”
end
end
更复杂的关联优化：
# 多层级关联的预加载
@posts = Post.includes(comments: :user).all
# 或者使用preload和eager_load的精确控制
@posts = Post.preload(:comments).where(published: true)
@posts = Post.eager_load(:comments).where(comments: { approved: true })
1.1.2 批量操作与内存优化
处理大量数据时，避免一次性加载所有记录到内存中。
问题写法：
# 加载所有记录到内存，可能导致内存溢出
User.all.each do |user|
user.update(last_login_at: Time.current)
end
优化方案1 – find_each：
# 分批处理，默认每批1000条记录
User.find_each do |user|
user.update(last_login_at: Time.current)
end
# 可以自定义批次大小
User.find_each(batch_size: 500) do |user|
user.update(last_login_at: Time.current)
end
优化方案2 – update_all：
# 数据库层面批量更新，效率最高
User.where(active: true).update_all(last_login_at: Time.current)
优化方案3 – insert_all（Rails 6+）：
# 批量插入，避免回调和验证
users_data = [
{ name: ‘Alice’, email: ‘alice@example.com’ },
{ name: ‘Bob’, email: ‘bob@example.com’ }
]
User.insert_all(users_data)
1.1.3 索引优化策略
合理的数据库索引是提升查询性能的关键。
# 迁移文件中的索引创建
class AddIndexesToUsers < ActiveRecord::Migration[7.0]
def change
# 单列索引
add_index :users, :email, unique: true
# 复合索引
add_index :users, [:account_id, :created_at], order: { created_at: :desc }
# 部分索引（PostgreSQL）
add_index :users, :email, where: 'active = true'
# 全文索引（PostgreSQL）
add_index :users, :name, using: :gin, opclass: :gin_trgm_ops
end
end
索引使用原则：
为经常用于查询条件的列添加索引
为外键列添加索引
复合索引的列顺序很重要：最常用的查询条件放在前面
避免过度索引，因为索引会降低写入性能
1.2 数据库查询优化
1.2.1 选择性字段查询
避免查询不需要的字段，特别是包含大文本或二进制数据的字段。
# 不好的做法 - 查询所有字段
users = User.all
# 好的做法 - 只查询需要的字段
users = User.select(:id, :name, :email).all
# 在视图中使用时，可以使用pluck直接获取数组
user_emails = User.where(active: true).pluck(:email)
# 获取单个字段的值
first_user_name = User.first&.name # 只查询name字段
1.2.2 使用数据库函数
利用数据库的内置函数进行计算，减少数据传输。
# 统计查询
active_users_count = User.where(active: true).count
recent_users = User.where('created_at > ?’, 1.week.ago).count
# 使用数据库函数进行计算
User.select(‘*, DATEDIFF(NOW(), last_login_at) as days_since_login’)
# 在查询中使用CASE语句
users = User.select(<<~SQL)
users.*,
CASE
WHEN last_login_at > ? THEN ‘active’
ELSE ‘inactive’
END as status
SQL
1.2.3 复杂查询的SQL优化
对于复杂查询，直接编写SQL可能更高效。
# 使用Arel构建复杂查询
users = User.arel_table
posts = Post.arel_table
query = users
.project(users[:id], users[:name], posts[:title].count.as(‘post_count’))
.join(posts).on(users[:id].eq(posts[:user_id]))
.group(users[:id], users[:name])
.order(posts[:title].count.desc)
User.find_by_sql(query.to_sql)
1.3 缓存策略
1.3.1 片段缓存
在视图中缓存经常变化但计算成本高的部分。
<%# app/views/posts/index.html.erb %>
<% @posts.each do |post| %>
<% cache post do %>
<%= post.title %>
<%= truncate(post.content, length: 200) %>
By <%= post.user.name %>
<%= time_ago_in_words(post.created_at) %>
<% end %>
<% end %>
1.3.2 模型缓存
# 缓存模型查询结果
class Post < ApplicationRecord
# 缓存关联
has_many :comments, -> { order(created_at: :desc) }
# 缓存计数
def cached_comments_count
Rails.cache.fetch(“#{cache_key}/comments_count”) do
comments.count
end
end
end
# 在控制器中使用
class PostsController < ApplicationController
def show
@post = Rails.cache.fetch("post_#{params[:id]}_#{params[:updated_at]}", expires_in: 1.hour) do
Post.includes(comments: :user).find(params[:id])
end
end
end
1.3.3 Russian Doll Caching（俄罗斯套娃缓存）
<%# 嵌套缓存示例 %>
<% cache @post do %>
<%= @post.title %>
<%# 内部缓存依赖外部缓存 %>
<% cache @post.comments do %>
<% end %>
<% end %>
二、View层的高效应用与性能优化
2.1 模板优化策略
2.1.1 局部模板复用
<%# app/views/shared/_card.html.erb %>
<%= title %>
<%= yield %>
<% cache comment do %>
<%= comment.content %>
By <%= comment.user.name %>
<% end %>
<% end %>