6. Caching using Apache Geode or Pivotal GemFire

The caching pattern we demonstrated in the example above is a form of Look-Aside Caching.

Essentially, the item of interests is searched for in the cache first, before calling a potentially expensive operation, such a IO or network bound request resulting in either a blocking, or latency intensive operation. If the item can be found in the cache (usually, in-memory) then the item is returned without invoking the expensive operation. If the item cannot be found in the cache, then the operation must be invoked. However, the result of the operation is cached for subsequent requests when the the same input is provided.

Near Caching is another form of caching where the cache is collocated with the application. This is useful when the cache is configured using a client/server arrangement.

We already mentioned that Spring Boot for Apache Geode & Pivotal GemFire provides an auto-configured, ClientCache instance out-of-the-box, by default. The ClientCache instance is most effective when the data access operations, including cache access, is distributed to the servers in a cluster accessed by the client. This enables other cache client applications to access the same data. However, this also means that the application incurs a network hop penalty to evaluate the presence of the item in the cache.

To help avoid this network cost in a client/server topology, then a local application cache can be established to maintain a subset of the data in the corresponding server-side cache (known as a cache Region in GemFire/Geode), which contains only the data of interests to the application. This "local" cache is consulted before forwarding the lookup request to the server.

To enable Near Caching when using either Apache Geode or Pivotal GemFire, simply change the Region’s (i.e. the Cache in Spring’s Cache Abstraction) data management policy from PROXY (the default) to CACHING_PROXY, like so:

@SpringBootApplication
@EnableCachingDefinedRegions(clientRegionShortcut = ClientRegionShortcut.CACHING_PROXY)
class FinancialLoanApplication {

    public static void main(String[] args) {
        SpringApplication.run(FinancialLoanApplication.class, args);
    }
}

	Tip
	The default, client Region data management policy is ClientRegionShortcut.PROXY. As such, all data access operations are immediately forwarded to the server.

The final form of caching is Inline Caching.

When employing Inline Caching and a cache miss occurs, the application service method may still not be invoked since the cache (Region) can be configured to invoke a loader to load the missing entry.

With Apache Geode and Pivotal GemFire, the cache, or in GemFire/Geode terminology, Region, can be configured with a CacheLoader. This CacheLoader is implemented to retrieve the missing value from some external data source, which could be a RDBMS or any other type of data source.

	Tip
	See the Apache Geode User Guide on Data Loaders for more details.

You can use Spring to configure a CacheLoader as a bean in the Spring ApplicationContext and then wire it to the cache Region. Given the CacheLoader is a Spring bean, you can inject any DataSource you like into the CacheLoader.

While you can configure client Regions with CacheLoaders, it is more common to configure the corresponding server-side Region; for example:

@SpringBootApplication
@CacheServerApplication
class FinancialLoanApplicationServer {

    public static void main(String[] args) {
        SpringApplication.run(FinancialLoanApplicationServer.class, args);
    }

	@Bean("EligibilityDecisions")
	public PartitionedRegionFactoryBean<Object, Object> eligibilityDecisionsRegion(
            GemFireCache gemfireCache, CacheLoader decisionManagementSystemLoader) {

        PartitionedRegionFactoryBean<?, EligibilityDecision> eligibilityDecisionsRegion =
            new PartitionedRegionFactoryBean<>();

        eligibilityDecisionsRegion.setCache(gemfireCache);
        eligibilityDecisionsRegion.setCacheLoader(decisionManagementSystemLoader);
        eligibilityDecisionsRegion.setClose(false);
        eligibilityDecisionsRegion.setPersistent(false);

        return eligibilityDecisionsRegion;
    }


    @Bean
    public CacheLoader<?, EligibilityDecision> decisionManagementSystemLoader(
            DataSource dataSource) {

        return new DecisionManagementSystemLoader(dataSource);
    }
}

If the configured CacheLoader still cannot resolve the value, the the cache lookup operation results in a miss and the application service method will then be invoked.