Wie kann ich die cache-Methode mit Ruby/Rails?

Habe ich eine teure (zeitaufwendig), externe Anforderung mit einem anderen web-service, den ich machen muss, und ich möchte zwischengespeichert. Also habe ich versucht, auf diese idiom, indem Sie den folgenden in der application-controller:

def get_listings
  cache(:get_listings!)
end

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

Wenn ich rufe get_listings! in meinem controller ist alles cool, aber wenn ich Anrufe get_listings Schienen sich beschwert, dass kein block gegeben wurde. Und wenn ich sehe, dass die Methode, die ich sehen, dass er tatsächlich erwarten, dass ein block, und zusätzlich wie es aussieht, ist diese Methode nur für den Einsatz in Aussicht? Also ich vermute, dass, obwohl es war nicht angegeben, daß das Beispiel ist nur pseudocode.

Also meine Frage ist, wie kann ich den cache so etwas? Ich habe versucht, verschiedene andere Möglichkeiten, aber konnten nicht es herauszufinden. Danke!

InformationsquelleAutor Brandon Weiss | 2010-08-30

9

Als nruth schlägt, Schienen " built-in cache-speichern ist wahrscheinlich das, was Sie wollen.

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

def get_listings!
  Hpricot.XML(open(xml_feed))
end
```
fetch() holt sich den zwischengespeicherten Wert für den angegebenen Schlüssel, oder schreibt das Ergebnis des Blocks in den cache, wenn es nicht vorhanden ist.

Standardmäßig die Schienen-cache verwendet die Datei speichern, aber in einer Produktionsumgebung, memcached ist die bevorzugte option.

Siehe Abschnitt 2 http://guides.rubyonrails.org/caching_with_rails.html für mehr details.

InformationsquelleAutor Sidane
14

ein-code-Ansatz könnte wie folgt Aussehen:
```
def get_listings
  @listings ||= get_listings!
end

def get_listings!
  Hpricot.XML(open(xml_feed))
end
```
die cache das Ergebnis auf einer pro-Anfrage-basis (neue controller-Instanz pro Anfrage), Sie können aber auch ein Blick auf die "memoize" Helfer eine api option.

Wenn Sie möchten, zu teilen und diese über Anfragen hinweg nicht speichern Daten auf die Klasse Objekte, wie Ihre app nicht threadsicher, es sei denn, Sie sind gut im concurrent programming & sicherstellen, dass die threads nicht gegenseitig stören, ist der Zugriff auf die Daten auf der freigegebenen variable.

Den "rails Weg" zum cache über Anträge ist die Schienen.cache-Speicher. Memcached wird viel benutzt, aber vielleicht finden Sie die Datei oder den Speicher für Ihre Bedürfnisse. Es hängt wirklich davon ab, wie, die Sie bereitstellen, und ob Sie möchten, um zu priorisieren, cache-hits, Einstellzeit, Speicher (RAM) oder eine gehostete Lösung wie z.B. eine heroku-addon.
- Ja, ich möchte auf jeden Fall ein cache es zwischen den Anforderungen. Ich hatte mir überlegt Sie in der Datenbank gespeichert und alle tun es manuell, aber ich hoffe, es ist ein einfacher Weg, es zu tun.
- Vielleicht werfen Sie einen Blick auf die docs/api für ActiveSupport::Cache::Store - könnte passen, was Sie nach. Ich habe nicht mit ihm gearbeitet, mich aber bin sicher, es gibt blog-posts oder andere hier, die diese z.B. mit memcached.
InformationsquelleAutor nruth
3

Können Sie die cache_method gem:
```
gem install cache_method
require 'cache_method'
```
In Ihrem code:
```
def get_listings
  Hpricot.XML(open(xml_feed))
end
cache_method :get_listings
```
Bemerken Sie möglicherweise entledigte ich mich get_listings!. Wenn Sie einen Weg, um die Daten manuell aktualisieren, schlage ich vor:
```
def refresh
  clear_method_cache :get_listings
end
```
Hier ist ein weiterer Leckerbissen:
```
def get_listings
  Hpricot.XML(open(xml_feed))
end
cache_method :get_listings, (60*60) # automatically expire cache after an hour
```
- Übrigens, Sie sollten sich auf die Edelstein-docs, um zu sehen, wie die Konfiguration der gem. Hinweis: CacheMethod.config.Speicher - = - Schienen.cache
InformationsquelleAutor Seamus Abshere
1

Können Sie auch cachethod gem (https://github.com/reneklacan/cachethod)
```
gem 'cachethod'
```
Dann ist es tödlich, einfach den cache-Methode ein Ergebnis
```
class Dog
  cache_method :some_method, expires_in: 1.minutes

  def some_method arg1
    ..
  end
end
```
Es unterstützt auch das argument level caching

InformationsquelleAutor Rene

Es wurde vorgeschlagen cache_method Juwel, obwohl es ziemlich schwer ist. Wenn Sie brauchen, um rufen Sie die Methode ohne Argumente, die Lösung ist ganz einfach:

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

dann können Sie es in jeder Klasse:

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

Hinweis - dies wird auch cache-null, das ist der einzige Grund, es zu benutzen, anstatt @cached_value ||=

InformationsquelleAutor Daniel Garmoshka

0

Anderen Antworten sind gut, aber wenn Sie möchten, eine einfache von hand gerollt Ansatz können Sie dies tun. Eine Methode definieren, wie die unten in deiner Klasse...
```
def use_cache_if_available(method_name,&hard_way)
 @cached_retvals ||= {}  # or initialize in constructor
 return @cached_retvals[method_name] if @cached_retvals.has_key?(method_name)
 @cached_retvals[method_name] = hard_way.call
end
```
Danach, für jede Methode, die Sie Zwischenspeichern möchten, Sie können wickeln Sie die Methode Körper so etwas wie dieses...
```
def some_expensive_method(arg1, arg2, arg3)
  use_cache_if_available(__method__) {
    calculate_it_the_hard_way_here
  }
end
```
Einer Sache, dass diese besser ist als die einfachste Methode, die oben aufgeführt ist, dass es ein cache nil. Es hat die Bequemlichkeit, die es nicht erfordern, doppelte Methoden. Wohl dem gem-Ansatz ist sauberer, aber.

InformationsquelleAutor David Foster

Spät zur party, aber wenn jemand kommt hier zu suchen.

Verwende ich zur Durchführung dieses kleine Modul, um von Projekt zu Projekt, ich finden es praktisch und erweiterbar genug, ohne das hinzufügen einer extra-gem. Es verwendet die Rails.cache backend, so verwenden Sie es bitte nur, wenn Sie eine haben.

# 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

Dann in einem Initialisierer:

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

Dann in einem Modell:

# 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

An dieser Stelle, es funktioniert nur mit Modellen, kann aber leicht verallgemeinert.

InformationsquelleAutor dgilperez

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.