How to update a GemFire Region based on changes in some other Region

Question

My retail application has various contexts like receive, transfer etc. The requests to these contexts are handled by RESTful microservices developed using Spring Boot. The persistence layer is Cassandra. This is shared by all services as we couldn't do a vertical scaling for microservices at DB level as the services are tightly coupled conceptually.

We want vertical scaling at GemFire end by creating different Regions for different contexts.

For example, a BOX table in Cassandra will be updated by Region Box-Receive(receive context) and Region Box-Transfer(transfer context) via CacheWriter.

Our problem is how to maintain data sync between these two Regions? Please suggest any other approach also for separation at GemFire end.

gemfire version-

<dependency>
        <groupId>com.gemstone.gemfire</groupId>
        <artifactId>gemfire</artifactId>
        <version>8.2.6</version>
</dependency>

Answer 1

One alternative approach, since you are using Spring Boot would be to do the following:

1. First annotation your @SpringBootApplication class with @EnableGemfireCacheTransactions...

Example:

@SpringBootApplication
@EnableGemfireCacheTransactions
@EnableGemfireRepositories
class YourSpringBootApplication { 

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

    ...
}

The @EnableGemfireCacheTransactions annotation enables Spring Data GemFire's GemfireTransactionManager, which integrates GemFire's CacheTransactionManager with Spring Transaction Management infrastructure which then allows you to do this...

2. Now, just annotate your @Service application component transactional service methods with core Spring's @Transactional annotation, like so...

   @Service class YourBoxReceiverTransferService {

   @Transactional
   public <return-type> update(ReceiveContext receiveContext, 
           TransferContext transferContext {
   
       ...
       receiveContextRepository.save(receiveContext);
       transferContextRepository.save(transferContext);
       ...
   }
   

   }

As you can see here, I also used Spring Data (GemFire's) Repository infrastructure to manage the persistence operations (e.g. CRUD), which will be used appropriately in the transactional scoped-context setup by Spring.

2 advantages with the Spring approach, over using GemFire's public API, which unnecessarily couples you to GemFire (a definite code smell, particularly in a Spring context), is...

1. You don't have to place a bunch of boilerplate, crap code in to your application components, which does not belong there!

2. Using Spring's Transaction Management infrastructure, it is extremely easy to change your Transaction Management Strategy, such as by switching from GemFire's local-only cache transactions, to say, Global, JTA-based Transactions if the need every arises (such as, oh, well, now I need to send a message over a JMS message queue after the GemFire Region's and Cassandra BOX Table are updated to notify some downstream process that the Receiver/Transfer context has been updated). With Spring's Transaction Management infrastructure, you do not need to change a single line of application code to change transaction management strategies (such as local to global, or global to local, etc).

Hope this helps!

-John