PHP CacheBackendInterface::getMultiple方法代码示例

 /**
  * {@inheritdoc}
  */
 public function getMultiple(&$cids, $allow_invalid = FALSE)
 {
     foreach ($cids as &$cid) {
         $cid = $this->decorate($cid);
     }
     return $this->decorated->getMultiple($cids, $allow_invalid);
 }

 /**
  * {@inheritdoc}
  */
 public function readMultiple(array $names)
 {
     $data_to_return = array();
     $cache_keys_map = $this->getCacheKeys($names);
     $cache_keys = array_values($cache_keys_map);
     $cached_list = $this->cache->getMultiple($cache_keys);
     if (!empty($cache_keys)) {
         // $cache_keys_map contains the full $name => $cache_key map, while
         // $cache_keys contains just the $cache_key values that weren't found in
         // the cache.
         // @see \Drupal\Core\Cache\CacheBackendInterface::getMultiple()
         $names_to_get = array_keys(array_intersect($cache_keys_map, $cache_keys));
         $list = $this->storage->readMultiple($names_to_get);
         // Cache configuration objects that were loaded from the storage, cache
         // missing configuration objects as an explicit FALSE.
         $items = array();
         foreach ($names_to_get as $name) {
             $data = isset($list[$name]) ? $list[$name] : FALSE;
             $data_to_return[$name] = $data;
             $items[$cache_keys_map[$name]] = array('data' => $data);
         }
         $this->cache->setMultiple($items);
     }
     // Add the configuration objects from the cache to the list.
     $cache_keys_inverse_map = array_flip($cache_keys_map);
     foreach ($cached_list as $cache_key => $cache) {
         $name = $cache_keys_inverse_map[$cache_key];
         $data_to_return[$name] = $cache->data;
     }
     // Ensure that only existing configuration objects are returned, filter out
     // cached information about missing objects.
     return array_filter($data_to_return);
 }

 /**
  * {@inheritdoc}
  */
 public function getMultiple(&$cids, $allow_invalid = FALSE)
 {
     // Retrieve as many cache items as possible from the fast backend. (Some
     // cache entries may have been created before the last write to this cache
     // bin and therefore be stale/wrong/inconsistent.)
     $cids_copy = $cids;
     $cache = array();
     $last_write_timestamp = $this->getLastWriteTimestamp();
     if ($last_write_timestamp) {
         foreach ($this->fastBackend->getMultiple($cids, $allow_invalid) as $item) {
             if ($item->created < $last_write_timestamp) {
                 $cids[array_search($item->cid, $cids_copy)] = $item->cid;
             } else {
                 $cache[$item->cid] = $item;
             }
         }
     }
     // If there were any cache entries that were not available in the fast
     // backend, retrieve them from the consistent backend and store them in the
     // fast one.
     if ($cids) {
         foreach ($this->consistentBackend->getMultiple($cids, $allow_invalid) as $item) {
             $cache[$item->cid] = $item;
             $this->fastBackend->set($item->cid, $item->data);
         }
     }
     return $cache;
 }

 /**
  * {@inheritdoc}
  */
 public function getMultiple(&$cids, $allow_invalid = FALSE)
 {
     $cids_copy = $cids;
     $cache = array();
     // If we can determine the time at which the last write to the consistent
     // backend occurred (we might not be able to if it has been recently
     // flushed/restarted), then we can use that to validate items from the fast
     // backend, so try to get those first. Otherwise, we can't assume that
     // anything in the fast backend is valid, so don't even bother fetching
     // from there.
     $last_write_timestamp = $this->getLastWriteTimestamp();
     if ($last_write_timestamp) {
         // Items in the fast backend might be invalid based on their timestamp,
         // but we can't check the timestamp prior to getting the item, which
         // includes unserializing it. However, unserializing an invalid item can
         // throw an exception. For example, a __wakeup() implementation that
         // receives object properties containing references to code or data that
         // no longer exists in the application's current state.
         //
         // Unserializing invalid data, whether it throws an exception or not, is
         // a waste of time, but we only incur it while a cache invalidation has
         // not yet finished propagating to all the fast backend instances.
         //
         // Most cache backend implementations should not wrap their internal
         // get() implementations with a try/catch, because they have no reason to
         // assume that their data is invalid, and doing so would mask
         // unserialization errors of valid data. We do so here, only because the
         // fast backend is non-authoritative, and after discarding its
         // exceptions, we proceed to check the consistent (authoritative) backend
         // and allow exceptions from that to bubble up.
         try {
             $items = $this->fastBackend->getMultiple($cids, $allow_invalid);
         } catch (\Exception $e) {
             $cids = $cids_copy;
             $items = array();
         }
         // Even if items were successfully fetched from the fast backend, they
         // are potentially invalid if older than the last time the bin was
         // written to in the consistent backend, so only keep ones that aren't.
         foreach ($items as $item) {
             if ($item->created < $last_write_timestamp) {
                 $cids[array_search($item->cid, $cids_copy)] = $item->cid;
             } else {
                 $cache[$item->cid] = $item;
             }
         }
     }
     // If there were any cache entries that were not available in the fast
     // backend, retrieve them from the consistent backend and store them in the
     // fast one.
     if ($cids) {
         foreach ($this->consistentBackend->getMultiple($cids, $allow_invalid) as $item) {
             $cache[$item->cid] = $item;
             // Don't write the cache tags to the fast backend as any cache tag
             // invalidation results in an invalidation of the whole fast backend.
             $this->fastBackend->set($item->cid, $item->data, $item->expire);
         }
     }
     return $cache;
 }

 /**
  * {@inheritdoc}
  */
 public function readMultiple(array $names)
 {
     $list = array();
     // The names array is passed by reference and will only contain the names of
     // config object not found after the method call.
     // @see \Drupal\Core\Cache\CacheBackendInterface::getMultiple()
     $cached_list = $this->cache->getMultiple($names);
     if (!empty($names)) {
         $list = $this->storage->readMultiple($names);
         // Cache configuration objects that were loaded from the storage, cache
         // missing configuration objects as an explicit FALSE.
         $items = array();
         foreach ($names as $name) {
             $items[$name] = array('data' => isset($list[$name]) ? $list[$name] : FALSE);
         }
         $this->cache->setMultiple($items);
     }
     // Add the configuration objects from the cache to the list.
     foreach ($cached_list as $name => $cache) {
         $list[$name] = $cache->data;
     }
     // Ensure that only existing configuration objects are returned, filter out
     // cached information about missing objects.
     return array_filter($list);
 }

 /**
  * {@inheritdoc}
  */
 public function getMultiple(&$cids, $allow_invalid = FALSE)
 {
     $cidsCopy = $cids;
     $cache = $this->cacheBackend->getMultiple($cids, $allow_invalid);
     foreach ($cidsCopy as $cid) {
         if (in_array($cid, $cids)) {
             $this->cacheDataCollector->registerCacheMiss($this->bin, $cid);
         } else {
             $cacheCopy = new \StdClass();
             $cacheCopy->cid = $cache[$cid]->cid;
             $cacheCopy->expire = $cache[$cid]->expire;
             $cacheCopy->tags = $cache[$cid]->tags;
             $this->cacheDataCollector->registerCacheHit($this->bin, $cacheCopy);
         }
     }
     return $cache;
 }

 /**
  * Gets entities from the persistent cache backend.
  *
  * @param array|null &$ids
  *   If not empty, return entities that match these IDs. IDs that were found
  *   will be removed from the list.
  *
  * @return \Drupal\Core\Entity\ContentEntityInterface[]
  *   Array of entities from the persistent cache.
  */
 protected function getFromPersistentCache(array &$ids = NULL)
 {
     if (!$this->entityType->isPersistentlyCacheable() || empty($ids)) {
         return array();
     }
     $entities = array();
     // Build the list of cache entries to retrieve.
     $cid_map = array();
     foreach ($ids as $id) {
         $cid_map[$id] = $this->buildCacheId($id);
     }
     $cids = array_values($cid_map);
     if ($cache = $this->cacheBackend->getMultiple($cids)) {
         // Get the entities that were found in the cache.
         foreach ($ids as $index => $id) {
             $cid = $cid_map[$id];
             if (isset($cache[$cid])) {
                 $entities[$id] = $cache[$cid]->data;
                 unset($ids[$index]);
             }
         }
     }
     return $entities;
 }