ContextQMD
Back to Redisson

Integration With Spring

docs/integration-with-spring.md

latest33.7 KB
Original Source

Spring Boot Starter

Integrates Redisson with Spring Boot library. Depends on Spring Data Redis module.

Supports Spring Boot 1.3.x - 4.0.x

Usage

  1. Add redisson-spring-boot-starter dependency into your project:

    <div class="grid cards" markdown>

    • Redisson PRO

      Maven

      xml
      <dependency>
   <groupId>pro.redisson</groupId>
   <artifactId>redisson-spring-boot-starter</artifactId>
   <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      compile 'pro.redisson:redisson-spring-boot-starter:xVERSIONx'

      License key configuration

    • Community Edition

      Maven

      xml
      <dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson-spring-boot-starter</artifactId>
   <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      compile 'org.redisson:redisson-spring-boot-starter:xVERSIONx'
    </div>

    Redisson PRO vs. Community Edition ➜

    redisson-spring-boot-starter depends on redisson-spring-data module compatible with the latest version of Spring Boot. Downgrade redisson-spring-data module if necessary to support previous Spring Boot versions:

    |redisson-spring-data module name|Spring Boot version| |----------------------------|-------------------| |redisson-spring-data-16 |1.3.y | |redisson-spring-data-17 |1.4.y | |redisson-spring-data-18 |1.5.y | |redisson-spring-data-2x |2.x.y | |redisson-spring-data-3x |3.x.y | |redisson-spring-data-4x |4.x.y |

    For Gradle, you can downgrade to redisson-spring-data-27 this way:

    groovy
    implementation ("org.redisson:redisson-spring-boot-starter:xVERSIONx") {
   exclude group: 'org.redisson', module: 'redisson-spring-data-40'
}
implementation "org.redisson:redisson-spring-data-27:xVERSIONx"

    For Maven, you can downgrade to redisson-spring-data-27 this way:

    xml
    <dependencies>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>xVERSIONx</version>
        <exclusions>
            <exclusion>
                <groupId>org.redisson</groupId>
                <artifactId>redisson-spring-data-40</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-data-27</artifactId>
        <version>xVERSIONx</version>
    </dependency>
</dependencies>

  2. Add settings into application.settings file:

    Using common Spring Boot 3.x+ settings:

    yaml
    spring:
  data:
    redis:
      database: 
      host:
      port:
      password:
      ssl: 
      timeout:
      connectTimeout:
      clientName:
      cluster:
        nodes:
      sentinel:
        master:
        nodes:

    Using common Spring Boot up to 2.7.x settings:

    yaml
    spring:
  redis:
    database: 
    host:
    port:
    password:
    ssl: 
    timeout:
    connectTimeout:
    clientName:
    cluster:
      nodes:
    sentinel:
      master:
      nodes:

    Using Redisson config file: (single mode, replicated mode, cluster mode, sentinel mode, proxy mode, multi cluster mode, multi sentinel mode)

    yaml
    spring:
  redis:
   redisson: 
      file: classpath:redisson.yaml

    Using Redisson settings: (single mode, replicated mode, cluster mode, sentinel mode, proxy mode, multi cluster mode, multi sentinel mode)

    yaml
    spring:
  redis:
   redisson: 
      config: |
        clusterServersConfig:
          idleConnectionTimeout: 10000
          connectTimeout: 10000
          timeout: 3000
          retryAttempts: 3
          retryInterval: 1500
          failedSlaveReconnectionInterval: 3000
          failedSlaveCheckInterval: 60000
          password: null
          subscriptionsPerConnection: 5
          clientName: null
          loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
          subscriptionConnectionMinimumIdleSize: 1
          subscriptionConnectionPoolSize: 50
          slaveConnectionMinimumIdleSize: 24
          slaveConnectionPoolSize: 64
          masterConnectionMinimumIdleSize: 24
          masterConnectionPoolSize: 64
          readMode: "SLAVE"
          subscriptionMode: "SLAVE"
          nodeAddresses:
          - "redis://127.0.0.1:7004"
          - "redis://127.0.0.1:7001"
          - "redis://127.0.0.1:7000"
          scanInterval: 1000
          pingConnectionInterval: 0
          keepAlive: false
          tcpNoDelay: false
        threads: 16
        nettyThreads: 32
        codec: !<org.redisson.codec.Kryo5Codec> {}
        transportMode: "NIO"

  3. Available Spring Beans:

    • RedissonClient
    • RedissonRxClient
    • RedissonReactiveClient
    • RedisTemplate
    • ReactiveRedisTemplate
    • ReactiveRedisOperations

FAQ

Q: How to replace Netty version brought by Spring Boot?

You need to define netty version in properties section of your Maven project.

xml
    <properties>
          <netty.version>4.2.9.Final</netty.version> 
    </properties>

Q: How to disable Redisson?

You may not have Redis or Valkey in some environments. In this case Redisson can be disabled:

  • Using Annotations
    Spring Boot 4.0+
java
@SpringBootApplication
@EnableAutoConfiguration(exclude = {
    RedissonAutoConfigurationV4.class})
public class Application {
   
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Spring Boot 2.7+
```java
@SpringBootApplication
@EnableAutoConfiguration(exclude = {
    RedissonAutoConfigurationV2.class})
public class Application {
   
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Spring Boot up to 2.6

java
@SpringBootApplication
@EnableAutoConfiguration(exclude = {
    RedissonAutoConfiguration.class})
public class Application {
   
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
  • Using application.yml file
    Spring Boot 4.0+
yaml
spring:
  autoconfigure:
    exclude:
      - org.redisson.spring.starter.RedissonAutoConfigurationV4

Spring Boot 2.7+

yaml
spring:
  autoconfigure:
    exclude:
      - org.redisson.spring.starter.RedissonAutoConfigurationV2

Spring Boot up to 2.6

yaml
spring:
  autoconfigure:
    exclude:
      - org.redisson.spring.starter.RedissonAutoConfiguration

{% include 'cache/Spring-cache.md' %}

Spring Session

Redisson integrates with Spring Session by providing RedissonConnectionFactory, which implements Spring Data Redis's RedisConnectionFactory and ReactiveRedisConnectionFactory interfaces. This allows Spring Session to use Redisson as the underlying Valkey or Redis client for session storage and retrieval.

Dependencies

Ensure you have Spring Session library in your classpath, add it if necessary:

  1. Add Spring Session Data Redis library in classpath:
    Maven:

    xml
    <dependency>
  <groupId>org.springframework.session</groupId>
  <artifactId>spring-session-data-redis</artifactId>
  <version>4.0.0</version>
</dependency>

    Gradle:

    gradle
    compile 'org.springframework.session:spring-session-data-redis:4.0.0'

  2. Add Redisson Spring Data Redis library in classpath:

    <div class="grid cards" markdown>

    • Redisson PRO

      Maven

      xml
      <dependency>
   <groupId>pro.redisson</groupId>
   <artifactId>redisson-spring-data-40</artifactId>
   <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      compile 'pro.redisson:redisson-spring-data-40:xVERSIONx'

      License key configuration

    • Community Edition

      Maven

      xml
      <dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson-spring-data-40</artifactId>
   <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      compile 'org.redisson:redisson-spring-data-40:xVERSIONx'
    </div>

    Redisson PRO vs. Community Edition ➜

!!! note Valkey or Redis notify-keyspace-events setting should contain Exg letters to make Spring Session integration work.

Spring Http Session configuration

Add configuration class which extends AbstractHttpSessionApplicationInitializer class:

java
@Configuration
@EnableRedisHttpSession
public class SessionConfig extends AbstractHttpSessionApplicationInitializer { 

     @Bean
     public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
         return new RedissonConnectionFactory(redisson);
     }

     @Bean(destroyMethod = "shutdown")
     public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
        Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
     }

}

Spring WebFlux’s Session configuration

Add configuration class which extends AbstractReactiveWebInitializer class:

java
@Configuration
@EnableRedisWebSession
public class SessionConfig extends AbstractReactiveWebInitializer { 

     @Bean
     public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
         return new RedissonConnectionFactory(redisson);
     }

     @Bean(destroyMethod = "shutdown")
     public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
        Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
     }
}

Spring Boot configuration

  1. Add Redisson Spring Boot Starter module.

  2. Define the following properties in Spring Boot settings:

    spring.session.store-type=redis
spring.redis.redisson.file=classpath:redisson.yaml
spring.session.timeout.seconds=900

Local Cache

This feature is available only in Redisson PRO edition.

Redisson PRO provides local caching implementation for Spring Session.

local cache - a so-called near cache used to speed up read operations and avoid network roundtrips. It caches the whole Spring Session on the Redisson side and then uses the cached copy instead of loading it on each request.getSession() method access. The cached Session is updated/removed via pub/sub notifications.

To utilize this feature follow the steps below.

  1. Add Redisson Spring Session library in classpath.

    Maven

    xml
    <dependency>
   <groupId>pro.redisson</groupId>
   <!-- for Spring Session v2.x.x - v2.1.x -->
   <artifactId>redisson-spring-session-20</artifactId>
   <!-- for Spring Session v2.2.x - v2.7.x -->
   <artifactId>redisson-spring-session-22</artifactId>
   <!-- for Spring Session v3.x.x - v3.2.x -->
   <artifactId>redisson-spring-session-30</artifactId>
   <!-- for Spring Session v3.3.x - v4.x.x -->
   <artifactId>redisson-spring-session-33</artifactId>
   <version>xVERSIONx</version>
</dependency>

    Gradle

    groovy
    // for Spring Session v2.x.x - v2.1.x
compile 'pro.redisson:redisson-spring-session-20:xVERSIONx'
// for Spring Session v2.2.x - v2.7.x
compile 'pro.redisson:redisson-spring-session-22:xVERSIONx'
// for Spring Session v3.x.x - v3.2.x
compile 'pro.redisson:redisson-spring-session-30:xVERSIONx'
// for Spring Session v3.3.x - v4.x.x
compile 'pro.redisson:redisson-spring-session-33:xVERSIONx'

  2. Define configuration

    Use @EnableLocalCachedRedisSession annotation for Redis-backed HTTP session management with local caching.
    Use @EnableLocalCachedRedisWebSession annotation for Redis-backed Spring WebFlux’s WebSession management with local caching.

    java
    @Configuration
@EnableLocalCachedRedisSession 
// or 
@EnableLocalCachedRedisWebSession
public class SessionConfig extends AbstractHttpSessionApplicationInitializer { 

	@Bean
	public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
		return new RedissonConnectionFactory(redisson);
	}

	@Bean(destroyMethod = "shutdown")
	public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
	   Config config = Config.fromYAML(configFile.getInputStream());
	   return Redisson.create(config);
	}

}

    Configuration Settings

    The @EnableLocalCachedRedisSession annotation provides the following configuration settings:

    • maxInactiveIntervalInSeconds - Specifies the maximum time, in seconds, that a session can remain idle before it expires. Default is 1800.

    • namespace - Specifies a custom namespace for Redis keys to enable session isolation across multiple applications. The namespace changes the Redis key prefix from the default spring:session: to <redisNamespace>:. This allows multiple applications to share the same Redis instance while maintaining separate session storage. Default is "spring:session".

    • flushMode - Specifies when session changes are written to Redis. Default is FlushMode.ON_SAVE. Available modes:

      • FlushMode.ON_SAVE (default) - Session changes are written to Redis only when SessionRepository.save(Session) is explicitly invoked. In web applications, this occurs automatically just before the HTTP response is committed. This mode offers better performance by batching updates.
      • FlushMode.IMMEDIATE - Session changes are written to Redis immediately as they occur. Use this mode when session data must be immediately visible across multiple application instances, though it may impact performance.

    • saveMode - Save mode for the session. Default is SaveMode.ON_SET_ATTRIBUTE.

    • cleanupCron - Specifies the cron expression for scheduling the expired session cleanup task. Default is "0 * * * * *".

    • broadcastSessionUpdates - Specifies whether session updates should be broadcast to other application instances. When enabled, session attribute changes are published to Redis pub/sub channels, allowing other application instances to update their local caches. This ensures session consistency across a distributed deployment. Disable this feature if you have a single application instance or do not require real-time session synchronization across instances, which can reduce Redis network traffic. Default is true.

    Use @EnableLocalCachedRedisWebSession annotation provides the following configuration settings:

    • maxInactiveIntervalInSeconds - Specifies the maximum time, in seconds, that a session can remain idle before it expires. Default is 1800.

    • namespace - Specifies a custom namespace for Redis keys to enable session isolation across multiple applications. The namespace changes the Redis key prefix from the default spring:session: to <redisNamespace>:. This allows multiple applications to share the same Redis instance while maintaining separate session storage. Default is "spring:session".

    • saveMode - Save mode for the session. Default is SaveMode.ON_SET_ATTRIBUTE.

    • broadcastSessionUpdates - Specifies whether session updates should be broadcast to other application instances. When enabled, session attribute changes are published to Redis pub/sub channels, allowing other application instances to update their local caches. This ensures session consistency across a distributed deployment. Disable this feature if you have a single application instance or do not require real-time session synchronization across instances, which can reduce Redis network traffic. Default is true.

Spring Transaction Manager

Redisson provides implementation of both org.springframework.transaction.PlatformTransactionManager and org.springframework.transaction.ReactiveTransactionManager interfaces to participant in Spring transactions. See also Transactions section.

Add redisson-spring-transaction dependency into your project:

<div class="grid cards" markdown>

  • Redisson PRO

    Maven

    xml
    <dependency>
   <groupId>pro.redisson</groupId>
   <artifactId>redisson-spring-transaction</artifactId>
   <version>xVERSIONx</version>
</dependency>

    Gradle

    groovy
    compile 'pro.redisson:redisson-spring-transaction:xVERSIONx'

  • Community Edition

    Maven

    xml
    <dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson-spring-transaction</artifactId>
   <version>xVERSIONx</version>
</dependency>

    Gradle

    groovy
    compile 'org.redisson:redisson-spring-transaction:xVERSIONx'
</div>

Redisson PRO vs. Community Edition ➜

Spring Transaction Management

java
@Configuration
@EnableTransactionManagement
public class RedissonTransactionContextConfig {
    
    @Bean
    public TransactionalBean transactionBean() {
        return new TransactionalBean();
    }
    
    @Bean
    public RedissonTransactionManager transactionManager(RedissonClient redisson) {
        return new RedissonTransactionManager(redisson);
    }
    
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
         Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
    }
    
}


public class TransactionalBean {

    @Autowired
    private RedissonTransactionManager transactionManager;

    @Transactional
    public void commitData() {
        RTransaction transaction = transactionManager.getCurrentTransaction();
        RMap<String, String> map = transaction.getMap("test1");
        map.put("1", "2");
    }

}

Reactive Spring Transaction Management

java
@Configuration
@EnableTransactionManagement
public class RedissonReactiveTransactionContextConfig {
    
    @Bean
    public TransactionalBean transactionBean() {
        return new TransactionalBean();
    }
    
    @Bean
    public ReactiveRedissonTransactionManager transactionManager(RedissonReactiveClient redisson) {
        return new ReactiveRedissonTransactionManager(redisson);
    }
    
    @Bean(destroyMethod="shutdown")
    public RedissonReactiveClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
         Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.createReactive(config);
    }
    
}

public class TransactionalBean {

    @Autowired
    private ReactiveRedissonTransactionManager transactionManager;

    @Transactional
    public Mono<Void> commitData() {
        Mono<RTransactionReactive> transaction = transactionManager.getCurrentTransaction();
        return transaction.flatMap(t -> {
            RMapReactive<String, String> map = t.getMap("test1");
            return map.put("1", "2");
        }).then();
    }

}

Spring Cloud Stream

This feature is available only in Redisson PRO edition.

Redisson implements Spring Cloud Stream Binder based on Valkey or Redis using the Reliable Queue for messages delivery.

Compatible with Spring versions below.

Spring Cloud StreamSpring CloudSpring Boot
5.0.x2025.1.x4.0.x
4.3.x2025.0.x3.5.x
4.2.x2024.0.x3.4.x
4.1.x2023.0.x3.0.x - 3.3.x
4.0.x2022.0.x3.0.x - 3.3.x
3.2.x2021.0.x2.6.x, 2.7.x (Starting with 2021.0.3 of Spring Cloud)
3.1.x2020.0.x2.4.x, 2.5.x (Starting with 2020.0.3 of Spring Cloud)

To use binder with Redisson you need to add Spring Cloud Stream Binder library in classpath:

Maven:

xml
<dependency>
    <groupId>pro.redisson</groupId>
    <artifactId>spring-cloud-stream-binder-redisson</artifactId>
    <version>xVERSIONx</version>
</dependency>

Gradle:

gradle
compile 'pro.redisson:spring-cloud-stream-binder-redisson:xVERSIONx'

Receiving messages

Register the input binder (an event sink) for receiving messages as follows:

java
@Bean
public Consumer<MyObject> receiveMessage() {
  return obj -> {
     // consume received object ...
  };
}

Define channel id in the configuration file application.properties.

Consumer settings:

  • pollBatchSize - Sets the maximum number of messages to retrieve in a single poll operation. Default value is 10.

  • visibilityTimeout - Sets the visibility timeout for retrieved messages. The time period during which a message is invisible to other consumers after being retrieved. This prevents duplicate processing and allows the message to reappear in the queue if it wasn't acknowledged during that timeout. Default value is 30 seconds.

  • negativeAcknowledgeDelay - Specifies the delay duration before a message handled with an exception is eligible for redelivery. Default value is 15 seconds.

Example for receiveMessage bean defined above connected to my-channel channel:

spring.cloud.stream.bindings.receiveMessage-in-0.destination=my-channel
spring.cloud.stream.redisson.bindings.receiveMessage-in-0.consumer.pollBatchSize=15
spring.cloud.stream.redisson.bindings.receiveMessage-in-0.consumer.visibilityTimeout=60s

YAML configuration:

spring:
  cloud:
    stream:
      bindings:
        receiveMessage-in-0:
          destination: my-channel
      redisson:
        bindings:
          receiveMessage-in-0:
            consumer:
              pollBatchSize: 15
              visibilityTimeout: 60s

Publishing messages

  • Publish messages using an output binder

    Register the output binder (an event source) for publishing messages as follows:

    java
    @Bean
public Supplier<MyObject> feedSupplier() {
    return () -> {
           // ...
           return new MyObject();
    };
}

  • Publish messages using org.springframework.cloud.stream.function.StreamBridge object

     ```java
 StreamBridge bridge;
 
 bridge.send("feedSupplier-out-0", new MyObject());
 ```

Define channel id in the configuration file application.properties. Example for feedSupplier bean defined above connected to my-channel channel:

spring.cloud.stream.bindings.feedSupplier-out-0.destination=my-channel
spring.cloud.stream.bindings.feedSupplier-out-0.producer.useNativeEncoding=true

YAML configuration:

spring:
  cloud:
    stream:
      bindings:
        feedSupplier-out-0:
          destination: my-channel
          producer:
          	useNativeEncoding: true

Spring Data Redis

Redisson implements RedisConnectionFactory and ReactiveRedisConnectionFactory interfaces from Spring Data Redis module, allowing usage of RedisTemplate, ReactiveRedisTemplate or ReactiveRedisOperations objects.

Usage

  1. Add redisson-spring-data dependency into your project:

    <div class="grid cards" markdown>

    • Redisson PRO

      Maven

      xml
      <dependency>
    <groupId>pro.redisson</groupId>
    <!-- for Spring Data Redis v.1.6.x -->
    <artifactId>redisson-spring-data-16</artifactId>
    <!-- for Spring Data Redis v.1.7.x -->
    <artifactId>redisson-spring-data-17</artifactId>
    <!-- for Spring Data Redis v.1.8.x -->
    <artifactId>redisson-spring-data-18</artifactId>
    <!-- for Spring Data Redis v.2.0.x -->
    <artifactId>redisson-spring-data-20</artifactId>
    <!-- for Spring Data Redis v.2.1.x -->
    <artifactId>redisson-spring-data-21</artifactId>
    <!-- for Spring Data Redis v.2.2.x -->
    <artifactId>redisson-spring-data-22</artifactId>
    <!-- for Spring Data Redis v.2.3.x -->
    <artifactId>redisson-spring-data-23</artifactId>
    <!-- for Spring Data Redis v.2.4.x -->
    <artifactId>redisson-spring-data-24</artifactId>
    <!-- for Spring Data Redis v.2.5.x -->
    <artifactId>redisson-spring-data-25</artifactId>
    <!-- for Spring Data Redis v.2.6.x -->
    <artifactId>redisson-spring-data-26</artifactId>
    <!-- for Spring Data Redis v.2.7.x -->
    <artifactId>redisson-spring-data-27</artifactId>
    <!-- for Spring Data Redis v.3.0.x -->
    <artifactId>redisson-spring-data-30</artifactId>
    <!-- for Spring Data Redis v.3.1.x -->
    <artifactId>redisson-spring-data-31</artifactId>
    <!-- for Spring Data Redis v.3.2.x -->
    <artifactId>redisson-spring-data-32</artifactId>
    <!-- for Spring Data Redis v.3.3.x -->
    <artifactId>redisson-spring-data-33</artifactId>
    <!-- for Spring Data Redis v.3.4.x -->
    <artifactId>redisson-spring-data-34</artifactId>
    <!-- for Spring Data Redis v.3.5.x -->
    <artifactId>redisson-spring-data-35</artifactId>
    <!-- for Spring Data Redis v.4.0.x -->
    <artifactId>redisson-spring-data-40</artifactId>
    <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      // for Spring Data Redis v.1.6.x
compile 'pro.redisson:redisson-spring-data-16:xVERSIONx'
// for Spring Data Redis v.1.7.x
compile 'pro.redisson:redisson-spring-data-17:xVERSIONx'
// for Spring Data Redis v.1.8.x
compile 'pro.redisson:redisson-spring-data-18:xVERSIONx'
// for Spring Data Redis v.2.0.x
compile 'pro.redisson:redisson-spring-data-20:xVERSIONx'
// for Spring Data Redis v.2.1.x
compile 'pro.redisson:redisson-spring-data-21:xVERSIONx'
// for Spring Data Redis v.2.2.x
compile 'pro.redisson:redisson-spring-data-22:xVERSIONx'
// for Spring Data Redis v.2.3.x
compile 'pro.redisson:redisson-spring-data-23:xVERSIONx'
// for Spring Data Redis v.2.4.x
compile 'pro.redisson:redisson-spring-data-24:xVERSIONx'
// for Spring Data Redis v.2.5.x
compile 'pro.redisson:redisson-spring-data-25:xVERSIONx'
// for Spring Data Redis v.2.6.x
compile 'pro.redisson:redisson-spring-data-26:xVERSIONx'
// for Spring Data Redis v.2.7.x
compile 'pro.redisson:redisson-spring-data-27:xVERSIONx'
// for Spring Data Redis v.3.0.x
compile 'pro.redisson:redisson-spring-data-30:xVERSIONx'
// for Spring Data Redis v.3.1.x
compile 'pro.redisson:redisson-spring-data-31:xVERSIONx'
// for Spring Data Redis v.3.2.x
compile 'pro.redisson:redisson-spring-data-32:xVERSIONx'
// for Spring Data Redis v.3.3.x
compile 'pro.redisson:redisson-spring-data-33:xVERSIONx'
// for Spring Data Redis v.3.4.x
compile 'pro.redisson:redisson-spring-data-34:xVERSIONx'
// for Spring Data Redis v.3.5.x
compile 'pro.redisson:redisson-spring-data-35:xVERSIONx'
// for Spring Data Redis v.4.0.x
compile 'pro.redisson:redisson-spring-data-40:xVERSIONx'

      License key configuration

    • Community Edition

      Maven

      xml
      <dependency>
    <groupId>org.redisson</groupId>
    <!-- for Spring Data Redis v.1.6.x -->
    <artifactId>redisson-spring-data-16</artifactId>
    <!-- for Spring Data Redis v.1.7.x -->
    <artifactId>redisson-spring-data-17</artifactId>
    <!-- for Spring Data Redis v.1.8.x -->
    <artifactId>redisson-spring-data-18</artifactId>
    <!-- for Spring Data Redis v.2.0.x -->
    <artifactId>redisson-spring-data-20</artifactId>
    <!-- for Spring Data Redis v.2.1.x -->
    <artifactId>redisson-spring-data-21</artifactId>
    <!-- for Spring Data Redis v.2.2.x -->
    <artifactId>redisson-spring-data-22</artifactId>
    <!-- for Spring Data Redis v.2.3.x -->
    <artifactId>redisson-spring-data-23</artifactId>
    <!-- for Spring Data Redis v.2.4.x -->
    <artifactId>redisson-spring-data-24</artifactId>
    <!-- for Spring Data Redis v.2.5.x -->
    <artifactId>redisson-spring-data-25</artifactId>
    <!-- for Spring Data Redis v.2.6.x -->
    <artifactId>redisson-spring-data-26</artifactId>
    <!-- for Spring Data Redis v.2.7.x -->
    <artifactId>redisson-spring-data-27</artifactId>
    <!-- for Spring Data Redis v.3.0.x -->
    <artifactId>redisson-spring-data-30</artifactId>
    <!-- for Spring Data Redis v.3.1.x -->
    <artifactId>redisson-spring-data-31</artifactId>
    <!-- for Spring Data Redis v.3.2.x -->
    <artifactId>redisson-spring-data-32</artifactId>
    <!-- for Spring Data Redis v.3.3.x -->
    <artifactId>redisson-spring-data-33</artifactId>
    <!-- for Spring Data Redis v.3.4.x -->
    <artifactId>redisson-spring-data-34</artifactId>
    <!-- for Spring Data Redis v.3.5.x -->
    <artifactId>redisson-spring-data-35</artifactId>
    <!-- for Spring Data Redis v.4.0.x -->
    <artifactId>redisson-spring-data-40</artifactId>
    <version>xVERSIONx</version>
</dependency>

      Gradle

      groovy
      // for Spring Data Redis v.1.6.x
compile 'org.redisson:redisson-spring-data-16:xVERSIONx'
// for Spring Data Redis v.1.7.x
compile 'org.redisson:redisson-spring-data-17:xVERSIONx'
// for Spring Data Redis v.1.8.x
compile 'org.redisson:redisson-spring-data-18:xVERSIONx'
// for Spring Data Redis v.2.0.x
compile 'org.redisson:redisson-spring-data-20:xVERSIONx'
// for Spring Data Redis v.2.1.x
compile 'org.redisson:redisson-spring-data-21:xVERSIONx'
// for Spring Data Redis v.2.2.x
compile 'org.redisson:redisson-spring-data-22:xVERSIONx'
// for Spring Data Redis v.2.3.x
compile 'org.redisson:redisson-spring-data-23:xVERSIONx'
// for Spring Data Redis v.2.4.x
compile 'org.redisson:redisson-spring-data-24:xVERSIONx'
// for Spring Data Redis v.2.5.x
compile 'org.redisson:redisson-spring-data-25:xVERSIONx'
// for Spring Data Redis v.2.6.x
compile 'org.redisson:redisson-spring-data-26:xVERSIONx'
// for Spring Data Redis v.2.7.x
compile 'org.redisson:redisson-spring-data-27:xVERSIONx'
// for Spring Data Redis v.3.0.x
compile 'org.redisson:redisson-spring-data-30:xVERSIONx'
// for Spring Data Redis v.3.1.x
compile 'org.redisson:redisson-spring-data-31:xVERSIONx'
// for Spring Data Redis v.3.2.x
compile 'org.redisson:redisson-spring-data-32:xVERSIONx'
// for Spring Data Redis v.3.3.x
compile 'org.redisson:redisson-spring-data-33:xVERSIONx'
// for Spring Data Redis v.3.4.x
compile 'org.redisson:redisson-spring-data-34:xVERSIONx'
// for Spring Data Redis v.3.5.x
compile 'org.redisson:redisson-spring-data-35:xVERSIONx'
// for Spring Data Redis v.4.0.x
compile 'org.redisson:redisson-spring-data-40:xVERSIONx'
    </div>

    Redisson PRO vs. Community Edition ➜

  2. Register RedissonConnectionFactory in Spring context:

    java
    @Configuration
public class RedissonSpringDataConfig {

   @Bean
   public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
       return new RedissonConnectionFactory(redisson);
   }

   @Bean(destroyMethod = "shutdown")
   public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
       Config config = Config.fromYAML(configFile.getInputStream());
       return Redisson.create(config);
   }

}

{% include 'spring-ai-vector-store.md' %}