Building Ultra-Fast APIs with Spring Boot 3.2 and Redis Caching

Introduction — Why Cache Matters In modern microservice architectures, performance and scalability are not optional — they are the foundation. When APIs serve hundreds of requests per second, even milliseconds add up. Every database call, if repeated, can drain response time and system resources. That’s where caching comes in. performance and scalability caching Caching means temporarily storing frequently accessed data in memory so that future requests can be served much faster without hitting the database. Caching Among various caching solutions, Redis stands out as: Redis Blazingly fast (in-memory store) Easy to integrate Open source and lightweight Supports advanced data structures and pub/sub models Blazingly fast (in-memory store) Easy to integrate Open source and lightweight Supports advanced data structures and pub/sub models Here, we’ll build a real-world API using Spring Boot 3.2 and integrate Redis caching to achieve high performance with minimal code. real-world API Spring Boot 3.2 Redis caching Real-World Use Case Real-World Use Case Imagine you’re building a Service for an e-commerce platform. Service The API fetches product details from the database. Users often view the same products multiple times. Without caching, every request hits the DB. With caching, once a product is fetched, it’s stored in Redis — subsequent calls are served instantly. The API fetches product details from the database. Users often view the same products multiple times. Without caching, every request hits the DB. With caching, once a product is fetched, it’s stored in Redis — subsequent calls are served instantly. This approach reduces: Database load API latency Cloud compute cost Database load API latency Cloud compute cost Architecture Overview Architecture Overview Project Setup Project Setup Step 1: Create a Spring Boot Project Step 1: Create a Spring Boot Project Generate from https://start.spring.io https://start.spring.io https://start.spring.io Dependencies Dependencies Spring Web Spring Data JPA Spring Data Redis Lombok H2 Database (for demo) Spring Web Spring Data JPA Spring Data Redis Lombok H2 Database (for demo) Use Use Spring Boot: 3.2.x Java: 17+ Build Tool: Maven Spring Boot: 3.2.x Spring Boot: Java: 17+ Java: Build Tool: Maven Build Tool: Folder Structure Folder Structure springboot-redis-cache/ │ ├── src/main/java/com/example/redis/ │ ├── controller/ │ │ └── ProductController.java │ ├── entity/ │ │ └── Product.java │ ├── repository/ │ │ └── ProductRepository.java │ ├── service/ │ │ └── ProductService.java │ ├── RedisCacheApplication.java │ └── resources/ ├── application.yml └── data.sql springboot-redis-cache/ │ ├── src/main/java/com/example/redis/ │ ├── controller/ │ │ └── ProductController.java │ ├── entity/ │ │ └── Product.java │ ├── repository/ │ │ └── ProductRepository.java │ ├── service/ │ │ └── ProductService.java │ ├── RedisCacheApplication.java │ └── resources/ ├── application.yml └── data.sql Step-by-Step Implementation Step-by-Step Implementation Step 1 — The Product Entity Step 1 — The Product Entity package com.example.rediscache.model; import jakarta.persistence.*; import lombok.*; @Entity @Table(name = "product") @Data @NoArgsConstructor @AllArgsConstructor public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Double price; /** * @return the id */ // Default constructor (required for JPA and deserialization) public Product() {} // All-arguments constructor public Product(Long id, String name, double price) { this.id = id; this.name = name; this.price = price; } // Getters and setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } } package com.example.rediscache.model; import jakarta.persistence.*; import lombok.*; @Entity @Table(name = "product") @Data @NoArgsConstructor @AllArgsConstructor public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Double price; /** * @return the id */ // Default constructor (required for JPA and deserialization) public Product() {} // All-arguments constructor public Product(Long id, String name, double price) { this.id = id; this.name = name; this.price = price; } // Getters and setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } } This simple entity represents a product stored in the database. Step 2 — Repository Step 2 — Repository package com.example.rediscache.repository; import com.example.rediscache.model.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface ProductRepository extends JpaRepository { } package com.example.rediscache.repository; import com.example.rediscache.model.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface ProductRepository extends JpaRepository { } Step 3 — Service Layer with Caching package com.example.rediscache.service; import com.example.rediscache.model.Product; import com.example.rediscache.repository.ProductRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.annotation.*; import org.springframework.stereotype.Service; import java.util.List; @Service @CacheConfig(cacheNames = {"product", "allProducts"}) public class ProductService { @Autowired private ProductRepository repo; @Cacheable(value = "product", key = "#id") public Product getProductById(Long id) { System.out.println("[DB] Fetching product by id: " + id); return repo.findById(id).orElse(null); } @Cacheable(value = "allProducts") public List getAllProducts() { System.out.println("[DB] Fetching all products"); return repo.findAll(); } @Caching(put = {@CachePut(value = "product", key = "#result.id")}, evict = {@CacheEvict(value = "allProducts", allEntries = true)}) public Product saveOrUpdate(Product product) { Product p = repo.save(product); System.out.println("[DB] Saved product: " + p.getId()); return p; } @CacheEvict(value = "product", key = "#id") public void deleteProduct(Long id) { repo.deleteById(id); System.out.println("[DB] Deleted product: " + id); } } package com.example.rediscache.service; import com.example.rediscache.model.Product; import com.example.rediscache.repository.ProductRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.annotation.*; import org.springframework.stereotype.Service; import java.util.List; @Service @CacheConfig(cacheNames = {"product", "allProducts"}) public class ProductService { @Autowired private ProductRepository repo; @Cacheable(value = "product", key = "#id") public Product getProductById(Long id) { System.out.println("[DB] Fetching product by id: " + id); return repo.findById(id).orElse(null); } @Cacheable(value = "allProducts") public List getAllProducts() { System.out.println("[DB] Fetching all products"); return repo.findAll(); } @Caching(put = {@CachePut(value = "product", key = "#result.id")}, evict = {@CacheEvict(value = "allProducts", allEntries = true)}) public Product saveOrUpdate(Product product) { Product p = repo.save(product); System.out.println("[DB] Saved product: " + p.getId()); return p; } @CacheEvict(value = "product", key = "#id") public void deleteProduct(Long id) { repo.deleteById(id); System.out.println("[DB] Deleted product: " + id); } } Key annotations explained Key annotations explained Annotation Purpose @Cacheable First checks Redis; if not found, calls DB and stores in cache @CachePut Updates both the DB and the cache simultaneously @CacheEvict Removes the entry from the cache when a record is deleted @CacheConfig Sets a common cache name for the service Annotation Purpose @Cacheable First checks Redis; if not found, calls DB and stores in cache @CachePut Updates both the DB and the cache simultaneously @CacheEvict Removes the entry from the cache when a record is deleted @CacheConfig Sets a common cache name for the service Annotation Purpose Annotation Annotation Purpose Purpose @Cacheable First checks Redis; if not found, calls DB and stores in cache @Cacheable @Cacheable First checks Redis; if not found, calls DB and stores in cache First checks Redis; if not found, calls DB and stores in cache @CachePut Updates both the DB and the cache simultaneously @CachePut @CachePut Updates both the DB and the cache simultaneously Updates both the DB and the cache simultaneously @CacheEvict Removes the entry from the cache when a record is deleted @CacheEvict @CacheEvict Removes the entry from the cache when a record is deleted Removes the entry from the cache when a record is deleted @CacheConfig Sets a common cache name for the service @CacheConfig @CacheConfig Sets a common cache name for the service Sets a common cache name for the service Step 4 — Controller package com.example.rediscache.controller; import com.example.rediscache.model.Product; import com.example.rediscache.service.ProductService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.net.URI; import java.util.List; @RestController @RequestMapping("/api/products") public class ProductController { @Autowired private ProductService service; @GetMapping("/{id}") public ResponseEntity getProduct(@PathVariable Long id) { Product p = service.getProductById(id); if (p == null) return ResponseEntity.notFound().build(); return ResponseEntity.ok(p); } @GetMapping public ResponseEntity > getAll() { return ResponseEntity.ok(service.getAllProducts()); } @PostMapping public ResponseEntity create(@RequestBody Product product) { Product p = service.saveOrUpdate(product); return ResponseEntity.created(URI.create("/api/products/" + p.getId())).body(p); } @PutMapping("/{id}") public ResponseEntity update(@PathVariable Long id, @RequestBody Product product) { product.setId(id); Product p = service.saveOrUpdate(product); return ResponseEntity.ok(p); } @DeleteMapping("/{id}") public ResponseEntity delete(@PathVariable Long id) { service.deleteProduct(id); return ResponseEntity.ok("Deleted"); } } package com.example.rediscache.controller; import com.example.rediscache.model.Product; import com.example.rediscache.service.ProductService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.net.URI; import java.util.List; @RestController @RequestMapping("/api/products") public class ProductController { @Autowired private ProductService service; @GetMapping("/{id}") public ResponseEntity getProduct(@PathVariable Long id) { Product p = service.getProductById(id); if (p == null) return ResponseEntity.notFound().build(); return ResponseEntity.ok(p); } @GetMapping public ResponseEntity > getAll() { return ResponseEntity.ok(service.getAllProducts()); } @PostMapping public ResponseEntity create(@RequestBody Product product) { Product p = service.saveOrUpdate(product); return ResponseEntity.created(URI.create("/api/products/" + p.getId())).body(p); } @PutMapping("/{id}") public ResponseEntity update(@PathVariable Long id, @RequestBody Product product) { product.setId(id); Product p = service.saveOrUpdate(product); return ResponseEntity.ok(p); } @DeleteMapping("/{id}") public ResponseEntity delete(@PathVariable Long id) { service.deleteProduct(id); return ResponseEntity.ok("Deleted"); } } Step 5 — Configuration spring: cache: type: redis redis: host: localhost port: 6379 datasource: url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE driver-class-name: org.h2.Driver username: sa password: jpa: hibernate: ddl-auto: update show-sql: false logging: level: root: INFO com.example.rediscache: DEBUG spring: cache: type: redis redis: host: localhost port: 6379 datasource: url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE driver-class-name: org.h2.Driver username: sa password: jpa: hibernate: ddl-auto: update show-sql: false logging: level: root: INFO com.example.rediscache: DEBUG Step 6 — Main Class package com.example.rediscache; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cache.annotation.EnableCaching; @SpringBootApplication @EnableCaching public class SpringbootRedisCacheApplication { public static void main(String[] args) { SpringApplication.run(SpringbootRedisCacheApplication.class, args); } } package com.example.rediscache; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cache.annotation.EnableCaching; @SpringBootApplication @EnableCaching public class SpringbootRedisCacheApplication { public static void main(String[] args) { SpringApplication.run(SpringbootRedisCacheApplication.class, args); } } Step 7 — pom.xml Step 7 — pom.xml org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-data-jpa org.springframework.boot spring-boot-starter-data-redis org.springframework.boot spring-boot-starter-cache com.h2database h2 runtime org.projectlombok lombok 1.18.32 provided org.springframework.boot spring-boot-starter-test test org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-data-jpa org.springframework.boot spring-boot-starter-data-redis org.springframework.boot spring-boot-starter-cache com.h2database h2 runtime org.projectlombok lombok 1.18.32 provided org.springframework.boot spring-boot-starter-test test Step-by-Step Validation Step 1 — Start Redis Run redis-server redis-server Keep it running. Verify in CMD redis-cli ping redis-cli ping Output PONG PONG Step 2 — Run the Spring Boot App Run As → Java Application Step 3 — Add Products POST → http://localhost:8080/api/products { "name": "MacBook", "price": 1699.99 } POST → http://localhost:8080/api/products { "name": "MacBook", "price": 1699.99 } Console log Fetching from DB for ID: 1 Fetching from DB for ID: 1 RedisInsight now shows a key: products::4 products::4 Step 4 — Fetch Cached Product Step 4 — Fetch Cached Product GET → http://localhost:8080/products/1 GET → GET → http://localhost:8080/products/1 Output (same as before), but console log doesn’t show “Fetching from DB” — because it’s now served directly from Redis. “Fetching from DB” Cache Hit Successful! Cache Hit Successful! Step 5 — Delete Product and Verify Eviction Step 5 — Delete Product and Verify Eviction DELETE → http://localhost:8080/products/1 DELETE → DELETE → http://localhost:8080/products/1 Then check RedisInsight again — the key products::1 disappears. products::1 Cache Eviction Successful! Cache Eviction Successful! How It Works How It Works First Request First Request Cache is empty. Data is fetched from the database. Result stored in Redis under key products::1. Cache is empty. Data is fetched from the database. Result stored in Redis under key products::1. products::1. Next Requests Next Requests Fetched directly from Redis (milliseconds response time). Fetched directly from Redis (milliseconds response time). Update/Delete Update/Delete @CachePut refreshes the cache after saving. @CacheEvict removes outdated entries. @CachePut refreshes the cache after saving. @CacheEvict removes outdated entries. Observing Redis in Real-Time (Using RedisInsight) Observing Redis in Real-Time (Using RedisInsight) Open RedisInsight (https://redis.io/insight) RedisInsight (https://redis.io/insight https://redis.io/insigh t t ) Steps: Steps: Connect → localhost:6379 Go to “Keys” tab. You’ll see cached entries like products::1. Connect → localhost:6379 localhost:6379 localhost:6379 Go to “Keys” tab. You’ll see cached entries like products::1. products::1. Double-click to view serialized data. You’ll see cached object details, including ID, name, and price. Double-click to view serialized data. You’ll see cached object details, including ID, name, and price. On deletion, it disappears immediately — proving cache eviction. You can set cache expiry to automatically refresh stale data On deletion, it disappears immediately — proving cache eviction. You can set cache expiry to automatically refresh stale data spring: cache: redis: time-to-live: 60000 # 60 seconds spring: cache: redis: time-to-live: 60000 # 60 seconds Performance Comparison Operation Type Without Cache (MySQL) With Redis Cache First Fetch ~120 ms ~120 ms Subsequent ~5 ms ~2 ms Delete Product 90 ms 90 ms + Evict Operation Type Without Cache (MySQL) With Redis Cache First Fetch ~120 ms ~120 ms Subsequent ~5 ms ~2 ms Delete Product 90 ms 90 ms + Evict Operation Type Without Cache (MySQL) With Redis Cache Operation Type Operation Type Without Cache (MySQL) Without Cache (MySQL) With Redis Cache With Redis Cache First Fetch ~120 ms ~120 ms First Fetch First Fetch ~120 ms ~120 ms ~120 ms ~120 ms Subsequent ~5 ms ~2 ms Subsequent Subsequent ~5 ms ~5 ms ~2 ms ~2 ms Delete Product 90 ms 90 ms + Evict Delete Product Delete Product 90 ms 90 ms 90 ms + Evict 90 ms + Evict Result: ~60x faster on repeated reads! Result: Advantages of Redis Caching Benefit Description Blazing Fast Data served from memory, not DB Cost Efficient Reduces DB reads & compute load Smart Expiration TTLs prevent stale data Reusability Cache layer works across services Reliable Redis supports clustering & persistence Benefit Description Blazing Fast Data served from memory, not DB Cost Efficient Reduces DB reads & compute load Smart Expiration TTLs prevent stale data Reusability Cache layer works across services Reliable Redis supports clustering & persistence Benefit Description Benefit Benefit Description Description Blazing Fast Data served from memory, not DB Blazing Fast Blazing Fast Data served from memory, not DB Data served from memory, not DB Cost Efficient Reduces DB reads & compute load Cost Efficient Cost Efficient Reduces DB reads & compute load Reduces DB reads & compute load Smart Expiration TTLs prevent stale data Smart Expiration Smart Expiration TTLs prevent stale data TTLs prevent stale data Reusability Cache layer works across services Reusability Reusability Cache layer works across services Cache layer works across services Reliable Redis supports clustering & persistence Reliable Reliable Redis supports clustering & persistence Redis supports clustering & persistence Real-World Scenarios Product Catalog/Inventory APIs → Cache product and pricing data for thousands of users. User Profile Data → Frequently accessed user details are cached for instant retrieval. Currency Conversion / Configurations → Cache frequently used lookups. Microservice Communication → Cache service responses to minimize inter-service latency. Product Catalog/Inventory APIs → Cache product and pricing data for thousands of users. Product Catalog/Inventory APIs User Profile Data → Frequently accessed user details are cached for instant retrieval. User Profile Data Currency Conversion / Configurations → Cache frequently used lookups. Currency Conversion / Configurations Microservice Communication → Cache service responses to minimize inter-service latency. Microservice Communication Summary Summary By integrating Redis caching into your Spring Boot application You offload database pressure. You enhance user experience through faster responses. You build APIs that can handle higher concurrency efficiently. You offload database pressure. You enhance user experience through faster responses. You build APIs that can handle higher concurrency efficiently. Concept Description @Cacheable Fetch from cache or DB if missing @CachePut Update cache with new value @CacheEvict Remove entry from cache Redis TTL Expire cache automatically Concept Description @Cacheable Fetch from cache or DB if missing @CachePut Update cache with new value @CacheEvict Remove entry from cache Redis TTL Expire cache automatically Concept Description Concept Concept Description Description @Cacheable Fetch from cache or DB if missing @Cacheable @Cacheable Fetch from cache or DB if missing Fetch from cache or DB if missing @CachePut Update cache with new value @CachePut @CachePut Update cache with new value Update cache with new value @CacheEvict Remove entry from cache @CacheEvict @CacheEvict Remove entry from cache Remove entry from cache Redis TTL Expire cache automatically Redis TTL Redis TTL Expire cache automatically Expire cache automatically One design pattern, one configuration — massive performance gains. One design pattern, one configuration — massive performance gains.