phpfastcache
9.2.3
Como el V9 no es relativamente compatible con versiones anteriores, lea atentamente la guía de migración para garantizar la migración más fluida posible. Uno de los mayores cambios es el sistema de configuración, que ahora es un objeto que reemplaza la matriz primitiva que solíamos implementar en aquel entonces. Además, tenga en cuenta que V9 requiere al menos PHP 8 o superior para funcionar correctamente.
Más información en Wiki La simplicidad de la abstracción: una clase para muchos cachés de backend. No es necesario volver a escribir el código muchas veces.
Siéntase libre de proponer un conductor haciendo una nueva solicitud de extracción , ¡son bienvenidos!
| Conductores habituales | Conductores de alto rendimiento | Impulsores de desarrollo (Core) | Controladores agregados en clúster (núcleo) |
|---|---|---|---|
Apcu (núcleo)(Se eliminó el soporte de APC) | Arangodb (Extensión) | Devnull | FullReplicationCluster |
Dynamodb (extensión) | Cassandra(Datastax ya no mantiene la extensión PHP, podría quedar obsoleta en v10) | Devrandom | SemiReplicationCluster |
Files (núcleo) | CouchBasev3 (núcleo)(Quedará obsoleto a partir de v10) | Memory(Anteriormente llamado Memstatic ) | MasterSlaveReplicationCluster |
Firestore (extensión) | CouchBasev4 (Extensión) | RandomReplicationCluster | |
Leveldb (núcleo) | Couchdb (Extensión) | ||
Memcache(d) (núcleo) | Mongodb (extensión) | ||
Solr (Extensión) | Predis (núcleo) | ||
Sqlite (núcleo) | Ravendb _(Extensión) | ||
Wincache (núcleo)( Obsoleto a partir de v9.2, se eliminará a partir de v10) | Relay (Para finales de 2024) | ||
Zend Disk Cache (núcleo) | Redis / RedisCluster (núcleo) | ||
Ssdb (núcleo) | |||
Zend Memory Cache (núcleo) |
* Descripciones de controladores disponibles en DOCS/DRIVERS.md
A partir de v9.2 se lanzó una nueva extensión de Couchbase: Couchbasev4. También se agregó una nueva extensión de controlador: Ravendb . El controlador se desarrollará activamente en la función para permitir una mejor configuración detallada. Esta nueva extensión es el comienzo de una nueva era para Phpfastcache junto con algunas otras:
Muchos controladores se han movido del núcleo a su propio subrepositorio como una extensión independiente: Arangodb , Couchdb , Dynamodb , Firestore , Mongodb , Solr .
Se pueden agregar fácilmente a través del compositor, por ejemplo: composer install phpfastcache/couchbasev4-extension Sin embargo, Couchbasev3 permanecerá en el núcleo por razones de compatibilidad, pero quedará obsoleto.
Phpfastcache se ha desarrollado a lo largo de los años con 3 objetivos principales:
Phpfastcache le proporciona muchas API útiles:
| Método | Devolver | Descripción |
|---|---|---|
addTag($tagName) | ExtendedCacheItemInterface | Agrega una etiqueta |
addTags(array $tagNames) | ExtendedCacheItemInterface | Agrega múltiples etiquetas |
append($data) | ExtendedCacheItemInterface | Agrega datos a una cadena o una matriz (push) |
decrement($step = 1) | ExtendedCacheItemInterface | Broma redundante... |
expiresAfter($ttl) | ExtendedCacheItemInterface | Le permite extender la vida útil de una entrada sin alterar su valor (anteriormente conocido como touch()) |
expiresAt($expiration) | ExtendedCacheItemInterface | Establece el tiempo de vencimiento para este elemento de caché (como un objeto DateTimeInterface) |
get() | mixed | El captador, obviamente, devuelve su objeto de caché. |
getCreationDate() | DatetimeInterface | Obtiene la fecha de creación de este elemento de caché (como un objeto DateTimeInterface) * |
getDataAsJsonString() | string | Devuelve los datos como una cadena json bien formateada |
getEncodedKey() | string | Devuelve el identificador (clave) del elemento final e interno, generalmente utilizado con fines de depuración. |
getExpirationDate() | ExtendedCacheItemInterface | Obtiene la fecha de vencimiento como un objeto Datetime |
getKey() | string | Devuelve el identificador del artículo (clave) |
getLength() | int | Obtiene la longitud de los datos si los datos son una cadena, una matriz u objetos que implementan la interfaz Countable . |
getModificationDate() | DatetimeInterface | Obtiene la fecha de modificación de este elemento de caché (como un objeto DateTimeInterface) * |
getTags() | string[] | Obtiene las etiquetas |
hasTag(string $tagName) | bool | Compruebe si el elemento de caché contiene una etiqueta específica |
hasTags(array $tagNames, int $strategy): bool | bool | Compruebe si el elemento de caché contiene una o más etiquetas específicas con estrategia opcional (el valor predeterminado es TAG_STRATEGY_ONE) |
isTagged(): bool | bool | Compruebe si el elemento de caché tiene al menos una etiqueta (v9.2) |
getTagsAsString($separator = ', ') | string | Obtiene los datos como una cadena separada por $separator |
getTtl() | int | Obtiene el tiempo de vida restante como un número entero |
increment($step = 1) | ExtendedCacheItemInterface | Para permitirnos contar con un elemento entero |
isEmpty() | bool | Comprueba si los datos están vacíos o no a pesar del estado de acierto/error. |
isExpired() | bool | Comprueba si tu entrada de caché ha caducado |
isHit() | bool | Comprueba si su entrada de caché existe y aún es válida, es el equivalente a isset() |
isNull() | bool | Comprueba si los datos son nulos o no a pesar del estado de acierto/error. |
prepend($data) | ExtendedCacheItemInterface | Antepone datos a una cadena o una matriz (unshift) |
removeTag($tagName) | ExtendedCacheItemInterface | Elimina una etiqueta |
removeTags(array $tagNames) | ExtendedCacheItemInterface | Elimina varias etiquetas |
set($value) | ExtendedCacheItemInterface | El configurador, para aquellos que se lo perdieron, puede ser cualquier cosa excepto recursos u objetos no serializadores (por ejemplo: objetos PDO, punteros de archivos, etc.). |
setCreationDate($expiration) | DatetimeInterface | Establece la fecha de creación de este elemento de caché (como un objeto DateTimeInterface) * |
setEventManager($evtMngr) | ExtendedCacheItemInterface | Establece el administrador de eventos |
setExpirationDate() | ExtendedCacheItemInterface | Alias de expireAt() (para más lógica de código) |
setModificationDate($expiration) | DatetimeInterface | Establece la fecha de modificación para este elemento de caché (como un objeto DateTimeInterface) * |
setTags(array $tags) | ExtendedCacheItemInterface | Establece múltiples etiquetas |
| * Requiere que la directiva de configuración "itemDetailedDate" esté habilitada; de lo contrario, se generará una LogicException |
| Métodos (por orden alfabético) | Devolver | Descripción |
|---|---|---|
appendItemsByTag($tagName, $data) | bool | Añade elementos mediante una etiqueta |
appendItemsByTags(array $tagNames, $data) | bool | Agrega elementos por uno de varios nombres de etiquetas |
attachItem($item) | void | (Re-)adjunta un elemento al grupo |
clear() | bool | Le permite vaciar completamente el caché y reiniciar desde el principio. |
commit() | bool | Conserva cualquier elemento de caché diferido |
decrementItemsByTag($tagName, $step = 1) | bool | Disminuye elementos por una etiqueta |
decrementItemsByTags(array $tagNames, $step = 1) | bool | Disminuye elementos por uno de varios nombres de etiquetas |
deleteItem($key) | bool | Elimina un elemento |
deleteItems(array $keys) | bool | Elimina uno o más elementos |
deleteItemsByTag($tagName) | bool | Elimina elementos por etiqueta |
deleteItemsByTags(array $tagNames, int $strategy) | bool | Elimina elementos por uno de varios nombres de etiquetas |
detachItem($item) | void | Separa un elemento de la piscina. |
getConfig() | ConfigurationOption | Devuelve el objeto de configuración. |
getConfigOption($optionName); | mixed | Devuelve un valor de configuración por su clave $optionName |
getDefaultConfig() | ConfigurationOption | Devuelve el objeto de configuración predeterminado (no modificado por la instancia del objeto) |
getDriverName() | string | Devuelve el nombre del controlador actual (sin el espacio de nombres) |
getEventManager() | EventManagerInterface | Obtiene el administrador de eventos |
getHelp() | string | Proporciona una ayuda muy básica para un conductor específico. |
getInstanceId() | string | Devuelve el ID de la instancia |
getItem($key) | ExtendedCacheItemInterface | Recupera un artículo y devuelve un artículo vacío si no se encuentra |
getItems(array $keys) | ExtendedCacheItemInterface[] | Recupera uno o más elementos y devuelve una serie de elementos. A partir de la versión 9.2 se realizó una mejora interna en este método. |
getAllItems(string $pattern = '') | ExtendedCacheItemInterface[] | (v9.2) Recupera todos los elementos de la caché con un límite estricto de 9999 elementos. Soporte limitado a algunos controladores |
getItemsAsJsonString(array $keys) | string | Devuelve una cadena json que representa una matriz de elementos. |
getItemsByTag($tagName, $strategy) | ExtendedCacheItemInterface[] | Devuelve artículos por una etiqueta |
getItemsByTags(array $tagNames, $strategy) | ExtendedCacheItemInterface[] | Devuelve artículos por uno de varios nombres de etiquetas |
getItemsByTagsAsJsonString(array $tagNames, $strategy) | string | Devuelve una cadena json que representa una matriz de elementos correspondientes |
getStats() | DriverStatistic | Devuelve las estadísticas de la caché como un objeto, útil para comprobar el espacio en disco utilizado por la caché, etc. |
hasEventManager() | bool | Consulta el administrador de eventos |
hasItem($key) | bool | Prueba si existe un elemento |
incrementItemsByTag($tagName, $step = 1, $strategy) | bool | Incrementa elementos por una etiqueta |
incrementItemsByTags(array $tagNames, $step = 1, $strategy) | bool | Incrementa los elementos por uno de varios nombres de etiquetas |
isAttached($item) | bool | Verificar si un elemento está (todavía) adjunto |
prependItemsByTag($tagName, $data, $strategy) | bool | Antepone elementos por una etiqueta |
prependItemsByTags(array $tagNames, $data, $strategy) | bool | Antepone elementos con uno de varios nombres de etiquetas |
save(CacheItemInterface $item) | bool | Persiste un elemento de caché inmediatamente |
saveDeferred(CacheItemInterface $item) | bool | Establece un elemento de caché para que persista más tarde |
saveMultiple(...$items) | bool | Persiste varios elementos de caché inmediatamente |
setEventManager(EventManagerInterface $evtMngr) | ExtendedCacheItemPoolInterface | Establece el administrador de eventos |
en V8 : ahora se admiten múltiples estrategias ( $strategy ) para el etiquetado:
TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE le permite obtener elementos de caché mediante al menos UNA de las etiquetas coincidentes especificadas. Comportamiento predeterminado.TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL le permite obtener elementos de caché mediante TODAS las etiquetas coincidentes especificadas (el elemento de caché puede tener etiquetas adicionales)TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY le permite obtener elementos de caché SOLO mediante las etiquetas coincidentes especificadas (el elemento de caché no puede tener etiquetas adicionales)También admite múltiples llamadas, etiquetado y configuración de carpeta para almacenamiento en caché. Mire nuestras carpetas de ejemplos para obtener más información.
Phpfastcache proporciona una clase que le brinda información básica sobre su instalación de Phpfastcache
PhpfastcacheApi::GetVersion();PhpfastcacheApi::getChangelog();PhpfastcacheApi::getPhpfastcacheVersion();PhpfastcacheApi::getPhpfastcacheChangelog(); Buenas noticias, a partir del V6, se proporciona un adaptador Psr16 para mantener el caché más simple usando getters/setters muy básicos:
get($key, $default = null);set($key, $value, $ttl = null);delete($key);clear();getMultiple($keys, $default = null);setMultiple($values, $ttl = null);deleteMultiple($keys);has($key);Uso básico:
<?php
use Phpfastcache Helper Psr16Adapter ;
$ defaultDriver = ' Files ' ;
$ Psr16Adapter = new Psr16Adapter ( $ defaultDriver );
if (! $ Psr16Adapter -> has ( ' test-key ' )){
// Setter action
$ data = ' lorem ipsum ' ;
$ Psr16Adapter -> set ( ' test-key ' , ' lorem ipsum ' , 300 ); // 5 minutes
} else {
// Getter action
$ data = $ Psr16Adapter -> get ( ' test-key ' );
}
/**
* Do your stuff with $data
*/Internamente, el adaptador Psr16 llama a Phpfastcache Api a través del administrador de caché.
A partir de V6, Phpfastcache proporciona un mecanismo de eventos. Puedes suscribirte a un evento pasando un Cierre a un evento activo:
<?php
use Phpfastcache EventManager ;
/**
* Bind the event callback
*/
EventManager:: getInstance ()-> onCacheGetItem ( function ( ExtendedCacheItemPoolInterface $ itemPool , ExtendedCacheItemInterface $ item ){
$ item -> set ( ' [HACKED BY EVENT] ' . $ item -> get ());
});Una devolución de llamada de evento se puede desvincular, pero DEBES proporcionar un nombre a la devolución de llamada previamente:
<?php
use Phpfastcache EventManager ;
/**
* Bind the event callback
*/
EventManager:: getInstance ()-> onCacheGetItem ( function ( ExtendedCacheItemPoolInterface $ itemPool , ExtendedCacheItemInterface $ item ){
$ item -> set ( ' [HACKED BY EVENT] ' . $ item -> get ());
}, ' myCallbackName ' );
/**
* Unbind the event callback
*/
EventManager:: getInstance ()-> unbindEventCallback ( ' onCacheGetItem ' , ' myCallbackName ' );A partir de V8 puedes simplemente suscribirte a cada evento de Phpfastcache.
Más información sobre la implementación y los eventos están disponibles en la Wiki.
A partir de la versión V6, Phpfastcache proporciona algunas ayudas para facilitar el código.
¡Que vengan más en el futuro, siéntete libre de contribuir!
Consulte WIKI para aprender cómo implementar la función de agrupación en clústeres de caché agregada.
composer require phpfastcache/phpfastcache <?php
use Phpfastcache CacheManager ;
use Phpfastcache Config ConfigurationOption ;
// Setup File Path on your config files
// Please note that as of the V6 .1 the "path" config
// can also be used for Unix sockets ( Redis , Memcache , etc )
CacheManager:: setDefaultConfig ( new ConfigurationOption ([
' path ' => ' /var/www/phpfastcache.com/dev/tmp ' , // or in windows "C:/tmp/"
]));
// In your class , function , you can call the Cache
$ InstanceCache = CacheManager:: getInstance ( ' files ' );
/**
* Try to get $products from Caching First
* product_page is "identity keyword";
*/
$ key = " product_page " ;
$ CachedString = $ InstanceCache -> getItem ( $ key );
$ your_product_data = [
' First product ' ,
' Second product ' ,
' Third product '
/* ... */
];
if (! $ CachedString -> isHit ()) {
$ CachedString -> set ( $ your_product_data )-> expiresAfter ( 5 ); //in seconds , also accepts Datetime
$ InstanceCache -> save ( $ CachedString ); // Save the cache item just like you do with doctrine and entities
echo ' FIRST LOAD // WROTE OBJECT TO CACHE // RELOAD THE PAGE AND SEE // ' ;
echo $ CachedString -> get ();
} else {
echo ' READ FROM CACHE // ' ;
echo $ CachedString -> get ()[ 0 ]; // Will print ' First product'
}
/**
* use your products here or return them;
*/
echo implode ( ' <br /> ' , $ CachedString -> get ()); // Will echo your product list Para los desarrolladores curiosos, hay muchos otros ejemplos disponibles aquí.
¿Encontró un problema o tiene una idea? ¡Ven aquí y cuéntanos!
