Struct CacheLayer 

pub struct CacheLayer<Req, K> { /* private fields */ }

A Tower Layer that applies response caching to a service.

This layer wraps a service with a Cache middleware that stores successful responses and returns cached values for subsequent requests with the same key.

State Isolation

Note: Each call to layer() creates a new cache store. If you need multiple services to share the same cache (e.g., when using a ServiceFactory that creates per-session services), use SharedCacheLayer instead, or call .shared() on this layer.

Examples

use tower_resilience_cache::CacheLayer;
use tower::ServiceBuilder;
use std::time::Duration;

let cache_layer = CacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build();

let service = ServiceBuilder::new()
    .layer(cache_layer)
    .service(my_service());

Implementations

impl<Req, K> CacheLayer<Req, K>

where K: Hash + Eq + Clone + Send + 'static,

pub fn new(config: CacheConfig<Req, K>) -> Self

Creates a new CacheLayer with the given configuration.

pub fn builder() -> CacheConfigBuilder<Req, K>

Creates a new builder for configuring a cache layer.

Examples

use tower_resilience_cache::CacheLayer;
use std::time::Duration;

let layer = CacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build();

pub fn shared<Resp>(self) -> SharedCacheLayer<Req, K, Resp>

where Resp: Clone + Send + 'static,

Converts this cache layer into a SharedCacheLayer that shares the cache store across all services created via layer().

This is useful when multiple service instances need to share the same cache, such as when services are created per-session or per-request.

Type Parameters

• Resp: The response type that will be cached. This must match the Response type of any service this layer is applied to.

Examples

use tower_resilience_cache::CacheLayer;
use tower::ServiceBuilder;
use std::time::Duration;

let shared_cache = CacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build()
    .shared::<String>();  // Specify the response type

// Both services share the same cache
let service1 = ServiceBuilder::new()
    .layer(shared_cache.clone())
    .service(my_service());

let service2 = ServiceBuilder::new()
    .layer(shared_cache)
    .service(my_service());

Trait Implementations

impl<Req: Clone, K: Clone> Clone for CacheLayer<Req, K>

fn clone(&self) -> CacheLayer<Req, K>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, Req, K> Layer<S> for CacheLayer<Req, K>

where K: Hash + Eq + Clone + Send + 'static, S: Service<Req>, S::Response: Clone + Send + 'static,

type Service = Cache<S, Req, K, <S as Service<Req>>::Response>

The wrapped service

fn layer(&self, service: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.