You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by na...@apache.org on 2021/11/10 12:54:08 UTC
[ignite] 01/02: IGNITE-14399 Document thin client support for
Ignite Spring Cache integration. (#9509)
This is an automated email from the ASF dual-hosted git repository.
namelchev pushed a commit to branch ignite-2.11
in repository https://gitbox.apache.org/repos/asf/ignite.git
commit 10d829b5c8163908abd9d5663f44791b1cc19e60
Author: Mikhail Petrov <32...@users.noreply.github.com>
AuthorDate: Mon Oct 25 15:50:33 2021 +0300
IGNITE-14399 Document thin client support for Ignite Spring Cache integration. (#9509)
(cherry picked from commit a567679bcd2e188c30ca1d9f378e55955a115e10)
---
.../spring/spring-caching.adoc | 382 +++++++++++++++++++--
.../spring/spring-tx.adoc | 90 +++--
2 files changed, 413 insertions(+), 59 deletions(-)
diff --git a/docs/_docs/extensions-and-integrations/spring/spring-caching.adoc b/docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
index bc57399..437c467 100644
--- a/docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
+++ b/docs/_docs/extensions-and-integrations/spring/spring-caching.adoc
@@ -16,25 +16,133 @@
== 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 above integration is achieved by providing implementations of the
+`CacheManager` Spring interface. There are two such implementations: `SpringCacheManager` and
+`IgniteClientSpringCacheManager`, which use either Apache Ignite node or Apache Ignite thin client to connect to the
+Apache Ignite cluster and perform data caching.
-Only two simple steps are required to plug in an Ignite cache into your Spring-based application:
+== Maven Configuration
-* 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.
+If you use 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 2.10.0 and earlier the `ignite-spring-cache-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Cache integration classes. If you use 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 version of Spring dependencies, that may conflict with version 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 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 need, respectively.
+
+The table below shows available versions of the Apache Ignite Spring Cache extension and compatible versions
+of the Apache Ignite and Spring.
+
+[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
+
+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:
+
+* 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 required.
* Configure `SpringCacheManager` as the cache manager in the Spring application context.
The embedded node can be started by `SpringCacheManager` itself. In this case you will need to provide a path to either
-the Ignite configuration XML file or `IgniteConfiguration` bean via `configurationPath` or `configuration`
+the Ignite configuration XML file or `IgniteConfiguration` instance via `configurationPath` or `configuration`
properties respectively (see examples below). Note that setting both is illegal and results in `IllegalArgumentException`.
+[discrete]
+=== Specifying Apache Ignite Node Configuration
+
[tabs]
--
-tab:configuration path[]
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public SpringCacheManager cacheManager() {
+ SpringCacheManager mgr = new SpringCacheManager();
+
+ mgr.setConfiguration(new IgniteConfiguration()
+ .setIgniteInstanceName("<name of the Ignite node instance>"));
+ // Other required configuration parameters.
+
+ return mgr;
+ }
+}
+----
+tab:XML[]
[source,xml]
----
<beans xmlns="http://www.springframework.org/schema/beans"
@@ -45,16 +153,43 @@ tab:configuration path[]
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/cache
http://www.springframework.org/schema/cache/spring-cache.xsd">
- <!-- Provide configuration file path. -->
+ <!-- Provide configuration bean. -->
<bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
- <property name="configurationPath" value="examples/config/spring-cache.xml"/>
+ <property name="configuration">
+ <bean class="org.apache.ignite.configuration.IgniteConfiguration">
+ ...
+ </bean>
+ </property>
</bean>
<!-- Enable annotation-driven caching. -->
<cache:annotation-driven/>
</beans>
----
-tab:configuration bean[]
+--
+
+[discrete]
+=== Specifying Path to Apache Ignite XML Node Configuration File
+
+[tabs]
+--
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public SpringCacheManager cacheManager() {
+ SpringCacheManager mgr = new SpringCacheManager();
+
+ mgr.setConfigurationPath("<path to an Apache Ignite configuration XML file (path can be absolute or relative to `IGNITE_HOME`)");
+
+ return mgr;
+ }
+}
+----
+tab:XML[]
[source,xml]
----
<beans xmlns="http://www.springframework.org/schema/beans"
@@ -65,30 +200,44 @@ tab:configuration bean[]
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/cache
http://www.springframework.org/schema/cache/spring-cache.xsd">
- <-- Provide configuration bean. -->
+ <!-- Provide configuration file path. -->
<bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
- <property name="configuration">
- <bean class="org.apache.ignite.configuration.IgniteConfiguration">
- ...
- </bean>
- </property>
+ <property name="configurationPath" value="<path to an Apache Ignite configuration XML file (path can be absolute or relative to `IGNITE_HOME`)"/>
</bean>
- <-- Enable annotation-driven caching. -->
+ <!-- Enable annotation-driven caching. -->
<cache:annotation-driven/>
</beans>
----
-
--
+[discrete]
+=== Specifying Name of the Manually Started Apache Ignite Node Instance
+
It's possible that you already have an Ignite node running when the cache manager is initialized (e.g., it was started using
-`ServletContextListenerStartup`). In this case you should simply provide the grid name via `gridName` property.
+`ServletContextListenerStartup`). In this case you should simply provide the grid name via `igniteInstanceName` property.
Note that if you don't set the grid name as well, the cache manager will try to use the default Ignite instance
(the one with the `null` name). Here is an example:
[tabs]
--
-tab:Using an already started Ignite instance[]
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public SpringCacheManager cacheManager() {
+ SpringCacheManager mgr = new SpringCacheManager();
+
+ mgr.setIgniteInstanceName("<name of the Apache Ignite node instance>");
+
+ return mgr;
+ }
+}
+----
+tab:XML[]
[source,xml]
----
<beans xmlns="http://www.springframework.org/schema/beans"
@@ -101,7 +250,7 @@ tab:Using an already started Ignite instance[]
http://www.springframework.org/schema/cache/spring-cache.xsd">
<!-- Provide grid name. -->
<bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
- <property name="gridName" value="myGrid"/>
+ <property name="igniteInstanceName" value="<name of the Apache Ignite node instance>"/>
</bean>
<!-- Enable annotation-driven caching. -->
@@ -117,18 +266,36 @@ 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.
-If otherwise not specified, a new cache will be created will all defaults. To customize it, you can provide a configuration
+If otherwise not specified, a new cache will be created with default configuration. To customize it, you can provide a configuration
template via `dynamicCacheConfiguration` property. For example, if you want to use `REPLICATED` caches instead of
`PARTITIONED`, you should configure `SpringCacheManager` like this:
[tabs]
--
-tab:Dynamic cache configuration[]
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public SpringCacheManager cacheManager() {
+ SpringCacheManager mgr = new SpringCacheManager();
+ ...
+
+ mgr.setDynamicCacheConfiguration(new CacheConfiguration<>("<cache name>")
+ .setCacheMode(CacheMode.REPLICATED));
+
+ return mgr;
+ }
+}
+----
+tab:XML[]
[source,xml]
----
<bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
@@ -136,6 +303,7 @@ tab:Dynamic cache configuration[]
<property name="dynamicCacheConfiguration">
<bean class="org.apache.ignite.configuration.CacheConfiguration">
+ <property name="name" value="<cache name>"/>
<property name="cacheMode" value="REPLICATED"/>
</bean>
</property>
@@ -148,7 +316,24 @@ You can also utilize near caches on client side. To achieve this, simply provide
[tabs]
--
-tab:Dynamic near cache configuration[]
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public SpringCacheManager cacheManager() {
+ SpringCacheManager mgr = new SpringCacheManager();
+ ...
+
+ mgr.setDynamicNearCacheConfiguration(new NearCacheConfiguration<>().setNearStartSize(1000));
+
+ return mgr;
+ }
+}
+----
+tab:XML[]
[source,xml]
----
<bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
@@ -163,6 +348,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 used by `IgniteClientSpringCacheManager` to access
+the cluster.
+There are several approaches to do this:
+
+[NOTE]
+====
+It is incorrect to mix multiple approaches - this results in the `IllegalArgumentException` exception during the manager startup.
+====
+
+[discrete]
+=== Specifying Instance of the Apache Ignite Thin Client
+
+[tabs]
+--
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public IgniteClient igniteClient() {
+ return Ignition.startClient(new ClientConfiguration().setAddresses("127.0.0.1:10800"));
+ }
+
+ @Bean
+ public IgniteClientSpringCacheManager cacheManager(IgniteClient cli) {
+ return new IgniteClientSpringCacheManager().setClientInstance(cli);
+ }
+}
+----
+tab:XML[]
+[source,xml]
+----
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:cache="http://www.springframework.org/schema/cache"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans.xsd
+ http://www.springframework.org/schema/cache
+ http://www.springframework.org/schema/cache/spring-cache.xsd">
+ <!--
+ Note that org.apache.ignite.IgniteClientSpringBean is available since Apache Ignite 2.11.0 version.
+ For Apache Ignite 2.10.0 and earlier `org.apache.ignite.client.IgniteClient` bean should be created
+ manually with concern of its connection to the Ignite cluster.
+ -->
+ <bean id="igniteClient" class="org.apache.ignite.IgniteClientSpringBean">
+ <property name="clientConfiguration">
+ <bean class="org.apache.ignite.configuration.ClientConfiguration">
+ <property name="addresses">
+ <list>
+ <value>127.0.0.1:10800</value>
+ </list>
+ </property>
+ </bean>
+ </property>
+ </bean>
+
+ <!-- Provide Apache Ignite thin client instance. -->
+ <bean id="cacheManager" class="org.apache.ignite.cache.spring.IgniteClientSpringCacheManager">
+ <property name="clientInstance" ref="igniteClient"/>
+ </bean>
+
+ <!-- Use annotation-driven cache configuration. -->
+ <cache:annotation-driven/>
+</beans>
+----
+--
+
+[discrete]
+=== Specifying Apache Ignite Thin Client Configuration
+
+In this case, Apache Ignite thin client instance is started automatically by the `IgniteClientSpringCacheManager` based
+on the provided configuration.
+
+[tabs]
+--
+tab:Java[]
+[source,java]
+----
+@Configuration
+@EnableCaching
+public class SpringApplicationConfiguration {
+ @Bean
+ public IgniteClientSpringCacheManager cacheManager() {
+ return new IgniteClientSpringCacheManager()
+ .setClientConfiguration(new ClientConfiguration()
+ .setAddresses("127.0.0.1:10800"));
+ }
+}
+----
+tab:XML[]
+[source,xml]
+----
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:cache="http://www.springframework.org/schema/cache"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans.xsd
+ http://www.springframework.org/schema/cache
+ http://www.springframework.org/schema/cache/spring-cache.xsd">
+ <!-- Provide configuration bean. -->
+ <bean id="cacheManager" class="org.apache.ignite.cache.spring.IgniteClientSpringCacheManager">
+ <property name="clientConfiguration">
+ <bean class="org.apache.ignite.configuration.ClientConfiguration">
+ <property name="addresses">
+ <list>
+ <value>127.0.0.1:10800</value>
+ </list>
+ </property>
+ </bean>
+ </property>
+ </bean>
+
+ <!-- Use annotation-driven cache configuration. -->
+ <cache:annotation-driven/>
+</beans>
+----
+--
+
+=== Dynamic Caches
+
+Dynamic Caches configuration for `IgniteClientSpringCacheManager` is performed the same way as for
+link:extensions-and-integrations/spring/spring-caching#dynamic-caches[SpringCacheManager]
+that uses Apache Ignite node instance to access the cluster.
+
== Example
Once you have added `SpringCacheManager` to your Spring application context, you can enable caching for any Java method by simply attaching an annotation to it.
diff --git a/docs/_docs/extensions-and-integrations/spring/spring-tx.adoc b/docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
index c33a33f..af9ec08 100644
--- a/docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
+++ b/docs/_docs/extensions-and-integrations/spring/spring-tx.adoc
@@ -22,10 +22,10 @@ transaction life-cycle.
Apache Ignite provides the `ignite-spring-tx-ext` extension that allows to manage
https://ignite.apache.org/docs/latest/key-value-api/transactions#performing-transactions[Apache Ignite Transactions, window="_blank"]
-through the Spring Transactions abstraction. The mentioned integration is achieved by providing implementations of the
+through the Spring Transactions abstraction. The mentioned above integration is achieved by providing implementations of the
`TransactionManager` Spring Transactions interface. There are two such implementations: `SpringTransactionManager` and
-`IgniteClientSpringTransactionManager`, which use Apache Ignite node or Apache Ignite thin client to connect to the
-Apache Ignite cluster and manage the Apache Ignite transactions, respectively.
+`IgniteClientSpringTransactionManager`, which use either Apache Ignite node or Apache Ignite thin client to connect to the
+Apache Ignite cluster and manage the Apache Ignite transactions.
To enable declarative transaction management in your Spring application, create and configure
`SpringTransactionManager` or `IgniteClientSpringTransactionManager` bean in the Spring application context. The choice
@@ -33,13 +33,13 @@ of implementation depends on your preferable way to access the Apache Ignite clu
== Maven Configuration
-If you are using Maven to manage dependencies in your project, you can add Spring Transactions extension dependencies to
+If you use Maven to manage dependencies in your project, you can add Spring Transactions extension dependencies to
the application's `pom.xml` file like this:
[NOTE]
====
-For Apache Ignite versions earlier than `2.11.0`, the `ignite-spring-tx-ext` dependency must be added to
-classpath before `ignite-spring`, due to duplication of Spring Transactions integration classes. If you are using Maven
+For Apache Ignite 2.10.0 and earlier the `ignite-spring-tx-ext` dependency must be added to
+classpath before `ignite-spring`, due to duplication of Spring Transactions integration classes. If you use Maven
to manage dependencies, place `ignite-spring-tx-ext` before the `ignite-spring` dependency in the
application's `pom.xml` file.
====
@@ -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 version of Spring dependencies, that may conflict with version 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 and earlier the following list of Spring dependencies must be excluded to
+ avoid possible Spring versions conflicts:
+ - 'spring-core'
+ - 'spring-aop'
+ - 'spring-context'
+ - 'spring-expressions'
+ - 'spring-beans'
+ - 'spring-jdbc'
+ - 'spring-tx'
+ -->
<dependency>
<groupId>org.apache.ignite</groupId>
- <artifactId>ignite-core</artifactId>
+ <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>
<dependency>
@@ -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
-Apache Ignite dependency you are interested in, respectively.
+`${ignite.version}` with an actual version of Apache Ignite Spring Transactions extension, Spring, and
+Apache Ignite dependency you need, 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.
+The table below shows available versions of the Apache Ignite Spring Transactions extension and compatible versions
+of the Apache Ignite and Spring.
-[cols="4,5", opts="header"]
+[cols="4,5,5", opts="header"]
|===
-|Apache Ignite Spring Transactions extension version | Compatible Apache Ignite versions
-| 1.0.0 | All versions since 2.8.0
+|Apache Ignite Spring Transactions 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 Transaction Manager Configuration
@@ -96,8 +122,8 @@ and link:extensions-and-integrations/spring/spring-tx#transaction-concurrency-mo
=== Cluster Connection Configuration
-Cluster connection configuration defines Apache Ignite node that `SpringTransactionManager` uses to access the cluster.
-To do this, you can use the following approaches.
+Cluster connection configuration defines Apache Ignite node used by `SpringTransactionManager` to access the cluster.
+There are several approaches to do this:
[NOTE]
====
@@ -136,14 +162,14 @@ tab:XML[]
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
- <-- Provide Apache Ignite instance name. -->
+ <!-- Provide Apache Ignite instance name. -->
<bean id="transactionManager" class="org.apache.ignite.transactions.spring.SpringTransactionManager">
<property
name="igniteInstanceName"
value="<name of the Apache Ignite node instance>"/>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----
@@ -184,7 +210,7 @@ tab:XML[]
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
- <-- Provide configuration bean. -->
+ <!-- Provide configuration bean. -->
<bean id="transactionManager" class="org.apache.ignite.transactions.spring.SpringTransactionManager">
<property name="configuration">
<bean id="gridCfg" class="org.apache.ignite.configuration.IgniteConfiguration">
@@ -193,7 +219,7 @@ tab:XML[]
</property>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----
@@ -231,14 +257,14 @@ tab:XML[]
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
- <-- Provide configuration file path. -->
+ <!-- Provide configuration file path. -->
<bean id="transactionManager" class="org.apache.ignite.transactions.spring.SpringTransactionManager">
<property
name="configurationPath"
value="<path to an Apache Ignite configuration XML file (path can be absolute or relative to `IGNITE_HOME`)"/>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----
@@ -293,13 +319,13 @@ tab:XML[]
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
- <-- Provide Apache Ignite instance name. -->
+ <!-- Provide Apache Ignite instance name. -->
<bean id="transactionManager" class="org.apache.ignite.transactions.spring.SpringTransactionManager">
<!-- Here is appropriate connection configuration. -->
<property name="transactionConcurrency" value="OPTIMISTIC"/>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----
@@ -360,7 +386,7 @@ tab:XML[]
<property name="transactionConcurrency" value="PESSIMISTIC"/>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----
@@ -386,8 +412,8 @@ This chapter shows how to set up `IgniteClientSpringTransactionManager` that rel
to the cluster and manage transactions.
=== Cluster Connection Configuration
-Cluster connection configuration defines Apache Ignite thin client instance that `IgniteClientSpringTransactionManager`
-uses to access the cluster.
+Cluster connection configuration defines Apache Ignite thin client instance used by `IgniteClientSpringTransactionManager`
+to access the cluster.
[tabs]
--
@@ -399,7 +425,7 @@ tab:Java[]
public static class SpringApplicationConfiguration {
@Bean
public IgniteClient igniteClient() {
- return Ignition.startClient(new ClientConfiguration().setAddresses("127.0.0.1:10800));
+ return Ignition.startClient(new ClientConfiguration().setAddresses("127.0.0.1:10800"));
}
@Bean
@@ -423,7 +449,7 @@ tab:XML[]
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--
Note that org.apache.ignite.IgniteClientSpringBean is available since Apache Ignite 2.11.0 version.
- For Apache Ignite versions earlier than 2.11.0 org.apache.ignite.client.IgniteClient bean should be created
+ For Apache Ignite 2.10.0 and earlier `org.apache.ignite.client.IgniteClient` bean should be created
manually with concern of its connection to the Ignite cluster.
-->
<bean id="igniteClient" class="org.apache.ignite.IgniteClientSpringBean">
@@ -438,12 +464,12 @@ tab:XML[]
</property>
</bean>
- <-- Provide Apache Ignite client instance. -->
+ <!-- Provide Apache Ignite client instance. -->
<bean id="transactionManager" class="org.apache.ignite.transactions.spring.IgniteClientSpringTransactionManager">
<property name="clientInstance" ref="igniteClientBean"/>
</bean>
- <-- Use annotation-driven transaction configuration. -->
+ <!-- Use annotation-driven transaction configuration. -->
<tx:annotation-driven/>
</beans>
----