In this post, we feature a comprehensive Tutorial on Spring Data Pivotal Gemfire. Pivotal Gemfire is an in-memory data grid solution powered by Apache Geode. The applications built with Pivotal Gemfire allow you to scale your system easily across distributed server nodes. Pivotal Gemfire ensures data consistency irrespective of the distribution architecture. It enables the applications to serve real time data to millions of users.
\nSpring framework, on the other hand, is an widely used framework that provides the foundation to build enterprise scale application. In this article, we discuss how Spring Data, one of the many modules of Spring framework, integrates with Pivotal Gemfire to speed the development process and bring the power of Spring Framework into Pivotal Gemfire applications.<\/p>\n
Before we jump into the tutorial, it is necessary to understand the assumptions that are made and the tools that will be required to proceed with the tutorial. Herein, I assume that you understand the below:<\/p>\n
Throughout the tutorial, we will be using the below tools and specifications:<\/p>\n
To begin with the project, let us create a Maven project and add the below dependency.<\/p>\n
pom.xml<\/em><\/span><\/p>\n Save the project with these dependencies and allow it to build. The above file contains the necessary Spring Boot dependencies and also the Spring Data dependency for Pivotal Gemfire. Once the project has downloaded the relevant dependencies, you can proceed with the coding part.<\/p>\n Spring Data with Pivotal Gemfire helps us configure the access to distributed data access centres. This combination helps us lower the hits to the disk and maintain a better response time using in-memory caching levels. The tutorial will take you through this complete setup and configuration process.<\/p>\n To begin with, the primary requirement is to create an entity. Let us create a simple Person entity that holds the details of a person like the name and age of person. To create such an entity, use the below code.<\/p>\n PersonEntity.java<\/em><\/span><\/p>\n As you can see, there are two attributes – name and age along with a Persistent constructor. Here, notice carefully that the class ha been annotated with the annotation It is being assumed here that you understand that Pivotal does not have any automated key generation system in place. Hence, before actually proceeding with data persistence, you need to ensure that the id field is set.<\/p>\n Spring Data clubbed with the Pivotal Gemfire framework is all about storing and persisting data. It focusses on managing the access to the data by this. Additionally, it also inherits the powerful features of Spring Data framework like the power to derive the queries. The power of framework is that you do not need to learn the pivotal gemfire query language any more. All you need to do is write few java code snippets and the framework will build the queries in the backend. PersonQueries.java<\/em><\/span><\/p>\n In the above code, notice carefully that the class extends Now that we have our query and entity ready, let us begin with the creation of actual application that helps in the data transaction. The application will be created with the view to instantiate the entity and transact the data. The below code creates the application with all the necessary components.<\/p>\n App.java<\/em><\/span><\/p>\n The above class contains all the possible queries calls for the defined entity. Notice here that the class has been annotated with numerous annotations. The description of each annotation is provided below:<\/p>\n Occasionally, there might be a case where we do not wish to expose all the Spring Data entities into the Gemfire framework. This can be prevented by explicitly specifying the class that is being extended by the desired entities. This can be done using its property There are three different cache configurations possible in Pivotal. Depending on the region that we plan to use, we can use one of the desired annotation to specify the caching and data persistence with the Pivotal Gemfire backend using Spring Data framework. Below are the three possible annotations that could be used:<\/p>\n Pivotal Gemfire supports multiple caching topologies like client\/server, peer to peer and even WAN or LAN arrangements. In the client\/server caching topology, the clients cache the queried data while server caches all of it. In the peer to peer topology, even device in the network will cache the data to provide it to the nearest peers. In case of WAN or LAN topology, your device caches the data if you are connected to the specific network and starts distributing data to the other users. In the above case, we have used client caching and hence once the query has been executed, the caching will be done entirely on the client side. We have specified the region We connected the entity to a region named In this guide, you are creating three local Person objects, Abhishek, Sumit John. Initially, they only exist in memory. After creating them, you have to save them to Pivotal GemFire.<\/p>\n Now you run several queries. The first looks up everyone by name. Then you execute a handful of queries to find adults, babies, and teens, all using the age attribute. With the logging turned up, you can see the queries Spring Data for Pivotal GemFire writes on your behalf.<\/p>\n Now that we have understood the code perfeclty, its time for the next step. The next step is to actually execute the code and see how the code works. To execute the code, run the application as a Java application in your Spring Tool Suite or IntelliJ. On executing the application, you see an output that is similar to the one shown below. It may slightly vary depending on the version of libraries that you might be using.<\/p>\n As it can be seen, the application got executed and the lamba functions fetched use the data according to specified filters. Notice here that we created a completion entity, stored it and retrieved it without really doing any setup for the Pivotal gemfire database. These queries returned us the instances without any major efforts. In this manner, Spring Data annotations help in simplifying the application development for the Pivotal Gemfire applications and help you reduce the whole effort of coding and setting up from scratch.<\/p>\n In order to build this application and export it elsewhere to use it remotely, all you need to do is use Maven to build the application jar. To do so, just execute the below command.<\/p>\n The above command will build a runnable jar for you to execute in any system. Thus, you can build easily portable applications using Spring Data Framework with the Pivotal Gemfire data distribution.<\/p>\n The STS project of what has been discussed above can be found at the below link.<\/p>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\" xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n <modelVersion>4.0.0<\/modelVersion>\n <groupId>org.springframework.samples<\/groupId>\n <artifactId>pivotal_tutorial<\/artifactId>\n <version>0.0.1-SNAPSHOT<\/version>\n \n \n <parent>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-parent<\/artifactId>\n <version>2.0.3.RELEASE<\/version>\n <\/parent>\n\n\n <properties>\n <spring-shell.version>1.2.0.RELEASE<\/spring-shell.version>\n <\/properties>\n\n <repositories>\n <repository>\n <id>spring-releases<\/id>\n <url>https:\/\/repo.spring.io\/libs-release<\/url>\n <\/repository>\n <\/repositories>\n\n <dependencies>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter<\/artifactId>\n <exclusions>\n <exclusion>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-logging<\/artifactId>\n <\/exclusion>\n <\/exclusions>\n <\/dependency>\n <dependency>\n <groupId>org.springframework.data<\/groupId>\n <artifactId>spring-data-gemfire<\/artifactId>\n <\/dependency>\n <dependency>\n <groupId>org.springframework.shell<\/groupId>\n <artifactId>spring-shell<\/artifactId>\n <version>${spring-shell.version}<\/version>\n <scope>runtime<\/scope>\n <\/dependency>\n <dependency>\n <groupId>org.projectlombok<\/groupId>\n <artifactId>lombok<\/artifactId>\n <\/dependency>\n <\/dependencies>\n\n <build>\n <plugins>\n <plugin>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-maven-plugin<\/artifactId>\n <\/plugin>\n <\/plugins>\n <\/build>\n\n<\/project>\n\n<\/pre>\n4. Creating an entity<\/h2>\n
package pivotal_tutorial;\n\nimport java.io.Serializable;\n\nimport org.springframework.data.annotation.Id;\nimport org.springframework.data.annotation.PersistenceConstructor;\nimport org.springframework.data.gemfire.mapping.annotation.Region;\n\nimport lombok.Getter;\n\n@Region(value = \"People\")\npublic class PersonEntity implements Serializable {\n\n @Id\n @Getter\n private final String name;\n\n @Getter\n private final int age;\n\n @PersistenceConstructor\n public PersonEntity(String name, int age) {\n this.name = name;\n this.age = age;\n }\n\n public String getName() {\n\t\treturn name;\n\t}\n\n\tpublic int getAge() {\n\t\treturn age;\n\t}\n\n\t@Override\n public String toString() {\n return String.format(\"%s is %d years old\", getName(), getAge());\n }\n}\n<\/pre>\n@Region<\/code>. This annotation is a Pivotal indicator to tell the framework to store the instance of this class with a specific name. When it reads the annotation @Region(\"People\")<\/code>, it will understand that the instance of PersonEntity has to be stored in the name of People. The field annotated with the annotation @Id<\/code> will be the unique key for the instance.5. Creating simple queries<\/h2>\n
\nLet us start by creating similar snippets for the entity shown above.<\/p>\npackage pivotal_tutorial;\nimport org.springframework.data.gemfire.repository.query.annotation.Trace;\nimport org.springframework.data.repository.CrudRepository;\n\npublic interface PersonRepo extends CrudRepository<PersonEntity, String> {\n\n @Trace\n PersonEntity findByName(String name);\n\n @Trace\n Iterable findByAgeGreaterThan(int age);\n\n @Trace\n Iterable findByAgeLessThan(int age);\n\n @Trace\n Iterable findByAgeGreaterThanAndAgeLessThan(int greaterThanAge, int lessThanAge);\n}\n<\/pre>\nCrudRepository<\/code> which is a class provided by Spring Data framework. The annotation @Trace<\/code> identifies that the concerned functions need to be used for creating queries for the Pivotal Gemfire framework running in the backend. The functions are quite simple to understand. A brief explanation has been provided below:<\/p>\n\n
findByName<\/code>: Finds the entity by the value of name provided as an argument<\/li>\nfindByAgeGreaterThan<\/code>: Finds the entities with age greater than the provided value. Returns an iterable list of PersonEntity<\/code> instances.<\/li>\nfindAgeLessThan<\/code>: Finds the entities with age less than the provided value. Returns an iterable list of PersonEntity<\/code> instances.<\/li>\nfindByAgeGreaterThanAndLessThan<\/code>: Finds the entities with age greater than or less than the provided value. Returns an iterable list of PersonEntity<\/code> instances.<\/li>\n<\/ul>\n6. Creating an application<\/h2>\n
package pivotal_tutorial;\nimport static java.util.Arrays.asList;\nimport static java.util.stream.StreamSupport.stream;\n\nimport java.io.IOException;\n\nimport org.apache.geode.cache.client.ClientRegionShortcut;\nimport org.springframework.boot.ApplicationRunner;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.data.gemfire.config.annotation.ClientCacheApplication;\nimport org.springframework.data.gemfire.config.annotation.EnableEntityDefinedRegions;\nimport org.springframework.data.gemfire.repository.config.EnableGemfireRepositories;\n\n@SpringBootApplication\n@ClientCacheApplication(name = \"AccessingDataGemFireApplication\", logLevel = \"error\")\n@EnableEntityDefinedRegions(basePackageClasses = PersonEntity.class,\n clientRegionShortcut = ClientRegionShortcut.LOCAL)\n@EnableGemfireRepositories\npublic class App {\n\n public static void main(String[] args) throws IOException {\n SpringApplication.run(App.class, args);\n }\n\n @Bean\n ApplicationRunner run(PersonRepo personRepository) {\n\n return args -> {\n\n PersonEntity abk = new PersonEntity(\"Abhishek Kothari\", 26);\n PersonEntity sumit = new PersonEntity(\"Sumit Punjabi\", 25);\n PersonEntity john = new PersonEntity(\"John Doe\", 34);\n\n System.out.println(\"Entering into accessing data from Pivotal GemFire framework\");\n\n asList(abk, sumit, john).forEach(person -> System.out.println(\"\\t\" + person));\n\n System.out.println(\"Saving Alice, Bob and Carol to Pivotal GemFire...\");\n\n personRepository.save(abk);\n personRepository.save(sumit);\n personRepository.save(john);\n\n System.out.println(\"Lookup each person by name...\");\n\n asList(abk.getName(), sumit.getName(), john.getName())\n .forEach(name -> System.out.println(\"\\t\" + personRepository.findByName(name)));\n\n System.out.println(\"Query adults (over 18):\");\n\n stream(personRepository.findByAgeGreaterThan(18).spliterator(), false)\n .forEach(person -> System.out.println(\"\\t\" + person));\n\n System.out.println(\"Query teens (less than 30):\");\n\n stream(personRepository.findByAgeLessThan(30).spliterator(), false)\n .forEach(person -> System.out.println(\"\\t\" + person));\n\n System.out.println(\"Query teens (between 12 and 30):\");\n\n stream(personRepository.findByAgeGreaterThanAndAgeLessThan(12, 30).spliterator(), false)\n .forEach(person -> System.out.println(\"\\t\" + person));\n };\n }\n}\n<\/pre>\n@SpringBootApplication<\/code>: This annotation specifies that the class is to be treated as the starting point of Spring boot application.
\n@ClientCacheApplication<\/code>: This annotation specifies that the application should use client side caching of data powered by Spring Data in the backend.
\n@EnableDefinedRegions<\/code>: The annotation is used to specify the entities that need to be used and made available. This annotation basically does the task of exposing the methods of the corresponding entities for the class.
\n@EnableGemfireRepositories<\/code>: This is the most important annotation. The purpose of the annotation is clear from the name itself. This annotation is mandatory to enable the gemfire repository on the start of Spring application. This annotation will force scan the current package for finding the entities extending one of the Spring Data repository classes like the PersonEntity<\/code>.<\/p>\nbasePackageClasses = TheRepository.class<\/code>
\nIt is to be noted here that in the region definition we have specified a local region. This is important for Pivotal Gemfire. In order to store data, Pivotal requires atleast 1 or more regions.
\n[ulp id=’c4qGwqz2zZ7CesZd’]
\n <\/p>\n7. Cache Configuration<\/h2>\n
@ClientCacheApplication<\/code>: Caches data client side in local storage
\n@PeerCacheApplication<\/code>: Caches data between peers
\n@CacheServerApplication<\/code>: Caches data on the server side<\/p>\nLOCAL<\/code> for the same reason.<\/p>\nPeople<\/code>. This was specified using the annotation Region<\/code>. This annotation was used from the Spring Data framework. This region is later mapped in the application layer using the code snippet ClientRegionFactoryBean<String, PersonEntity><\/code> for bean definition. Thus, we injected a bean definition as well as defined the instance in the region People which would have otherwise been impossible without Spring Data framework.<\/p>\n8. Storing of objects<\/h2>\n
9. Executing the code and building a jar<\/h2>\n
\n . ____ _ __ _ _\n \/\\\\ \/ ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\\n( ( )\\___ | '_ | '_| | '_ \\\/ _` | \\ \\ \\ \\\n \\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )\n ' |____| .__|_| |_|_| |_\\__, | \/ \/ \/ \/\n =========|_|==============|___\/=\/_\/_\/_\/\n :: Spring Boot :: (v2.0.3.RELEASE)\n\n[info 2018\/08\/30 20:36:45.110 IST tid=0x1] Starting App on MacBook-Air.local with PID 96473 (\/Users\/abhishekkothari\/Documents\/workspace-sts-3.9.5.RELEASE\/pivotal_tutorial\/target\/classes started by abhishekkothari in \/Users\/abhishekkothari\/Documents\/workspace-sts-3.9.5.RELEASE\/pivotal_tutorial)\n\n[info 2018\/08\/30 20:36:45.118 IST tid=0x1] No active profile set, falling back to default profiles: default\n\n[info 2018\/08\/30 20:36:45.219 IST tid=0x1] Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@6c1a5b54: startup date [Thu Aug 30 20:36:45 IST 2018]; root of context hierarchy\n\nSLF4J: Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".\nSLF4J: Defaulting to no-operation (NOP) logger implementation\nSLF4J: See http:\/\/www.slf4j.org\/codes.html#StaticLoggerBinder for further details.\nEntering into accessing data from Pivotal GemFire framework\n\tAbhishek Kothari is 26 years old\n\tSumit Punjabi is 25 years old\n\tJohn Doe is 34 years old\nSaving Alice, Bob and Carol to Pivotal GemFire...\nLookup each person by name...\n\tAbhishek Kothari is 26 years old\n\tSumit Punjabi is 25 years old\n\tJohn Doe is 34 years old\nQuery adults (over 18):\n\tSumit Punjabi is 25 years old\n\tJohn Doe is 34 years old\n\tAbhishek Kothari is 26 years old\nQuery teens (less than 30):\n\tSumit Punjabi is 25 years old\n\tAbhishek Kothari is 26 years old\nQuery teens (between 12 and 30):\n\tSumit Punjabi is 25 years old\n\tAbhishek Kothari is 26 years old\n<\/pre>\n
.\/mvnw spring-boot:run\n<\/pre>\n
10. Download the Project<\/h2>\n