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/21 13:31:21 UTC
[GitHub] [ignite] ololo3000 opened a new pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
ololo3000 opened a new pull request #9509:
URL: https://github.com/apache/ignite/pull/9509
Thank you for submitting the pull request to the Apache Ignite.
In order to streamline the review of the contribution
we ask you to ensure the following steps have been taken:
### The Contribution Checklist
- [ ] There is a single JIRA ticket related to the pull request.
- [ ] The web-link to the pull request is attached to the JIRA ticket.
- [ ] The JIRA ticket has the _Patch Available_ state.
- [ ] The pull request body describes changes that have been made.
The description explains _WHAT_ and _WHY_ was made instead of _HOW_.
- [ ] The pull request title is treated as the final commit message.
The following pattern must be used: `IGNITE-XXXX Change summary` where `XXXX` - number of JIRA issue.
- [ ] A reviewer has been mentioned through the JIRA comments
(see [the Maintainers list](https://cwiki.apache.org/confluence/display/IGNITE/How+to+Contribute#HowtoContribute-ReviewProcessandMaintainers))
- [ ] The pull request has been checked by the Teamcity Bot and
the `green visa` attached to the JIRA ticket (see [TC.Bot: Check PR](https://mtcga.gridgain.com/prs.html))
### Notes
- [How to Contribute](https://cwiki.apache.org/confluence/display/IGNITE/How+to+Contribute)
- [Coding abbreviation rules](https://cwiki.apache.org/confluence/display/IGNITE/Abbreviation+Rules)
- [Coding Guidelines](https://cwiki.apache.org/confluence/display/IGNITE/Coding+Guidelines)
- [Apache Ignite Teamcity Bot](https://cwiki.apache.org/confluence/display/IGNITE/Apache+Ignite+Teamcity+Bot)
If you need any help, please email dev@ignite.apache.org or ask anу advice on http://asf.slack.com _#ignite_ channel.
--
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
[GitHub] [ignite] ololo3000 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
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
[GitHub] [ignite] ololo3000 commented on pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
ololo3000 commented on pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#issuecomment-950354590
@Silberfuchs1 I have fixed the comments you mentioned. Could you take another look, please?
--
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
[GitHub] [ignite] NSAmelchev merged pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
NSAmelchev merged pull request #9509:
URL: https://github.com/apache/ignite/pull/9509
--
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
[GitHub] [ignite] ololo3000 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
ololo3000 commented on a change in pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#discussion_r735439035
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
##########
@@ -103,10 +103,10 @@ 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, and
-Apache Ignite dependency you are interested in, respectively.
+Apache Ignite dependency you are need, respectively.
Review comment:
Done.
--
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
[GitHub] [ignite] ololo3000 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
ololo3000 commented on a change in pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#discussion_r735141432
##########
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:
Done.
--
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
[GitHub] [ignite] Silberfuchs1 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
Silberfuchs1 commented on a change in pull request #9509:
URL: https://github.com/apache/ignite/pull/9509#discussion_r735434525
##########
File path: docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
##########
@@ -103,10 +103,10 @@ 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, and
-Apache Ignite dependency you are interested in, respectively.
+Apache Ignite dependency you are need, respectively.
Review comment:
Apache Ignite dependency you are need, respectively. --> Apache Ignite dependency you need, respectively.
--
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
[GitHub] [ignite] Silberfuchs1 commented on a change in pull request #9509: IGNITE-14399 Documents thin client support for Ignite Spring Cache integration.
Posted by GitBox <gi...@apache.org>.
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