老师, 复杂的lambda嵌套调用, 适当使用换行和缩进可以增加可读性, 并相对轻松地看出层级关系.

@Repository
public class CoffeeOrderRepository {
    @Autowired
    private DatabaseClient databaseClient;

    public Mono<Long> save(CoffeeOrder order) {
        return databaseClient
            .insert()
            .into("t_order")
            .value("customer", order.getCustomer())
            .value(
                "state",
                order
                    .getState()
                    .ordinal()
            )
            .value(
                "create_time",
                new Timestamp(
                    order
                        .getCreateTime()
                        .getTime()
                )
            )
            .value(
                "update_time",
                new Timestamp(
                    order
                        .getUpdateTime()
                        .getTime()
                )
            )
            .fetch()
            .first()
            .flatMap(m -> Mono.just((Long) m.get("ID")))
            .flatMap(id ->
                Flux
                    .fromIterable(order.getItems())
                    .flatMap(c ->
                        databaseClient
                            .insert()
                            .into("t_order_coffee")
                            .value("coffee_order_id", id)
                            .value("items_id", c.getId())
                            .then()
                    )
                    .then(Mono.just(id))
            );
    }
}

老师，您好：
     我想请教一下，通过reactive方式入库的时候，数据库事务是怎么保证的呢？
比如您项目中的CoffeeOrderRepository类，在做save操作的时候，代码如下：
 return databaseClient.insert().into("t_order")
                .value("customer", order.getCustomer())
                .value("state", order.getState().ordinal())
                .value("create_time", new Timestamp(order.getCreateTime().getTime()))
                .value("update_time", new Timestamp(order.getUpdateTime().getTime()))
                .fetch()
                .first()
                .flatMap(m -> Mono.just((Long) m.get("ID")))
                .flatMap(id -> Flux.fromIterable(order.getItems())
                        .flatMap(c -> databaseClient.insert().into("t_order_coffee")
                                .value("coffee_order_id", id)
                                .value("items_id", c.getId())
                                .then()).then(Mono.just(id)));
是先入库了t_order，然后获取ID以后，再循环入库t_order_coffee。如果在入库t_order_coffee的时候，有一个数据出错了，如何保证事务统一呢？另外，您前面也讲过，我们可以指定不同线程来执行flux操作，我们在做这种批量数据入库的时候，是不是要保证在一个线程下才能保证事物呢？

老师，我在本章节示例代码的基础上，做如下修改：
1. 先不执行CoffeeService中的initCache方法，即先不将数据库中的咖啡放入redis
2.修改CoffeeService中的findOneCoffee方法，以实现将从数据库查询到的咖啡放入redis的功能，但为何不起作用（未被放入redis）？
修改后的findOneCoffee代码如下：
public Mono<Coffee> findOneCoffee(String name) {
        return reactiveRedisTemplate.opsForValue().get(PREFIX + name)
                .switchIfEmpty(
                        coffeeRepository.findByName(name)
                                .doOnSuccess(coffee -> {
                                    log.info("Loading Coffee {} From Database", coffee.getName());
                                    reactiveRedisTemplate.opsForValue()
                                            .set(PREFIX + coffee.getName(), coffee)
                                            .map(o -> reactiveRedisTemplate.expire(PREFIX + coffee.getName(), Duration.ofMinutes(1))
                                                    .doOnSuccess(v -> log.info("Save Coffee {} to Cache Successfully!", coffee.getName())));
                                })
                );
    }

老师您好，我在这章中看到您使用@JsonSerialize和@JsonDeserialize，于是乎想自己试一把，我自己写了ListSerialize和ListDeserialize，然后在entity中的List<String>类型的imageUrls属性上使用，目的就是想在JPA持久化该entity到数据库时使用ListSerialize，从数据库获取数据后使用ListDeserialize，但在项目启动的时候，就报了如下错误：
Caused by: org.hibernate.MappingException: Could not determine type for: java.util.List, at table: image_urls, for columns: [org.hibernate.mapping.Column(image_urls)]

现在我想请问老师，是不是我对这两个注解的使用上理解有问题？