Spring @CacheEvict行为

Question

I am trying to understand the behavior of @CacheEvict in Spring Cache Abstraction. Here is my sample application

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

Application

@SpringBootApplication
@EnableCaching
public class Application implements ApplicationListener<ApplicationReadyEvent>  {
    private final OrderService orderService;
    public Application (OrderService orderService) {
        this.orderService = orderService;
    }
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
    @Override
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        List<Order> orders = orderService.getPendingOrders();
        System.out.println("Found " + orders.size() + " Pending Orders.");
        orderService.fulFillOrder(orders.stream().findFirst().get());
        orders = orderService.getPendingOrders();
        System.out.println("Found " + orders.size() + " Pending Orders.");
    }
}

Model

public class Order {
    final int id;
    final int qty;
    final String status;
    Order (int id, int qty, String status) {
        this.id = id;
        this.qty = qty;
        this.status = status;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        if (id != order.id) return false;
        if (qty != order.qty) return false;
        return status.equals(order.status);
    }
    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + qty;
        result = 31 * result + status.hashCode();
        return result;
    }
}

Service

@Service
public class OrderService {
    @Cacheable("pendingOrders")
    public List<Order> getPendingOrders() {
        System.out.println("Creating Orders... Expensive Operation...");
        List<Order> pendingOrders = new ArrayList<>();
        pendingOrders.add(new Order(1, 10, "PENDING"));
        pendingOrders.add(new Order(2, 10, "PENDING"));
        return Collections.unmodifiableList(pendingOrders);
    }

    @CacheEvict("pendingOrders")
    public void fulFillOrder(Order order) {

        System.out.println("Fulfilling Order...");
    }
}

Actual Output

Creating Orders... Expensive Operation...
Found 2 Pending Orders.
Removing Order...
Found 2 Pending Orders.

Expected Output

Creating Orders... Expensive Operation...
Found 2 Pending Orders.
Removing Order...
Found 1 Pending Orders.

I am expecting that the Order being Fulfilled gets evicted from the "pendingOrders" cache. But this doesn't appear to be happening. Thoughts?

Answer 1

This is correct behaviour.

@Override
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        List<Order> orders = orderService.getPendingOrders();
        System.out.println("Found " + orders.size() + " Pending Orders.");
        orderService.fulFillOrder(orders.stream().findFirst().get());
        orders = orderService.getPendingOrders();
        System.out.println("Found " + orders.size() + " Pending Orders.");
    }

I am expecting that the Order being Fulfilled gets evicted from the "pendingOrders" cache. But this doesn't appear to be happening. Thoughts?

This is because you are calling getPendingOrders() again to re-fill the cache with 2 Orders returned by this method.

You are calling orderService.getPendingOrders(); again after fullfilling the order. getPendingOrders() always returns 2 hard-coded Orders, and those are again put in cache as the getPendingOrders method is annotated with @Cacheable. hence you are getting below again after Order is fulfilled.

Found 2 Pending Orders.

As per the javadocs

@Cacheable Annotation indicating that the result of invoking a method (or all methods in a class) can be cached.

@CacheEvict Annotation indicating that a method (or all methods on a class) triggers a cache evict operation.