Object Mapping (and more) for Redis!
Redis OM Spring extends Spring Data Redis to take full advantage of the power of Redis.
Project Stage | Snapshot | Issues | License | |
---|---|---|---|---|
Table of contents
The Redis OM family of projects aim is to provide high-level abstractions idiomatically implemented for your language/platform of choice. We currently cater to the Node, Python, .Net and Spring communities.
Redis OM Spring provides powerful repository and custom object-mapping abstractions built on top of the powerful Spring Data Redis (SDR) framework.
This preview release provides all of SDRs capabilities plus:
@Document
annotation to map Spring Data models to Redis JSON documents- Enhances SDR's
@RedisHash
via@EnableRedisEnhancedRepositories
to:- uses Redis' native search engine (RediSearch) for secondary indexing
- uses ULID for
@Id
annotated fields
RedisDocumentRepository
with automatic implementation of Repository interfaces for complex querying capabilities using@EnableRedisDocumentRepositories
- Declarative Search Indices via
@Indexable
- Full-text Search Indices via
@Searchable
@Bloom
annotation to determine very fast, with and with high degree of certainty, whether a value is in a collection.
Note: Redis OM Spring currently works only with Jedis.
Here is a quick teaser of an application using Redis OM Spring to map a Spring Data model using a RedisJSON document.
Redis OM Spring relies on the power of the RediSearch and RedisJSON modules. We have provided a docker compose YAML file for you to quickly get started. To launch the docker compose application, on the command line (or via Docker Desktop), clone this repository and run (from the root folder):
docker compose up
Use the @EnableRedisDocumentRepositories
annotation to scan for @Document
annotated Spring models,
Inject repositories beans implementing RedisDocumentRepository
which you can use for CRUD operations and custom queries (all by declaring Spring Data Query Interfaces):
package com.redis.om.documents;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.geo.Point;
import com.redis.om.documents.domain.Company;
import com.redis.om.documents.repositories.CompanyRepository;
@SpringBootApplication
@Configuration
@EnableRedisDocumentRepositories(basePackages = "com.redis.om.documents.*")
public class RomsDocumentsApplication {
@Autowired
CompanyRepository companyRepo;
@Bean
CommandLineRunner loadTestData() {
return args -> {
// remove all companies
companyRepo.deleteAll();
// Create a couple of `Company` domain entities
Company redis = Company.of(
"Redis", "https://redis.com", new Point(-122.066540, 37.377690), 526, 2011 //
);
redis.setTags(Set.of("fast", "scalable", "reliable"));
Company microsoft = Company.of(
"Microsoft", "https://microsoft.com", new Point(-122.124500, 47.640160), 182268, 1975 //
);
microsoft.setTags(Set.of("innovative", "reliable"));
// save companies to the database
companyRepo.save(redis);
companyRepo.save(microsoft);
};
}
public static void main(String[] args) {
SpringApplication.run(RomsDocumentsApplication.class, args);
}
}
Like many other Spring Data projects, an annotation at the class level determines how instances
of the class are persisted. Redis OM Spring provides the @Document
annotation to persist models as JSON documents using RedisJSON:
package com.redis.om.documents.domain;
import java.util.HashSet;
import java.util.Set;
import org.springframework.data.annotation.Id;
import org.springframework.data.geo.Point;
import com.redis.om.spring.annotations.Document;
import com.redis.om.spring.annotations.Searchable;
import lombok.*;
@Data
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@Document
public class Company {
@Id private String id;
@Searchable private String name;
@Indexed private Point location;
@Indexed private Set<String> tags = new HashSet<String>();
@Indexed private Integer numberOfEmployees;
@Indexed private Integer yearFounded;
private String url;
private boolean publiclyListed;
// ...
}
Redis OM Spring, replaces the conventional UUID
primary key strategy generation with a ULID
(Universally Unique Lexicographically Sortable Identifier) which is faster to generate and easier on the eyes.
Redis OM Spring data repository's goal, like other Spring Data repositories, is to significantly reduce the amount of boilerplate code required to implement data access. Simply create a Java interface
that extends RedisDocumentRepository
that takes the domain class to manage as well as the ID type of the domain class as type arguments. RedisDocumentRepository
extends Spring Data's PagingAndSortingRepository
.
Declare query methods on the interface. You can both, expose CRUD methods or create declarations for complex queries that Redis OM Spring will fullfil at runtime:
package com.redis.om.documents.repositories;
import java.util.*;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;
import org.springframework.data.repository.query.Param;
import com.redis.om.documents.domain.Company;
import com.redis.om.spring.annotations.Query;
import com.redis.om.spring.repository.RedisDocumentRepository;
public interface CompanyRepository extends RedisDocumentRepository<Company, String> {
// find one by property
Optional<Company> findOneByName(String name);
// geospatial query
Iterable<Company> findByLocationNear(Point point, Distance distance);
// find by tag field, using JRediSearch "native" annotation
@Query("@tags:{$tags}")
Iterable<Company> findByTags(@Param("tags") Set<String> tags);
// find by numeric property
Iterable<Company> findByNumberOfEmployees(int noe);
// find by numeric property range
Iterable<Company> findByNumberOfEmployeesBetween(int noeGT, int noeLT);
// starting with/ending with
Iterable<Company> findByNameStartingWith(String prefix);
}
The repository proxy has two ways to derive a store-specific query from the method name:
- By deriving the query from the method name directly.
- By using a manually defined query using the
@Query
or@Aggregation
annotations.
None Yet
<repositories>
<repository>
<id>snapshots-repo</id>
<url>https://s01.oss.sonatype.org/content/repositories/snapshots/</url>
</repository>
</repositories>
and
<dependency>
<groupId>com.redis.om</groupId>
<artifactId>redis-om-spring</artifactId>
<version>${version}</version>
</dependency>
Ready to learn more? Check out the getting started guide.
The Redis OM documentation is available here.
- roms-documents:
- Simple API example of
@Document
mapping, Spring Repositories and Querying. - Run with
./mvnw install -Dmaven.test.skip && ./mvnw spring-boot:run -pl demos/roms-documents
- Simple API example of
- rds-hashes:
- Simple API example of
@RedisHash
, enhanced secondary indices and querying. - Run with
./mvnw install -Dmaven.test.skip && ./mvnw spring-boot:run -pl demos/roms-hashes
- Simple API example of
- rds-permits:
- Port of Elena Kolevska's Quick Start: Using RediSearch with JSON Demo to Redis OM Spring.
- Run with
./mvnw install -Dmaven.test.skip && ./mvnw spring-boot:run -pl demos/roms-permits
If you run into trouble or have any questions, we're here to help!
First, check the FAQ. If you don't find the answer there, hit us up on the Redis Discord Server.
Some advanced features of Redis OM rely on core features from two source available Redis modules: RediSearch and RedisJSON.
You can run these modules in your self-hosted Redis deployment, or you can use Redis Enterprise, which includes both modules.
To learn more, read our documentation.
We'd love your contributions!
Bug reports are especially helpful at this stage of the project. You can open a bug report on GitHub.
You can also contribute documentation -- or just let us know if something needs more detail. Open an issue on GitHub to get started.
Redis OM uses the BSD 3-Clause license.