BoxCache Provider
The BoxCache Provider is BoxLang's default, high-performance cache implementation.
The BoxCache Provider is BoxLang's default, high-performance cache implementation. It provides a comprehensive caching solution with pluggable object stores, configurable eviction policies, automatic maintenance, and extensive monitoring capabilities. The BoxCache Provider serves as the foundation for most caching needs in BoxLang applications.
Overview
The BoxCache Provider (BoxCacheProvider) is designed to be:
High Performance: Uses efficient concurrent data structures and async operations
Flexible Storage: Supports multiple object store backends (memory, disk, custom)
Intelligent Eviction: Configurable eviction policies (LRU, MRU, LFU, etc.)
Self-Maintaining: Automatic expiration, reaping, and memory management
Event-Driven: Comprehensive event broadcasting for cache operations
Thread-Safe: Fully concurrent and thread-safe for multi-threaded applications
Observable: Rich statistics and monitoring capabilities
Accessing the BoxCache Provider
The primary way to access BoxCache instances in BoxLang is through the cache() BIF:
// Get the default cache (usually BoxCache provider)
defaultCache = cache();
// Get a named BoxCache instance
userCache = cache("userSessions");
productCache = cache("productCatalog");
// Check cache type
println( "Cache type: " & cache().getType() ); // Outputs: BoxLangCore Storage Operations
Setting Data
The BoxCache Provider offers multiple ways to store data with flexible timeout options:
myCache = cache("myCache");
// Basic storage (uses default timeouts)
myCache.set("user:123", userData);
// With custom timeout (in seconds)
myCache.set("session:abc", sessionData, 1800); // 30 minutes
// With both timeout and last access timeout
myCache.set("temp:xyz", tempData, 3600, 900); // 1 hour total, 15 min idle
// With metadata
metadata = {"priority": 5, "category": "user"};
myCache.set("user:456", userData, 3600, 1800, metadata);
// Bulk storage with same timeouts
entries = {
"product:100": product1,
"product:101": product2,
"product:102": product3
};
myCache.set(entries); // Uses default timeouts
myCache.set(entries, 7200, 3600); // 2 hours, 1 hour idleGetting Data
Retrieve data with built-in null safety using the Attempt pattern. Please see the Attempt construct section.
Basic Retrieval Patterns
// Traditional approach with explicit checking
result = cache().get( "user:123" )
if ( result.isPresent() ) {
user = result.get()
processUser( user )
} else {
// Handle cache miss
user = loadUserFromDatabase( 123 )
cache().set( "user:123", user, 1800 )
}
// Functional approach with orElse fallback
user = cache().get( "user:123" )
.orElse( loadUserFromDatabase( 123 ) )
// Lazy fallback with orElseGet (only executed if cache miss)
user = cache().get( "user:123" )
.orElseGet( function() {
var freshUser = loadUserFromDatabase( 123 )
cache().set( "user:123", freshUser, 1800 )
return freshUser
} )
// Get with default value
config = cache().get( "app:config" )
.orElse( getDefaultConfiguration() )Functional Transformations
// Transform cached data with map()
userDisplayName = cache().get( "user:123" )
.map( ( user ) -> user.firstName & " " & user.lastName )
.orElse( "Unknown User" )
// Chain multiple transformations
userPermissions = cache().get( "user:123" )
.map( ( user ) -> user.roleID )
.map( ( roleID ) -> loadRolePermissions( roleID ) )
.orElse( [ ] )
// Conditional processing with filter()
activeUser = cache().get( "user:123" )
.filter( ( user ) -> user.status == "active" )
.orElse( null )
// Complex transformation with flatMap()
userPreferences = cache().get( "user:123" )
.flatMap( function( user ) {
return cache().get( "preferences:" & user.userID )
} )
.orElse( getDefaultPreferences() )Validation and Type Safety
// Validate cached data before use
validatedUser = cache().get( "user:123" )
.toBeType( "struct" )
.toSatisfy( ( user ) -> structKeyExists( user, "userID" ) && structKeyExists( user, "email" ) )
if ( validatedUser.isValid() ) {
user = validatedUser.get()
// Safe to use user data
} else {
// Invalid or corrupted cache data
cache().clear( "user:123" )
user = loadUserFromDatabase( 123 )
}
// Validate numeric ranges
score = cache().get( "game:score:123" )
.toBeBetween( 0, 1000 )
.orElse( 0 )
// Validate with regex patterns
email = cache().get( "user:email:123" )
.toMatchRegex( "^[A-Za-z0-9+_.-]+@(.+)$" )
.orElse( "no-email@example.com" )Side Effects and Actions
// Execute side effects with ifPresent()
cache().get( "user:123" )
.ifPresent( function( user ) {
updateLastAccessed( user.userID )
logUserActivity( user.userID, "cache_hit" )
} )
.ifEmpty( function() {
logCacheMiss( "user:123" )
} )
// Conditional actions based on validation
cache().get( "session:abc123" )
.toSatisfy( ( session ) -> session.expiresAt > now() )
.ifValid( function( session ) {
extendSessionTimeout( session.sessionID )
} )
.ifInvalid( function( session ) {
cache().clear( "session:abc123" )
invalidateSession( session.sessionID )
} )
// Chain multiple conditional actions
cache().get( "user:123" )
.ifPresent( function( user ) {
writeLog( "User " & user.userID & " loaded from cache", "info" )
} )
.filter( ( user ) -> user.lastLogin > dateAdd( "d", -30, now() ) )
.ifPresent( function( user ) {
writeLog( "Recent user activity detected", "info" )
} )
.ifEmpty( function() {
writeLog( "User not recently active or not cached", "warn" )
} )Error Handling and Recovery
// Graceful error handling with orThrow()
function getRequiredUser( userID ) {
return cache().get( "user:" & userID )
.orThrow( "UserNotFound", "User " & userID & " not found in cache" )
}
// Try cache with multiple fallbacks
userData = cache().get( "user:primary:123" )
.or( function() {
return cache().get( "user:backup:123" )
} )
.orElseGet( function() {
return loadUserFromDatabase( 123 )
} )
// Attempt with validation and recovery
safeUserData = cache().get( "user:123" )
.toBeType( "struct" )
.filter( ( user ) -> !structIsEmpty( user ) )
.or( function() {
// Try backup cache
return cache( "backup" ).get( "user:123" )
} )
.orElseGet( function() {
// Last resort - load from database
var user = loadUserFromDatabase( 123 )
// Cache for next time
cache().set( "user:123", user, 3600 )
return user
} )Stream Operations
// Process cached data as streams
cache().get( "user:123" )
.stream()
.map( ( user ) -> user.departmentID )
.forEach( function( deptID ) {
processDepartment( deptID )
} )
// Combine multiple cache results
userIDs = [ "123", "456", "789" ]
activeUsers = userIDs
.map( function( id ) {
return cache().get( "user:" & id )
} )
.filter( ( attempt ) -> attempt.isPresent() )
.map( ( attempt ) -> attempt.get() )
.filter( ( user ) -> user.status == "active" )Advanced Functional Patterns
// Memoization pattern with cache
function getMemoizedData( key, expensiveFunction, timeout = 3600 ) {
return cache().get( key )
.orElseGet( function() {
var result = expensiveFunction()
cache().set( key, result, timeout )
return result
} )
}
// Usage
reportData = getMemoizedData( "report:monthly:2024", function() {
return generateComplexReport( "2024" )
}, 86400 )
// Circuit breaker pattern
function getWithCircuitBreaker( key, fallbackFunction ) {
var circuitKey = "circuit:" & key
var circuitState = cache().get( circuitKey ).orElse( "closed" )
if ( circuitState == "open" ) {
// Circuit is open, use fallback
return fallbackFunction()
}
return cache().get( key )
.ifEmpty( function() {
// Track failures
var failures = cache().get( "failures:" & key ).orElse( 0 ) + 1
cache().set( "failures:" & key, failures, 300 )
if ( failures >= 5 ) {
// Open circuit
cache().set( circuitKey, "open", 60 )
}
} )
.orElseGet( fallbackFunction )
}
// Cached computation with dependency invalidation
function getCachedWithDependencies( key, dependencies, computeFunction ) {
var cacheKey = key & ":" & hash( serialize( dependencies ) )
return cache().get( cacheKey )
.filter( function( cached ) {
// Validate dependencies haven't changed
return dependencies.every( function( dep ) {
var depValue = cache().get( "dep:" & dep )
return depValue.isPresent() &&
depValue.get().timestamp == cached.depTimestamp
} )
} )
.orElseGet( function() {
var result = computeFunction()
result.depTimestamp = now()
cache().set( cacheKey, result, 3600 )
return result
} )
}Bulk Retrieval with Functional Processing
// Process bulk results functionally
keys = [ "user:123", "user:456", "user:789" ]
results = cache().get( keys )
// Extract successful results and handle misses
users = [ ]
missingKeys = [ ]
for ( var key in results ) {
var attempt = results[ key ]
attempt
.ifPresent( function( user ) {
arrayAppend( users, user )
} )
.ifEmpty( function() {
arrayAppend( missingKeys, key )
} )
}
// Load missing users and cache them
if ( !arrayIsEmpty( missingKeys ) ) {
var missingUserIDs = missingKeys.map( ( key ) -> listLast( key, ":" ) )
var loadedUsers = loadUsersFromDatabase( missingUserIDs )
var cacheEntries = { }
for ( var user in loadedUsers ) {
arrayAppend( users, user )
cacheEntries[ "user:" & user.userID ] = user
}
cache().set( cacheEntries, 3600 )
}Silent Retrieval and Internal Operations
// Silent retrieval (no stats tracking)
internalConfig = cache().getQuiet( "internal:config" )
.orElseGet( function() {
return loadInternalConfiguration()
} )
// System operations without affecting cache statistics
systemHealth = cache().getQuiet( "system:health" )
.filter( ( health ) -> health.timestamp > dateAdd( "m", -5, now() ) )
.orElseGet( function() {
return performHealthCheck()
} )Filtered Retrieval with Complex Processing
// Get all user sessions and process them
userFilter = cacheFilter( "user:session:*" )
userSessions = cache().get( userFilter )
// Process each session attempt
activeSessions = [ ]
expiredSessions = [ ]
for ( var key in userSessions ) {
userSessions[ key ]
.filter( ( session ) -> session.expiresAt > now() )
.ifPresent( function( session ) {
arrayAppend( activeSessions, session )
} )
.ifEmpty( function() {
arrayAppend( expiredSessions, key )
} )
}
// Clean up expired sessions
if ( !arrayIsEmpty( expiredSessions ) ) {
cache().clear( expiredSessions )
}Get-or-Set Pattern
The BoxCache Provider includes the powerful getOrSet() method to eliminate double-lookup patterns:
// Basic get-or-set with default timeouts
userData = cache().getOrSet("user:123", () => {
return loadUserFromDatabase(123)
})
// With custom timeouts
productData = cache().getOrSet("product:456", () => {
return loadProductFromAPI(456)
}, 3600, 1800) // 1 hour, 30 min idle
// With metadata
reportData = cache().getOrSet("report:monthly", () => {
return generateMonthlyReport()
}, 86400, 43200, {"priority": 10}) // 24 hours, 12 hour idleClearing Data
Remove data from the cache with various options:
// Clear single key
cleared = cache().clear("user:123") // Returns true/false
// Clear multiple keys
results = cache().clear(["user:123", "user:456", "user:789"])
// Returns: {"user:123": true, "user:456": false, ...}
// Clear with pattern filter
userFilter = cacheFilter("user:session:*"
cache().clear(userFilter);
// Clear all data
cache().clearAll()
// Silent clear (no events or stats)
cache().clearQuiet("internal:temp")Key Management and Filtering
Getting Cache Keys
// Get all keys
allKeys = cache().getKeys()
// Get keys with filter
sessionKeys = cache().getKeys(cacheFilter("session:*"))
userKeys = cache().getKeys(cacheFilter("user:*"))
// Stream processing for large caches
cache().getKeysStream()
.filter( (key) => {
return key.startsWith("temp:") &&
cache().getQuiet(key).isPresent()
})
.forEach( (key) => {
cache().clear(key)
})Using Cache Filters
Cache filters provide powerful pattern matching for bulk operations:
// Wildcard filters
tempFilter = cacheFilter("temp:*") // All temp keys
userFilter = cacheFilter("user:session:*") // User sessions
apiFilter = cacheFilter("api:v?:*") // API versions (v1, v2, etc.)
// Regex filters
emailFilter = cacheFilter(".*@domain\.com$", true )
idFilter = cacheFilter("^id_\d{4,6}$", true)
// Custom filter functions
expiredFilter = (key) => {
var entry = cache().getQuiet(key)
if (!entry.isPresent()) return false;
var data = entry.get();
return structKeyExists(data, "expiry") &&
data.expiry < now();
};
// Use filters in operations
cache().clear(tempFilter)
cache().get(userFilter)
cache().lookup(expiredFilter)Lookup Operations
Check for key existence without retrieving data:
// Basic lookup (with stats tracking)
exists = cache().lookup("user:123")
// Silent lookup (no stats)
exists = cache().lookupQuiet("internal:config")
// Bulk lookup
results = cache().lookup(["user:123", "user:456"])
// Returns: {"user:123": true, "user:456": false}
// Filtered lookup
userFilter = cacheFilter("user:*")
userExistence = cache().lookup(userFilter)Statistics and Monitoring
The BoxCache Provider includes comprehensive statistics tracking:
// Get cache statistics
stats = cache().getStats()
writeOutput("Hit Rate: " & numberFormat(stats.getHitRate() * 100, "0.00") & "%")
writeOutput("Hits: " & stats.getHits())
writeOutput("Misses: " & stats.getMisses())
writeOutput("Cache Size: " & cache().getSize())
// Cache metadata
writeOutput("Cache Name: " & cache().getName())
writeOutput("Provider Type: " & cache().getType())
writeOutput("Is Enabled: " & cache().isEnabled())
writeOutput("Reporting Enabled: " & cache().isReportingEnabled()
// Clear statistics
cache().clearStats()
// Object-specific metadata
metadata = cache().getCachedObjectMetadata("user:123")
if (!structIsEmpty(metadata)) {
writeOutput("Last Accessed: " & metadata.lastAccessed)
writeOutput("Hit Count: " & metadata.hits)
writeOutput("Created: " & metadata.created)
}
// Bulk metadata for reporting
metadataReport = cache().getStoreMetadataReport(100) // Limit to 100 entriesConfiguration and Properties
Access and understand cache configuration:
// Get cache configuration
config = cache().getConfig(
properties = config.properties;
writeOutput("Max Objects: " & properties.maxObjects)
writeOutput("Default Timeout: " & properties.defaultTimeout)
writeOutput("Eviction Policy: " & properties.evictionPolicy)
writeOutput("Object Store: " & properties.objectStore)
// Key configuration properties:
// - maxObjects: Maximum number of cached objects
// - defaultTimeout: Default expiration time in seconds
// - defaultLastAccessTimeout: Default idle timeout
// - evictionPolicy: LRU, MRU, LFU, MFU, FIFO, LIFO, Random
// - objectStore: ConcurrentHashMap, ConcurrentSoftReference, Disk, Custom
// - reapFrequency: How often to run maintenance (seconds)
// - freeMemoryPercentageThreshold: Memory threshold for eviction
// - useLastAccessTimeouts: Enable/disable idle timeoutsAsync Operations
BoxCache supports asynchronous operations for high-performance scenarios:
// Async get operation
future = cache().getAsync("user:123")
// Process the result when ready
future.thenAccept( (result) => {
if (result.isPresent()) {
user = result.get()
processUser(user)
}
});
// Or wait for completion
result = future.get() // Blocks until completeCache Maintenance
Manual Maintenance Operations
// Trigger reaping (cleanup expired entries)
cache().reap()
// Get cache size
size = cache().getSize()
// Check if cache is operational
if ( cache().isEnabled() ) {
// Cache is ready for operations
}Automatic Maintenance
BoxCache automatically handles:
Expiration Checking: Removes expired entries based on timeouts
Idle Timeout Management: Removes entries that haven't been accessed
Memory Threshold Eviction: Triggers eviction when memory usage is high
Scheduled Reaping: Periodic cleanup based on
reapFrequencysetting
Event Integration
BoxCache broadcasts events for all major operations:
// Cache events are automatically announced:
// - BEFORE_CACHE_ELEMENT_REMOVED / AFTER_CACHE_ELEMENT_REMOVED
// - AFTER_CACHE_ELEMENT_INSERT
// - AFTER_CACHE_ELEMENT_UPDATED
// - AFTER_CACHE_CLEAR_ALL
// Listen to events (if you have interceptor components)
class {
function afterCacheElementInsert(event, data) {
writeLog("Cache item added: " & data.key, "info")
}
function afterCacheElementRemoved(event, data) {
writeLog("Cache item removed: " & data.key & ", cleared: " & data.cleared, "info")
}
}Practical Usage Patterns
User Session Management
class {
function storeUserSession(sessionID, userData) {
var sessionKey = "session:" & sessionI
cache("sessions").set(sessionKey, userData, 3600, 180 ) // 1 hour, 30 min idle
}
function getUserSession(sessionID) {
var sessionKey = "session:" & sessionID
return cache("sessions").get(sessionKey)
}
function updateSessionActivity(sessionID) {
var sessionKey = "session:" & sessionID
var session = cache("sessions").get(sessionKey)
if (session.isPresent()) {
var sessionData = session.get()
sessionData.lastActivity = now()
cache("sessions").set(sessionKey, sessionData, 3600, 1800)
}
}
function clearUserSessions(userID) {
var filter = cacheFilter("session:*:user:" & userID)
cache("sessions").clear(filter)
}
}API Response Caching
class {
function getCachedAPIResponse(endpoint, params) {
var cacheKey = "api:" & endpoint & ":" & hash(serialize(params));
return cache("api").getOrSet(cacheKey, function() {
return makeAPICall(endpoint, params);
}, 600); // 10 minutes
}
function invalidateAPICache(endpoint) {
if (isNull(endpoint)) {
// Clear all API cache
cache("api").clear(cacheFilter("api:*"));
} else {
// Clear specific endpoint
cache("api").clear(cacheFilter("api:" & endpoint & ":*"));
}
}
function warmAPICache() {
var popularEndpoints = getPopularEndpoints();
for (var endpoint in popularEndpoints) {
getCachedAPIResponse(endpoint.name, endpoint.defaultParams);
}
}
}Database Query Caching
class {
function getCachedQuery(sql, params, timeout = 1800) {
var cacheKey = "query:" & hash(sql & params.tostring() );
return cache("queries").getOrSet(cacheKey, function() {
return queryExecute(sql, params);
}, timeout);
}
function invalidateQueryCache(tables) {
for (var table in tables) {
var filter = cacheFilter("query:*" & table & "*");
cache("queries").clear(filter);
}
}
function getQueryCacheStats() {
var stats = cache("queries").getStats();
return {
"hitRate": stats.getHitRate(),
"size": cache("queries").getSize(),
"hits": stats.getHits(),
"misses": stats.getMisses()
};
}
}Multi-Level Caching
class {
function getData(key) {
// Try L1 cache (fast, small)
var l1Result = cache("l1").get(key);
if (l1Result.isPresent()) {
return l1Result.get();
}
// Try L2 cache (slower, larger)
var l2Result = cache("l2").get(key);
if (l2Result.isPresent()) {
var data = l2Result.get();
// Promote to L1
cache("l1").set(key, data, 300); // 5 minutes in L1
return data;
}
// Load from source
var data = loadFromDatabase(key);
// Store in both levels
cache("l1").set(key, data, 300); // 5 minutes
cache("l2").set(key, data, 3600); // 1 hour
return data;
}
function invalidateData(key) {
cache("l1").clear(key);
cache("l2").clear(key);
}
}Performance Optimization
Efficient Key Design
// Good key patterns - hierarchical and descriptive
"user:profile:" & userID
"product:inventory:" & productID & ":" & warehouseID
"api:response:v1:" & endpoint & ":" & hash(params)
// Avoid overly complex keys
"user:" & userID & ":profile:settings:theme:color" // Too deep
// Use consistent naming conventions
"session:user:" & userID & ":" & sessionID
"session:admin:" & adminID & ":" & sessionIDBatch Operations
// Efficient bulk operations
function loadMultipleUsers(userIDs) {
var cacheKeys = {};
var missingIDs = [];
// Build cache keys
for (var userID in userIDs) {
cacheKeys["user:" & userID] = userID;
}
// Bulk lookup
var results = cache("users").get(arrayToList(structKeyArray(cacheKeys)));
var users = {};
// Process results and identify misses
for (var key in results) {
var result = results[key];
var userID = cacheKeys[key];
if (result.isPresent()) {
users[userID] = result.get();
} else {
arrayAppend(missingIDs, userID);
}
}
// Load missing users
if (!arrayIsEmpty(missingIDs)) {
var missingUsers = loadUsersFromDatabase(missingIDs);
var entriesToCache = {};
for (var userID in missingUsers) {
users[userID] = missingUsers[userID];
entriesToCache["user:" & userID] = missingUsers[userID];
}
// Bulk cache the missing users
cache("users").set(entriesToCache, 3600);
}
return users;
}Memory Management
// Monitor cache memory usage
function monitorCacheMemory() {
var caches = cacheNames();
var report = {};
for (var cacheName in caches) {
var cacheInstance = cache(cacheName);
var config = cacheInstance.getConfig();
var size = cacheInstance.getSize();
var maxSize = config.properties.maxObjects;
report[cacheName] = {
"size": size,
"maxSize": maxSize,
"utilizationPercent": (size / maxSize) * 100,
"stats": cacheInstance.getStats()
};
// Alert if approaching capacity
if ((size / maxSize) > 0.8) {
writeLog("Cache " & cacheName & " is " &
numberFormat((size/maxSize)*100, "0.0") & "% full", "warn");
}
}
return report;
}Error Handling and Resilience
Graceful Degradation
function resilientCacheOperation(key, fallbackFunction) {
try {
var result = cache().get(key);
if (result.isPresent()) {
return result.get();
}
} catch (any e) {
writeLog("Cache get error for key " & key & ": " & e.message, "error");
}
// Fallback to direct operation
var data = fallbackFunction();
// Try to cache the result
try {
cache().set(key, data, 1800);
} catch (any e) {
writeLog("Cache set error for key " & key & ": " & e.message, "warn");
}
return data;
}Health Checks
function checkCacheHealth() {
var health = {
"status": "healthy",
"issues": []
};
try {
var testKey = "healthcheck:" & createUUID();
var testValue = "test";
// Test write
cache().set(testKey, testValue, 60);
// Test read
var result = cache().get(testKey);
if (!result.isPresent() || result.get() != testValue) {
arrayAppend(health.issues, "Cache read/write test failed");
health.status = "unhealthy";
}
// Test delete
cache().clear(testKey);
// Check stats
var stats = cache().getStats();
if (stats.getHitRate() < 0.5 && stats.getHits() > 100) {
arrayAppend(health.issues, "Low hit rate: " & numberFormat(stats.getHitRate() * 100, "0.00") & "%");
health.status = "degraded";
}
// Check size
var size = cache().getSize();
var config = cache().getConfig();
var maxSize = config.properties.maxObjects;
if (size > (maxSize * 0.9)) {
arrayAppend(health.issues, "Cache nearly full: " & size & "/" & maxSize);
health.status = "degraded";
}
} catch (any e) {
arrayAppend(health.issues, "Cache operation failed: " & e.message);
health.status = "unhealthy";
}
return health;
}Best Practices
1. Key Naming Conventions
// Use consistent, hierarchical naming
"user:profile:" & userID
"session:data:" & sessionID
"product:details:" & productID
"api:response:" & version & ":" & endpoint
// Include versioning for data structures
"user:profile:v2:" & userID
"config:app:v1:" & environment2. Appropriate Timeouts
// Short-lived dynamic data
cache().set("stock:price:" & symbol, price, 30); // 30 seconds
// User sessions
cache().set("session:" & sessionID, sessionData, 3600, 1800 // 1 hour, 30 min idle
// Reference data
cache().set("config:app", appConfig, 86400) // 24 hours
// Computed reports
cache().set("report:daily", reportData, 43200) // 12 hours3. Memory Efficiency
// Store minimal necessary data
cache().set("user:summary:" & userID, {
"name": user.name,
"email": user.email,
"role": user.role
}, 3600)
// Instead of storing the entire user object
// cache().set("user:full:" & userID, entireUserObject, 3600);4. Strategic Cache Warming
function warmCriticalCaches() {
// Warm high-traffic reference data
var appConfig = loadApplicationConfig()
cache().set("config:app", appConfig, 86400)
// Warm popular user sessions
var activeUsers = getActiveUserIDs()
for (var userID in activeUsers) {
var userData = loadUserProfile(userID)
cache().set("user:profile:" & userID, userData, 3600)
}
// Warm frequently accessed products
var popularProducts = getPopularProductIDs()
for (var productID in popularProducts) {
var productData = loadProductDetails(productID)
cache().set("product:details:" & productID, productData, 7200)
}
}Conclusion
The BoxCache Provider offers a comprehensive, high-performance caching solution for BoxLang applications. By leveraging its rich feature set including flexible storage options, intelligent eviction policies, comprehensive monitoring, and powerful filtering capabilities, developers can build scalable, efficient applications.
Key advantages of BoxCache Provider:
Developer Friendly: Simple BIF-based access with powerful functionality
High Performance: Concurrent operations, async support, and efficient data structures
Flexible Configuration: Pluggable object stores and eviction policies
Production Ready: Comprehensive monitoring, event integration, and automatic maintenance
Scalable: Supports everything from simple key-value caching to complex multi-level architectures
Whether you're caching user sessions, API responses, database queries, or computed data, the BoxCache Provider provides the tools and flexibility needed to optimize your application's performance and scalability.
Last updated
Was this helpful?