Instead of manually handling **caching**, you can use **annotations** that automatically **manage** the process. Let's take a look at the **annotations** available.

## Caching Results

The `@Cacheable` **annotation** is applied to **methods** whose **results** should be **cached**. When the **method** is called again with the same **parameters**, the **result** is retrieved from the **cache**.

```java
@Cacheable(value = "usersCache", key = "#userId")
public User getUserById(String userId) {
    return userRepository.findById(userId);
}
```

In this example, the `getUserById` **method** caches the **result** of a **user query** by their `ID` in a **cache** named `"usersCache"`. If the **method** is called again with the same `userId`, the **data** is retrieved from the **cache** instead of executing the **query** against the **database**.

## Updating the Cache

The `@CachePut` **annotation** updates the **cache** every time the **method** is executed, regardless of whether the **result** was **cached** previously.

```java
@CachePut(value = "usersCache", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user);
}
```

The `@CachePut` **annotation** is used to **update** the **cache** each time the `updateUser` **method** is called. This is useful when the **data** changes and you need to **synchronize** the **cache** with the changes in the **database**. The **cache** is updated with the **key** corresponding to the **user ID**.

# Clearing the Cache
The `@CacheEvict` **annotation** is used to **remove** **data** from the **cache**, such as when a **user** is **deleted** from the **database**.

```java
@CacheEvict(value = "usersCache", key = "#userId")
public void deleteUser(String userId) {
    userRepository.deleteById(userId);
}
```

In this **example**, the `deleteUser` **method** **removes** the **entry** from the **cache** with the **key** equal to `userId`.

# Combined Cache Operations
The `@Caching` **annotation** allows **multiple caching operations** to be performed within a **single method**, combining `@CachePut` and `@CacheEvict`.

```java
@Caching(
    put = { @CachePut(value = "usersCache", key = "#user.id") },
    evict = { @CacheEvict(value = "usersCache", key = "#user.id") }
)
public User updateUser(User user) {
    return userRepository.save(user);
}
```

In this **example**, the `updateUser` **method** simultaneously **updates** the **cache** with the **new state** of the **user** using `@CachePut` and **removes** the **old entry** from the **cache** using `@CacheEvict`. This is useful when you need to **perform multiple cache operations** at the same **time**.

What is the purpose of the `@CachePut` annotation?

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

Annotations for Working with Cache

Caching Results

Updating the Cache

Clearing the Cache

Combined Cache Operations

1. When would you use `@CacheEvict`?

2. What is the purpose of the `@CachePut` annotation?