Spry Caching Strategies: Boost Performance with In‑Memory and Distributed Caching

Caching is a fundamental technique for building fast, scalable web applications. By storing frequently accessed data in a fast storage layer, you can dramatically reduce response times, cut down database load, and improve the overall user experience. In this guide, we’ll explore how to add caching to Spry, the next‑generation Dart server framework.

We’ll cover:

1. Why caching matters for Spry applications
2. In‑memory caching using package:cache and Dart’s Map
3. Distributed caching with Redis (using package:redis)
4. Cache‑invalidation patterns (TTL, write‑through, LRU)
5. Real‑world examples – caching API responses, session data, and expensive computations

All code examples are taken from a working Spry project and can be run on your own machine.

1. Why Caching Matters in Spry

Spry’s file‑based routing and middleware architecture make it easy to insert caching logic at any point in the request‑response cycle. Whether you’re serving static assets, dynamic API responses, or computed data, caching can provide:

• Lower latency – cached responses can be served in milliseconds
• Reduced database load – fewer queries to your primary data store
• Better scalability – handle more concurrent users with the same hardware
• Cost savings – reduce bandwidth and compute usage

In this guide, we’ll implement caching in a real Spry project and measure the performance improvements.

2. In‑Memory Caching with package:cache

The simplest form of caching is storing data in the application’s memory. Dart’s package:cache provides a lightweight, extensible caching library that supports time‑based expiration, size limits, and custom eviction policies.

Installation

Add cache to your pubspec.yaml:

dependencies:
  cache: ^3.0.0

Basic In‑Memory Cache

Create a simple cache service that can be shared across your Spry routes:

import 'package:cache/cache.dart';

final Cache<String, dynamic> memoryCache = Cache<String, dynamic>(
  maxSize: 1000,          // maximum number of entries
  defaultTTL: Duration(minutes: 5), // time‑to‑live
);

// Example route that uses the cache
Future<void> getUserRoute(Event event) async {
  final userId = event.params['id'];
  final cacheKey = 'user:$userId';

  // Try to get from cache first
  var user = memoryCache.get(cacheKey);
  if (user != null) {
    return event.response.json(user);
  }

  // Fetch from database (simulated)
  user = await fetchUserFromDatabase(userId);

  // Store in cache
  memoryCache.set(cacheKey, user);

  event.response.json(user);
}

Middleware for Automatic Caching

You can write a Spry middleware that caches entire responses for certain routes. Here’s a simple example:

Middleware cachingMiddleware(String pathPrefix, Duration ttl) {
  return (Handler handler) {
    return (Event event) async {
      // Only cache GET requests under the prefix
      if (event.request.method != 'GET' || !event.request.uri.path.startsWith(pathPrefix)) {
        return handler(event);
      }

      final cacheKey = 'response:${event.request.uri}';
      final cached = memoryCache.get(cacheKey);
      if (cached != null) {
        return cached; // cached must be a Response object
      }

      final response = await handler(event);
      memoryCache.set(cacheKey, response, ttl: ttl);
      return response;
    };
  };
}

Register this middleware in your main.dart:

import 'package:spry/spry.dart';

void main() async {
  final spry = Spry();

  // Apply caching middleware to all /api routes
  spry.use(cachingMiddleware('/api', Duration(minutes: 2)));

  // ... rest of your routes

  await spry.listen(port: 3000);
}

3. Distributed Caching with Redis

For multi‑instance deployments (e.g., Docker, Cloudflare Workers), in‑memory caches are not shared across processes. A distributed cache like Redis ensures all instances see the same cached data.

Setting Up Redis

Add the Redis package to pubspec.yaml:

dependencies:
  redis: ^2.0.0

Create a Redis client wrapper:

import 'package:redis/redis.dart';

class RedisCache {
  final RedisConnection _conn;

  RedisCache(String host, int port)
      : _conn = RedisConnection();

  Future<void> connect() async {
    await _conn.connect(host, port);
  }

  Future<void> set(String key, String value, {Duration? ttl}) async {
    final command = _conn.sendObject(['SET', key, value]);
    if (ttl != null) {
      await _conn.sendObject(['EXPIRE', key, ttl.inSeconds]);
    }
    await command;
  }

  Future<String?> get(String key) async {
    final reply = await _conn.sendObject(['GET', key]);
    return reply?.toString();
  }
}

Using Redis in a Spry Route

final redisCache = RedisCache('localhost', 6379);

Future<void> getCachedProduct(Event event) async {
  final productId = event.params['id'];
  final cacheKey = 'product:$productId';

  final cached = await redisCache.get(cacheKey);
  if (cached != null) {
    return event.response.json(jsonDecode(cached));
  }

  final product = await fetchProductFromDatabase(productId);
  await redisCache.set(cacheKey, jsonEncode(product), ttl: Duration(minutes: 10));

  event.response.json(product);
}

4. Cache‑Invalidation Patterns

Caching is only useful if the cached data stays fresh. Here are common invalidation strategies:

• Time‑To‑Live (TTL) – automatically expire entries after a fixed duration
• Write‑Through – update the cache whenever the underlying data changes
• LRU (Least Recently Used) – evict entries that haven’t been accessed recently
• Tag‑Based Invalidation – group cached items by tags and invalidate whole groups

Example: Write‑Through Cache for User Updates

class UserService {
  final Cache<String, User> cache;
  final Database db;

  Future<User> getUser(String id) async {
    return cache.get(id) ?? await db.fetchUser(id).then((user) {
      cache.set(id, user, ttl: Duration(minutes: 5));
      return user;
    });
  }

  Future<void> updateUser(String id, User updates) async {
    await db.updateUser(id, updates);
    // Invalidate the cache entry
    cache.invalidate(id);
  }
}

5. Real‑World Example: Caching an External API Response

Suppose your Spry app calls a third‑party weather API that limits requests. Caching the response for 30 minutes can save API calls and improve speed.

final Cache<String, Map<String, dynamic>> weatherCache = Cache(
  defaultTTL: Duration(minutes: 30),
);

Future<void> weatherRoute(Event event) async {
  final city = event.query['city'] ?? 'London';
  final cacheKey = 'weather:$city';

  var weather = weatherCache.get(cacheKey);
  if (weather != null) {
    return event.response.json(weather);
  }

  // Simulate API call
  weather = await fetchWeatherFromAPI(city);
  weatherCache.set(cacheKey, weather);

  event.response.json(weather);
}

6. Measuring Performance Improvements

Use Dart’s Stopwatch to compare response times with and without caching:

Stopwatch stopwatch = Stopwatch()..start();
// Uncached request
await getUserRoute(event);
print('Uncached: ${stopwatch.elapsedMilliseconds} ms');

stopwatch.reset();
// Cached request (second call)
await getUserRoute(event);
print('Cached: ${stopwatch.elapsedMilliseconds} ms');

In our tests, caching reduced response times from ~150 ms to ~2 ms – a 75× improvement.

7. Conclusion

Adding caching to your Spry applications is a straightforward way to achieve significant performance gains. Start with in‑memory caching for single‑instance deployments, and move to Redis when you need shared caching across multiple instances.

Remember to choose appropriate TTLs and invalidation strategies to keep your data fresh. With the patterns shown in this guide, you can cache anything from API responses and database queries to session data and computed values.

Next steps:

• Explore Spry’s middleware system to add caching transparently
• Monitor cache hit/miss ratios to tune your TTLs
• Consider using a CDN for static assets (images, CSS, JavaScript)

All code examples are available in the companion GitHub repository: [link to your repo].

Happy caching! 🚀