18、视图缓存与文件上传技术详解

视图缓存与文件上传技术详解

1. 视图缓存基础

视图缓存是提升应用性能的重要手段。在实现事物网格的缓存之前，我们先从缓存 Thing::Cell 的 show 状态开始。

class Thing::Cell < Cell::Concept
  cache :show

  def show
    render
  end
end

上述代码中， cache :show 表明要对 show 状态进行缓存。当这个单元格首次渲染时， show 状态正常运行，其返回值会被保存到缓存存储中。通常，这是一个由单元格渲染的 HTML 片段，并被推送到 Rails 缓存层。下次渲染该单元格时，它会检查缓存存储中是否有 show 状态的缓存版本。如果有，就会直接返回相同的 HTML 片段，而无需再次运行 show 方法。

不过，由于没有提供缓存键，单元格状态会被永久缓存，无论输入如何，缓存结果都相同。为了维护不同的缓存版本，我们需要提供缓存键。

2. 缓存键的计算

Cells 提供了多种计算缓存键的方法。可以简单地给缓存存储传递一个过期时间：

cache :show, expires_in: 10.minutes

但这种方法可能会为同一单元格的不同输入提供相同的片段，从而影响视图。更推荐的方式是传递一个块：

cache :show do
  [model.id, model.updated_at]
end

这个块会在实际状态调用之前，在单元格实例上下文中执行。它会根据 model.id 和 model.updated_at 计算一个唯一的缓存键。例如：

thing #=> <Thing id: 1 updated_at: 22/06/2015-19:38>
concept("thing/cell", thing).()
#=> "thing/cell/show/1/22/06/2015/19/39"

当模型的 updated_at 字段发生变化时，缓存键也会改变，从而触发重新渲染。

3. 缓存键的过期处理

当事物被编辑， updated_at 属性改变时，重新渲染单元格会生成一个新的缓存键。

thing #=> <Thing id: 1 updated_at: 01/01/2016-12:09>
concept("thing/cell", thing).()
#=> "thing/cell/show/1/01/01/2016/12/09"

这样，当调用 show 方法时，单元格会发现新键在缓存存储中没有对应的片段，从而重新运行该状态。通过巧妙选择缓存键算法，可以避免手动删除旧的缓存条目，缓存存储会在检测到旧条目一段时间未使用后自动处理。

4. 调试视图缓存

在实现复合网格缓存之前，我们可以使用一些技巧来调试缓存逻辑。首先，在 config/development.rb 中开启缓存：

Rails.application.configure do
  config.action_controller.perform_caching = true
end

这将激活 Cells 中的缓存逻辑。然后，在需要监控的单元格中手动包含 Cell::Caching::Notifications 模块：

class Thing::Cell < Cell::Concept
  include Cell::Caching::Notifications
end

最后，订阅这些特定的通知。在 config/initializers/cells.rb 中添加以下订阅分配：

ActiveSupport::Notifications.subscribe "read_fragment.cells" do |name ..|
  Rails.logger.debug "CACHE: #{payload}"
end

这样，每当运行与缓存相关的单元格逻辑时，服务器日志中会显示类似如下的输出：

CACHE write: {:key=>"cells/thing/show/39/26/5/6/19/6/2015/5/170/false/UTC"}
CACHE: {:key=>"cells/thing/show/39/26/5/6/19/6/2015/5/170/false/UTC"}

5. 组合视图的缓存

对于主页上的事物网格，我们可以选择缓存单个事物框，也可以缓存整个网格。为了最小化主页的渲染，我们选择缓存整个网格。

class Thing::Cell < Cell::Concept
  class Grid < Cell::Concept
    cache :show do
      Thing.latest.last.id
    end

    def show
      things = Thing.latest
      concept("thing/cell", collection: things, last: things.last)
    end
  end
end

上述代码中，我们使用最新模型的 ID 作为缓存键。只要没有新的事物添加，缓存的网格片段就会一直存在。但这种方法存在一个问题，当旧事物更新时，缓存不会过期，因为最新事物的 ID 没有改变。

6. CacheVersion 模式

对于复杂的组合视图和缓存，我们可以使用 CacheVersion 模式。该模式使用持久存储来维护缓存键，并在应用状态改变时故意更新该键。

class Grid < Cell::Concept
  cache :show do
    CacheVersion.for("thing/cell/grid")
  end
end

CacheVersion 类的实现如下：

class CacheVersion < ActiveRecord::Base
  def self.for(name)
    where(name: name).first or create(name: name)
  end

  def cache_key # called in AS::Cache#retrieve_cache_key.
    updated_at
  end

  def expire!
    update_attribute(:updated_at, (updated_at || Time.now) + 1.second)
  end
end

该模式的工作流程如下：
1. 单元格的版本器向 CacheVersion 类查询“其”键，它只知道“其”缓存名称。
2. CacheVersion 查找或创建一个键，该键通常是 updated_at 字段，并将其作为一行持久化到 cache_versions 表中。
3. 只要键不变，单元格就会被缓存。
4. 当网格发生变化时，缓存键过期，过期逻辑放在操作中。

7. 操作中的过期处理

事物网格只有在新事物添加或现有事物更新时才需要更新。创建和更新事物都通过操作进行，因此在 Thing::Create 和 Thing::Update 类中触发缓存过期。

class Thing::Create < Trailblazer::Operation
  callback do
    # ..
    on_create :expire_cache!
  end

  def expire_cache!(thing)
    CacheVersion.for("thing/cell/grid").expire!
  end
end

当新事物创建时， expire_cache! 方法会被调用，它会获取代表网格状态的 EventVersion 实例，并调用 expire! 方法，从而使缓存键递增。下次从单元格获取该缓存键时，就会发现没有缓存条目，进而重新渲染网格。

8. 模式讨论

这种方法存在一些问题。首先，将过期和缓存逻辑放在 CacheVersion 类中，违背了无逻辑模型的理念。后续可以将其移到操作中，以便从控制台触发过期。其次，操作需要知道视图细节， expire_cache! 方法将单元格的视图令牌传递给 CacheVersion ，这使得业务和视图紧密耦合。不过，这是目前实现需求的快速简便方法。当缓存变得更复杂时，操作可以调度到一个缓存过期类，该类知道哪些操作会影响应用的哪些缓存部分。

9. 文件上传

为了让事物页面更丰富，我们允许用户上传事物的图片。首先，在 app/views/things/new.html.haml 中的事物表单中添加文件上传字段：

= simple_form_for @form do |f|
  = f.input :description
  = f.input :file, as: :file

然后，在表单中添加 file 属性：

class Thing::Create < Trailblazer::Operation
  contract do
    # ..
    property :file, virtual: true
  end

  def process(params)
    validate(params) do |f|
      raise f.file.inspect #=> <UploadedFile>
    end
  end
end

由于 file 属性是虚拟的，表单不会尝试在模型上设置该属性，只是保留对上传文件对象的引用。

10. 使用 Paperdragon 处理文件上传

为了处理上传的图片，我们使用 Paperdragon 宝石。它与 ActiveRecord 无耦合，能让我们完全控制图像处理、S3 同步等操作。

contract do
  # ..
  property :file, virtual: true

  extend Paperdragon::Model::Writer
  processable_writer :image
  property :image_meta_data
end

上述代码中， processable_writer :image 为处理器实例提供了一个 image! 方法。 Paperdragon 要求操作的类有一个可写的 image_meta_data 字段，处理完不同版本的图像并存储后，它会将图像位置、文件名等信息推送到该字段。

11. 图像处理

在操作的 process 方法中实现图像处理：

def process(params)
  validate(params[:thing]) do |f|
    upload_image!(f)
    # ..
  end
end

def upload_image!(contract)
  contract.image!(contract.file) do |v|
    v.process!(:original)
    v.process!(:thumb) { |job| job.thumb!("120x120#") }
  end
end

上述代码中，调用 image! 方法并传入实际文件，会实例化一个 Paperdragon 处理器。在块中，我们指示 Paperdragon 存储原始版本和缩略图版本的图像。处理完图像后， Paperdragon 会将它们存储在配置的位置，并创建一个包含文件名的元数据哈希，推送到合同的 image_meta_data 字段。最后，当调用 sync 时，表单双胞胎会将 image_meta_data 字段写入模型。

总结

通过视图缓存和文件上传技术，我们可以显著提升应用的性能和用户体验。视图缓存通过合理设置缓存键和过期策略，避免了不必要的渲染；文件上传则为应用增添了更多的交互性。在实际应用中，我们需要根据具体需求选择合适的技术和策略，并不断优化和调试，以确保应用的高效运行。

流程图

graph TD;
    A[开始] --> B[视图缓存设置];
    B --> C[计算缓存键];
    C --> D[缓存过期处理];
    D --> E[调试视图缓存];
    E --> F[组合视图缓存];
    F --> G[CacheVersion模式];
    G --> H[操作中过期处理];
    H --> I[文件上传设置];
    I --> J[使用Paperdragon处理];
    J --> K[图像处理];
    K --> L[结束];

表格

技术点	描述
视图缓存	通过缓存单元格状态提升性能，需设置缓存键避免永久缓存
缓存键计算	可传递过期时间或使用块计算唯一键
CacheVersion模式	使用持久存储维护缓存键，在应用状态改变时更新
文件上传	通过表单添加文件字段，使用Paperdragon处理上传和存储

12. 深入理解视图缓存的优势与挑战

视图缓存虽然能显著提升应用性能，但也存在一些挑战。其优势在于减少了重复渲染的开销，尤其在高并发场景下，能有效降低服务器负载，提高响应速度。然而，缓存的使用也带来了数据一致性的问题。如果缓存更新不及时，用户可能会看到过时的数据。

为了更好地应对这些挑战，我们需要在缓存键的设计和过期策略上更加精细。例如，在缓存事物网格时，使用 CacheVersion 模式可以在一定程度上解决数据一致性问题，但对于一些复杂的业务场景，可能还需要结合其他技术手段。

13. 缓存键设计的最佳实践

在设计缓存键时，应遵循以下原则：
1. 唯一性 ：确保每个不同的视图状态都有唯一的缓存键，避免不同数据使用相同的缓存。
2. 可读性 ：缓存键应具有一定的可读性，方便调试和维护。
3. 动态性 ：缓存键应能反映数据的变化，当数据更新时，缓存键也相应改变。

例如，在使用 CacheVersion 模式时，以 updated_at 作为缓存键，能很好地满足这些原则。同时，我们还可以结合业务逻辑，添加更多的信息到缓存键中，如用户角色、数据筛选条件等。

14. 文件上传的安全性考虑

在实现文件上传功能时，安全性是至关重要的。以下是一些需要注意的方面：
1. 文件类型验证 ：只允许上传指定类型的文件，防止恶意文件上传。
2. 文件大小限制 ：设置合理的文件大小限制，避免服务器被大文件占用过多资源。
3. 路径安全 ：确保上传的文件路径不会被恶意利用，防止目录遍历攻击。

在 Paperdragon 中，我们可以在上传前对文件进行验证，确保其符合安全要求。例如：

def upload_image!(contract)
  file = contract.file
  if valid_file_type?(file) && valid_file_size?(file)
    contract.image!(file) do |v|
      v.process!(:original)
      v.process!(:thumb) { |job| job.thumb!("120x120#") }
    end
  else
    # 处理文件不符合要求的情况
  end
end

def valid_file_type?(file)
  allowed_types = ['image/jpeg', 'image/png']
  allowed_types.include?(file.content_type)
end

def valid_file_size?(file)
  max_size = 5.megabytes
  file.size <= max_size
end

15. 性能优化与监控

为了确保应用的性能，我们需要对视图缓存和文件上传功能进行性能优化和监控。
1. 缓存命中率监控 ：通过监控缓存命中率，了解缓存的使用效率。如果命中率过低，可能需要调整缓存键或过期策略。
2. 文件上传速度监控 ：监控文件上传的速度，确保用户体验良好。如果上传速度过慢，可能需要优化服务器配置或网络环境。
3. 性能测试 ：定期进行性能测试，模拟高并发场景，发现潜在的性能问题并及时解决。

16. 未来发展趋势

随着技术的不断发展，视图缓存和文件上传技术也在不断演进。未来，我们可能会看到以下趋势：
1. 智能缓存 ：缓存系统能够根据用户行为和数据变化自动调整缓存策略，实现更高效的缓存管理。
2. 分布式缓存 ：在分布式系统中，使用分布式缓存技术，如 Redis Cluster，提高缓存的可用性和性能。
3. 云存储集成 ：文件上传与云存储服务的集成将更加紧密，提供更可靠、可扩展的存储解决方案。

17. 总结与展望

视图缓存和文件上传是现代 Web 应用中不可或缺的功能。通过合理使用视图缓存，可以显著提升应用的性能和响应速度；而文件上传功能则为应用增添了更多的交互性和实用性。

在实际应用中，我们需要根据具体需求选择合适的技术和策略，并不断优化和调试。同时，要关注技术的发展趋势，及时引入新的技术和方法，以提升应用的竞争力。

流程图

graph TD;
    A[开始性能优化] --> B[监控缓存命中率];
    B --> C{命中率是否达标};
    C -- 是 --> D[继续监控];
    C -- 否 --> E[调整缓存键或过期策略];
    E --> F[重新测试];
    F --> B;
    A --> G[监控文件上传速度];
    G --> H{上传速度是否达标};
    H -- 是 --> D;
    H -- 否 --> I[优化服务器或网络];
    I --> F;
    D --> J[结束性能优化];

表格

技术点	优化方向
视图缓存	调整缓存键设计、优化过期策略、使用分布式缓存
文件上传	加强安全性验证、优化上传速度、集成云存储

通过以上的分析和总结，我们对视图缓存和文件上传技术有了更深入的理解。在实际开发中，我们应充分发挥这些技术的优势，同时注意解决可能出现的问题，以打造高性能、安全可靠的 Web 应用。