first commit

Author: slorello89

.github/media/redis-cache-demo-grafana.png

@@ -0,0 +1,21 @@
+.gradle
+**/build/
+!src/**/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
+.project
+# JDT-specific (Eclipse Java Development Tools)
+.classpath

.github/media/redis-cache-demo-search.png

@@ -0,0 +1,77 @@
+# Business Source License
+
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+“Business Source License” is a trademark of MariaDB Corporation Ab
+
+
+Licensor:
+Redis Ltd., on behalf of itself and its affiliates and subsidiaries worldwide
+Licensed Work:
+
+
+The Licensed Work means the Redis Streams Java client libraries described [here](https://github.com/redis-field-engineering/redis-streams-java-dist)
+
+Additional Use Grant:
+
+You may make production use of the Licensed Work solely in connection with the
+following products offered by Redis Ltd. or its subsidiaries or affiliates
+(collectively, “Redis”):
+(i) Redis Community Edition as described [here](https://redis.io/docs/latest/get-started/);
+(ii) Redis Cloud as described [here](https://redis.io/cloud/); or
+(iii) Redis Software as described [here](https://redis.io/enterprise/):
+(collectively, the “Redis Services”), provided that such usage is not additionally made
+in connection or combination with a Competitive Offering.
+
+A “Competitive Offering” is a Product that is offered to third parties on either a
+paid basis, including through paid support arrangements, or a non-paid basis,
+that significantly overlaps with the capabilities of the Licensed Work or the Redis Services.
+If Your Product is not a Competitive Offering when You first make it generally available,
+it will not become a Competitive Offering later due to Redis releasing a new version of the
+Licensed Work with additional capabilities.
+
+“Product” means software that is offered to end users to manage in their own
+environments or offered as a service on a hosted basis.
+
+Change Date: Four years from the date the Licensed Work is published
+
+Change License: MIT
+
+Terms:
+
+The Licensor hereby grants you the right to copy, modify, create derivative works,
+redistribute, and make non-production use of the Licensed Work. The Licensor
+may make an Additional Use Grant, above, permitting limited production use.
+
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under the
+terms of the Change License, and the rights granted in the paragraph above terminate.
+
+
+If your use of the Licensed Work does not comply with the requirements currently
+in effect as described in this License, you must purchase a commercial license from
+the Licensor, its affiliated entities, or authorized resellers, or you must refrain
+from using the Licensed Work.
+
+
+All copies of the original and modified Licensed Work, and derivative works of the
+Licensed Work, are subject to this License. This License applies separately for each
+version of the Licensed Work and the Change Date may vary for each version of the
+Licensed Work released by Licensor.
+
+
+You must conspicuously display this License on each original or modified copy of
+the Licensed Work. If you receive the Licensed Work in original or modified form from
+a third party, the terms and conditions set forth in this License apply to your use of that work.
+
+
+Any use of the Licensed Work in violation of this License will automatically terminate
+your rights under this License for the current and all other versions of the Licensed Work.
+
+
+This License does not grant you any right in any trademark or logo of Licensor or its
+affiliates (provided that you may use a trademark or logo of Licensor as expressly required by this License).
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS.
+LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING
+(WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.

.github/media/redis-cache-demo.png

@@ -0,0 +1,234 @@
+= Redis Cache
+:linkattrs:
+:project-owner:   redis-field-engineering
+:project-name:    redis-cache-java
+:project-group:   com.redis
+:project-version: 0.1.2
+:project-url:     https://github.com/{project-owner}/{project-name}
+:product-name:    Redis Cache
+:codecov-token:   2cAc3dgZRA
+:artifact-id:     redis-cache-core
+:imagesdir:       .github/media
+
+image:https://github.com/{project-owner}/{project-name}/actions/workflows/early-access.yml/badge.svg["Build Status", link="https://github.com/{project-owner}/{project-name}/actions/workflows/early-access.yml"]
+image:https://codecov.io/gh/{project-owner}/{project-name}/graph/badge.svg?token={codecov-token}["Coverage", link="https://codecov.io/gh/{project-owner}/{project-name}"]
+
+Redis Cache is a cache abstraction for the Java ecosystem that leverages enterprise Redis features like indexing and query.
+It provides an implementation of Spring Framework's https://docs.spring.io/spring-framework/reference/6.1/integration.html#cache[Cache Abstraction].
+
+== Usage
+
+=== Dependency
+
+.Maven
+[source,xml]
+[subs="verbatim,attributes"]
+----
+<dependency>
+    <groupId>{project-group}</groupId>
+    <artifactId>{artifact-id}</artifactId>
+    <version>{project-version}</version>
+</dependency>
+----
+
+.Gradle
+[source,groovy]
+[subs="attributes"]
+----
+dependencies {
+    implementation '{project-group}:{artifact-id}:{project-version}'
+}
+----
+
+=== Setup
+
+To use {product-name} as a backing implementation, add `RedisCacheManager` to your configuration as follows:
+
+[source,java]
+-----
+@Bean
+public RedisCacheManager cacheManager(RedisModulesClient client) {
+   return RedisCacheManager.create(client);
+}
+-----
+
+`RedisCacheManager` behavior can be configured with `RedisCacheManagerBuilder`, letting you set the default `RedisCacheConfiguration` and predefined caches.
+
+[source,java]
+-----
+RedisCacheManager cacheManager = RedisCacheManager.builder(client)
+  .defaults(RedisCacheConfiguration.defaultConfig())
+  .configuration("hashCache", RedisCacheConfiguration.defaultConfig().hash())
+  .configuration("jsonCache", RedisCacheConfiguration.defaultConfig().json())
+  .configuration("stringCache", RedisCacheConfiguration.defaultConfig().string())
+  .build();
+-----
+
+As shown in the preceding example, `RedisCacheManager` allows custom configuration on a per-cache basis.
+
+The behavior of `RedisCache` created by `RedisCacheManager` is defined with `RedisCacheConfiguration`.
+
+=== Configuration
+
+The `RedisCacheConfiguration` object is the entry point to configure a Redis cache and enable its features.
+
+==== Key Function
+
+Use `keyFunction(KeyFunction function)` to set the `KeyFunction` used to compute Redis keys.
+
+Default is `KeyFunction.SIMPLE` which produces keys in the form `<cache>:<key>`.
+
+==== Key Expiration
+
+To enable entry time-to-live (TTL) use `entryTtl(Duration duration)` or `entryTtl(TtlFunction function)`.
+
+Default is `TtlFunction.PERSISTENT` which does not expire keys.
+
+==== Redis Data Type
+
+Use `redisType(RedisType type)` to change the type of data-structure backing the cache.
+
+Possible values are `HASH`, `STRING`, and `JSON`.
+
+Default is `HASH`.
+
+Each type has a corresponding value mapper which can be overriden:
+
+* `HASH`: `hashMapper(RedisHashMapper mapper)`
+* `STRING`: `stringMapper(RedisStringMapper mapper)`
+* `JSON`: `jsonMapper(RedisStringMapper mapper)`
+
+==== Client-Side Caching
+
+Client-side caching (also known as local or near caching) can be enabled by setting `localCache(Map<String, Object> cache)`.
+
+For example with a simple `java.util.Map` implementation: `localCache(new HashMap<>())`.
+
+For more control over the behavior of the local cache it is recommended to use an in-memory cache implementation like https://github.com/ben-manes/caffeine[Caffeine]:
+
+[source,java]
+----
+Cache<String, Object> localCache = Caffeine.newBuilder()
+            .maximumSize(10000)
+            .expireAfterWrite(Duration.ofMinutes(5))
+            .build();
+return RedisCacheConfiguration.defaultConfig().localCache(localCache.asMap());
+----
+
+See the https://github.com/ben-manes/caffeine/wiki[Caffeine Documentation] for more configuration options.
+
+==== Metrics
+
+{product-name} uses Micrometer to publish metrics.
+To enable metrics, set a `MeterRegistry` in your `RedisCacheConfiguration`:
+
+[source,java]
+----
+RedisCacheConfiguration.defaultConfig().meterRegistry(registry);
+----
+
+The following metrics are published:
+
+[cols="2,2,1,5"]
+|===
+| Name | Tags | Type | Description
+
+| `cache.gets`
+| `result=hit\|miss`
+| Counter
+| The number of times cache lookup methods have returned a cached (hit) or uncached (miss) value.
+
+| `cache.puts`
+| 
+| Counter
+| The number of entries added to the cache.
+
+| `cache.evictions`
+| 
+| Counter
+| The number of times the cache was evicted.
+
+| `cache.gets.latency`
+| 
+| Timer
+| Cache get latency
+
+| `cache.puts.latency`
+| 
+| Timer
+| Cache put latency
+
+| `cache.evictions.latency`
+| 
+| Timer
+| Cache eviction latency
+
+| `cache.local.gets`
+| `result=hit\|miss`
+| Counter
+| The number of times local cache lookup methods have returned a cached (hit) or uncached (miss) value.
+
+| `cache.local.evictions`
+| 
+| Counter
+| The number of times the local cache was evicted.
+
+
+|===
+
+NOTE: All metrics expose their corresponding cache name as a tag: `name=<cache>`.
+
+== Quick Start
+
+To understand how {product-name} works, it's best to try it for yourself.
+
+This example showcases a Spring Boot application using {product-name}.
+
+First, clone this git repository:
+
+[source,console,subs="verbatim,attributes"]
+----
+git clone {project-url}.git
+cd {project-name}
+----
+
+Next, register and create an API read-access token at https://developer.themoviedb.org/docs/getting-started[themoviedb.org].
+
+Set the following environment variable with the token:
+
+[source,console]
+----
+export TMDB_TOKEN=<your API read-access token>
+----
+
+Finally use Docker Compose to launch containers for Redis and the {product-name} demo app instance:
+
+[source,console]
+----
+docker compose up
+----
+
+You can then access the demo at http://localhost:8080/[localhost:8080].
+
+As you click around on the different pages, notice how the response time improves after the first time you request a page.
+
+image:redis-cache-demo.png[]
+
+Open another browser window and access Grafana at http://localhost:3000/[localhost:3000].
+Use username/password `admin`/`admin` to log in.
+You can skip changing password.
+
+Arrange your browser windows with the demo app on the left and Grafana on the right:
+
+image:redis-cache-demo-grafana.png[]
+
+Notice the HTTP response time decreasing with cache hits, and increasing with API requests.
+
+Now click on the http://localhost:8080/movies/search[Search] link to search the cache, for example with keyword `corleone`.
+
+Notice how quickly search results are returned: the search feature is powered by Redis.
+
+Search response time can be visualized with the panel at the bottom of the Grafana dashboard.
+
+image:redis-cache-demo-search.png[]
+

.gitignore

@@ -0,0 +1,27 @@
+services:
+  prometheus:
+    image: prom/prometheus
+    ports:
+      - 9090:9090
+    volumes:
+      - ./samples/redis-cache-demo/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
+  grafana:
+    image: grafana/grafana
+    ports:
+      - 3000:3000
+    volumes:
+      - ./samples/redis-cache-demo/grafana/provisioning:/etc/grafana/provisioning
+  redis:
+    image: redis/redis-stack-server
+    ports:
+      - 6379:6379
+  demo:
+    image: ghcr.io/redis-field-engineering/redis-cache-demo:early-access
+    restart: on-failure
+    depends_on:
+      - redis
+    ports:
+      - 8080:8080
+    environment:
+      - SPRING_DATA_REDIS_HOST=redis
+      - TMDB_TOKEN=${TMDB_TOKEN}