You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@ignite.apache.org by GitBox <gi...@apache.org> on 2021/10/24 15:07:16 UTC
[GitHub] [ignite] Silberfuchs1 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Silberfuchs1 commented on a change in pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#discussion_r735127114
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
Review comment:
which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
cluster and perform data caching, respectively. --> ...which use either Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite cluster and perform data caching.
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -117,7 +265,7 @@ Keep in mind that the node started inside your application is an entry point to
You can start as many remote standalone nodes as you need and all these nodes will participate in caching the data.
====
-== Dynamic Caches
+=== Dynamic Caches
While you can have all required caches predefined in Ignite configuration, it's not required. If Spring wants to use a
cache that doesn't exist, the `SpringCacheManager` will automatically create it.
Review comment:
Line 273: ...a new cache will be created will all defaults --> ...with all defaults...?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring version conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring</artifactId>
+ <version>${ignite.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ </exclusion>
+ </exclusions>
+</dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+</dependency>
+----
+--
+
+Replace `${ignite-spring-cache-ext.version}`, `${spring.version}`, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Cache extension, Spring, and
+Apache Ignite dependency you are interested in, respectively.
+
+The table below shows available versions of the Apache Ignite Spring Cache extension and corresponding versions
+of the Apache Ignite and Spring each one is compatible with.
+
+[cols="4,5,5", opts="header"]
+|===
+|Apache Ignite Spring Cache extension version | Apache Ignite versions | Spring versions
+| 1.0.0 | All versions since 2.11.0 | All versions since 4.3.0
+|===
+
+== Apache Ignite Node Cache Manager Configuration
+
+=== Cluster Connection Configuration
+
+Only two simple steps are required to plug in an Ignite cache into your Spring-based application using Ignite node to
Review comment:
using Ignite node --> that uses Ignite node
or
To plug in an Ignite cache into your Spring-based application that uses Ignite node to connect to Apache Ignite cluster you need to perform just two simple steps:
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -163,6 +347,149 @@ tab:Dynamic near cache configuration[]
----
--
+== Apache Ignite Thin Client Cache Manager Configuration
+This chapter shows how to set up `IgniteClientSpringCacheManager` that relies on Ignite thin client to connect
+to the Ignite cluster and perform caching.
+
+[IMPORTANT]
+====
+[discrete]
+`IgniteClientSpringCacheManager` does not support Spring Cache synchronous mode
+(https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cache/annotation/Cacheable.html#sync--[Cacheable#sync, window=_blank]).
+If this feature is crucial to your application, choose the
+link:extensions-and-integrations/spring/spring-caching#apache-ignite-node-cache-manager-configuration[SpringCacheManager]
+that uses an Ignite node to connect to Ignite cluster.
+====
+
+=== Cluster Connection Configuration
+Cluster connection configuration defines Apache Ignite thin client that `IgniteClientSpringCacheManager` uses to access
+the cluster.
+To do this, you can use the following approaches.
Review comment:
There are several approaches to do this:
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
Review comment:
If you are using --> If you use...
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
Review comment:
The mentioned integration is achieved by providing...
Mentioned where? Above mentioned, you mean?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring version conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring</artifactId>
+ <version>${ignite.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ </exclusion>
+ </exclusions>
+</dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+</dependency>
+----
+--
+
+Replace `${ignite-spring-cache-ext.version}`, `${spring.version}`, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Cache extension, Spring, and
+Apache Ignite dependency you are interested in, respectively.
+
+The table below shows available versions of the Apache Ignite Spring Cache extension and corresponding versions
+of the Apache Ignite and Spring each one is compatible with.
+
+[cols="4,5,5", opts="header"]
+|===
+|Apache Ignite Spring Cache extension version | Apache Ignite versions | Spring versions
+| 1.0.0 | All versions since 2.11.0 | All versions since 4.3.0
+|===
+
+== Apache Ignite Node Cache Manager Configuration
+
+=== Cluster Connection Configuration
+
+Only two simple steps are required to plug in an Ignite cache into your Spring-based application using Ignite node to
Review comment:
Only --> Just
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring version conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring</artifactId>
+ <version>${ignite.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ </exclusion>
+ </exclusions>
+</dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+</dependency>
+----
+--
+
+Replace `${ignite-spring-cache-ext.version}`, `${spring.version}`, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Cache extension, Spring, and
+Apache Ignite dependency you are interested in, respectively.
+
+The table below shows available versions of the Apache Ignite Spring Cache extension and corresponding versions
+of the Apache Ignite and Spring each one is compatible with.
+
+[cols="4,5,5", opts="header"]
+|===
+|Apache Ignite Spring Cache extension version | Apache Ignite versions | Spring versions
+| 1.0.0 | All versions since 2.11.0 | All versions since 4.3.0
+|===
+
+== Apache Ignite Node Cache Manager Configuration
+
+=== Cluster Connection Configuration
+
+Only two simple steps are required to plug in an Ignite cache into your Spring-based application using Ignite node to
+connect to Apache Ignite cluster:
* Start an Ignite node with proper configuration in embedded mode (i.e., in the same JVM where the application is running). It can already have predefined caches, but it's not required - caches will be created automatically on first access if needed.
Review comment:
needed --> required?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring version conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring</artifactId>
+ <version>${ignite.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ </exclusion>
+ </exclusions>
+</dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+</dependency>
+----
+--
+
+Replace `${ignite-spring-cache-ext.version}`, `${spring.version}`, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Cache extension, Spring, and
+Apache Ignite dependency you are interested in, respectively.
+
+The table below shows available versions of the Apache Ignite Spring Cache extension and corresponding versions
+of the Apache Ignite and Spring each one is compatible with.
Review comment:
each one, what do you mean?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
Review comment:
depends on Spring dependencies which version may conflict with versions --> depends on version of Spring dependencies, that may conflict with versions
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
Review comment:
For Apache Ignite 2.11.0 version and earlier --> For Apache Ignite 2.11.0 and earlier
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
+to manage dependencies, place `ignite-spring-cache-ext` before the `ignite-spring` dependency in the
+application's `pom.xml` file.
+====
+
+[tabs]
+--
+tab:pom.xml[]
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring-cache-ext</artifactId>
+ <version>${ignite-spring-cache-ext.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${ignite.version}</version>
+</dependency>
+
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
+ with version updated to match the Spring version used in your project.
+
+ For Apache Ignite 2.11.0 version and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring version conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
+<dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-spring</artifactId>
+ <version>${ignite.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ </exclusion>
+ </exclusions>
+</dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+</dependency>
+----
+--
+
+Replace `${ignite-spring-cache-ext.version}`, `${spring.version}`, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Cache extension, Spring, and
+Apache Ignite dependency you are interested in, respectively.
Review comment:
Apache Ignite dependency you are interested in, respectively. --> Apache Ignite dependency you need, respectively.
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -16,25 +16,132 @@
== Overview
-Ignite is shipped with `SpringCacheManager` - an implementation of http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache Abstraction, window=_blank].
-It provides an annotation-based way to enable caching for Java methods so that the result of a method execution is stored
-in an Ignite cache. Later, if the same method is called with the same set of parameter values, the result will be retrieved
-from the cache instead of actually executing the method.
+http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html[Spring Cache, window=_blank]
+abstraction provides an annotation-based way to enable caching for Java methods so that the result of a method execution
+is stored in an external cache storage. Later, if the same method is called with the same set of parameter values, the result
+will be retrieved from the cache instead of actually executing the method.
-== Enabling Ignite for Spring Caching
+Apache Ignite provides the `ignite-spring-cache-ext` extension that allows to use Apache Ignite Cache as an external
+storage for the Spring Cache abstraction. The mentioned integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the Apache Ignite
+cluster and perform data caching, respectively.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
+
+If you are using Maven to manage dependencies in your project, you can add Apache Ignite Spring Cache extension
+dependencies to the application's `pom.xml` file like this:
+
+[NOTE]
+====
+For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you are using Maven
Review comment:
If you use Maven
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -163,6 +347,149 @@ tab:Dynamic near cache configuration[]
----
--
+== Apache Ignite Thin Client Cache Manager Configuration
+This chapter shows how to set up `IgniteClientSpringCacheManager` that relies on Ignite thin client to connect
+to the Ignite cluster and perform caching.
+
+[IMPORTANT]
+====
+[discrete]
+`IgniteClientSpringCacheManager` does not support Spring Cache synchronous mode
+(https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cache/annotation/Cacheable.html#sync--[Cacheable#sync, window=_blank]).
+If this feature is crucial to your application, choose the
+link:extensions-and-integrations/spring/spring-caching#apache-ignite-node-cache-manager-configuration[SpringCacheManager]
+that uses an Ignite node to connect to Ignite cluster.
+====
+
+=== Cluster Connection Configuration
+Cluster connection configuration defines Apache Ignite thin client that `IgniteClientSpringCacheManager` uses to access
+the cluster.
+To do this, you can use the following approaches.
+
+[NOTE]
+====
+Mixing of multiple approaches is incorrect and results in the exception during the manager startup.
Review comment:
which exception, could you specify it?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
##########
@@ -57,14 +57,40 @@ tab:pom.xml[]
<dependency>
<groupId>org.apache.ignite</groupId>
- <artifactId>ignite-spring</artifactId>
+ <artifactId>ignite-core</artifactId>
<version>${ignite.version}</version>
</dependency>
+<!-- Note, that 'ignite-spring' depends on Spring dependencies which version may conflict with versions of Spring
+ dependencies used in your project. It is safe to exclude Spring dependencies from 'ignite-spring' and add them
Review comment:
depends on Spring dependencies which version may conflict with versions --> depends on version of Spring dependencies, that may conflict with versions
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -163,6 +347,149 @@ tab:Dynamic near cache configuration[]
----
--
+== Apache Ignite Thin Client Cache Manager Configuration
+This chapter shows how to set up `IgniteClientSpringCacheManager` that relies on Ignite thin client to connect
+to the Ignite cluster and perform caching.
+
+[IMPORTANT]
+====
+[discrete]
+`IgniteClientSpringCacheManager` does not support Spring Cache synchronous mode
+(https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cache/annotation/Cacheable.html#sync--[Cacheable#sync, window=_blank]).
+If this feature is crucial to your application, choose the
+link:extensions-and-integrations/spring/spring-caching#apache-ignite-node-cache-manager-configuration[SpringCacheManager]
+that uses an Ignite node to connect to Ignite cluster.
+====
+
+=== Cluster Connection Configuration
+Cluster connection configuration defines Apache Ignite thin client that `IgniteClientSpringCacheManager` uses to access
Review comment:
Cluster connection configuration defines Apache Ignite thin client that `IgniteClientSpringCacheManager` uses --> Cluster connection configuration defines Apache Ignite thin client used by `IgniteClientSpringCacheManager`
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
##########
@@ -76,16 +102,16 @@ tab:pom.xml[]
--
Replace `${ignite-spring-tx-ext.version}`, `${spring.version}`, and
-`${ignite.version}` with an actual version of Apache Ignite Spring Transactions extension, Spring Transactions, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Transactions extension, Spring, and
Apache Ignite dependency you are interested in, respectively.
The table below shows available versions of the Apache Ignite Spring Transactions extension and corresponding versions
-of the Apache Ignite each one is compatible with.
+of the Apache Ignite and Spring each one is compatible with.
Review comment:
each one, what do you mean?
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -163,6 +347,149 @@ tab:Dynamic near cache configuration[]
----
--
+== Apache Ignite Thin Client Cache Manager Configuration
+This chapter shows how to set up `IgniteClientSpringCacheManager` that relies on Ignite thin client to connect
+to the Ignite cluster and perform caching.
+
+[IMPORTANT]
+====
+[discrete]
+`IgniteClientSpringCacheManager` does not support Spring Cache synchronous mode
+(https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cache/annotation/Cacheable.html#sync--[Cacheable#sync, window=_blank]).
+If this feature is crucial to your application, choose the
+link:extensions-and-integrations/spring/spring-caching#apache-ignite-node-cache-manager-configuration[SpringCacheManager]
+that uses an Ignite node to connect to Ignite cluster.
+====
+
+=== Cluster Connection Configuration
+Cluster connection configuration defines Apache Ignite thin client that `IgniteClientSpringCacheManager` uses to access
+the cluster.
+To do this, you can use the following approaches.
+
+[NOTE]
+====
+Mixing of multiple approaches is incorrect and results in the exception during the manager startup.
Review comment:
It is incorrect to mix multiple approaches...
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
##########
@@ -117,7 +265,7 @@ Keep in mind that the node started inside your application is an entry point to
You can start as many remote standalone nodes as you need and all these nodes will participate in caching the data.
====
-== Dynamic Caches
+=== Dynamic Caches
While you can have all required caches predefined in Ignite configuration, it's not required. If Spring wants to use a
cache that doesn't exist, the `SpringCacheManager` will automatically create it.
Review comment:
or with default configuration
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
##########
@@ -76,16 +102,16 @@ tab:pom.xml[]
--
Replace `${ignite-spring-tx-ext.version}`, `${spring.version}`, and
-`${ignite.version}` with an actual version of Apache Ignite Spring Transactions extension, Spring Transactions, and
+`${ignite.version}` with an actual version of Apache Ignite Spring Transactions extension, Spring, and
Apache Ignite dependency you are interested in, respectively.
Review comment:
you are interested in --> you need
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org