Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Ruby

Làm Chủ Transaction Trong Ruby on Rails: 5 Thực Hành Thiết Kế Cốt Lõi

Vấn đề tính toàn vẹn dữ liệu là một trong những vấn đề database phổ biến nhất mà các Rails developer gặp phải. Bên cạnh việc cho phép validation phù hợp, các transaction blocks được thiết kế đúng đắn đảm bảo dữ liệu không bị tạo hoặc cập nhật một cách từng phần.

Tuy nhiên, transactions cũng có thể gây hại cho ứng dụng — thậm chí làm sập toàn bộ database — khi không được thiết kế đúng cách.

Bài viết này cung cấp một tập hợp các thực hành tốt cho việc làm việc với transactions. Các mẹo khá đơn giản, nhưng chúng sẽ giúp làm cho transactions của bạn trở nên "chắc chắn", dễ đọc và an toàn tương đối.

Hãy đi sâu vào chủ đề!

1. Sử Dụng Bang Methods (Phương Thức Có Dấu !) Trong Rails Khi Có Thể

Trong Rails, các phiên bản phương thức có dấu ! cho bạn sự tự tin rằng một lỗi sẽ được raise khi có sự cố xảy ra.

Ví dụ, phương thức #save cũng tồn tại phiên bản save!. Bạn có thể muốn dùng phiên bản này trong controller nếu không muốn raise lỗi:

def create
  @user = User.new(user_params)
  if @user.save
    redirect_to @user
  else
    render :new
  end
end

Cách tiếp cận trên sẽ không hoạt động tốt trong transactions. Bằng cách dùng save, chúng ta không thể roll back quá trình khi lỗi được raise. Đó là lý do tại sao việc dùng phiên bản ! của các phương thức lại quan trọng:

User.transaction do
  user = User.create!(name: 'John')
  Membership.create!(user: user, group: group)
end

Trong ví dụ trên, transaction thành công ngay cả khi record membership không được tạo, và chúng ta kết thúc với cấu trúc dữ liệu bị hỏng trong database.

Nếu dùng phiên bản sau, transaction sẽ revert do lỗi ActiveRecord::RecordNotSaved:

User.transaction do
  user = User.create!(name: 'John')
  Membership.create!(user: user, group: group)
end

2. Xử Lý Lỗi Trong Rails Transactions Đúng Cách

Khi nói đến lỗi trong transactions, có một số quy tắc bạn nên tuân thủ. Tuân theo các quy tắc này, bạn sẽ có code dễ đọc và hoạt động tốt, không gây nhầm lẫn cho các developer khác hoặc hành vi lạ khó debug.

Không Rescue Từ ActiveRecord::StatementInvalid

ActiveRecord::StatementInvalid là một lỗi đặc biệt được raise khi có sự cố ở cấp độ database. Không bao giờ rescue từ lỗi này. Bạn nên luôn được thông báo rõ ràng khi có sự cố với database query.

Tránh code sau:

User.transaction do
  user = User.create!(name: 'John')
  Membership.create!(user: user, group: group)
rescue ActiveRecord::StatementInvalid
  # Xử lý lỗi - KHÔNG NÊN LÀM VẬY
end

Sử Dụng Rescue Ở Mức Đúng

Nếu bạn dùng rescue ở mức sau, bạn sẽ bắt được lỗi:

begin
  User.transaction do
    user = User.create!(name: 'John')
    Membership.create!(user: user, group: group)
  end
rescue ActiveRecord::RecordInvalid => e
  # Xử lý lỗi
end

Transaction không roll back vì bạn đã bắt lỗi. Hãy để lỗi được raise và bắt nó bên ngoài transaction block:

begin
  User.transaction do
    user = User.create!(name: 'John')
    Membership.create!(user: user, group: group)
  end
rescue ActiveRecord::RecordInvalid => e
  # Xử lý lỗi - transaction đã roll back
end

Trong cách tiếp cận trên, transaction roll back nếu có lỗi, và bạn bắt được lỗi. Đây là cách đúng để bắt lỗi được raise bên trong transactions mà không ghi đè hành vi transaction.

Không Bắt Generic Errors (Lỗi Chung)

Bạn nên tránh bắt các lỗi chung như StandardError hoặc ArgumentError. Đây giống như một quy tắc chung cho code dễ đọc và dễ test, nhưng đáng để nhắc lại.

Việc bắt các lỗi này có thể khiến debugging khó khăn hơn, vì các nơi khác trong code có thể raise các lỗi tương tự. Điều này có thể làm lặng một số vấn đề nghiêm trọng trong app không nhất thiết liên quan đến nơi bạn rescue chúng.

Sử Dụng Lỗi Rollback Mặc Của ActiveRecord Một Cách Khôn Ngoan

ActiveRecord cung cấp một lớp lỗi đặc biệt mà bạn có thể dùng bên trong transaction để thực hiện rollback lặng lẽ. Bạn roll back transaction bằng cách raise ActiveRecord::Rollback, nhưng lỗi này không được raise ra ngoài, khác với các lỗi khác. Hãy nhớ hành vi này và dùng nó khôn ngoan.

3. Biết Khi Nào Nên Tránh Dùng Transactions Trong Rails

Giống như bất cứ thứ gì, bạn không nên lạm dụng transactions trong code. Ví dụ, một lỗi phổ biến là chỉ wrap một query đơn lẻ vào transaction. Điều này không có ý nghĩa vì nếu query không thành công, không có gì để roll back cả.

Một lỗi phổ biến khác là wrap code không liên quan đến database call vào transaction. Bạn nên tránh cách tiếp cận này, vì transaction sẽ giữ connection trừ khi code bên trong block thực thi xong. Hãy giới hạn code bên trong block chỉ gọi database, nếu có thể.

4. Hiểu Nhược Điểm Của Transactions

Transactions giúp duy trì tính toàn vẹn dữ liệu bên trong database, nhưng bạn cũng nên nhận ra nhược điểm của chúng. Ví dụ, các queries được wrap trong transaction block tiêu tốn nhiều tài nguyên DB hơn single queries.

Nhược điểm khác của việc dùng transactions là nó dẫn đến code phức tạp hơn. Transactions có thể làm code kém readable hơn khi dùng sai cách.

5. Sử Dụng Transaction Block Trong Ngữ Cảnh Đúng

Bạn có thể dùng phương thức transaction khi một class kế thừa từ class ActiveRecord. Điều này không có nghĩa là phiên bản bạn dùng không quan trọng. Mặc dù có thể không quan trọng từ góc độ functional, nhưng nó quan trọng về việc đảm bảo code dễ đọc.

Ba phiên bản phổ biến dùng phương thức transaction:

# 1. Trên ActiveRecord::Base
ActiveRecord::Base.transaction do
  # ...
end

# 2. Trên model class
User.transaction do
  # ...
end

# 3. Trên model instance
user.transaction do
  # ...
end

Khi bạn dùng nhiều models và mix việc gọi instance methods với classes bên trong block, bạn nên dùng ActiveRecord::Base.transaction:

ActiveRecord::Base.transaction do
  user = User.create!(name: 'John')
  user.posts.create!(title: 'Hello')
  Comment.create!(post: user.posts.first, body: 'Great!')
end

Nếu bạn chủ yếu xử lý code thuộc về một model cụ thể, hãy gọi transaction method trên class:

User.transaction do
  user = User.create!(name: 'John')
  user.posts.create!(title: 'Hello')
end

Khi bạn thao tác trên một model instance, việc gọi transaction method trên instance level là hợp lý:

user.transaction do
  user.update!(name: 'Jane')
  user.posts.create!(title: 'New Post')
end

Tất nhiên, các quy tắc này không phải là chính thức. Chúng chỉ là gợi ý để làm code dễ đọc hơn.

Bước Tiếp Theo: Xem Xét Lại Transactions Trong Dự Án Ruby on Rails Của Bạn

Tôi hy vọng bạn thấy các mẹo làm việc với transactions trong Ruby on Rails này hữu ích.

Chúng ta đã bao quát tầm quan trọng của việc thiết kế Rails transactions đúng đắn để cải thiện tính toàn vẹn dữ liệu và đảm bảo các quy trình thực hiện mà không có side effects bất ngờ.

Tuy nhiên, một chính sách xử lý lỗi phù hợp không chỉ có lợi khi dùng transactions — nó cũng sẽ cải thiện toàn bộ codebase của bạn. Hãy nhớ điều này lần sau khi bạn mong đợi code của mình sẽ throw một số lỗi.

Bây giờ là lúc tuyệt vời để xem xét lại transactions trong thiết kế dự án Ruby on Rails của bạn để tránh lỗi. Thiết kế cho giao tiếp hiệu quả và tin cậy với database để làm cho ứng dụng ổn định hơn.

Happy coding!

P.S. Nếu bạn muốn đọc các bài Ruby Magic ngay khi xuất bản, hãy đăng ký newsletter Ruby Magic để không bỏ lỡ bất kỳ bài viết nào!

Paweł Dąbrowski

Tác giả khách Paweł là người đam mê open-source và tìm kiếm sự phát triển với hơn một thập kỷ kinh nghiệm viết cho cả con người và máy tính. Anh kết nối các chấm để tạo ra phần mềm chất lượng cao và xây dựng mối quan hệ giá trị với con người và doanh nghiệp.

Tất cả bài viết của Paweł Dąbrowski