Mastering Caching in Go with cache

Caching is a critical component of modern software systems, allowing applications to achieve faster response times, reduce database load, and improve overall user experience. The cache_go package provides a robust and versatile interface for managing caches in Go, with support for various providers such as Redis, in-memory caching, and Memcached. Its dynamic and structured approach makes it a perfect choice for developers who want to build performant and reliable caching layers.

Installation

go get github.com/harryosmar/cache-go

🚀 Why Use cache_go?

cache_go abstracts the complexities of caching and provides a seamless interface to interact with various caching backends. It also comes with a wrapper for dynamic TTL management, ensuring cached data remains relevant.

Key Features:

Unified Cache Interface: Simplifies interactions with Redis, memory-based caches, and Memcached.
Dynamic TTL Management: Easily manage expiration times for cached data based on its properties.
Structured Data Handling: Marshals and unmarshals JSON data seamlessly.
Flexible Methods: Supports key-value storage, list operations, key pattern searching, and more.
Customizable Cacheable Logic: Integrates with fallback functions to fetch data when cache misses occur.

🛠️ Getting Started with cache_go

To get started, implement the CacheRepo interface for your caching backend (e.g., Redis):

type CacheRepo interface {
    Store(ctx context.Context, key string, value []byte, exp time.Duration) error
	StoreWithoutTTL(ctx context.Context, key string, value []byte) error
	Get(ctx context.Context, key string) ([]byte, bool, error)
	Delete(ctx context.Context, key string) error
	Increment(ctx context.Context, key string) (int64, error)
	IncrementWithTTL(ctx context.Context, key string, exp time.Duration) (int64, error)
	LPush(ctx context.Context, key string, value []byte) error
	LRange(ctx context.Context, key string, start int64, end int64) ([]string, error)
	LTrim(ctx context.Context, key string, start int64, end int64) error
	LRem(ctx context.Context, key string, count int64, value []byte) error
	KeysByPattern(ctx context.Context, pattern string) ([]string, error)
	ValuesByKeys(ctx context.Context, keys []string) ([]interface{}, error)
	Close() error
	Ping(ctx context.Context) error
}

This interface ensures uniformity across caching backends and simplifies caching operations.

⚙️ Dynamic TTL with GetFromCacheWithDynamicTTL

For data with variable expiration needs, use GetFromCacheWithDynamicTTL:

type Product struct {
    Id int64
    Name string
    IsDiscounted bool
}

func GetProduct(ctx context.Context, cache CacheRepo, productID string) (*Product, error) {
    return GetFromCacheWithDynamicTTL(ctx, cache, productID, "product", func(ctx context.Context, data *Product) time.Duration {
        // Set shorter TTL for discounted products
        if data.IsDiscounted {
            return 5 * time.Minute
        }
        return 1 * time.Hour
    }, fetchProductFromDB)
}

func fetchProductFromDB(ctx context.Context, productID string) (*Product, error) {
    return &Product{
        Id:1,
        Name: "macbook",
        IsDiscounted: true,
    }, nil
}

🟢 Supported Cache Providers

Redis: Highly performant and distributed, ideal for production.
In-Memory: Lightweight and fast, suitable for single-node applications.
Memcached: Simple and scalable for basic caching needs.

🎯 Final Thoughts

The cache_go package simplifies caching in Go with its intuitive interface, support for multiple backends, and robust methods. Whether you're building a high-throughput API or an interactive web application, integrating caching effectively can significantly enhance your system's performance.

By leveraging cache_go, you can:

Minimize latency for frequently accessed data.
Reduce dependency on slower data sources.
Easily extend your caching solution as your needs grow.

Mastering Caching in Go with cache_go