класс ActiveSupport::Cache::Store

# File activesupport/lib/active_support/cache.rb, line 523
def cleanup(options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support cleanup")
end

Очищает кэш, удаляя устаревшие записи.

Параметры передаются в реализацию базового кэша.

Некоторые реализации могут не поддерживать этот метод.

# File activesupport/lib/active_support/cache.rb, line 533
def clear(options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support clear")
end

Очищает весь кэш. Будьте осторожны с этим методом, так как он может повлиять на другие процессы, если используется общий кэш.

Хэш параметров передаётся в реализацию базового кэша.

Некоторые реализации могут не поддерживать этот метод.

# File activesupport/lib/active_support/cache.rb, line 514
def decrement(name, amount = 1, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support decrement")
end

Уменьшает целое значение в кэше.

Параметры передаются в реализацию базового кэша.

Некоторые реализации могут не поддерживать этот метод.

# File activesupport/lib/active_support/cache.rb, line 471
def delete(name, options = nil)
  options = merged_options(options)

  instrument(:delete, name) do
    delete_entry(normalize_key(name, options), options)
  end
end

Удаляет запись из кэша. Возвращает true если запись была удалена.

Параметры передаются в реализацию базового кэша.

# File activesupport/lib/active_support/cache.rb, line 496
def delete_matched(matcher, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support delete_matched")
end

Удаляет все записи с ключами, соответствующими шаблону.

Параметры передаются в реализацию базового кэша.

Некоторые реализации могут не поддерживать этот метод.

# File activesupport/lib/active_support/cache.rb, line 482
def exist?(name, options = nil)
  options = merged_options(options)

  instrument(:exist?, name) do
    entry = read_entry(normalize_key(name, options), options)
    (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
  end
end

Возвращает true если кэш содержит запись для заданного ключа.

Параметры передаются в реализацию базового кэша.

# File activesupport/lib/active_support/cache.rb, line 314
def fetch(name, options = nil)
  if block_given?
    options = merged_options(options)
    key = normalize_key(name, options)

    entry = nil
    instrument(:read, name, options) do |payload|
      cached_entry = read_entry(key, options) unless options[:force]
      entry = handle_expired_entry(cached_entry, key, options)
      entry = nil if entry && entry.mismatched?(normalize_version(name, options))
      payload[:super_operation] = :fetch if payload
      payload[:hit] = !!entry if payload
    end

    if entry
      get_entry_value(entry, name, options)
    else
      save_block_result_to_cache(name, options) { |_name| yield _name }
    end
  elsif options && options[:force]
    raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
  else
    read(name, options)
  end
end

Извлекает данные из кэша по заданному ключу. Если в кэше есть данные с заданным ключом, возвращаются эти данные.

Если таких данных в кэше нет (промах кэша), возвращается nil. Однако, если передан блок, этот блок получит ключ и будет выполнен в случае промаха кэша. Возвращаемое значение блока будет записано в кэш под заданным ключом, и это значение будет возвращено.

cache.write('today', 'Monday')
cache.fetch('today')  # => "Monday"

cache.fetch('city')   # => nil
cache.fetch('city') do
  'Duckburgh'
end
cache.fetch('city')   # => "Duckburgh"

Вы также можете указать дополнительные параметры через аргумент options. Установка force: true принудительно создает промах кэша, то есть мы рассматриваем значение кэша как отсутствующее, даже если оно есть. Передача блока обязательна, когда force равно true, так как это всегда приводит к записи в кэш.

cache.write('today', 'Monday')
cache.fetch('today', force: true) { 'Tuesday' } # => 'Tuesday'
cache.fetch('today', force: true) # => ArgumentError

Параметр :force полезен, когда вы вызываете другой метод, чтобы узнать, нужно ли принудительно записывать в кэш. В противном случае, яснее просто вызвать Cache#write.

Установка skip_nil: true не будет кешировать значение nil:

cache.fetch('foo') { nil }
cache.fetch('bar', skip_nil: true) { nil }
cache.exist?('foo') # => true
cache.exist?('bar') # => false

Установка compress: false отключает сжатие записи в кэше.

Установка :expires_in задаст время истечения срока действия записи в кэше. Все кэши поддерживают автоматическое истечение содержимого через указанное количество секунд. Это значение может быть указано в качестве параметра конструктору (в этом случае все записи будут затронуты), или его можно передать методам fetch или write для воздействия только на одну запись.

cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 5.minutes)
cache.write(key, value, expires_in: 1.minute) # Set a lower value for one entry

Установка :version проверяет, что кэш, хранящийся по адресу name, имеет ту же версию. В случае несовпадения возвращается nil, несмотря на содержание. Эта функция используется для поддержки повторно используемых ключей кэша.

Установка :race_condition_ttl очень полезна в ситуациях, когда запись в кэше используется очень часто и подвергается большой нагрузке. Если кэш истекает, и из-за большой нагрузки несколько разных процессов попытаются прочитать данные напрямую, а затем все они попытаются записать в кэш. Чтобы избежать этой ситуации, первый процесс, обнаруживший истекший элемент кэша, увеличит время истечения кэша на значение, заданное в :race_condition_ttl. Да, этот процесс продлевает время жизни устаревшего значения ещё на несколько секунд. Из-за продлённой жизни предыдущего кэша другие процессы продолжат использовать немного устаревшие данные чуть дольше. Тем временем этот первый процесс выполнит запись нового значения в кэш. После этого все процессы начнут получать новое значение. Важно, чтобы :race_condition_ttl было небольшим.

Если процесс, восстанавливающий запись, завершается ошибкой, запись будет восстановлена через указанное количество секунд. Также обратите внимание, что время жизни устаревшего кэша продлевается только если он истёк недавно. В противном случае генерируется новое значение, и :race_condition_ttl не играет никакой роли.

# Set all values to expire after one minute.
cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)

cache.write('foo', 'original value')
val_1 = nil
val_2 = nil
sleep 60

Thread.new do
  val_1 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
    sleep 1
    'new value 1'
  end
end

Thread.new do
  val_2 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
    'new value 2'
  end
end

cache.fetch('foo') # => "original value"
sleep 10 # First thread extended the life of cache by another 10 seconds
cache.fetch('foo') # => "new value 1"
val_1 # => "new value 1"
val_2 # => "original value"

Другие параметры будут обрабатываться конкретной реализацией хранилища кэша. Внутренне, вызов fetch вызывает read_entry, а при промахе кэша вызывает write_entry. options будет передано в вызовы read и write.

Например, метод write MemCacheStore поддерживает параметр :raw, который сообщает серверу memcached хранить все значения в виде строк. Этот параметр можно использовать и с fetch:

cache = ActiveSupport::Cache::MemCacheStore.new
cache.fetch("foo", force: true, raw: true) do
  :bar
end
cache.fetch('foo') # => "bar"

# File activesupport/lib/active_support/cache.rb, line 434
def fetch_multi(*names)
  raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." unless block_given?

  options = names.extract_options!
  options = merged_options(options)

  instrument :read_multi, names, options do |payload|
    reads   = read_multi_entries(names, options)
    writes  = {}
    ordered = names.each_with_object({}) do |name, hash|
      hash[name] = reads.fetch(name) { writes[name] = yield(name) }
    end

    payload[:hits] = reads.keys
    payload[:super_operation] = :fetch_multi

    write_multi(writes, options)

    ordered
  end
end

Извлекает данные из кэша по заданным ключам. Если в кэше есть данные с заданными ключами, возвращаются эти данные. В противном случае, вызывается переданный блок для каждого ключа, для которого данных нет, и результат записывается в кэш и возвращается. Таким образом, вам нужно передать блок, который возвращает данные для записи в кэш. Если вы не хотите записывать в кэш, когда кэш не найден, используйте read_multi.

Возвращает хэш с данными для каждого из имён. Например:

cache.write("bim", "bam")
cache.fetch_multi("bim", "unknown_key") do |key|
  "Fallback value for key: #{key}"
end
# => { "bim" => "bam",
#      "unknown_key" => "Fallback value for key: unknown_key" }

Параметры передаются в реализацию базового кэша. Например:

cache.fetch_multi("fizz", expires_in: 5.seconds) do |key|
  "buzz"
end
# => {"fizz"=>"buzz"}
cache.read("fizz")
# => "buzz"
sleep(6)
cache.read("fizz")
# => nil

# File activesupport/lib/active_support/cache.rb, line 505
def increment(name, amount = 1, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support increment")
end

Увеличивает целое значение в кэше.

Параметры передаются в реализацию базового кэша.

Некоторые реализации могут не поддерживать этот метод.

# File activesupport/lib/active_support/cache.rb, line 194
def mute
  previous_silence, @silence = defined?(@silence) && @silence, true
  yield
ensure
  @silence = previous_silence
end

Отключает логирование внутри блока.

# File activesupport/lib/active_support/cache.rb, line 349
def read(name, options = nil)
  options = merged_options(options)
  key     = normalize_key(name, options)
  version = normalize_version(name, options)

  instrument(:read, name, options) do |payload|
    entry = read_entry(key, options)

    if entry
      if entry.expired?
        delete_entry(key, options)
        payload[:hit] = false if payload
        nil
      elsif entry.mismatched?(version)
        payload[:hit] = false if payload
        nil
      else
        payload[:hit] = true if payload
        entry.value
      end
    else
      payload[:hit] = false if payload
      nil
    end
  end
end

Считывает данные из кэша по заданному ключу. Если в кэше есть данные с этим ключом, возвращаются эти данные. В противном случае, возвращается nil.

Обратите внимание, если данные были записаны с параметрами :expires_in или :version, эти условия применяются до возврата данных.

Параметры передаются в реализацию базового кэша.

# File activesupport/lib/active_support/cache.rb, line 382
def read_multi(*names)
  options = names.extract_options!
  options = merged_options(options)

  instrument :read_multi, names, options do |payload|
    read_multi_entries(names, options).tap do |results|
      payload[:hits] = results.keys
    end
  end
end

Считывает несколько значений одновременно из кэша. Параметры могут быть переданы в последнем аргументе.

Некоторые реализации кэша могут оптимизировать этот метод.

Возвращает хэш, сопоставляющий предоставленные имена со значениями, найденными в кэше.

# File activesupport/lib/active_support/cache.rb, line 188
def silence!
  @silence = true
  self
end

Отключает логирование.

# File activesupport/lib/active_support/cache.rb, line 459
def write(name, value, options = nil)
  options = merged_options(options)

  instrument(:write, name, options) do
    entry = Entry.new(value, options.merge(version: normalize_version(name, options)))
    write_entry(normalize_key(name, options), entry, options)
  end
end

Записывает значение в кэш с указанным ключом.

Параметры передаются в реализацию базового кэша.

# File activesupport/lib/active_support/cache.rb, line 394
def write_multi(hash, options = nil)
  options = merged_options(options)

  instrument :write_multi, hash, options do |payload|
    entries = hash.each_with_object({}) do |(name, value), memo|
      memo[normalize_key(name, options)] = Entry.new(value, options.merge(version: normalize_version(name, options)))
    end

    write_multi_entries entries, options
  end
end

Кэш API хранилища для записи нескольких значений одновременно.