We'll fully **assemble** our application and test it using **Redis** and **Spring Boot**. **Caching** will significantly speed up request processing and reduce the load on the **database**.

# Brief Summary from the Video
In our program, we used the **following logic**: when a user is **added** to the main **database**, their data is not **cached** because it's not necessary yet.

```java
@Transactional
public User createUser(User user) {
    return userRepository.save(user);
}
```

The `createUser` method simply **saves** the user to the **database**.

When a **request comes** in to fetch a **user's data** by `ID`, we first check if the **information** is available in the **Redis cache**. This helps avoid unnecessary **database queries** if the data is already **cached**.

```java
@Transactional
@Cacheable(value = "user-cache", key = "#id")
@SneakyThrows
public User getUserById(Long id) {
    Thread.sleep(100);
    return userRepository.findById(id).orElseThrow(
            () -> new RuntimeException(String.format("User with this id: %d not found", id))
    );
}
```

Using the `@Cacheable` annotation, we **cache** the data under the key `user-cache`, which includes the value of the **id** (`user-cache:20` for a user with ID `20`). If the data is in the **cache**, it is retrieved and returned. If the data is not in the **cache**, the method queries the **database**.

When **deleting data** from the **database**, it's important to **remove** it from the **cache** as well to ensure the data remains **consistent** and outdated information is not used.

```java
@CacheEvict(value="user-cache", key="#id")
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}
```

The `deleteUser` method **deletes** the user from the **database** and **clears** their data from the **Redis cache** to prevent using **outdated information** in future queries.

# Benefits of Caching

Now for the exciting part — why did we implement **caching**? After adding the **Redis cache**, requests became much **faster** — literally up to **20 times faster**! This is clearly demonstrated in the screenshots below.

## Before Caching

Before implementing **caching**, each request went directly to the **database**, resulting in significant **delays** during processing.

## After Caching
With **caching** in place, most requests are now handled by **Redis**, which significantly **reduces response time**.

# Summary
**Caching** with **Redis** has allowed us to **optimize** the application's **performance**, **speed up** request processing, and **reduce** the load on the **database**. This approach is especially beneficial for **high-traffic applications** where request processing **speed** is crucial.

This course will introduce you to the fundamentals of Redis and its use in real-world applications. We'll cover key Redis commands, data types, key expiration and transactions, as well as how to integrate Redis with Spring for efficient data caching.

This section provides an introduction to Redis, highlighting its core features and common use cases. You’ll learn how to install Redis on different platforms, including Windows and macOS, and get familiar with the basics of connecting to and starting the Redis server.

Here, we explore the essential Redis commands for managing and manipulating data effectively. You'll learn how to set, retrieve, increment, and delete data using commands like SET, GET, EXISTS, INCR, DECR, and tackle practical tasks to apply these concepts in real-world scenarios.

Here, you will learn about key Redis data types, including Lists, Sets, Sorted Sets, and Hashes. You will explore their functionality and practical applications through focused exercises designed to reinforce your understanding of each data type.

You'll explore advanced features of Redis, including managing key lifecycles, executing transactions, and leveraging the Pub/Sub messaging system. Additionally, you'll learn essential security practices to safeguard your Redis environment against unauthorized access.

This section introduces the fundamentals of caching and demonstrates how to configure Redis as a cache in a Spring application. It covers key caching annotations and practical examples of caching queries in web applications, concluding with a summary of the main concepts.

Introduction to Redis

Practical Use of Hashes

Brief Summary from the Video

Benefits of Caching

Before Caching

After Caching

Summary