Gọi lại

Đăng ký gọi lại

Trong Rails, lệnh gọi lại là một cơ chế để thực thi mã cụ thể trong vòng đời của một đối tượng mô hình. Lệnh gọi lại có thể thực thi mã cụ thể trong các hoạt động như tạo, cập nhật và xóa đối tượng mô hình, chẳng hạn như thực thi logic nhất định trước khi lưu đối tượng hoặc thực hiện các thao tác dọn dẹp trước khi đối tượng bị xóa.

Có hai loại lệnh gọi lại trong Rails: trước lệnh gọi lại và sau lệnh gọi lại. Cuộc gọi lại trước được thực thi trước khi thao tác được thực thi và cuộc gọi lại sau được thực thi sau khi thao tác được thực thi. Loại gọi lại có thể được chỉ định bằng tiền tố before_ và after_.

Dưới đây là một số loại gọi lại phổ biến:

• trước khi xác thực Và sau khi xác thực : Thực hiện lệnh gọi lại trước và sau khi xác thực đối tượng.
• trước khi lưu Và sau khi lưu : Thực hiện lệnh gọi lại trước và sau khi lưu đối tượng.
• trước khi tạo Và sau khi tạo : Thực hiện lệnh gọi lại trước và sau khi tạo đối tượng.
• trước khi cập nhật Và sau khi cập nhật : Thực hiện lệnh gọi lại trước và sau khi cập nhật đối tượng.
• trước khi hủy Và sau khi hủy : Thực hiện lệnh gọi lại trước và sau khi xóa đối tượng.

Để đăng ký một lệnh gọi lại, bạn có thể sử dụng tiền tố before_ hoặc after_ trong lớp mô hình để chỉ định loại gọi lại, sau đó chỉ định phương thức sẽ được thực thi:

                        
                          lớp Người dùng < ApplicationRecord trước khi lưu :normalize_email riêng tư def normalize_email self.email = email.downcase kết thúc kết thúc

                        
                      

Trong ví dụ trên, chúng tôi đã đăng ký phương thức normalize_email làm lệnh gọi lại before_save. Điều này có nghĩa là Rails sẽ tự động gọi phương thức normalize_email trước khi lưu đối tượng User. Trong phương thức normalize_email, chúng ta chuyển đổi thuộc tính email thành chữ thường để đảm bảo rằng tất cả địa chỉ email đều là chữ thường.

Cần lưu ý rằng khi đăng ký một cuộc gọi lại, bạn phải chỉ định tên của phương thức sẽ được thực thi, có thể là một phương thức thể hiện hoặc một phương thức lớp. Bất kỳ thuộc tính hoặc phương thức nào của đối tượng mô hình đều có thể được sử dụng trong phương thức gọi lại để thực hiện logic cụ thể, chẳng hạn như cập nhật các đối tượng khác, gửi email, v.v.

Việc sử dụng lệnh gọi lại cho phép chúng ta kiểm soát linh hoạt hơn hành vi của các đối tượng mô hình và thực hiện các thao tác tùy ý trong vòng đời của đối tượng. Đồng thời, lệnh gọi lại cũng có thể cải thiện khả năng đọc và khả năng bảo trì của mã, giúp mã dễ hiểu và sửa đổi hơn.

Các cuộc gọi lại có sẵn

Trong Rails, bạn có thể đăng ký nhiều loại lệnh gọi lại khác nhau để thực thi mã cụ thể trong vòng đời của một đối tượng mô hình. Các loại gọi lại sau đây có sẵn:

Tạo và lưu đối tượng

• trước khi xác thực : Thực hiện gọi lại trước khi xác thực đối tượng.
• sau khi xác thực : Thực hiện gọi lại sau khi xác thực đối tượng.
• trước khi lưu : Thực hiện gọi lại trước khi lưu đối tượng, bao gồm các thao tác mới và cập nhật.
• xung quanh_lưu : Thực hiện lệnh gọi lại trước và sau khi lưu đối tượng, sử dụng năng suất phương pháp thực hiện thao tác lưu.
• sau khi lưu : Thực hiện gọi lại sau khi lưu đối tượng, bao gồm các thao tác mới và cập nhật.
• trước khi tạo : Thực hiện lệnh gọi lại trước khi tạo đối tượng.
• xung quanh_tạo : Thực hiện các lệnh gọi lại trước và sau khi tạo đối tượng, sử dụng năng suất phương pháp thực hiện thao tác tạo.
• sau khi tạo : Thực hiện lệnh gọi lại sau khi đối tượng được tạo.

Cập nhật và xóa đối tượng

• trước khi cập nhật : Thực hiện lệnh gọi lại trước khi cập nhật đối tượng.
• xung quanh_cập_nhật : Thực hiện lệnh gọi lại trước và sau khi cập nhật đối tượng, sử dụng năng suất phương pháp thực hiện các hoạt động cập nhật.
• sau khi cập nhật : Thực hiện lệnh gọi lại sau khi cập nhật đối tượng.
• trước khi hủy : Thực hiện gọi lại trước khi xóa đối tượng.
• xung quanh_phá hủy : Thực hiện gọi lại trước và sau khi xóa đối tượng, sử dụng năng suất phương pháp thực hiện thao tác xóa.
• sau khi hủy : Thực hiện gọi lại sau khi xóa đối tượng.

Đối tượng liên quan

• trước khi thêm liên kết : Thực hiện lệnh gọi lại trước khi thêm đối tượng liên quan.
• sau khi thêm liên kết : Thực hiện lệnh gọi lại sau khi thêm đối tượng liên quan.
• trước khi xóa liên kết : Thực hiện gọi lại trước khi xóa đối tượng liên quan.
• sau khi xóa liên kết : Thực hiện gọi lại sau khi xóa đối tượng liên quan.

khác

• sau khi khởi tạo : Thực hiện gọi lại sau khi khởi tạo đối tượng.
• sau khi tìm : Thực hiện lệnh gọi lại sau khi tìm thấy đối tượng từ cơ sở dữ liệu.

Để đăng ký một lệnh gọi lại, bạn chỉ định loại gọi lại bằng phương thức gọi lại tương ứng trong lớp mô hình, sau đó chỉ định phương thức sẽ được thực thi. Ví dụ: để thực hiện logic cụ thể trước khi lưu một đối tượng, bạn có thể sử dụng phương thức before_save:

                        
                          lớp Người dùng < ApplicationRecord trước khi lưu :normalize_email riêng tư def normalize_email self.email = email.downcase kết thúc kết thúc

                        
                      

Trong ví dụ trên, chúng tôi đã đăng ký phương thức normalize_email làm lệnh gọi lại before_save. Điều này có nghĩa là Rails sẽ tự động gọi phương thức normalize_email trước khi lưu đối tượng User. Trong phương thức normalize_email, chúng ta chuyển đổi thuộc tính email thành chữ thường để đảm bảo rằng tất cả địa chỉ email đều là chữ thường.

Cần lưu ý rằng bất kỳ thuộc tính hoặc phương thức nào của đối tượng mô hình đều có thể được sử dụng trong phương thức gọi lại để thực hiện logic cụ thể, chẳng hạn như cập nhật các đối tượng khác, gửi email, v.v. Việc sử dụng lệnh gọi lại cho phép chúng ta kiểm soát linh hoạt hơn hành vi của các đối tượng mô hình và thực hiện các thao tác tùy ý trong vòng đời của đối tượng. Đồng thời, lệnh gọi lại cũng có thể cải thiện khả năng đọc và khả năng bảo trì của mã, giúp mã dễ hiểu và sửa đổi hơn.

Điều gì xảy ra nếu thuộc tính được cập nhật trước khi gọi lại?

Nếu bạn cố cập nhật thuộc tính trong lệnh gọi lại, điều này có thể gây ra một số vấn đề. Vì thứ tự thực hiện của các lệnh gọi lại không được xác định nên trong một số trường hợp, các cập nhật thuộc tính có thể bị ghi đè bởi các lệnh gọi lại khác hoặc bởi dữ liệu liên tục trong cơ sở dữ liệu.

Ví dụ: nếu chúng tôi cố gắng cập nhật một thuộc tính trong lệnh gọi lại before_save và có một lệnh gọi lại khác trong lệnh gọi lại after_save cũng cố cập nhật cùng một thuộc tính, thì giá trị thuộc tính cuối cùng có thể không được xác định vì lệnh gọi lại được thực hiện cuối cùng sẽ ghi đè lên giá trị trước đó . giá trị.

Để tránh tình trạng này, bạn nên cố gắng tránh cập nhật thuộc tính trong lệnh gọi lại. Nếu bạn thực sự cần cập nhật một thuộc tính, bạn có thể sử dụng phương thức update_column để cập nhật thuộc tính, phương thức này có thể cập nhật trực tiếp thuộc tính vào cơ sở dữ liệu mà không kích hoạt các lệnh gọi lại khác. Tuy nhiên, cần lưu ý rằng việc sử dụng phương thức update_column sẽ bỏ qua tất cả quá trình xác thực, bao gồm cả xác thực được xác định bởi mô hình, vì vậy cần phải thận trọng khi sử dụng.

Ngoài ra, nếu cần sử dụng dữ liệu từ các đối tượng mô hình khác trong lệnh gọi lại, bạn có thể di chuyển logic vào đối tượng bộ điều khiển hoặc dịch vụ để đảm bảo tính chính xác và khả năng bảo trì của dữ liệu.

after_initialize và after_find

after_initialize và after_find đều là các phương thức gọi lại trong mô hình ActiveRecord.

Phương thức after_initialize được gọi khi một đối tượng ActiveRecord mới được tạo hoặc một đối tượng hiện có được tải từ cơ sở dữ liệu. Phương thức này có thể được sử dụng để thực hiện logic khởi tạo tùy ý, chẳng hạn như thiết lập các giá trị mặc định hoặc khởi tạo các đối tượng liên quan. Không giống như các lệnh gọi lại khác, phương thức after_initialize không cần nhận bất kỳ tham số nào vì nó được gọi ngay sau khi đối tượng được tạo.

Dưới đây là một ví dụ minh họa cách sử dụng phương thức after_initialize để đặt giá trị mặc định khi tạo một đối tượng mới:

                        
                          lớp Người dùng < ApplicationRecord after_initialize :set_defaults private def set_defaults self.status ||= "active" end end

                        
                      

Trong ví dụ trên, chúng ta đã đăng ký phương thức set_defaults làm lệnh gọi lại after_initialize. Trong phương thức set_defaults, chúng tôi kiểm tra xem thuộc tính trạng thái có bằng 0 hay không và nếu có, hãy đặt nó thành giá trị mặc định là "hoạt động".

Phương thức after_find sẽ được gọi sau khi tìm thấy đối tượng ActiveRecord từ cơ sở dữ liệu. Phương pháp này có thể được sử dụng để thực hiện logic xử lý hậu kỳ tùy ý, chẳng hạn như tính toán các thuộc tính hoặc cập nhật các đối tượng liên quan. Phương thức after_find nhận một tham số, đó là đối tượng ActiveRecord được tải từ cơ sở dữ liệu.

Dưới đây là ví dụ minh họa cách sử dụng phương thức after_find để tính tuổi của người dùng:

                        
                          lớp Người dùng < ApplicationRecord after_find :calculate_age riêng tư def calculate_age self.age = Ngày.hôm.nay.năm - sinh.năm kết thúc kết thúc

                        
                      

Trong ví dụ trên, chúng ta đã đăng ký phương thức Calculate_age làm lệnh gọi lại after_find. Trong phương thức Calculate_age, chúng ta tính tuổi của người dùng bằng cách sử dụng thuộc tính birthday của đối tượng người dùng được tải từ cơ sở dữ liệu và lưu kết quả vào thuộc tính age.

需要注意的是， after_find 方法只会在从数据库中加载对象时被调用，而不会在实例化新对象时被调用。如果需要在对象创建后执行某些逻辑，应该使用 after_initialize 方法.

after_touch什么 意思

after_touch 是Rails中的一个回调方法，它会在一个已关联的对象被touch操作更新后被触发。在Rails中，touch操作指的是在更新一个对象时，同时更新关联对象的更新时间戳（ updated_at ）字段。这个操作可以用来实现缓存失效、重新计算统计数据等功能.

例如，假设你有一个 User 模型和一个 Post 模型，一个用户可以拥有多篇文章。当你更新某篇文章时，你可能需要更新相关用户的更新时间戳，以便在用户列表或其他地方正确地排序。你可以使用 touch 选项来实现这一点，如下所示:

                        
                          class Post < ApplicationRecord belongs_to :user, touch: true end class User < ApplicationRecord has_many :posts after_touch :update_sorting def update_sorting # 更新用户排序，例如更新`updated_at`字段 self.touch end end

                        
                      

这段代码定义了两个Active Record模型， Post 和 User ，它们之间存在一个一对多的关联关系.

在 Post 模型中，使用 belongs_to :user, touch: true 声明了一个属于关联，表示一篇文章属于一个用户。 touch: true 选项表示当文章被更新时，自动更新与之关联的用户的 updated_at 字段，以便在用户列表或其他地方正确地排序.

在 User 模型中，使用 has_many :posts 声明了一个拥有多个关联，表示一个用户可以拥有多篇文章。 after_touch :update_sorting 声明了一个 after_touch 回调方法，表示当与之关联的一篇文章被touch操作更新时，自动调用 update_sorting 方法更新用户排序，例如更新 updated_at 字段.

在 update_sorting 方法中，使用 self.touch 方法更新用户的 updated_at 字段，以便在用户列表或其他地方正确地排序.

需要注意的是，这段代码中使用了touch操作来实现自动更新关联对象的更新时间戳，这可以用来实现缓存失效、重新计算统计数据等功能。在Rails中，touch操作是一种常见的技巧，可以用来简化代码并提高性能.

需要注意的是， after_touch 回调方法只会在touch操作触发更新时被调用。如果你手动更新了 updated_at 字段， after_touch 回调方法不会被调用.

运行回调

这些是Rails中常用的Active Record模型操作方法，下面分别介绍它们的作用:

1. create(attributes = {}) ：创建一个新的模型对象并将其保存到数据库中。可以传入一个哈希表参数 attributes 表示要创建的模型对象的属性值.

2. create!(attributes = {}) ：与 create 相同，但如果保存失败会抛出异常.

3. destroy ：从数据库中删除当前模型对象.

4. destroy! ：与 destroy 相同，但如果删除失败会抛出异常.

5. destroy_all ：删除符合条件的所有模型对象，不进行任何回调和验证.

6. destroy_by(conditions) ：根据条件删除符合条件的单个模型对象，不进行任何回调和验证.

7. save ：将当前模型对象的属性值保存到数据库中。如果对象不存在，则创建一个新的对象.

8. save! ：与 save 相同，但如果保存失败会抛出异常.

9. save(validate: false) ：与 save 相同，但不进行模型对象的验证.

10. toggle! ：将当前模型对象的布尔类型属性取反并保存到数据库中.

11. touch ：更新当前模型对象的 updated_at 字段，并保存到数据库中。这个方法通常用于更新缓存或触发回调方法.

12. update_attribute(name, value) ：更新当前模型对象的单个属性值，并直接保存到数据库中，不进行任何验证.

13. update(attributes) ：更新当前模型对象的属性值，并保存到数据库中。可以传入一个哈希表参数 attributes 表示要更新的属性值.

14. update!(attributes) ：与 update 相同，但如果更新失败会抛出异常.

15. valid? ：检查当前模型对象是否通过验证。如果验证失败，可以使用 errors 方法查看错误信息.

这些方法是Rails中常用的Active Record模型操作方法，可以用于创建、更新、删除和验证模型对象。需要注意的是，这些方法中有些会触发回调方法、进行验证或抛出异常，具体使用时需要根据实际情况选择合适的方法.

最后此篇关于Callback详解的文章就讲到这里了,如果你想了解更多关于Callback详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。