A cache is a hardware or software component that stores data so future requests for that data can be served faster; the data stored in a cache might be the result of an earlier computation, or the duplicate of data stored elsewhere. A cache hit occurs when the requested data can be found in a cache, while a cache miss occurs when it cannot. Cache hits are served by reading data from the cache, which is faster than recomputing a result or reading from a slower data store. (Ref=Wikipedia)

To be cost-effective and to enable efficient use of data, caches must be relatively small. Nevertheless, caches have proven themselves in many areas of computing because access patterns in typical computer applications exhibit the locality of reference. Moreover, access patterns exhibit temporal locality if data is requested again that has been recently requested already, while spatial locality refers to requests for data physically stored close to data that has been already requested. (Ref=Wikipedia)

A cache is made up of copies of the data in some backing store. When a cache client (web browser, program etc.) needs to access data, it first checks the cache. If an entry is found, the data in the cache is used. This situation is known as a cache hit. Cashe miss is the situation where data is not found in the cache. The previously uncached data fetched from the backing store during miss handling is copied into the cache and the cache manager may also eject some other entry in order to make space.

A Write-around cache allows write operations to be written to storage, skipping the cache, and cache is loaded only once a cache miss happens. Write-through cache and Write-back cache writes data to both the cache and storage.  Difference is that, while write-through cache considers a write complete only after writing to both cache and store, write-back cache returns immediately after writing to cache and writes to store later. Both has their pros and cons.

Spring Framework provides support for transparently adding caching into an existing Spring application, similar to the transaction support. The caching abstraction allows consistent use of various caching solutions with minimal impact on the code. Spring also makes good use of annotations. For example, the caching feature can be declaratively enabled by simply adding the @EnableCaching annotation to any of the configuration classes.

Further notes will focus on using caching with Spring.