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 16:29:14 UTC
[GitHub] [ignite] ololo3000 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
ololo3000 commented on a change in pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#discussion_r735141282
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
I have simplified this sentence.
I mean that each row of the table matches version of extension with compatible versions of Ignite and Spring.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
Done.
##########
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:
I have simplified this sentence.
I mean that each row of the table matches version of extension with compatible versions of Ignite and Spring.
--
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