Comment puis-je cache une méthode avec Ruby/Rails?

Comme nruth suggère, de Rails intégrés dans la banque de cache est probablement ce que vous voulez.

Essayer:

def get_listings
  Rails.cache.fetch(:listings) { get_listings! }
end

def get_listings!
  Hpricot.XML(open(xml_feed))
end

fetch() récupère la valeur mise en cache de la clé spécifiée, ou écrit le résultat du bloc dans le cache si elle n'existe pas.

Par défaut, les Rails cache utilise le stockage de fichiers, mais dans un environnement de production, memcached est l'option préférée.

Voir la section 2 de http://guides.rubyonrails.org/caching_with_rails.html pour plus de détails.

Vous pouvez utiliser le cache_method gem:

gem install cache_method
require 'cache_method'

Dans votre code:

def get_listings
  Hpricot.XML(open(xml_feed))
end
cache_method :get_listings

Vous remarquerez peut-être que je me suis débarrassé de get_listings!. Si vous avez besoin d'une manière d'actualiser les données manuellement, je suggère:

def refresh
  clear_method_cache :get_listings
end

Voici une autre curiosité: la

def get_listings
  Hpricot.XML(open(xml_feed))
end
cache_method :get_listings, (60*60) # automatically expire cache after an hour

Il a été suggéré cache_method gem, même si elle est assez lourde. Si vous devez appeler la méthode sans argument, la solution est très simple:

Object.class_eval do

  def self.cache_method(method_name)
    original_method_name = "_original_#{method_name}"
    alias_method original_method_name, method_name
    define_method method_name do
      @cache ||= {}
      @cache[method_name] = send original_method_name unless @cache.key?(method_name)
      @cache[method_name]
    end
  end

end

alors vous pouvez l'utiliser dans n'importe quelle classe:

def get_listings
  Hpricot.XML(open(xml_feed))
end
cache_method :get_listings

Noter que ce sera également le cache de néant, qui est la seule raison de l'utiliser au lieu de @cached_value ||=

La fin de la partie, mais au cas où quelqu'un arrive ici à la recherche.

- Je utiliser pour réaliser ce petit module autour d'un projet à l'autre, je trouve ça pratique et suffisamment extensible, sans l'ajout d'un supplément de gem. Il utilise le Rails.cache backend, alors utilisez-le seulement si vous en possédez un.

# lib/active_record/cache_method.rb
module ActiveRecord
  module CacheMethod
    extend ActiveSupport::Concern

    module ClassMethods
      # To be used with a block
      def cache_method(args = {})
        @caller = caller
        caller_method_name = args.fetch(:method_name)     { @caller[0][/`.*'/][1..-2] }
        expires_in         = args.fetch(:expires_in)      { 24.hours }
        cache_key          = args.fetch(:cache_key)       { "#{self.name.underscore}/methods/#{caller_method_name}" }

        Rails.cache.fetch(cache_key, expires_in: expires_in) do
          yield
        end
      end
    end

    # To be used with a block
    def cache_method(args = {})
      @caller = caller
      caller_method_name = args.fetch(:method_name) { @caller[0][/`.*'/][1..-2] }
      expires_in         = args.fetch(:expires_in)  { 24.hours }
      cache_key          = args.fetch(:cache_key)   { "#{self.class.name.underscore}-#{id}-#{updated_at.to_i}/methods/#{caller_method_name}" }

      Rails.cache.fetch(cache_key, expires_in: expires_in) do
        yield
      end
    end
  end
end

Puis dans un initialiseur:

# config/initializers/active_record.rb
require 'active_record/cache_method'
ActiveRecord::Base.send :include, ActiveRecord::CacheMethod

Et puis, dans un modèle:

# app/models/user.rb
class User < AR 
  def self.my_slow_class_method
    cache_method do 
      # some slow things here
    end
  end

  def this_is_also_slow(var)
    custom_key_depending_on_var = ...
    cache_method(key_name: custom_key_depending_on_var, expires_in: 10.seconds) do 
      # other slow things depending on var
    end
  end
end

À ce stade, il ne fonctionne qu'avec les modèles, mais peut facilement être généralisé.