CacheBox has been designed to work under the following CFML Engines:
Adobe ColdFusion 9+
Railo 4.1+
Lucee 4.5+
Our CacheBox RefCard will get you up and running in now time.
Cache Aggregator
Ability to aggregate different caching engines
Ability to aggregate different configurations of the same caches
Rich aggregation event model
Granular logging
Fast and Simple to use
Fast ColdFusion and Java hybrid cache
Simple API and configuration parameters
Small Footprint
No need to create it, configure it or manage it if used within a ColdBox Application
Solid Core
Multi-Threaded
Based on Java Concurrency Classes
Multiple Eviction Policies: LRU,LFU and FIFO
Memory Management & Memory Sensitive caching based on Java Soft References
High Load Tested
Fully Documented
Extensible & Flexible
Cache Listeners for event broadcasting
Create your own custom eviction policies
Create your own cache providers
Create your own CacheBox object storages
Extensive and granular purging mechanisms (regular expressions and key snippets)
Highly Configurable
JVM Threshold Checks
Object Limits
Ability to time expire objects
Eternal (singletons) and time-lived objects
Object purging based on object usage (Access Timeouts)
Fully configurable at runtime via dynamic configurations and hot-updates
Visually Appealing and Useful
Fully featured caching monitor and commands panel
Complete cache performance reports
CacheBox is a cache aggregator, in which you can aggregate different caching engines or types of the same engine into one single umbrella. It gives you built in logging (via LogBox), an event model, synchronization, shutdown/startup procedures, reporting, interaction consoles and best of all a cache agnostic API.
CacheBox gives you the ability to manage and create your own, what we call Cache Providers that talk to different caching engines that you would like to configure in your applications. By aggregating them within CacheBox you get the added benefit of a rich event model for all caches to share, reporting and debugging.
These cache providers also share the same interaction API and thus gives you a nice level of abstraction, higher extensibility and flexibility when planning your applications or trying to scale them out.
You can build your applications based on this abstract API and then be able to configure the caches for your applications at runtime. This gives you greater flexibility and scalability when planning and writing your applications as they can be targeted for ANY CFML engine or version.
Caching has been a central concern in the ColdBox Platform since its very first version. We have always been concerned with mission critical applications, scalability and the ability to provide granular caching aspects to ColdFusion (CFML) applications within a single in-process caching engine.
Foremost, CacheBox behaves as an in-memory cache designed for objects, data, HTML fragments or anything you like. It has various tuning parameters such as default object timeout, default last access timeout, maximum objects to have in cache, a JVM memory threshold, a reaping frequency, eviction policies, an event model and so much more.
We also make use of object stores (inspired by EHCache) for the CacheBox caching engine. This means that CacheBox can be configured to store its cached objects in different locations other than memory. This gives us great flexibility because we offer a wide gamut of storage options plus the concept of actually building your own storages. Currently we offer object stores based on concurrency classes, java soft references (memory sensitive), file storage, JDBC replication, and more coming soon.
We have a great cache debugger where you can visualize all your configured caches right from within your application. You can see the performance of the cache, the contents and even issue commands to the targeted cache provider.
