Table Of Contents<\/h3>\n\n- 1. Introduction<\/a><\/dt>\n
- \n
\n- 1.1 Spring Framework<\/a><\/dt>\n
- 1.2 Spring Cache<\/a><\/dt>\n
- 1.3 EhCache<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 2. Spring Cache Tutorial<\/a><\/dt>\n
- \n
\n- 2.1 Tools used<\/a><\/dt>\n
- 2.2 Project Structure<\/a><\/dt>\n
- 2.3 Project Creation<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 3. Application Building<\/a><\/dt>\n
- \n
\n- 3.1 Maven Dependencies<\/a><\/dt>\n
- 3.2 Java Class Creation<\/a><\/dt>\n
- 3.3 EhCache Configuration File<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 4. Run the Application<\/a><\/dt>\n
- 5. Project Demo<\/a><\/dt>\n
- 6. Conclusion<\/a><\/dt>\n
- 7. Download the Eclipse Project<\/a><\/dt>\n<\/dl>\n<\/div>\n
<\/a>1. Introduction<\/h2>\n<\/a>1.1 Spring Framework<\/h3>\n\n- Spring is an open-source framework created to address the complexity of an enterprise application development<\/li>\n
- One of the chief advantages of the Spring framework is its layered architecture, which allows developers to be selective about which of its components they can use while providing a cohesive framework for
J2EE<\/code> application development<\/li>\n- Spring framework provides support and integration to various technologies for e.g.:\n
\n- Support for Transaction Management<\/li>\n
- Support for interaction with the different databases<\/li>\n
- Integration with the Object Relationship frameworks for e.g. Hibernate, iBatis etc<\/li>\n
- Support for Dependency Injection<\/span> which means all the required dependencies will be resolved with the help of containers<\/li>\n
- Support for
REST<\/code> style web-services<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/a>1.2 Spring Cache<\/h3>\n\n- Spring framework provides support for transparently adding the caching to an application at the startup time, thereby increasing the application performance<\/li>\n
- This is an abstract framework where spring only provides the layer where other third-party caching implementations can be easily plugged for storing the data<\/li>\n
- In short, the cache storage is not implemented by the spring framework whereas enabling and caching is supported by the spring out of the box<\/li>\n
- Caching is supported for the methods and it works well if the method returns the same result for the given input for the multiple invocations<\/li>\n<\/ul>\n
1.2.1 Cache Providers in Spring Framework<\/h4>\n
Developers know that the actual implementation of the cache is by the third party library and spring framework provides only the abstraction layer for enabling that specific cache implementation to store the data. So there are the following caches that are supported by the spring framework:<\/p>\n
\n- JDK (i.e.
java.util.concurrent.ConcurrentMap<\/code>) Based Caches<\/li>\n- EhCache 2.x<\/li>\n
- Gemfire Cache<\/li>\n
- Guava Cache<\/li>\n
- JCache (JSR 107)<\/li>\n
- Infinispan<\/li>\n
- Couchbase<\/li>\n<\/ul>\n
1.2.2 Cache Annotations in Spring Framework<\/h4>\n
The following below is the list of Spring Caching Annotations<\/span>. These are specific to the spring framework and apart from that, there are few more annotations<\/a> that are implemented as part of the JCache (JSR \u2013 107). Let us take a closer look at each annotation:<\/p>\n\n- Enable Cache<\/strong>: This tag enables the caching because caching in spring is not enabled by default<\/em>. The caching feature can be declaratively enabled by simply adding the
@EnableCaching<\/code> annotation to any of the configuration classes. Here is an example:\n@EnableCaching\npublic class SpringCacheImplementation {\n\tpublic static void main(String[] args) {\n\t\t\tapplicationObj.run(SpringCacheImplementation.class, args);\n\t}\n}\n<\/pre>\nIn an XML<\/code>, developers can also enable the caching by using the below tag:<\/p>\n<cache:annotation-driven \/>\n<\/pre>\n<\/li>\n
- Cache Configurations<\/strong>: This tag configures the cache manager where the backing data is to be stored and retrieved for the quick response<\/li>\n
- Caching Declarations<\/strong>: This tag Identifies the methods that have to be cached and defines their caching policy<\/li>\n<\/ul>\n
After enabling the cache<\/span> developers can use the below list of declarative annotations:<\/p>\n\n- Cacheable<\/strong>: The
@Cacheable<\/code> annotation is one of the most important and common annotation for caching the requests. If developers annotate a method with @Cacheable<\/code> annotation and multiple requests are received by the application, then this annotation will not execute the method multiple times, instead, it will send the result from the cached storage. Here is an example:\n@Cacheable(value=\"cities\")\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n- CachePut<\/strong>: The
@CachePut<\/code> annotation helps for updating the cache with the latest execution without stopping the method execution. The primary difference between the @Cacheable<\/code> and the @CachePut<\/code> annotation is that @Cacheable<\/code> will skip running the method whereas @CachePut<\/code> will actually run the method and then put its results in the cache. Here is an example:\n@CachePut(value=\"cities\")\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\nDo note, it is not<\/strong> recommended to use both the annotations for the same method as it will result in the unexpected results<\/p>\n<\/li>\n- CacheEvict<\/strong>: The
@CacheEvict<\/code> annotation is used for removing a single cache or clearing the entire cache from the cache storage so that fresh values can be loaded into the cache again. If developers set the allEntries=true<\/code>, then the entire cache will be cleared. Here is an example:\n@CacheEvict(value=\"cities\", allEntries=true)\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n- Caching<\/strong>: What if developers want to use the multiple annotations of the same type for caching a method? The
@Caching<\/code> annotation is used for grouping the multiple annotations of the same type together when one annotation is not sufficient for the specifying the suitable condition. For e.g., Developers can put the multiple @CacheEvict<\/code> or @CachePut<\/code> annotations inside the @Caching<\/code> annotation to narrow down the conditions as they need. Here is an example:\n@Caching(evict = {@CacheEvict(\"cities\"), @CacheEvict(value=\"city-list\", key=\"#city.name\") })\npublic List findAllCity(){\n\treturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n<\/ul>\n<\/a>1.3 EhCache<\/h3>\nEhcache<\/strong> is one of the most popular caching implementation available as the open source caching implementation. This is located under the package: org.springframework.cache.ehcache<\/code>. To use it, developers simply need to declare the appropriate CacheManager<\/code>. Here is an example:<\/p>\n<bean id=\"cacheManager\" class=\"org.springframework.cache.ehcache.EhcacheCacheManager\" p:cache-manager=\"ehcache\"\/>\n\n<!-- Ehcache Library Setup -->\n<bean id=\"ehcache\" class=\"org.springframework.cache.ehcache.EhCacheManagerFactoryBean\" p:config-location=\"ehcache.xml\"\/>\n<\/pre>\nDo note, ehcache.xml<\/code> should be present in the classpath or any other location where the spring application can load it without any issues. This configuration file provides details about the cache size, file name etc. <\/div> <\/div><\/p>\nNow, open up the Eclipse IDE and let\u2019s see how to implement the cache in the spring framework!<\/p>\n
<\/a>2. Spring Caching Tutorial<\/h2>\n<\/a>2.1 Tools Used<\/h3>\nWe are using Eclipse Kepler SR2, JDK 8, MySQL and Maven. Having said that, we have tested the code against JDK 1.7 and it works well.<\/p>\n
<\/a>2.2 Project Structure<\/h3>\nFirstly, let\u2019s review the final project structure, in case you are confused about where you should create the corresponding files or folder later!<\/p>\n
\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-project-guide-1.jpg\")
<\/a>Fig. 1: Spring Cache Application Structure<\/figcaption><\/figure>\n<\/div>\n<\/a>2.3 Project Creation<\/h3>\nThis section will demonstrate on how to create a Java-based Maven project with Eclipse. In Eclipse IDE, go to File -> New -> Maven Project<\/code>.<\/p>\n\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-1.jpg\")
<\/a>Fig. 2: Create Maven Project<\/figcaption><\/figure>\n<\/div>\nIn the New Maven Project window, it will ask you to select the project location. By default, ‘Use default workspace location’ will be selected. Select the ‘Create a simple project (skip archetype selection)’ checkbox and just click on next button to proceed.<\/p>\n
\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-2.jpg\")
<\/a>Fig. 3: Project Details<\/figcaption><\/figure>\n<\/div>\nIt will ask you to \u2018Enter the group and the artifact id for the project’. We will input the details as shown in the below image. The version number will be by default: 0.0.1-SNAPSHOT<\/code>.<\/p>\n\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-3.jpg\")
<\/a>Fig. 4: Archetype Parameters<\/figcaption><\/figure>\n<\/div>\nClick on Finish and the creation of a maven project is completed. If you observe, it has downloaded the maven dependencies and a pom.xml<\/code> file will be created. It will have the following code:<\/p>\npom.xml<\/em><\/span><\/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\t<modelVersion>4.0.0<\/modelVersion>\n\t<groupId>SpringCache<\/groupId>\n\t<artifactId>SpringCache<\/artifactId>\n\t<version>0.0.1-SNAPSHOT<\/version>\n\t<packaging>jar<\/packaging>\n<\/project>\n<\/pre>\nWe can start adding the dependencies that developers want like Spring Core, Spring Context, EhCache etc. Let\u2019s start building the application!<\/p>\n
<\/a>3. Application Building<\/h2>\nBelow are the steps involved in developing this application.<\/p>\n
<\/a>3.1 Maven Dependencies<\/h3>\nHere we will specify the required dependencies and the rest dependencies will be automatically resolved by Maven. The updated<\/strong> file will have the following code:<\/p>\npom.xml<\/em><\/span><\/p>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n\txsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n\t<modelVersion>4.0.0<\/modelVersion>\n\t<groupId>SpringCache<\/groupId>\n\t<artifactId>SpringCache<\/artifactId>\n\t<version>0.0.1-SNAPSHOT<\/version>\n\t<packaging>jar<\/packaging>\n\t<dependencies>\n\t\t<!-- Spring Framework Dependencies -->\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-core<\/artifactId>\n\t\t\t<version>4.3.0.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-context<\/artifactId>\n\t\t\t<version>4.3.0.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<!-- Spring Framework Dependency For EhCache & Others -->\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-context-support<\/artifactId>\n\t\t\t<version>4.1.4.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<!-- EhCache Dependency -->\n\t\t<dependency>\n\t\t\t<groupId>net.sf.ehcache<\/groupId>\n\t\t\t<artifactId>ehcache<\/artifactId>\n\t\t\t<version>2.10.2.2.21<\/version>\n\t\t<\/dependency>\n\t<\/dependencies>\n\t<build>\n\t\t<finalName>${project.artifactId}<\/finalName>\n\t<\/build>\n<\/project><\/pre>\n<\/a>3.2 Java Class Creation<\/h3>\nLet\u2019s create the required Java files. Right-click on src\/main\/java<\/code> folder, New -> Package<\/code>.<\/p>\n\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-4.jpg\")
<\/a>Fig. 5: Java Package Creation<\/figcaption><\/figure>\n<\/div>\nA new pop window will open where we will enter the package name as: com.jcg.spring.cache<\/code>.<\/p>\n\n![\"spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-5.jpg\")
<\/a>Fig. 6: Java Package Name (com.jcg.spring.cache)<\/figcaption><\/figure>\n<\/div>\nOnce the package is created in the application, we will need to create the Model, the Cache Configuration, and the Implementation classes. Right-click on the newly created package: New -> Class<\/code>.<\/p>\n\n![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-6.jpg\")
<\/a>Fig. 7: Java Class Creation<\/figcaption><\/figure>\n<\/div>\nA new pop window will open and enter the file name as: Employee<\/code>. The model class will be created inside the package: com.jcg.spring.cache<\/code>.[ulp id=’7POIYxRf1FUtPpmL’]<\/p>\n\n![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-7.jpg\")
<\/a>Fig. 8: Java Class (Employee.java)<\/figcaption><\/figure>\n<\/div>\nRepeat the step (i.e. Fig. 7) and enter the filename as: SpringConfig<\/code>. The cache configuration class enables the caching with the help of @EnableCaching<\/code> tag and declares the EhCacheCacheManager<\/code>.<\/p>\n\n![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-8.jpg\")
<\/a>Fig. 9: Java Class (SpringConfig.java)<\/figcaption><\/figure>\n<\/div>\nAgain, repeat the step (i.e. Fig. 7) and enter the filename as: AppMain<\/code>. The implementation class will get the bean from the cache configuration and calls the getEmployeeName()<\/code> method of the Employee<\/code> bean class.<\/p>\n\n![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-project-guide-9.jpg\")
<\/a>Fig. 10: Java Class (AppMain.java)<\/figcaption><\/figure>\n<\/div>\n3.2.1 Implementation of Model Class<\/h4>\n
In this example, we have a cache named as employeeCache<\/code> in ehcache.xml<\/code> and this same name is provided in the @Cacheable<\/code> annotation. Spring framework will hit the getEmployeeName()<\/code> method for the first time and the result of this method will be cached and for the same argument value, the framework will not hit the method every time. Once the cache is expired, then the spring framework will hit the method again for the same argument value.<\/p>\nAdd the following code to it:<\/p>\n
Employee.java<\/em><\/span><\/p>\npackage com.jcg.spring.cache;\n\nimport org.springframework.cache.annotation.Cacheable;\n\npublic class Employee {\n\n\tprivate String emp_name = \"\";\n\n\t\/\/This 'employeeCache' Is Declared In The 'ehcache.xml'\n\t@Cacheable(value=\"employeeCache\") \n\tpublic String getEmployeeName(int emp_id) {\t\t\n\t\tif(emp_id == 101) {\n\t\t\temp_name = \"Java Code Geek\";\t\t\t\n\t\t} else {\n\t\t\temp_name = \"Daniel Atlas\";\n\t\t}\n\t\treturn emp_name;\n\t}\n}<\/pre>\n3.2.2 Implementation of Cache Configuration Class<\/h4>\n
This class will be annotated with @EnableCaching<\/code> annotation and developers need to create the bean for EhCacheManagerFactoryBean<\/code> and EhCacheCacheManager<\/code> class. Add the following code to it:<\/p>\nSpringConfig.java<\/em><\/span><\/p>\npackage com.jcg.spring.cache;\n\nimport org.springframework.beans.factory.annotation.Configurable;\nimport org.springframework.cache.CacheManager;\nimport org.springframework.cache.annotation.EnableCaching;\nimport org.springframework.cache.ehcache.EhCacheCacheManager;\nimport org.springframework.cache.ehcache.EhCacheManagerFactoryBean;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.core.io.ClassPathResource;\n\n@Configurable @EnableCaching\npublic class SpringConfig {\n\n\tprivate static EhCacheManagerFactoryBean cacheManagerfactoryBean;\n\n\t@Bean\n\tpublic Employee getEmployee(){\n\t\treturn new Employee();\t\n\t}\n\n\t@Bean\n\tpublic CacheManager getEhCacheManager() {\n\t\treturn new EhCacheCacheManager(getEhCacheFactory().getObject());\n\t}\n\n\t@Bean\n\tpublic EhCacheManagerFactoryBean getEhCacheFactory() {\n\t\tcacheManagerfactoryBean = new EhCacheManagerFactoryBean();\n\t\tcacheManagerfactoryBean.setShared(true);\n\t\tcacheManagerfactoryBean.setConfigLocation(new ClassPathResource(\"ehcache.xml\"));\t\t\n\t\treturn cacheManagerfactoryBean;\n\t}\n}<\/pre>\n3.2.3 Implementation of Utility Class<\/h4>\n
This class will get the bean from the cache configuration and calls the getEmployeeName()<\/code> method of the Employee<\/code> bean class to display the values. Add the following code to it:<\/p>\nAppMain.java<\/em><\/span><\/p>\npackage com.jcg.spring.cache;\n\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class AppMain {\n\n\tstatic int emp_id;\n\n\tpublic static void main(String[] args) {\n\n\t\tAnnotationConfigApplicationContext contextObj = new AnnotationConfigApplicationContext ();\n\t\tcontextObj.register(SpringConfig.class);\n\t\tcontextObj.refresh();\n\n\t\tEmployee empObj = (Employee) contextObj.getBean(Employee.class);\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The First Time.\n\t\temp_id = 101;\n\t\tSystem.out.println(\"Fetching Employee Name With Id?= \" + emp_id);\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The Second Time & This Time Method Will Not Execute As Result Will Be Fetched From Cache.\n\t\tSystem.out.println(\"\\n!--- Again Fetching Employee Name With Id?= \" + emp_id + \". Result Will Be Fetched From The Cache ---!\");\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The Third Time With A Different Value.\n\t\temp_id = 102;\n\t\tSystem.out.println(\"\\nFetching Employee Name With Id?= \" + emp_id);\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Closing The Spring Context.\n\t\tcontextObj.close();\n\t}\n}<\/pre>\n<\/a>3.3 EhCache Configuration File<\/h3>\nTo configure the ehcache, developers need to implement a configuration file i.e. ehcache.xml<\/code> which provides the cache implementations to the spring application. Right-click on SpringCache\/src\/main\/resources<\/code> folder, New -> Other<\/code>.<\/p>\n\n![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-xml-guide-1.jpg\")
<\/a>Fig. 11: XML File Creation<\/figcaption><\/figure>\n<\/div>\nA new pop window will open and select the wizard as an XML<\/code> file.<\/p>\n
- \n
- 1.1 Spring Framework<\/a><\/dt>\n
- 1.2 Spring Cache<\/a><\/dt>\n
- 1.3 EhCache<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 2. Spring Cache Tutorial<\/a><\/dt>\n
- \n
- \n
- 2.1 Tools used<\/a><\/dt>\n
- 2.2 Project Structure<\/a><\/dt>\n
- 2.3 Project Creation<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 3. Application Building<\/a><\/dt>\n
- \n
- \n
- 3.1 Maven Dependencies<\/a><\/dt>\n
- 3.2 Java Class Creation<\/a><\/dt>\n
- 3.3 EhCache Configuration File<\/a><\/dt>\n<\/dl>\n<\/dd>\n
- 4. Run the Application<\/a><\/dt>\n
- 5. Project Demo<\/a><\/dt>\n
- 6. Conclusion<\/a><\/dt>\n
- 7. Download the Eclipse Project<\/a><\/dt>\n<\/dl>\n<\/div>\n
<\/a>1. Introduction<\/h2>\n
<\/a>1.1 Spring Framework<\/h3>\n
- \n
- Spring is an open-source framework created to address the complexity of an enterprise application development<\/li>\n
- One of the chief advantages of the Spring framework is its layered architecture, which allows developers to be selective about which of its components they can use while providing a cohesive framework for
J2EE<\/code> application development<\/li>\n- Spring framework provides support and integration to various technologies for e.g.:\n
- \n
- Support for Transaction Management<\/li>\n
- Support for interaction with the different databases<\/li>\n
- Integration with the Object Relationship frameworks for e.g. Hibernate, iBatis etc<\/li>\n
- Support for Dependency Injection<\/span> which means all the required dependencies will be resolved with the help of containers<\/li>\n
- Support for
REST<\/code> style web-services<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/a>1.2 Spring Cache<\/h3>\n
- \n
- Spring framework provides support for transparently adding the caching to an application at the startup time, thereby increasing the application performance<\/li>\n
- This is an abstract framework where spring only provides the layer where other third-party caching implementations can be easily plugged for storing the data<\/li>\n
- In short, the cache storage is not implemented by the spring framework whereas enabling and caching is supported by the spring out of the box<\/li>\n
- Caching is supported for the methods and it works well if the method returns the same result for the given input for the multiple invocations<\/li>\n<\/ul>\n
1.2.1 Cache Providers in Spring Framework<\/h4>\n
Developers know that the actual implementation of the cache is by the third party library and spring framework provides only the abstraction layer for enabling that specific cache implementation to store the data. So there are the following caches that are supported by the spring framework:<\/p>\n
- \n
- JDK (i.e.
java.util.concurrent.ConcurrentMap<\/code>) Based Caches<\/li>\n- EhCache 2.x<\/li>\n
- Gemfire Cache<\/li>\n
- Guava Cache<\/li>\n
- JCache (JSR 107)<\/li>\n
- Infinispan<\/li>\n
- Couchbase<\/li>\n<\/ul>\n
1.2.2 Cache Annotations in Spring Framework<\/h4>\n
The following below is the list of Spring Caching Annotations<\/span>. These are specific to the spring framework and apart from that, there are few more annotations<\/a> that are implemented as part of the JCache (JSR \u2013 107). Let us take a closer look at each annotation:<\/p>\n
- \n
- Enable Cache<\/strong>: This tag enables the caching because caching in spring is not enabled by default<\/em>. The caching feature can be declaratively enabled by simply adding the
@EnableCaching<\/code> annotation to any of the configuration classes. Here is an example:\n@EnableCaching\npublic class SpringCacheImplementation {\n\tpublic static void main(String[] args) {\n\t\t\tapplicationObj.run(SpringCacheImplementation.class, args);\n\t}\n}\n<\/pre>\nIn an
XML<\/code>, developers can also enable the caching by using the below tag:<\/p>\n<cache:annotation-driven \/>\n<\/pre>\n<\/li>\n
- Cache Configurations<\/strong>: This tag configures the cache manager where the backing data is to be stored and retrieved for the quick response<\/li>\n
- Caching Declarations<\/strong>: This tag Identifies the methods that have to be cached and defines their caching policy<\/li>\n<\/ul>\n
After enabling the cache<\/span> developers can use the below list of declarative annotations:<\/p>\n
- \n
- Cacheable<\/strong>: The
@Cacheable<\/code> annotation is one of the most important and common annotation for caching the requests. If developers annotate a method with@Cacheable<\/code> annotation and multiple requests are received by the application, then this annotation will not execute the method multiple times, instead, it will send the result from the cached storage. Here is an example:\n@Cacheable(value=\"cities\")\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n- CachePut<\/strong>: The
@CachePut<\/code> annotation helps for updating the cache with the latest execution without stopping the method execution. The primary difference between the@Cacheable<\/code> and the@CachePut<\/code> annotation is that@Cacheable<\/code> will skip running the method whereas@CachePut<\/code> will actually run the method and then put its results in the cache. Here is an example:\n@CachePut(value=\"cities\")\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\nDo note, it is not<\/strong> recommended to use both the annotations for the same method as it will result in the unexpected results<\/p>\n<\/li>\n
- CacheEvict<\/strong>: The
@CacheEvict<\/code> annotation is used for removing a single cache or clearing the entire cache from the cache storage so that fresh values can be loaded into the cache again. If developers set theallEntries=true<\/code>, then the entire cache will be cleared. Here is an example:\n@CacheEvict(value=\"cities\", allEntries=true)\npublic List findAllCity(){\nreturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n- Caching<\/strong>: What if developers want to use the multiple annotations of the same type for caching a method? The
@Caching<\/code> annotation is used for grouping the multiple annotations of the same type together when one annotation is not sufficient for the specifying the suitable condition. For e.g., Developers can put the multiple@CacheEvict<\/code> or@CachePut<\/code> annotations inside the@Caching<\/code> annotation to narrow down the conditions as they need. Here is an example:\n@Caching(evict = {@CacheEvict(\"cities\"), @CacheEvict(value=\"city-list\", key=\"#city.name\") })\npublic List findAllCity(){\n\treturn (List) cityRepository.findAll();\n}\n<\/pre>\n<\/li>\n<\/ul>\n<\/a>1.3 EhCache<\/h3>\n
Ehcache<\/strong> is one of the most popular caching implementation available as the open source caching implementation. This is located under the package:
org.springframework.cache.ehcache<\/code>. To use it, developers simply need to declare the appropriateCacheManager<\/code>. Here is an example:<\/p>\n<bean id=\"cacheManager\" class=\"org.springframework.cache.ehcache.EhcacheCacheManager\" p:cache-manager=\"ehcache\"\/>\n\n<!-- Ehcache Library Setup -->\n<bean id=\"ehcache\" class=\"org.springframework.cache.ehcache.EhCacheManagerFactoryBean\" p:config-location=\"ehcache.xml\"\/>\n<\/pre>\n
Do note,
ehcache.xml<\/code> should be present in the classpath or any other location where the spring application can load it without any issues. This configuration file provides details about the cache size, file name etc.<\/div> <\/div><\/p>\nNow, open up the Eclipse IDE and let\u2019s see how to implement the cache in the spring framework!<\/p>\n
<\/a>2. Spring Caching Tutorial<\/h2>\n
<\/a>2.1 Tools Used<\/h3>\n
We are using Eclipse Kepler SR2, JDK 8, MySQL and Maven. Having said that, we have tested the code against JDK 1.7 and it works well.<\/p>\n
<\/a>2.2 Project Structure<\/h3>\n
Firstly, let\u2019s review the final project structure, in case you are confused about where you should create the corresponding files or folder later!<\/p>\n
\n<\/a>Fig. 1: Spring Cache Application Structure<\/figcaption><\/figure>\n<\/div>\n <\/a>2.3 Project Creation<\/h3>\n
This section will demonstrate on how to create a Java-based Maven project with Eclipse. In Eclipse IDE, go to
File -> New -> Maven Project<\/code>.<\/p>\n\n<\/a>Fig. 2: Create Maven Project<\/figcaption><\/figure>\n<\/div>\n In the New Maven Project window, it will ask you to select the project location. By default, ‘Use default workspace location’ will be selected. Select the ‘Create a simple project (skip archetype selection)’ checkbox and just click on next button to proceed.<\/p>\n
\n<\/a>Fig. 3: Project Details<\/figcaption><\/figure>\n<\/div>\n It will ask you to \u2018Enter the group and the artifact id for the project’. We will input the details as shown in the below image. The version number will be by default:
0.0.1-SNAPSHOT<\/code>.<\/p>\n\n<\/a>Fig. 4: Archetype Parameters<\/figcaption><\/figure>\n<\/div>\n Click on Finish and the creation of a maven project is completed. If you observe, it has downloaded the maven dependencies and a
pom.xml<\/code> file will be created. It will have the following code:<\/p>\npom.xml<\/em><\/span><\/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\t<modelVersion>4.0.0<\/modelVersion>\n\t<groupId>SpringCache<\/groupId>\n\t<artifactId>SpringCache<\/artifactId>\n\t<version>0.0.1-SNAPSHOT<\/version>\n\t<packaging>jar<\/packaging>\n<\/project>\n<\/pre>\n
We can start adding the dependencies that developers want like Spring Core, Spring Context, EhCache etc. Let\u2019s start building the application!<\/p>\n
<\/a>3. Application Building<\/h2>\n
Below are the steps involved in developing this application.<\/p>\n
<\/a>3.1 Maven Dependencies<\/h3>\n
Here we will specify the required dependencies and the rest dependencies will be automatically resolved by Maven. The updated<\/strong> file will have the following code:<\/p>\n
pom.xml<\/em><\/span><\/p>\n
<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n\txsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n\t<modelVersion>4.0.0<\/modelVersion>\n\t<groupId>SpringCache<\/groupId>\n\t<artifactId>SpringCache<\/artifactId>\n\t<version>0.0.1-SNAPSHOT<\/version>\n\t<packaging>jar<\/packaging>\n\t<dependencies>\n\t\t<!-- Spring Framework Dependencies -->\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-core<\/artifactId>\n\t\t\t<version>4.3.0.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-context<\/artifactId>\n\t\t\t<version>4.3.0.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<!-- Spring Framework Dependency For EhCache & Others -->\n\t\t<dependency>\n\t\t\t<groupId>org.springframework<\/groupId>\n\t\t\t<artifactId>spring-context-support<\/artifactId>\n\t\t\t<version>4.1.4.RELEASE<\/version>\n\t\t<\/dependency>\n\t\t<!-- EhCache Dependency -->\n\t\t<dependency>\n\t\t\t<groupId>net.sf.ehcache<\/groupId>\n\t\t\t<artifactId>ehcache<\/artifactId>\n\t\t\t<version>2.10.2.2.21<\/version>\n\t\t<\/dependency>\n\t<\/dependencies>\n\t<build>\n\t\t<finalName>${project.artifactId}<\/finalName>\n\t<\/build>\n<\/project><\/pre>\n<\/a>3.2 Java Class Creation<\/h3>\n
Let\u2019s create the required Java files. Right-click on
src\/main\/java<\/code> folder,New -> Package<\/code>.<\/p>\n\n<\/a>Fig. 5: Java Package Creation<\/figcaption><\/figure>\n<\/div>\n A new pop window will open where we will enter the package name as:
com.jcg.spring.cache<\/code>.<\/p>\n\n<\/a>Fig. 6: Java Package Name (com.jcg.spring.cache)<\/figcaption><\/figure>\n<\/div>\n Once the package is created in the application, we will need to create the Model, the Cache Configuration, and the Implementation classes. Right-click on the newly created package:
New -> Class<\/code>.<\/p>\n\n<\/a>Fig. 7: Java Class Creation<\/figcaption><\/figure>\n<\/div>\n A new pop window will open and enter the file name as:
Employee<\/code>. The model class will be created inside the package:com.jcg.spring.cache<\/code>.[ulp id=’7POIYxRf1FUtPpmL’]<\/p>\n\n<\/a>Fig. 8: Java Class (Employee.java)<\/figcaption><\/figure>\n<\/div>\n Repeat the step (i.e. Fig. 7) and enter the filename as:
SpringConfig<\/code>. The cache configuration class enables the caching with the help of@EnableCaching<\/code> tag and declares theEhCacheCacheManager<\/code>.<\/p>\n\n<\/a>Fig. 9: Java Class (SpringConfig.java)<\/figcaption><\/figure>\n<\/div>\n Again, repeat the step (i.e. Fig. 7) and enter the filename as:
AppMain<\/code>. The implementation class will get the bean from the cache configuration and calls thegetEmployeeName()<\/code> method of theEmployee<\/code> bean class.<\/p>\n\n<\/a>Fig. 10: Java Class (AppMain.java)<\/figcaption><\/figure>\n<\/div>\n 3.2.1 Implementation of Model Class<\/h4>\n
In this example, we have a cache named as
employeeCache<\/code> inehcache.xml<\/code> and this same name is provided in the@Cacheable<\/code> annotation. Spring framework will hit thegetEmployeeName()<\/code> method for the first time and the result of this method will be cached and for the same argument value, the framework will not hit the method every time. Once the cache is expired, then the spring framework will hit the method again for the same argument value.<\/p>\nAdd the following code to it:<\/p>\n
Employee.java<\/em><\/span><\/p>\n
package com.jcg.spring.cache;\n\nimport org.springframework.cache.annotation.Cacheable;\n\npublic class Employee {\n\n\tprivate String emp_name = \"\";\n\n\t\/\/This 'employeeCache' Is Declared In The 'ehcache.xml'\n\t@Cacheable(value=\"employeeCache\") \n\tpublic String getEmployeeName(int emp_id) {\t\t\n\t\tif(emp_id == 101) {\n\t\t\temp_name = \"Java Code Geek\";\t\t\t\n\t\t} else {\n\t\t\temp_name = \"Daniel Atlas\";\n\t\t}\n\t\treturn emp_name;\n\t}\n}<\/pre>\n3.2.2 Implementation of Cache Configuration Class<\/h4>\n
This class will be annotated with
@EnableCaching<\/code> annotation and developers need to create the bean forEhCacheManagerFactoryBean<\/code> andEhCacheCacheManager<\/code> class. Add the following code to it:<\/p>\nSpringConfig.java<\/em><\/span><\/p>\n
package com.jcg.spring.cache;\n\nimport org.springframework.beans.factory.annotation.Configurable;\nimport org.springframework.cache.CacheManager;\nimport org.springframework.cache.annotation.EnableCaching;\nimport org.springframework.cache.ehcache.EhCacheCacheManager;\nimport org.springframework.cache.ehcache.EhCacheManagerFactoryBean;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.core.io.ClassPathResource;\n\n@Configurable @EnableCaching\npublic class SpringConfig {\n\n\tprivate static EhCacheManagerFactoryBean cacheManagerfactoryBean;\n\n\t@Bean\n\tpublic Employee getEmployee(){\n\t\treturn new Employee();\t\n\t}\n\n\t@Bean\n\tpublic CacheManager getEhCacheManager() {\n\t\treturn new EhCacheCacheManager(getEhCacheFactory().getObject());\n\t}\n\n\t@Bean\n\tpublic EhCacheManagerFactoryBean getEhCacheFactory() {\n\t\tcacheManagerfactoryBean = new EhCacheManagerFactoryBean();\n\t\tcacheManagerfactoryBean.setShared(true);\n\t\tcacheManagerfactoryBean.setConfigLocation(new ClassPathResource(\"ehcache.xml\"));\t\t\n\t\treturn cacheManagerfactoryBean;\n\t}\n}<\/pre>\n3.2.3 Implementation of Utility Class<\/h4>\n
This class will get the bean from the cache configuration and calls the
getEmployeeName()<\/code> method of theEmployee<\/code> bean class to display the values. Add the following code to it:<\/p>\nAppMain.java<\/em><\/span><\/p>\n
package com.jcg.spring.cache;\n\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class AppMain {\n\n\tstatic int emp_id;\n\n\tpublic static void main(String[] args) {\n\n\t\tAnnotationConfigApplicationContext contextObj = new AnnotationConfigApplicationContext ();\n\t\tcontextObj.register(SpringConfig.class);\n\t\tcontextObj.refresh();\n\n\t\tEmployee empObj = (Employee) contextObj.getBean(Employee.class);\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The First Time.\n\t\temp_id = 101;\n\t\tSystem.out.println(\"Fetching Employee Name With Id?= \" + emp_id);\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The Second Time & This Time Method Will Not Execute As Result Will Be Fetched From Cache.\n\t\tSystem.out.println(\"\\n!--- Again Fetching Employee Name With Id?= \" + emp_id + \". Result Will Be Fetched From The Cache ---!\");\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Calling 'getEmployeeName' Method For The Third Time With A Different Value.\n\t\temp_id = 102;\n\t\tSystem.out.println(\"\\nFetching Employee Name With Id?= \" + emp_id);\n\t\tSystem.out.println(\"Name?= \" + empObj.getEmployeeName(emp_id));\n\n\t\t\/\/ Closing The Spring Context.\n\t\tcontextObj.close();\n\t}\n}<\/pre>\n<\/a>3.3 EhCache Configuration File<\/h3>\n
To configure the ehcache, developers need to implement a configuration file i.e.
ehcache.xml<\/code> which provides the cache implementations to the spring application. Right-click onSpringCache\/src\/main\/resources<\/code> folder,New -> Other<\/code>.<\/p>\n\n<\/a>Fig. 11: XML File Creation<\/figcaption><\/figure>\n<\/div>\n A new pop window will open and select the wizard as an
XML<\/code> file.<\/p>\n - CachePut<\/strong>: The
- Cache Configurations<\/strong>: This tag configures the cache manager where the backing data is to be stored and retrieved for the quick response<\/li>\n
- JDK (i.e.
- Support for
- Spring framework provides support and integration to various technologies for e.g.:\n
- 3.2 Java Class Creation<\/a><\/dt>\n
- 2.2 Project Structure<\/a><\/dt>\n
- 1.2 Spring Cache<\/a><\/dt>\n
![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-xml-guide-2.jpg\")
<\/a>![\"Fig.](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/09\/spring-cache-example-xml-guide-3.jpg\")
<\/a>