Chapter 12. New Features and Enhancements in 7.3.0

This release adds several enhancements to Data Grid integration with the Spring Framework:

public void put(Object key, Object value, long lifespan, TimeUnit unit) {
      this.cacheImplementation.put(key, value != null ? value : NullValue.NULL, lifespan, unit);
}

public void put(Object key, Object value, long lifespan, TimeUnit unit) {
      this.cacheImplementation.put(key, value != null ? value : NullValue.NULL, lifespan, unit);
}

public void put(final Object key, final Object value) {
      this.nativeCache.put(key, value);
      try {
         if (writeTimeout > 0)
            this.nativeCache.putAsync(key, value != null ? value : NullValue.NULL).get(writeTimeout, TimeUnit.MILLISECONDS);
         else
            this.nativeCache.put(key, value != null ? value : NullValue.NULL);
      } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         throw new CacheException(e);
      } catch (ExecutionException | TimeoutException e) {
         throw new CacheException(e);
      }
   }

public void put(final Object key, final Object value) {
      this.nativeCache.put(key, value);
      try {
         if (writeTimeout > 0)
            this.nativeCache.putAsync(key, value != null ? value : NullValue.NULL).get(writeTimeout, TimeUnit.MILLISECONDS);
         else
            this.nativeCache.put(key, value != null ? value : NullValue.NULL);
      } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         throw new CacheException(e);
      } catch (ExecutionException | TimeoutException e) {
         throw new CacheException(e);
      }
   }

Data Grid seamlessly integrates with Hibernate as an (L2) cache provider to improve the performance of your application’s persistence layer.

Hibernate provides Object/Relational Mapping (ORM) capabilities for Java and is a fully compliant JPA (Java Persistence API) persistence provider. Hibernate uses first-level (L1) caching where objects in the cache are bound to sessions. As an L2 cache provider, Data Grid acts as a global cache for objects across all sessions.

You can configure Data Grid as the L2 cache in:

For complete information on enabling L2 cache, along with information for different deployment scenarios, see JPA/Hibernate L2 Cache in the documentation.

This release provides support for using Red Hat SSO to secure access to Data Grid in Library (embedded) Mode.

See the secure-embedded-cache quickstart for more information and to deploy and run a sample application that demonstrates integration with Red Hat SSO.

Java, C++, and C# Hot Rod clients can now start and participate in transactions.

The Java Hot Rod client supports both FULL_XA and NON_XA transaction modes. C++ and C# Hot Rod clients provide support for NON_XA transaction modes only.

For more information, see Hot Rod Transactions.

The ServerStatistics interface now exposes statistics for the Java Hot Rod client through JMX.

You must enable JMX statistics in your Hot Rod client implementation, as in the following example:

ConfigurationBuilder builder = new ConfigurationBuilder();
builder.addServer()
        	.host("127.0.0.1")
        	.port(11222)
        	.statistics()
        	.enable()
        	.jmxEnable();

ConfigurationBuilder builder = new ConfigurationBuilder();
builder.addServer()
        	.host("127.0.0.1")
        	.port(11222)
        	.statistics()
        	.enable()
        	.jmxEnable();

For more information, see ServerStatistics in the Javadocs.

This release improves configuration for the Java Hot Rod client with the hotrod-client.properties file. You can configure near cache settings, cross-site (xsite) properties, settings to control authentication and encryption, and more.

For more information, see the Hot Rod client configuration summary.

The Hot Rod Java client is built with the Netty framework, providing improved performance and support for executing operations concurrently over the same connection.

In previous releases, application-executed operations were done synchronously or delegated to dedicated thread pools.

As of this release, operations are executed asynchronously and the response is processed in the HotRod-client-async-pool thread pool. Operations can be multiplexed over the same connection, which requires fewer connections.

For more information, see the Javadocs:

The node.js Hot Rod client adds support for native JSON objects as keys and values. In previous releases, the client supported String keys and values only.

To use native JSON objects, you must configure the client as follows:

var infinispan = require('infinispan');
var connected = infinispan.client(
    {port: 11222, host: '127.0.0.1'}
    , {
        dataFormat : {
            keyType: 'application/json',
            valueType: 'application/json'
        }
    }
);
connected.then(function (client) {
  var clientPut = client.put({k: 'key'}, {v: 'value'});
  var clientGet = clientPut.then(
      function() { return client.get({k: 'key'}); });
  var showGet = clientGet.then(
      function(value) { console.log("get({k: 'key'})=" + JSON.stringify(value)); });
  return showGet.finally(
      function() { return client.disconnect(); });
}).catch(function(error) {
  console.log("Got error: " + error.message);
});

var infinispan = require('infinispan');
var connected = infinispan.client(
    {port: 11222, host: '127.0.0.1'}
    , {
        dataFormat : {
            keyType: 'application/json',
            valueType: 'application/json'
        }
    }
);
connected.then(function (client) {
  var clientPut = client.put({k: 'key'}, {v: 'value'});
  var clientGet = clientPut.then(
      function() { return client.get({k: 'key'}); });
  var showGet = clientGet.then(
      function(value) { console.log("get({k: 'key'})=" + JSON.stringify(value)); });
  return showGet.finally(
      function() { return client.disconnect(); });
}).catch(function(error) {
  console.log("Got error: " + error.message);
});

You can configure data types for keys and values separately. For example, you can configure keys as String and values as JSON.

This release includes the getCacheNames() method that returns a collection of caches names that have been defined declaratively or programmatically as well as the caches that have been created at runtime through RemoteCacheManager.

The Hot Rod protocol also now includes a @@cache@names admin task that returns cache names as a JSON array of strings, for example, ["cache1", "cache2"].

For more information, see:

Data Grid now lets you configure write-behind cache stores so that, in the event a write-behind operation fails, additional operations on the cache are not allowed. Additionally, modifications that failed to write to the cache store are queued until the underlying cache store becomes available.

You can configure fault tolerance with the connection-attempts, connection-interval, and fail-silently declaratively.

To configure fault tolerance programmatically, use the following:

For more information, see the documentation:

You can now use wildcards in configuration template names so that Data Grid applies the template to any matching caches.

For more information, see Cache configuration wildcards.

You can now create immutable configuration storage providers to prevent the creation or removal of caches.

Use the immutable-configuration-storage parameter when configuring Data Grid declaratively or programmatically use the IMMUTABLE configuration store in the global state.